1/* 2 * Copyright (c) 1982, 1986, 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 4. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * @(#)tty_pty.c 8.4 (Berkeley) 2/20/95 30 */ 31 32#include <sys/cdefs.h>
| 1/* 2 * Copyright (c) 1982, 1986, 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 4. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * @(#)tty_pty.c 8.4 (Berkeley) 2/20/95 30 */ 31 32#include <sys/cdefs.h>
|
33__FBSDID("$FreeBSD: head/sys/kern/tty_pty.c 130892 2004-06-21 22:57:16Z phk $");
| 33__FBSDID("$FreeBSD: head/sys/kern/tty_pty.c 131114 2004-06-25 21:54:49Z phk $");
|
34 35/* 36 * Pseudo-teletype Driver 37 * (Actually two drivers, requiring two entries in 'cdevsw') 38 */ 39#include "opt_compat.h" 40#include "opt_tty.h" 41#include <sys/param.h> 42#include <sys/systm.h> 43#include <sys/lock.h> 44#include <sys/mutex.h> 45#include <sys/sx.h> 46#ifndef BURN_BRIDGES 47#if defined(COMPAT_43) 48#include <sys/ioctl_compat.h> 49#endif 50#endif 51#include <sys/proc.h> 52#include <sys/tty.h> 53#include <sys/conf.h> 54#include <sys/fcntl.h> 55#include <sys/poll.h> 56#include <sys/kernel.h> 57#include <sys/vnode.h> 58#include <sys/signalvar.h> 59#include <sys/malloc.h> 60 61static MALLOC_DEFINE(M_PTY, "ptys", "pty data structures"); 62 63static void ptsstart(struct tty *tp); 64static void ptsstop(struct tty *tp, int rw); 65static void ptcwakeup(struct tty *tp, int flag); 66static struct cdev *ptyinit(struct cdev *cdev); 67 68static d_open_t ptsopen; 69static d_close_t ptsclose; 70static d_read_t ptsread; 71static d_write_t ptswrite; 72static d_ioctl_t ptyioctl; 73static d_open_t ptcopen; 74static d_close_t ptcclose; 75static d_read_t ptcread; 76static d_write_t ptcwrite; 77static d_poll_t ptcpoll; 78 79#define CDEV_MAJOR_S 5 80static struct cdevsw pts_cdevsw = { 81 .d_version = D_VERSION, 82 .d_open = ptsopen, 83 .d_close = ptsclose, 84 .d_read = ptsread, 85 .d_write = ptswrite, 86 .d_ioctl = ptyioctl, 87 .d_name = "pts", 88 .d_maj = CDEV_MAJOR_S, 89 .d_flags = D_TTY | D_NEEDGIANT, 90}; 91 92#define CDEV_MAJOR_C 6 93static struct cdevsw ptc_cdevsw = { 94 .d_version = D_VERSION, 95 .d_open = ptcopen, 96 .d_close = ptcclose, 97 .d_read = ptcread, 98 .d_write = ptcwrite, 99 .d_ioctl = ptyioctl, 100 .d_poll = ptcpoll, 101 .d_name = "ptc", 102 .d_maj = CDEV_MAJOR_C, 103 .d_flags = D_TTY | D_NEEDGIANT, 104}; 105 106#define BUFSIZ 100 /* Chunk size iomoved to/from user */ 107 108struct ptsc { 109 int pt_flags; 110 struct selinfo pt_selr, pt_selw; 111 u_char pt_send; 112 u_char pt_ucntl; 113 struct tty *pt_tty; 114 struct cdev *devs, *devc; 115 struct prison *pt_prison; 116}; 117 118#define PF_PKT 0x08 /* packet mode */ 119#define PF_STOPPED 0x10 /* user told stopped */
| 34 35/* 36 * Pseudo-teletype Driver 37 * (Actually two drivers, requiring two entries in 'cdevsw') 38 */ 39#include "opt_compat.h" 40#include "opt_tty.h" 41#include <sys/param.h> 42#include <sys/systm.h> 43#include <sys/lock.h> 44#include <sys/mutex.h> 45#include <sys/sx.h> 46#ifndef BURN_BRIDGES 47#if defined(COMPAT_43) 48#include <sys/ioctl_compat.h> 49#endif 50#endif 51#include <sys/proc.h> 52#include <sys/tty.h> 53#include <sys/conf.h> 54#include <sys/fcntl.h> 55#include <sys/poll.h> 56#include <sys/kernel.h> 57#include <sys/vnode.h> 58#include <sys/signalvar.h> 59#include <sys/malloc.h> 60 61static MALLOC_DEFINE(M_PTY, "ptys", "pty data structures"); 62 63static void ptsstart(struct tty *tp); 64static void ptsstop(struct tty *tp, int rw); 65static void ptcwakeup(struct tty *tp, int flag); 66static struct cdev *ptyinit(struct cdev *cdev); 67 68static d_open_t ptsopen; 69static d_close_t ptsclose; 70static d_read_t ptsread; 71static d_write_t ptswrite; 72static d_ioctl_t ptyioctl; 73static d_open_t ptcopen; 74static d_close_t ptcclose; 75static d_read_t ptcread; 76static d_write_t ptcwrite; 77static d_poll_t ptcpoll; 78 79#define CDEV_MAJOR_S 5 80static struct cdevsw pts_cdevsw = { 81 .d_version = D_VERSION, 82 .d_open = ptsopen, 83 .d_close = ptsclose, 84 .d_read = ptsread, 85 .d_write = ptswrite, 86 .d_ioctl = ptyioctl, 87 .d_name = "pts", 88 .d_maj = CDEV_MAJOR_S, 89 .d_flags = D_TTY | D_NEEDGIANT, 90}; 91 92#define CDEV_MAJOR_C 6 93static struct cdevsw ptc_cdevsw = { 94 .d_version = D_VERSION, 95 .d_open = ptcopen, 96 .d_close = ptcclose, 97 .d_read = ptcread, 98 .d_write = ptcwrite, 99 .d_ioctl = ptyioctl, 100 .d_poll = ptcpoll, 101 .d_name = "ptc", 102 .d_maj = CDEV_MAJOR_C, 103 .d_flags = D_TTY | D_NEEDGIANT, 104}; 105 106#define BUFSIZ 100 /* Chunk size iomoved to/from user */ 107 108struct ptsc { 109 int pt_flags; 110 struct selinfo pt_selr, pt_selw; 111 u_char pt_send; 112 u_char pt_ucntl; 113 struct tty *pt_tty; 114 struct cdev *devs, *devc; 115 struct prison *pt_prison; 116}; 117 118#define PF_PKT 0x08 /* packet mode */ 119#define PF_STOPPED 0x10 /* user told stopped */
|
120#define PF_REMOTE 0x20 /* remote and flow controlled input */
| |
121#define PF_NOSTOP 0x40 122#define PF_UCNTL 0x80 /* user control mode */ 123 124#define TSA_PTC_READ(tp) ((void *)&(tp)->t_outq.c_cf) 125#define TSA_PTC_WRITE(tp) ((void *)&(tp)->t_rawq.c_cl) 126#define TSA_PTS_READ(tp) ((void *)&(tp)->t_canq) 127 128static char *names = "pqrsPQRS"; 129/* 130 * This function creates and initializes a pts/ptc pair 131 * 132 * pts == /dev/tty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv] 133 * ptc == /dev/pty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv] 134 * 135 * XXX: define and add mapping of upper minor bits to allow more 136 * than 256 ptys. 137 */ 138static struct cdev * 139ptyinit(struct cdev *devc) 140{ 141 struct cdev *devs; 142 struct ptsc *pt; 143 int n; 144 145 n = minor(devc); 146 /* For now we only map the lower 8 bits of the minor */ 147 if (n & ~0xff) 148 return (NULL); 149 150 devc->si_flags &= ~SI_CHEAPCLONE; 151 152 pt = malloc(sizeof(*pt), M_PTY, M_WAITOK | M_ZERO); 153 pt->devs = devs = make_dev(&pts_cdevsw, n, 154 UID_ROOT, GID_WHEEL, 0666, "tty%c%r", names[n / 32], n % 32); 155 pt->devc = devc; 156 157 pt->pt_tty = ttymalloc(pt->pt_tty); 158 devs->si_drv1 = devc->si_drv1 = pt; 159 devs->si_tty = devc->si_tty = pt->pt_tty; 160 pt->pt_tty->t_dev = devs; 161 return (devc); 162} 163 164/*ARGSUSED*/ 165static int 166ptsopen(struct cdev *dev, int flag, int devtype, struct thread *td) 167{ 168 struct tty *tp; 169 int error; 170 struct ptsc *pt; 171 172 if (!dev->si_drv1) 173 return(ENXIO); 174 pt = dev->si_drv1; 175 tp = dev->si_tty; 176 if ((tp->t_state & TS_ISOPEN) == 0) { 177 ttychars(tp); /* Set up default chars */ 178 tp->t_iflag = TTYDEF_IFLAG; 179 tp->t_oflag = TTYDEF_OFLAG; 180 tp->t_lflag = TTYDEF_LFLAG; 181 tp->t_cflag = TTYDEF_CFLAG; 182 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; 183 } else if (tp->t_state & TS_XCLUDE && suser(td)) 184 return (EBUSY); 185 else if (pt->pt_prison != td->td_ucred->cr_prison) 186 return (EBUSY); 187 if (tp->t_oproc) /* Ctrlr still around. */ 188 (void)ttyld_modem(tp, 1); 189 while ((tp->t_state & TS_CARR_ON) == 0) { 190 if (flag&FNONBLOCK) 191 break; 192 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH, 193 "ptsopn", 0); 194 if (error) 195 return (error); 196 } 197 error = ttyld_open(tp, dev); 198 if (error == 0) 199 ptcwakeup(tp, FREAD|FWRITE); 200 return (error); 201} 202 203static int 204ptsclose(struct cdev *dev, int flag, int mode, struct thread *td) 205{ 206 struct tty *tp; 207 int err; 208 209 tp = dev->si_tty; 210 err = ttyld_close(tp, flag); 211 (void) ttyclose(tp); 212 return (err); 213} 214 215static int 216ptsread(struct cdev *dev, struct uio *uio, int flag) 217{ 218 struct thread *td = curthread; 219 struct proc *p = td->td_proc; 220 struct tty *tp = dev->si_tty; 221 struct ptsc *pt = dev->si_drv1; 222 struct pgrp *pg; 223 int error = 0; 224 225again:
| 120#define PF_NOSTOP 0x40 121#define PF_UCNTL 0x80 /* user control mode */ 122 123#define TSA_PTC_READ(tp) ((void *)&(tp)->t_outq.c_cf) 124#define TSA_PTC_WRITE(tp) ((void *)&(tp)->t_rawq.c_cl) 125#define TSA_PTS_READ(tp) ((void *)&(tp)->t_canq) 126 127static char *names = "pqrsPQRS"; 128/* 129 * This function creates and initializes a pts/ptc pair 130 * 131 * pts == /dev/tty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv] 132 * ptc == /dev/pty[pqrsPQRS][0123456789abcdefghijklmnopqrstuv] 133 * 134 * XXX: define and add mapping of upper minor bits to allow more 135 * than 256 ptys. 136 */ 137static struct cdev * 138ptyinit(struct cdev *devc) 139{ 140 struct cdev *devs; 141 struct ptsc *pt; 142 int n; 143 144 n = minor(devc); 145 /* For now we only map the lower 8 bits of the minor */ 146 if (n & ~0xff) 147 return (NULL); 148 149 devc->si_flags &= ~SI_CHEAPCLONE; 150 151 pt = malloc(sizeof(*pt), M_PTY, M_WAITOK | M_ZERO); 152 pt->devs = devs = make_dev(&pts_cdevsw, n, 153 UID_ROOT, GID_WHEEL, 0666, "tty%c%r", names[n / 32], n % 32); 154 pt->devc = devc; 155 156 pt->pt_tty = ttymalloc(pt->pt_tty); 157 devs->si_drv1 = devc->si_drv1 = pt; 158 devs->si_tty = devc->si_tty = pt->pt_tty; 159 pt->pt_tty->t_dev = devs; 160 return (devc); 161} 162 163/*ARGSUSED*/ 164static int 165ptsopen(struct cdev *dev, int flag, int devtype, struct thread *td) 166{ 167 struct tty *tp; 168 int error; 169 struct ptsc *pt; 170 171 if (!dev->si_drv1) 172 return(ENXIO); 173 pt = dev->si_drv1; 174 tp = dev->si_tty; 175 if ((tp->t_state & TS_ISOPEN) == 0) { 176 ttychars(tp); /* Set up default chars */ 177 tp->t_iflag = TTYDEF_IFLAG; 178 tp->t_oflag = TTYDEF_OFLAG; 179 tp->t_lflag = TTYDEF_LFLAG; 180 tp->t_cflag = TTYDEF_CFLAG; 181 tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; 182 } else if (tp->t_state & TS_XCLUDE && suser(td)) 183 return (EBUSY); 184 else if (pt->pt_prison != td->td_ucred->cr_prison) 185 return (EBUSY); 186 if (tp->t_oproc) /* Ctrlr still around. */ 187 (void)ttyld_modem(tp, 1); 188 while ((tp->t_state & TS_CARR_ON) == 0) { 189 if (flag&FNONBLOCK) 190 break; 191 error = ttysleep(tp, TSA_CARR_ON(tp), TTIPRI | PCATCH, 192 "ptsopn", 0); 193 if (error) 194 return (error); 195 } 196 error = ttyld_open(tp, dev); 197 if (error == 0) 198 ptcwakeup(tp, FREAD|FWRITE); 199 return (error); 200} 201 202static int 203ptsclose(struct cdev *dev, int flag, int mode, struct thread *td) 204{ 205 struct tty *tp; 206 int err; 207 208 tp = dev->si_tty; 209 err = ttyld_close(tp, flag); 210 (void) ttyclose(tp); 211 return (err); 212} 213 214static int 215ptsread(struct cdev *dev, struct uio *uio, int flag) 216{ 217 struct thread *td = curthread; 218 struct proc *p = td->td_proc; 219 struct tty *tp = dev->si_tty; 220 struct ptsc *pt = dev->si_drv1; 221 struct pgrp *pg; 222 int error = 0; 223 224again:
|
226 if (pt->pt_flags & PF_REMOTE) { 227 while (isbackground(p, tp)) { 228 sx_slock(&proctree_lock); 229 PROC_LOCK(p); 230 if (SIGISMEMBER(p->p_sigacts->ps_sigignore, SIGTTIN) || 231 SIGISMEMBER(td->td_sigmask, SIGTTIN) || 232 p->p_pgrp->pg_jobc == 0 || p->p_flag & P_PPWAIT) { 233 PROC_UNLOCK(p); 234 sx_sunlock(&proctree_lock); 235 return (EIO); 236 } 237 pg = p->p_pgrp; 238 PROC_UNLOCK(p); 239 PGRP_LOCK(pg); 240 sx_sunlock(&proctree_lock); 241 pgsignal(pg, SIGTTIN, 1); 242 PGRP_UNLOCK(pg); 243 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ptsbg", 244 0); 245 if (error) 246 return (error); 247 } 248 if (tp->t_canq.c_cc == 0) { 249 if (flag & IO_NDELAY) 250 return (EWOULDBLOCK); 251 error = ttysleep(tp, TSA_PTS_READ(tp), TTIPRI | PCATCH, 252 "ptsin", 0); 253 if (error) 254 return (error); 255 goto again; 256 } 257 while (tp->t_canq.c_cc > 1 && uio->uio_resid > 0) 258 if (ureadc(getc(&tp->t_canq), uio) < 0) { 259 error = EFAULT; 260 break; 261 } 262 if (tp->t_canq.c_cc == 1) 263 (void) getc(&tp->t_canq); 264 if (tp->t_canq.c_cc) 265 return (error); 266 } else 267 if (tp->t_oproc) 268 error = ttyld_read(tp, uio, flag);
| 225 if (tp->t_oproc) 226 error = ttyld_read(tp, uio, flag);
|
269 ptcwakeup(tp, FWRITE); 270 return (error); 271} 272 273/* 274 * Write to pseudo-tty. 275 * Wakeups of controlling tty will happen 276 * indirectly, when tty driver calls ptsstart. 277 */ 278static int 279ptswrite(struct cdev *dev, struct uio *uio, int flag) 280{ 281 struct tty *tp; 282 283 tp = dev->si_tty; 284 if (tp->t_oproc == 0) 285 return (EIO); 286 return (ttyld_write(tp, uio, flag)); 287} 288 289/* 290 * Start output on pseudo-tty. 291 * Wake up process selecting or sleeping for input from controlling tty. 292 */ 293static void 294ptsstart(struct tty *tp) 295{ 296 struct ptsc *pt = tp->t_dev->si_drv1; 297 298 if (tp->t_state & TS_TTSTOP) 299 return; 300 if (pt->pt_flags & PF_STOPPED) { 301 pt->pt_flags &= ~PF_STOPPED; 302 pt->pt_send = TIOCPKT_START; 303 } 304 ptcwakeup(tp, FREAD); 305} 306 307static void 308ptcwakeup(struct tty *tp, int flag) 309{ 310 struct ptsc *pt = tp->t_dev->si_drv1; 311 312 if (flag & FREAD) { 313 selwakeuppri(&pt->pt_selr, TTIPRI); 314 wakeup(TSA_PTC_READ(tp)); 315 } 316 if (flag & FWRITE) { 317 selwakeuppri(&pt->pt_selw, TTOPRI); 318 wakeup(TSA_PTC_WRITE(tp)); 319 } 320} 321 322static int 323ptcopen(struct cdev *dev, int flag, int devtype, struct thread *td) 324{ 325 struct tty *tp; 326 struct ptsc *pt; 327 328 if (!dev->si_drv1) 329 ptyinit(dev); 330 if (!dev->si_drv1) 331 return(ENXIO); 332 tp = dev->si_tty; 333 if (tp->t_oproc) 334 return (EIO); 335 tp->t_timeout = -1; 336 tp->t_oproc = ptsstart; 337 tp->t_stop = ptsstop; 338 (void)ttyld_modem(tp, 1); 339 tp->t_lflag &= ~EXTPROC; 340 pt = dev->si_drv1; 341 pt->pt_prison = td->td_ucred->cr_prison; 342 pt->pt_flags = 0; 343 pt->pt_send = 0; 344 pt->pt_ucntl = 0; 345 return (0); 346} 347 348static int 349ptcclose(struct cdev *dev, int flags, int fmt, struct thread *td) 350{ 351 struct tty *tp; 352 353 tp = dev->si_tty; 354 (void)ttyld_modem(tp, 0); 355 356 /* 357 * XXX MDMBUF makes no sense for ptys but would inhibit the above 358 * l_modem(). CLOCAL makes sense but isn't supported. Special 359 * l_modem()s that ignore carrier drop make no sense for ptys but 360 * may be in use because other parts of the line discipline make 361 * sense for ptys. Recover by doing everything that a normal 362 * ttymodem() would have done except for sending a SIGHUP. 363 */ 364 if (tp->t_state & TS_ISOPEN) { 365 tp->t_state &= ~(TS_CARR_ON | TS_CONNECTED); 366 tp->t_state |= TS_ZOMBIE; 367 ttyflush(tp, FREAD | FWRITE); 368 } 369 370 tp->t_oproc = 0; /* mark closed */ 371 return (0); 372} 373 374static int 375ptcread(struct cdev *dev, struct uio *uio, int flag) 376{ 377 struct tty *tp = dev->si_tty; 378 struct ptsc *pt = dev->si_drv1; 379 char buf[BUFSIZ]; 380 int error = 0, cc; 381 382 /* 383 * We want to block until the slave 384 * is open, and there's something to read; 385 * but if we lost the slave or we're NBIO, 386 * then return the appropriate error instead. 387 */ 388 for (;;) { 389 if (tp->t_state&TS_ISOPEN) { 390 if (pt->pt_flags&PF_PKT && pt->pt_send) { 391 error = ureadc((int)pt->pt_send, uio); 392 if (error) 393 return (error); 394 if (pt->pt_send & TIOCPKT_IOCTL) { 395 cc = min(uio->uio_resid, 396 sizeof(tp->t_termios)); 397 uiomove(&tp->t_termios, cc, uio); 398 } 399 pt->pt_send = 0; 400 return (0); 401 } 402 if (pt->pt_flags&PF_UCNTL && pt->pt_ucntl) { 403 error = ureadc((int)pt->pt_ucntl, uio); 404 if (error) 405 return (error); 406 pt->pt_ucntl = 0; 407 return (0); 408 } 409 if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0) 410 break; 411 } 412 if ((tp->t_state & TS_CONNECTED) == 0) 413 return (0); /* EOF */ 414 if (flag & IO_NDELAY) 415 return (EWOULDBLOCK); 416 error = tsleep(TSA_PTC_READ(tp), TTIPRI | PCATCH, "ptcin", 0); 417 if (error) 418 return (error); 419 } 420 if (pt->pt_flags & (PF_PKT|PF_UCNTL)) 421 error = ureadc(0, uio); 422 while (uio->uio_resid > 0 && error == 0) { 423 cc = q_to_b(&tp->t_outq, buf, min(uio->uio_resid, BUFSIZ)); 424 if (cc <= 0) 425 break; 426 error = uiomove(buf, cc, uio); 427 } 428 ttwwakeup(tp); 429 return (error); 430} 431 432static void 433ptsstop(struct tty *tp, int flush) 434{ 435 struct ptsc *pt = tp->t_dev->si_drv1; 436 int flag; 437 438 /* note: FLUSHREAD and FLUSHWRITE already ok */ 439 if (flush == 0) { 440 flush = TIOCPKT_STOP; 441 pt->pt_flags |= PF_STOPPED; 442 } else 443 pt->pt_flags &= ~PF_STOPPED; 444 pt->pt_send |= flush; 445 /* change of perspective */ 446 flag = 0; 447 if (flush & FREAD) 448 flag |= FWRITE; 449 if (flush & FWRITE) 450 flag |= FREAD; 451 ptcwakeup(tp, flag); 452} 453 454static int 455ptcpoll(struct cdev *dev, int events, struct thread *td) 456{ 457 struct tty *tp = dev->si_tty; 458 struct ptsc *pt = dev->si_drv1; 459 int revents = 0; 460 int s; 461 462 if ((tp->t_state & TS_CONNECTED) == 0) 463 return (events & 464 (POLLHUP | POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM)); 465 466 /* 467 * Need to block timeouts (ttrstart). 468 */ 469 s = spltty(); 470 471 if (events & (POLLIN | POLLRDNORM)) 472 if ((tp->t_state & TS_ISOPEN) && 473 ((tp->t_outq.c_cc && (tp->t_state & TS_TTSTOP) == 0) || 474 ((pt->pt_flags & PF_PKT) && pt->pt_send) || 475 ((pt->pt_flags & PF_UCNTL) && pt->pt_ucntl))) 476 revents |= events & (POLLIN | POLLRDNORM); 477 478 if (events & (POLLOUT | POLLWRNORM)) 479 if (tp->t_state & TS_ISOPEN &&
| 227 ptcwakeup(tp, FWRITE); 228 return (error); 229} 230 231/* 232 * Write to pseudo-tty. 233 * Wakeups of controlling tty will happen 234 * indirectly, when tty driver calls ptsstart. 235 */ 236static int 237ptswrite(struct cdev *dev, struct uio *uio, int flag) 238{ 239 struct tty *tp; 240 241 tp = dev->si_tty; 242 if (tp->t_oproc == 0) 243 return (EIO); 244 return (ttyld_write(tp, uio, flag)); 245} 246 247/* 248 * Start output on pseudo-tty. 249 * Wake up process selecting or sleeping for input from controlling tty. 250 */ 251static void 252ptsstart(struct tty *tp) 253{ 254 struct ptsc *pt = tp->t_dev->si_drv1; 255 256 if (tp->t_state & TS_TTSTOP) 257 return; 258 if (pt->pt_flags & PF_STOPPED) { 259 pt->pt_flags &= ~PF_STOPPED; 260 pt->pt_send = TIOCPKT_START; 261 } 262 ptcwakeup(tp, FREAD); 263} 264 265static void 266ptcwakeup(struct tty *tp, int flag) 267{ 268 struct ptsc *pt = tp->t_dev->si_drv1; 269 270 if (flag & FREAD) { 271 selwakeuppri(&pt->pt_selr, TTIPRI); 272 wakeup(TSA_PTC_READ(tp)); 273 } 274 if (flag & FWRITE) { 275 selwakeuppri(&pt->pt_selw, TTOPRI); 276 wakeup(TSA_PTC_WRITE(tp)); 277 } 278} 279 280static int 281ptcopen(struct cdev *dev, int flag, int devtype, struct thread *td) 282{ 283 struct tty *tp; 284 struct ptsc *pt; 285 286 if (!dev->si_drv1) 287 ptyinit(dev); 288 if (!dev->si_drv1) 289 return(ENXIO); 290 tp = dev->si_tty; 291 if (tp->t_oproc) 292 return (EIO); 293 tp->t_timeout = -1; 294 tp->t_oproc = ptsstart; 295 tp->t_stop = ptsstop; 296 (void)ttyld_modem(tp, 1); 297 tp->t_lflag &= ~EXTPROC; 298 pt = dev->si_drv1; 299 pt->pt_prison = td->td_ucred->cr_prison; 300 pt->pt_flags = 0; 301 pt->pt_send = 0; 302 pt->pt_ucntl = 0; 303 return (0); 304} 305 306static int 307ptcclose(struct cdev *dev, int flags, int fmt, struct thread *td) 308{ 309 struct tty *tp; 310 311 tp = dev->si_tty; 312 (void)ttyld_modem(tp, 0); 313 314 /* 315 * XXX MDMBUF makes no sense for ptys but would inhibit the above 316 * l_modem(). CLOCAL makes sense but isn't supported. Special 317 * l_modem()s that ignore carrier drop make no sense for ptys but 318 * may be in use because other parts of the line discipline make 319 * sense for ptys. Recover by doing everything that a normal 320 * ttymodem() would have done except for sending a SIGHUP. 321 */ 322 if (tp->t_state & TS_ISOPEN) { 323 tp->t_state &= ~(TS_CARR_ON | TS_CONNECTED); 324 tp->t_state |= TS_ZOMBIE; 325 ttyflush(tp, FREAD | FWRITE); 326 } 327 328 tp->t_oproc = 0; /* mark closed */ 329 return (0); 330} 331 332static int 333ptcread(struct cdev *dev, struct uio *uio, int flag) 334{ 335 struct tty *tp = dev->si_tty; 336 struct ptsc *pt = dev->si_drv1; 337 char buf[BUFSIZ]; 338 int error = 0, cc; 339 340 /* 341 * We want to block until the slave 342 * is open, and there's something to read; 343 * but if we lost the slave or we're NBIO, 344 * then return the appropriate error instead. 345 */ 346 for (;;) { 347 if (tp->t_state&TS_ISOPEN) { 348 if (pt->pt_flags&PF_PKT && pt->pt_send) { 349 error = ureadc((int)pt->pt_send, uio); 350 if (error) 351 return (error); 352 if (pt->pt_send & TIOCPKT_IOCTL) { 353 cc = min(uio->uio_resid, 354 sizeof(tp->t_termios)); 355 uiomove(&tp->t_termios, cc, uio); 356 } 357 pt->pt_send = 0; 358 return (0); 359 } 360 if (pt->pt_flags&PF_UCNTL && pt->pt_ucntl) { 361 error = ureadc((int)pt->pt_ucntl, uio); 362 if (error) 363 return (error); 364 pt->pt_ucntl = 0; 365 return (0); 366 } 367 if (tp->t_outq.c_cc && (tp->t_state&TS_TTSTOP) == 0) 368 break; 369 } 370 if ((tp->t_state & TS_CONNECTED) == 0) 371 return (0); /* EOF */ 372 if (flag & IO_NDELAY) 373 return (EWOULDBLOCK); 374 error = tsleep(TSA_PTC_READ(tp), TTIPRI | PCATCH, "ptcin", 0); 375 if (error) 376 return (error); 377 } 378 if (pt->pt_flags & (PF_PKT|PF_UCNTL)) 379 error = ureadc(0, uio); 380 while (uio->uio_resid > 0 && error == 0) { 381 cc = q_to_b(&tp->t_outq, buf, min(uio->uio_resid, BUFSIZ)); 382 if (cc <= 0) 383 break; 384 error = uiomove(buf, cc, uio); 385 } 386 ttwwakeup(tp); 387 return (error); 388} 389 390static void 391ptsstop(struct tty *tp, int flush) 392{ 393 struct ptsc *pt = tp->t_dev->si_drv1; 394 int flag; 395 396 /* note: FLUSHREAD and FLUSHWRITE already ok */ 397 if (flush == 0) { 398 flush = TIOCPKT_STOP; 399 pt->pt_flags |= PF_STOPPED; 400 } else 401 pt->pt_flags &= ~PF_STOPPED; 402 pt->pt_send |= flush; 403 /* change of perspective */ 404 flag = 0; 405 if (flush & FREAD) 406 flag |= FWRITE; 407 if (flush & FWRITE) 408 flag |= FREAD; 409 ptcwakeup(tp, flag); 410} 411 412static int 413ptcpoll(struct cdev *dev, int events, struct thread *td) 414{ 415 struct tty *tp = dev->si_tty; 416 struct ptsc *pt = dev->si_drv1; 417 int revents = 0; 418 int s; 419 420 if ((tp->t_state & TS_CONNECTED) == 0) 421 return (events & 422 (POLLHUP | POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM)); 423 424 /* 425 * Need to block timeouts (ttrstart). 426 */ 427 s = spltty(); 428 429 if (events & (POLLIN | POLLRDNORM)) 430 if ((tp->t_state & TS_ISOPEN) && 431 ((tp->t_outq.c_cc && (tp->t_state & TS_TTSTOP) == 0) || 432 ((pt->pt_flags & PF_PKT) && pt->pt_send) || 433 ((pt->pt_flags & PF_UCNTL) && pt->pt_ucntl))) 434 revents |= events & (POLLIN | POLLRDNORM); 435 436 if (events & (POLLOUT | POLLWRNORM)) 437 if (tp->t_state & TS_ISOPEN &&
|
480 ((pt->pt_flags & PF_REMOTE) ? 481 (tp->t_canq.c_cc == 0) : 482 ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG - 2) ||
| 438 (((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG - 2) ||
|
483 (tp->t_canq.c_cc == 0 && (tp->t_lflag & ICANON))))) 484 revents |= events & (POLLOUT | POLLWRNORM); 485 486 if (events & POLLHUP) 487 if ((tp->t_state & TS_CARR_ON) == 0) 488 revents |= POLLHUP; 489 490 if (revents == 0) { 491 if (events & (POLLIN | POLLRDNORM)) 492 selrecord(td, &pt->pt_selr); 493 494 if (events & (POLLOUT | POLLWRNORM)) 495 selrecord(td, &pt->pt_selw); 496 } 497 splx(s); 498 499 return (revents); 500} 501 502static int 503ptcwrite(struct cdev *dev, struct uio *uio, int flag) 504{ 505 struct tty *tp = dev->si_tty; 506 u_char *cp = 0; 507 int cc = 0; 508 u_char locbuf[BUFSIZ]; 509 int cnt = 0; 510 struct ptsc *pt = dev->si_drv1; 511 int error = 0; 512 513again: 514 if ((tp->t_state&TS_ISOPEN) == 0) 515 goto block;
| 439 (tp->t_canq.c_cc == 0 && (tp->t_lflag & ICANON))))) 440 revents |= events & (POLLOUT | POLLWRNORM); 441 442 if (events & POLLHUP) 443 if ((tp->t_state & TS_CARR_ON) == 0) 444 revents |= POLLHUP; 445 446 if (revents == 0) { 447 if (events & (POLLIN | POLLRDNORM)) 448 selrecord(td, &pt->pt_selr); 449 450 if (events & (POLLOUT | POLLWRNORM)) 451 selrecord(td, &pt->pt_selw); 452 } 453 splx(s); 454 455 return (revents); 456} 457 458static int 459ptcwrite(struct cdev *dev, struct uio *uio, int flag) 460{ 461 struct tty *tp = dev->si_tty; 462 u_char *cp = 0; 463 int cc = 0; 464 u_char locbuf[BUFSIZ]; 465 int cnt = 0; 466 struct ptsc *pt = dev->si_drv1; 467 int error = 0; 468 469again: 470 if ((tp->t_state&TS_ISOPEN) == 0) 471 goto block;
|
516 if (pt->pt_flags & PF_REMOTE) { 517 if (tp->t_canq.c_cc) 518 goto block; 519 while ((uio->uio_resid > 0 || cc > 0) && 520 tp->t_canq.c_cc < TTYHOG - 1) { 521 if (cc == 0) { 522 cc = min(uio->uio_resid, BUFSIZ); 523 cc = min(cc, TTYHOG - 1 - tp->t_canq.c_cc); 524 cp = locbuf; 525 error = uiomove(cp, cc, uio); 526 if (error) 527 return (error); 528 /* check again for safety */ 529 if ((tp->t_state & TS_ISOPEN) == 0) { 530 /* adjust as usual */ 531 uio->uio_resid += cc; 532 return (EIO); 533 } 534 } 535 if (cc > 0) { 536 cc = b_to_q((char *)cp, cc, &tp->t_canq); 537 /* 538 * XXX we don't guarantee that the canq size 539 * is >= TTYHOG, so the above b_to_q() may 540 * leave some bytes uncopied. However, space 541 * is guaranteed for the null terminator if 542 * we don't fail here since (TTYHOG - 1) is 543 * not a multiple of CBSIZE. 544 */ 545 if (cc > 0) 546 break; 547 } 548 } 549 /* adjust for data copied in but not written */ 550 uio->uio_resid += cc; 551 (void) putc(0, &tp->t_canq); 552 ttwakeup(tp); 553 wakeup(TSA_PTS_READ(tp)); 554 return (0); 555 }
| |
556 while (uio->uio_resid > 0 || cc > 0) { 557 if (cc == 0) { 558 cc = min(uio->uio_resid, BUFSIZ); 559 cp = locbuf; 560 error = uiomove(cp, cc, uio); 561 if (error) 562 return (error); 563 /* check again for safety */ 564 if ((tp->t_state & TS_ISOPEN) == 0) { 565 /* adjust for data copied in but not written */ 566 uio->uio_resid += cc; 567 return (EIO); 568 } 569 } 570 while (cc > 0) { 571 if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 && 572 (tp->t_canq.c_cc > 0 || !(tp->t_lflag&ICANON))) { 573 wakeup(TSA_HUP_OR_INPUT(tp)); 574 goto block; 575 } 576 ttyld_rint(tp, *cp++); 577 cnt++; 578 cc--; 579 } 580 cc = 0; 581 } 582 return (0); 583block: 584 /* 585 * Come here to wait for slave to open, for space 586 * in outq, or space in rawq, or an empty canq. 587 */ 588 if ((tp->t_state & TS_CONNECTED) == 0) { 589 /* adjust for data copied in but not written */ 590 uio->uio_resid += cc; 591 return (EIO); 592 } 593 if (flag & IO_NDELAY) { 594 /* adjust for data copied in but not written */ 595 uio->uio_resid += cc; 596 if (cnt == 0) 597 return (EWOULDBLOCK); 598 return (0); 599 } 600 error = tsleep(TSA_PTC_WRITE(tp), TTOPRI | PCATCH, "ptcout", 0); 601 if (error) { 602 /* adjust for data copied in but not written */ 603 uio->uio_resid += cc; 604 return (error); 605 } 606 goto again; 607} 608 609/*ARGSUSED*/ 610static int 611ptyioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td) 612{ 613 struct tty *tp = dev->si_tty; 614 struct ptsc *pt = dev->si_drv1; 615 u_char *cc = tp->t_cc; 616 int stop, error; 617 618 if (devsw(dev)->d_open == ptcopen) { 619 switch (cmd) { 620 621 case TIOCGPGRP: 622 /* 623 * We avoid calling ttioctl on the controller since, 624 * in that case, tp must be the controlling terminal. 625 */ 626 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0; 627 return (0); 628 629 case TIOCPKT: 630 if (*(int *)data) { 631 if (pt->pt_flags & PF_UCNTL) 632 return (EINVAL); 633 pt->pt_flags |= PF_PKT; 634 } else 635 pt->pt_flags &= ~PF_PKT; 636 return (0); 637 638 case TIOCUCNTL: 639 if (*(int *)data) { 640 if (pt->pt_flags & PF_PKT) 641 return (EINVAL); 642 pt->pt_flags |= PF_UCNTL; 643 } else 644 pt->pt_flags &= ~PF_UCNTL; 645 return (0);
| 472 while (uio->uio_resid > 0 || cc > 0) { 473 if (cc == 0) { 474 cc = min(uio->uio_resid, BUFSIZ); 475 cp = locbuf; 476 error = uiomove(cp, cc, uio); 477 if (error) 478 return (error); 479 /* check again for safety */ 480 if ((tp->t_state & TS_ISOPEN) == 0) { 481 /* adjust for data copied in but not written */ 482 uio->uio_resid += cc; 483 return (EIO); 484 } 485 } 486 while (cc > 0) { 487 if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG - 2 && 488 (tp->t_canq.c_cc > 0 || !(tp->t_lflag&ICANON))) { 489 wakeup(TSA_HUP_OR_INPUT(tp)); 490 goto block; 491 } 492 ttyld_rint(tp, *cp++); 493 cnt++; 494 cc--; 495 } 496 cc = 0; 497 } 498 return (0); 499block: 500 /* 501 * Come here to wait for slave to open, for space 502 * in outq, or space in rawq, or an empty canq. 503 */ 504 if ((tp->t_state & TS_CONNECTED) == 0) { 505 /* adjust for data copied in but not written */ 506 uio->uio_resid += cc; 507 return (EIO); 508 } 509 if (flag & IO_NDELAY) { 510 /* adjust for data copied in but not written */ 511 uio->uio_resid += cc; 512 if (cnt == 0) 513 return (EWOULDBLOCK); 514 return (0); 515 } 516 error = tsleep(TSA_PTC_WRITE(tp), TTOPRI | PCATCH, "ptcout", 0); 517 if (error) { 518 /* adjust for data copied in but not written */ 519 uio->uio_resid += cc; 520 return (error); 521 } 522 goto again; 523} 524 525/*ARGSUSED*/ 526static int 527ptyioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td) 528{ 529 struct tty *tp = dev->si_tty; 530 struct ptsc *pt = dev->si_drv1; 531 u_char *cc = tp->t_cc; 532 int stop, error; 533 534 if (devsw(dev)->d_open == ptcopen) { 535 switch (cmd) { 536 537 case TIOCGPGRP: 538 /* 539 * We avoid calling ttioctl on the controller since, 540 * in that case, tp must be the controlling terminal. 541 */ 542 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0; 543 return (0); 544 545 case TIOCPKT: 546 if (*(int *)data) { 547 if (pt->pt_flags & PF_UCNTL) 548 return (EINVAL); 549 pt->pt_flags |= PF_PKT; 550 } else 551 pt->pt_flags &= ~PF_PKT; 552 return (0); 553 554 case TIOCUCNTL: 555 if (*(int *)data) { 556 if (pt->pt_flags & PF_PKT) 557 return (EINVAL); 558 pt->pt_flags |= PF_UCNTL; 559 } else 560 pt->pt_flags &= ~PF_UCNTL; 561 return (0);
|
646 647 case TIOCREMOTE: 648 if (*(int *)data) 649 pt->pt_flags |= PF_REMOTE; 650 else 651 pt->pt_flags &= ~PF_REMOTE; 652 ttyflush(tp, FREAD|FWRITE); 653 return (0);
| |
654 } 655 656 /* 657 * The rest of the ioctls shouldn't be called until 658 * the slave is open. 659 */ 660 if ((tp->t_state & TS_ISOPEN) == 0) 661 return (EAGAIN); 662 663 switch (cmd) { 664#ifndef BURN_BRIDGES 665#ifdef COMPAT_43 666 case TIOCSETP: 667 case TIOCSETN: 668#endif 669#endif 670 case TIOCSETD: 671 case TIOCSETA: 672 case TIOCSETAW: 673 case TIOCSETAF: 674 /* 675 * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG. 676 * ttywflush(tp) will hang if there are characters in 677 * the outq. 678 */ 679 ndflush(&tp->t_outq, tp->t_outq.c_cc); 680 break; 681 682 case TIOCSIG: 683 if (*(unsigned int *)data >= NSIG || 684 *(unsigned int *)data == 0) 685 return(EINVAL); 686 if ((tp->t_lflag&NOFLSH) == 0) 687 ttyflush(tp, FREAD|FWRITE); 688 if (tp->t_pgrp != NULL) { 689 PGRP_LOCK(tp->t_pgrp); 690 pgsignal(tp->t_pgrp, *(unsigned int *)data, 1); 691 PGRP_UNLOCK(tp->t_pgrp); 692 } 693 if ((*(unsigned int *)data == SIGINFO) && 694 ((tp->t_lflag&NOKERNINFO) == 0)) 695 ttyinfo(tp); 696 return(0); 697 } 698 } 699 if (cmd == TIOCEXT) { 700 /* 701 * When the EXTPROC bit is being toggled, we need 702 * to send an TIOCPKT_IOCTL if the packet driver 703 * is turned on. 704 */ 705 if (*(int *)data) { 706 if (pt->pt_flags & PF_PKT) { 707 pt->pt_send |= TIOCPKT_IOCTL; 708 ptcwakeup(tp, FREAD); 709 } 710 tp->t_lflag |= EXTPROC; 711 } else { 712 if ((tp->t_lflag & EXTPROC) && 713 (pt->pt_flags & PF_PKT)) { 714 pt->pt_send |= TIOCPKT_IOCTL; 715 ptcwakeup(tp, FREAD); 716 } 717 tp->t_lflag &= ~EXTPROC; 718 } 719 return(0); 720 } 721 error = ttyioctl(dev, cmd, data, flag, td); 722 if (error == ENOTTY) { 723 if (pt->pt_flags & PF_UCNTL && 724 (cmd & ~0xff) == UIOCCMD(0)) { 725 if (cmd & 0xff) { 726 pt->pt_ucntl = (u_char)cmd; 727 ptcwakeup(tp, FREAD); 728 } 729 return (0); 730 } 731 error = ENOTTY; 732 } 733 /* 734 * If external processing and packet mode send ioctl packet. 735 */ 736 if ((tp->t_lflag&EXTPROC) && (pt->pt_flags & PF_PKT)) { 737 switch(cmd) { 738 case TIOCSETA: 739 case TIOCSETAW: 740 case TIOCSETAF: 741#ifndef BURN_BRIDGES 742#ifdef COMPAT_43 743 case TIOCSETP: 744 case TIOCSETN: 745 case TIOCSETC: 746 case TIOCSLTC: 747 case TIOCLBIS: 748 case TIOCLBIC: 749 case TIOCLSET: 750#endif 751#endif 752 pt->pt_send |= TIOCPKT_IOCTL; 753 ptcwakeup(tp, FREAD); 754 break; 755 default: 756 break; 757 } 758 } 759 stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s')) 760 && CCEQ(cc[VSTART], CTRL('q')); 761 if (pt->pt_flags & PF_NOSTOP) { 762 if (stop) { 763 pt->pt_send &= ~TIOCPKT_NOSTOP; 764 pt->pt_send |= TIOCPKT_DOSTOP; 765 pt->pt_flags &= ~PF_NOSTOP; 766 ptcwakeup(tp, FREAD); 767 } 768 } else { 769 if (!stop) { 770 pt->pt_send &= ~TIOCPKT_DOSTOP; 771 pt->pt_send |= TIOCPKT_NOSTOP; 772 pt->pt_flags |= PF_NOSTOP; 773 ptcwakeup(tp, FREAD); 774 } 775 } 776 return (error); 777} 778 779static void 780pty_clone(void *arg, char *name, int namelen, struct cdev **dev) 781{ 782 int u; 783 784 if (*dev != NULL) 785 return; 786 if (bcmp(name, "pty", 3) != 0) 787 return; 788 if (name[5] != '\0') 789 return; 790 switch (name[3]) { 791 case 'p': u = 0; break; 792 case 'q': u = 32; break; 793 case 'r': u = 64; break; 794 case 's': u = 96; break; 795 case 'P': u = 128; break; 796 case 'Q': u = 160; break; 797 case 'R': u = 192; break; 798 case 'S': u = 224; break; 799 default: return; 800 } 801 if (name[4] >= '0' && name[4] <= '9') 802 u += name[4] - '0'; 803 else if (name[4] >= 'a' && name[4] <= 'v') 804 u += name[4] - 'a' + 10; 805 else 806 return; 807 *dev = make_dev(&ptc_cdevsw, u, 808 UID_ROOT, GID_WHEEL, 0666, "pty%c%r", names[u / 32], u % 32); 809 (*dev)->si_flags |= SI_CHEAPCLONE; 810 return; 811} 812 813static void 814ptc_drvinit(void *unused) 815{ 816 817 EVENTHANDLER_REGISTER(dev_clone, pty_clone, 0, 1000); 818} 819 820SYSINIT(ptcdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR_C,ptc_drvinit,NULL)
| 562 } 563 564 /* 565 * The rest of the ioctls shouldn't be called until 566 * the slave is open. 567 */ 568 if ((tp->t_state & TS_ISOPEN) == 0) 569 return (EAGAIN); 570 571 switch (cmd) { 572#ifndef BURN_BRIDGES 573#ifdef COMPAT_43 574 case TIOCSETP: 575 case TIOCSETN: 576#endif 577#endif 578 case TIOCSETD: 579 case TIOCSETA: 580 case TIOCSETAW: 581 case TIOCSETAF: 582 /* 583 * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG. 584 * ttywflush(tp) will hang if there are characters in 585 * the outq. 586 */ 587 ndflush(&tp->t_outq, tp->t_outq.c_cc); 588 break; 589 590 case TIOCSIG: 591 if (*(unsigned int *)data >= NSIG || 592 *(unsigned int *)data == 0) 593 return(EINVAL); 594 if ((tp->t_lflag&NOFLSH) == 0) 595 ttyflush(tp, FREAD|FWRITE); 596 if (tp->t_pgrp != NULL) { 597 PGRP_LOCK(tp->t_pgrp); 598 pgsignal(tp->t_pgrp, *(unsigned int *)data, 1); 599 PGRP_UNLOCK(tp->t_pgrp); 600 } 601 if ((*(unsigned int *)data == SIGINFO) && 602 ((tp->t_lflag&NOKERNINFO) == 0)) 603 ttyinfo(tp); 604 return(0); 605 } 606 } 607 if (cmd == TIOCEXT) { 608 /* 609 * When the EXTPROC bit is being toggled, we need 610 * to send an TIOCPKT_IOCTL if the packet driver 611 * is turned on. 612 */ 613 if (*(int *)data) { 614 if (pt->pt_flags & PF_PKT) { 615 pt->pt_send |= TIOCPKT_IOCTL; 616 ptcwakeup(tp, FREAD); 617 } 618 tp->t_lflag |= EXTPROC; 619 } else { 620 if ((tp->t_lflag & EXTPROC) && 621 (pt->pt_flags & PF_PKT)) { 622 pt->pt_send |= TIOCPKT_IOCTL; 623 ptcwakeup(tp, FREAD); 624 } 625 tp->t_lflag &= ~EXTPROC; 626 } 627 return(0); 628 } 629 error = ttyioctl(dev, cmd, data, flag, td); 630 if (error == ENOTTY) { 631 if (pt->pt_flags & PF_UCNTL && 632 (cmd & ~0xff) == UIOCCMD(0)) { 633 if (cmd & 0xff) { 634 pt->pt_ucntl = (u_char)cmd; 635 ptcwakeup(tp, FREAD); 636 } 637 return (0); 638 } 639 error = ENOTTY; 640 } 641 /* 642 * If external processing and packet mode send ioctl packet. 643 */ 644 if ((tp->t_lflag&EXTPROC) && (pt->pt_flags & PF_PKT)) { 645 switch(cmd) { 646 case TIOCSETA: 647 case TIOCSETAW: 648 case TIOCSETAF: 649#ifndef BURN_BRIDGES 650#ifdef COMPAT_43 651 case TIOCSETP: 652 case TIOCSETN: 653 case TIOCSETC: 654 case TIOCSLTC: 655 case TIOCLBIS: 656 case TIOCLBIC: 657 case TIOCLSET: 658#endif 659#endif 660 pt->pt_send |= TIOCPKT_IOCTL; 661 ptcwakeup(tp, FREAD); 662 break; 663 default: 664 break; 665 } 666 } 667 stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s')) 668 && CCEQ(cc[VSTART], CTRL('q')); 669 if (pt->pt_flags & PF_NOSTOP) { 670 if (stop) { 671 pt->pt_send &= ~TIOCPKT_NOSTOP; 672 pt->pt_send |= TIOCPKT_DOSTOP; 673 pt->pt_flags &= ~PF_NOSTOP; 674 ptcwakeup(tp, FREAD); 675 } 676 } else { 677 if (!stop) { 678 pt->pt_send &= ~TIOCPKT_DOSTOP; 679 pt->pt_send |= TIOCPKT_NOSTOP; 680 pt->pt_flags |= PF_NOSTOP; 681 ptcwakeup(tp, FREAD); 682 } 683 } 684 return (error); 685} 686 687static void 688pty_clone(void *arg, char *name, int namelen, struct cdev **dev) 689{ 690 int u; 691 692 if (*dev != NULL) 693 return; 694 if (bcmp(name, "pty", 3) != 0) 695 return; 696 if (name[5] != '\0') 697 return; 698 switch (name[3]) { 699 case 'p': u = 0; break; 700 case 'q': u = 32; break; 701 case 'r': u = 64; break; 702 case 's': u = 96; break; 703 case 'P': u = 128; break; 704 case 'Q': u = 160; break; 705 case 'R': u = 192; break; 706 case 'S': u = 224; break; 707 default: return; 708 } 709 if (name[4] >= '0' && name[4] <= '9') 710 u += name[4] - '0'; 711 else if (name[4] >= 'a' && name[4] <= 'v') 712 u += name[4] - 'a' + 10; 713 else 714 return; 715 *dev = make_dev(&ptc_cdevsw, u, 716 UID_ROOT, GID_WHEEL, 0666, "pty%c%r", names[u / 32], u % 32); 717 (*dev)->si_flags |= SI_CHEAPCLONE; 718 return; 719} 720 721static void 722ptc_drvinit(void *unused) 723{ 724 725 EVENTHANDLER_REGISTER(dev_clone, pty_clone, 0, 1000); 726} 727 728SYSINIT(ptcdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR_C,ptc_drvinit,NULL)
|