1 /* $OpenBSD: tty_pty.c,v 1.103 2020/07/20 14:34:16 deraadt Exp $ */ 2 /* $NetBSD: tty_pty.c,v 1.33.4.1 1996/06/02 09:08:11 mrg Exp $ */ 3 4 /* 5 * Copyright (c) 1982, 1986, 1989, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the University nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * @(#)tty_pty.c 8.4 (Berkeley) 2/20/95 33 */ 34 35 /* 36 * Pseudo-teletype Driver 37 * (Actually two drivers, requiring two entries in 'cdevsw') 38 */ 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/namei.h> 43 #include <sys/mount.h> 44 #include <sys/ioctl.h> 45 #include <sys/proc.h> 46 #include <sys/tty.h> 47 #include <sys/fcntl.h> 48 #include <sys/file.h> 49 #include <sys/filedesc.h> 50 #include <sys/uio.h> 51 #include <sys/kernel.h> 52 #include <sys/malloc.h> 53 #include <sys/vnode.h> 54 #include <sys/signalvar.h> 55 #include <sys/conf.h> 56 #include <sys/stat.h> 57 #include <sys/sysctl.h> 58 #include <sys/poll.h> 59 #include <sys/pledge.h> 60 #include <sys/rwlock.h> 61 62 #define BUFSIZ 100 /* Chunk size iomoved to/from user */ 63 64 /* 65 * pts == /dev/tty[p-zP-T][0-9a-zA-Z] 66 * ptc == /dev/pty[p-zP-T][0-9a-zA-Z] 67 */ 68 69 /* XXX this needs to come from somewhere sane, and work with MAKEDEV */ 70 #define TTY_LETTERS "pqrstuvwxyzPQRST" 71 #define TTY_SUFFIX "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" 72 73 static int pts_major; 74 75 struct pt_softc { 76 struct tty *pt_tty; 77 int pt_flags; 78 struct selinfo pt_selr, pt_selw; 79 u_char pt_send; 80 u_char pt_ucntl; 81 char pty_pn[11]; 82 char pty_sn[11]; 83 }; 84 85 #define NPTY_MIN 8 /* number of initial ptys */ 86 #define NPTY_MAX 992 /* maximum number of ptys supported */ 87 88 static struct pt_softc **pt_softc = NULL; /* pty array */ 89 static int npty = 0; /* size of pty array */ 90 static int maxptys = NPTY_MAX; /* maximum number of ptys */ 91 /* for pty array */ 92 struct rwlock pt_softc_lock = RWLOCK_INITIALIZER("ptarrlk"); 93 94 #define PF_PKT 0x08 /* packet mode */ 95 #define PF_STOPPED 0x10 /* user told stopped */ 96 #define PF_REMOTE 0x20 /* remote and flow controlled input */ 97 #define PF_NOSTOP 0x40 98 #define PF_UCNTL 0x80 /* user control mode */ 99 100 void ptyattach(int); 101 void ptcwakeup(struct tty *, int); 102 struct tty *ptytty(dev_t); 103 void ptsstart(struct tty *); 104 int sysctl_pty(int *, u_int, void *, size_t *, void *, size_t); 105 106 void filt_ptcrdetach(struct knote *); 107 int filt_ptcread(struct knote *, long); 108 void filt_ptcwdetach(struct knote *); 109 int filt_ptcwrite(struct knote *, long); 110 111 static struct pt_softc **ptyarralloc(int); 112 static int check_pty(int); 113 114 static gid_t tty_gid = TTY_GID; 115 116 void ptydevname(int, struct pt_softc *); 117 dev_t pty_getfree(void); 118 119 void ptmattach(int); 120 int ptmopen(dev_t, int, int, struct proc *); 121 int ptmclose(dev_t, int, int, struct proc *); 122 int ptmioctl(dev_t, u_long, caddr_t, int, struct proc *p); 123 static int ptm_vn_open(struct nameidata *); 124 125 void 126 ptydevname(int minor, struct pt_softc *pti) 127 { 128 char buf[11] = "/dev/XtyXX"; 129 int i, j; 130 131 i = minor / (sizeof(TTY_SUFFIX) - 1); 132 j = minor % (sizeof(TTY_SUFFIX) - 1); 133 if (i >= sizeof(TTY_LETTERS) - 1) { 134 pti->pty_pn[0] = '\0'; 135 pti->pty_sn[0] = '\0'; 136 return; 137 } 138 buf[5] = 'p'; 139 buf[8] = TTY_LETTERS[i]; 140 buf[9] = TTY_SUFFIX[j]; 141 memcpy(pti->pty_pn, buf, sizeof(buf)); 142 buf[5] = 't'; 143 memcpy(pti->pty_sn, buf, sizeof(buf)); 144 } 145 146 /* 147 * Allocate and zero array of nelem elements. 148 */ 149 struct pt_softc ** 150 ptyarralloc(int nelem) 151 { 152 struct pt_softc **pt; 153 154 pt = mallocarray(nelem, sizeof(struct pt_softc *), M_DEVBUF, 155 M_WAITOK|M_ZERO); 156 return pt; 157 } 158 159 /* 160 * Check if the minor is correct and ensure necessary structures 161 * are properly allocated. 162 */ 163 int 164 check_pty(int dev) 165 { 166 struct pt_softc *pti; 167 int minor = minor(dev); 168 169 rw_enter_write(&pt_softc_lock); 170 if (minor >= npty) { 171 struct pt_softc **newpt; 172 int newnpty; 173 174 /* check if the requested pty can be granted */ 175 if (minor >= maxptys) 176 goto limit_reached; 177 178 /* grow pty array by powers of two, up to maxptys */ 179 for (newnpty = npty; newnpty <= minor; newnpty *= 2) 180 ; 181 182 if (newnpty > maxptys) 183 newnpty = maxptys; 184 newpt = ptyarralloc(newnpty); 185 186 memcpy(newpt, pt_softc, npty * sizeof(struct pt_softc *)); 187 free(pt_softc, M_DEVBUF, npty * sizeof(struct pt_softc *)); 188 pt_softc = newpt; 189 npty = newnpty; 190 } 191 192 /* 193 * If the entry is not yet allocated, allocate one. 194 */ 195 if (!pt_softc[minor]) { 196 pti = malloc(sizeof(struct pt_softc), M_DEVBUF, 197 M_WAITOK|M_ZERO); 198 pti->pt_tty = ttymalloc(1000000); 199 pti->pt_tty->t_dev = dev; 200 ptydevname(minor, pti); 201 pt_softc[minor] = pti; 202 } 203 rw_exit_write(&pt_softc_lock); 204 return (0); 205 limit_reached: 206 rw_exit_write(&pt_softc_lock); 207 tablefull("pty"); 208 return (ENXIO); 209 } 210 211 /* 212 * Establish n (or default if n is 1) ptys in the system. 213 */ 214 void 215 ptyattach(int n) 216 { 217 /* maybe should allow 0 => none? */ 218 if (n <= 1) 219 n = NPTY_MIN; 220 pt_softc = ptyarralloc(n); 221 npty = n; 222 223 /* 224 * If we have pty, we need ptm too. 225 */ 226 ptmattach(1); 227 } 228 229 int 230 ptsopen(dev_t dev, int flag, int devtype, struct proc *p) 231 { 232 struct pt_softc *pti; 233 struct tty *tp; 234 int error; 235 236 if ((error = check_pty(dev))) 237 return (error); 238 239 pti = pt_softc[minor(dev)]; 240 tp = pti->pt_tty; 241 if ((tp->t_state & TS_ISOPEN) == 0) { 242 tp->t_state |= TS_WOPEN; 243 ttychars(tp); /* Set up default chars */ 244 tp->t_iflag = TTYDEF_IFLAG; 245 tp->t_oflag = TTYDEF_OFLAG; 246 tp->t_lflag = TTYDEF_LFLAG; 247 tp->t_cflag = TTYDEF_CFLAG; 248 tp->t_ispeed = tp->t_ospeed = B115200; 249 ttsetwater(tp); /* would be done in xxparam() */ 250 } else if (tp->t_state & TS_XCLUDE && suser(p) != 0) 251 return (EBUSY); 252 if (tp->t_oproc) /* Ctrlr still around. */ 253 tp->t_state |= TS_CARR_ON; 254 while ((tp->t_state & TS_CARR_ON) == 0) { 255 tp->t_state |= TS_WOPEN; 256 if (flag & FNONBLOCK) 257 break; 258 error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH, ttopen); 259 if (error) 260 return (error); 261 } 262 error = (*linesw[tp->t_line].l_open)(dev, tp, p); 263 ptcwakeup(tp, FREAD|FWRITE); 264 return (error); 265 } 266 267 int 268 ptsclose(dev_t dev, int flag, int mode, struct proc *p) 269 { 270 struct pt_softc *pti = pt_softc[minor(dev)]; 271 struct tty *tp = pti->pt_tty; 272 int error; 273 274 error = (*linesw[tp->t_line].l_close)(tp, flag, p); 275 error |= ttyclose(tp); 276 ptcwakeup(tp, FREAD|FWRITE); 277 return (error); 278 } 279 280 int 281 ptsread(dev_t dev, struct uio *uio, int flag) 282 { 283 struct proc *p = curproc; 284 struct process *pr = p->p_p; 285 struct pt_softc *pti = pt_softc[minor(dev)]; 286 struct tty *tp = pti->pt_tty; 287 int error = 0; 288 289 again: 290 if (pti->pt_flags & PF_REMOTE) { 291 while (isbackground(pr, tp)) { 292 if ((pr->ps_sigacts->ps_sigignore & sigmask(SIGTTIN)) || 293 (p->p_sigmask & sigmask(SIGTTIN)) || 294 pr->ps_pgrp->pg_jobc == 0 || 295 pr->ps_flags & PS_PPWAIT) 296 return (EIO); 297 pgsignal(pr->ps_pgrp, SIGTTIN, 1); 298 error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, ttybg); 299 if (error) 300 return (error); 301 } 302 if (tp->t_canq.c_cc == 0) { 303 if (flag & IO_NDELAY) 304 return (EWOULDBLOCK); 305 error = ttysleep(tp, &tp->t_canq, 306 TTIPRI | PCATCH, ttyin); 307 if (error) 308 return (error); 309 goto again; 310 } 311 while (tp->t_canq.c_cc > 1 && uio->uio_resid > 0) 312 if (ureadc(getc(&tp->t_canq), uio) < 0) { 313 error = EFAULT; 314 break; 315 } 316 if (tp->t_canq.c_cc == 1) 317 (void) getc(&tp->t_canq); 318 if (tp->t_canq.c_cc) 319 return (error); 320 } else 321 if (tp->t_oproc) 322 error = (*linesw[tp->t_line].l_read)(tp, uio, flag); 323 ptcwakeup(tp, FWRITE); 324 return (error); 325 } 326 327 /* 328 * Write to pseudo-tty. 329 * Wakeups of controlling tty will happen 330 * indirectly, when tty driver calls ptsstart. 331 */ 332 int 333 ptswrite(dev_t dev, struct uio *uio, int flag) 334 { 335 struct pt_softc *pti = pt_softc[minor(dev)]; 336 struct tty *tp = pti->pt_tty; 337 338 if (tp->t_oproc == 0) 339 return (EIO); 340 return ((*linesw[tp->t_line].l_write)(tp, uio, flag)); 341 } 342 343 /* 344 * Start output on pseudo-tty. 345 * Wake up process polling or sleeping for input from controlling tty. 346 */ 347 void 348 ptsstart(struct tty *tp) 349 { 350 struct pt_softc *pti = pt_softc[minor(tp->t_dev)]; 351 352 if (tp->t_state & TS_TTSTOP) 353 return; 354 if (pti->pt_flags & PF_STOPPED) { 355 pti->pt_flags &= ~PF_STOPPED; 356 pti->pt_send = TIOCPKT_START; 357 } 358 ptcwakeup(tp, FREAD); 359 } 360 361 int 362 ptsstop(struct tty *tp, int flush) 363 { 364 struct pt_softc *pti = pt_softc[minor(tp->t_dev)]; 365 int flag; 366 367 /* note: FLUSHREAD and FLUSHWRITE already ok */ 368 if (flush == 0) { 369 flush = TIOCPKT_STOP; 370 pti->pt_flags |= PF_STOPPED; 371 } else 372 pti->pt_flags &= ~PF_STOPPED; 373 pti->pt_send |= flush; 374 /* change of perspective */ 375 flag = 0; 376 if (flush & FREAD) 377 flag |= FWRITE; 378 if (flush & FWRITE) 379 flag |= FREAD; 380 ptcwakeup(tp, flag); 381 return 0; 382 } 383 384 void 385 ptcwakeup(struct tty *tp, int flag) 386 { 387 struct pt_softc *pti = pt_softc[minor(tp->t_dev)]; 388 389 if (flag & FREAD) { 390 selwakeup(&pti->pt_selr); 391 wakeup(&tp->t_outq.c_cf); 392 } 393 if (flag & FWRITE) { 394 selwakeup(&pti->pt_selw); 395 wakeup(&tp->t_rawq.c_cf); 396 } 397 } 398 399 int ptcopen(dev_t, int, int, struct proc *); 400 401 int 402 ptcopen(dev_t dev, int flag, int devtype, struct proc *p) 403 { 404 struct pt_softc *pti; 405 struct tty *tp; 406 int error; 407 408 if ((error = check_pty(dev))) 409 return (error); 410 411 pti = pt_softc[minor(dev)]; 412 tp = pti->pt_tty; 413 if (tp->t_oproc) 414 return (EIO); 415 tp->t_oproc = ptsstart; 416 (void)(*linesw[tp->t_line].l_modem)(tp, 1); 417 tp->t_lflag &= ~EXTPROC; 418 pti->pt_flags = 0; 419 pti->pt_send = 0; 420 pti->pt_ucntl = 0; 421 return (0); 422 } 423 424 int 425 ptcclose(dev_t dev, int flag, int devtype, struct proc *p) 426 { 427 struct pt_softc *pti = pt_softc[minor(dev)]; 428 struct tty *tp = pti->pt_tty; 429 430 (void)(*linesw[tp->t_line].l_modem)(tp, 0); 431 tp->t_state &= ~TS_CARR_ON; 432 tp->t_oproc = 0; /* mark closed */ 433 return (0); 434 } 435 436 int 437 ptcread(dev_t dev, struct uio *uio, int flag) 438 { 439 struct pt_softc *pti = pt_softc[minor(dev)]; 440 struct tty *tp = pti->pt_tty; 441 char buf[BUFSIZ]; 442 int error = 0, cc, bufcc = 0; 443 444 /* 445 * We want to block until the slave 446 * is open, and there's something to read; 447 * but if we lost the slave or we're NBIO, 448 * then return the appropriate error instead. 449 */ 450 for (;;) { 451 if (tp->t_state & TS_ISOPEN) { 452 if (pti->pt_flags & PF_PKT && pti->pt_send) { 453 error = ureadc((int)pti->pt_send, uio); 454 if (error) 455 return (error); 456 if (pti->pt_send & TIOCPKT_IOCTL) { 457 cc = MIN(uio->uio_resid, 458 sizeof(tp->t_termios)); 459 error = uiomove(&tp->t_termios, cc, uio); 460 if (error) 461 return (error); 462 } 463 pti->pt_send = 0; 464 return (0); 465 } 466 if (pti->pt_flags & PF_UCNTL && pti->pt_ucntl) { 467 error = ureadc((int)pti->pt_ucntl, uio); 468 if (error) 469 return (error); 470 pti->pt_ucntl = 0; 471 return (0); 472 } 473 if (tp->t_outq.c_cc && (tp->t_state & TS_TTSTOP) == 0) 474 break; 475 } 476 if ((tp->t_state & TS_CARR_ON) == 0) 477 return (0); /* EOF */ 478 if (flag & IO_NDELAY) 479 return (EWOULDBLOCK); 480 error = tsleep_nsec(&tp->t_outq.c_cf, TTIPRI | PCATCH, ttyin, 481 INFSLP); 482 if (error) 483 return (error); 484 } 485 if (pti->pt_flags & (PF_PKT|PF_UCNTL)) 486 error = ureadc(0, uio); 487 while (uio->uio_resid > 0 && error == 0) { 488 cc = MIN(uio->uio_resid, BUFSIZ); 489 cc = q_to_b(&tp->t_outq, buf, cc); 490 if (cc > bufcc) 491 bufcc = cc; 492 if (cc <= 0) 493 break; 494 error = uiomove(buf, cc, uio); 495 } 496 ttwakeupwr(tp); 497 if (bufcc) 498 explicit_bzero(buf, bufcc); 499 return (error); 500 } 501 502 503 int 504 ptcwrite(dev_t dev, struct uio *uio, int flag) 505 { 506 struct pt_softc *pti = pt_softc[minor(dev)]; 507 struct tty *tp = pti->pt_tty; 508 u_char *cp = NULL; 509 int cc = 0, bufcc = 0; 510 u_char buf[BUFSIZ]; 511 size_t cnt = 0; 512 int error = 0; 513 514 again: 515 if ((tp->t_state & TS_ISOPEN) == 0) 516 goto block; 517 if (pti->pt_flags & PF_REMOTE) { 518 if (tp->t_canq.c_cc) 519 goto block; 520 while (uio->uio_resid > 0 && tp->t_canq.c_cc < TTYHOG(tp) - 1) { 521 if (cc == 0) { 522 cc = MIN(uio->uio_resid, BUFSIZ); 523 cc = min(cc, TTYHOG(tp) - 1 - tp->t_canq.c_cc); 524 if (cc > bufcc) 525 bufcc = cc; 526 cp = buf; 527 error = uiomove(cp, cc, uio); 528 if (error) 529 goto done; 530 /* check again for safety */ 531 if ((tp->t_state & TS_ISOPEN) == 0) { 532 error = EIO; 533 goto done; 534 } 535 } 536 if (cc) 537 (void) b_to_q((char *)cp, cc, &tp->t_canq); 538 cc = 0; 539 } 540 (void) putc(0, &tp->t_canq); 541 ttwakeup(tp); 542 wakeup(&tp->t_canq); 543 goto done; 544 } 545 do { 546 if (cc == 0) { 547 cc = MIN(uio->uio_resid, BUFSIZ); 548 if (cc > bufcc) 549 bufcc = cc; 550 cp = buf; 551 error = uiomove(cp, cc, uio); 552 if (error) 553 goto done; 554 /* check again for safety */ 555 if ((tp->t_state & TS_ISOPEN) == 0) { 556 error = EIO; 557 goto done; 558 } 559 } 560 bufcc = cc; 561 while (cc > 0) { 562 if ((tp->t_rawq.c_cc + tp->t_canq.c_cc) >= TTYHOG(tp) - 2 && 563 (tp->t_canq.c_cc > 0 || !ISSET(tp->t_lflag, ICANON))) { 564 wakeup(&tp->t_rawq); 565 goto block; 566 } 567 if ((*linesw[tp->t_line].l_rint)(*cp++, tp) == 1 && 568 tsleep(tp, TTIPRI | PCATCH, "ttyretype", 1) == EINTR) 569 goto interrupt; 570 cnt++; 571 cc--; 572 } 573 cc = 0; 574 } while (uio->uio_resid > 0); 575 goto done; 576 block: 577 /* 578 * Come here to wait for slave to open, for space 579 * in outq, or space in rawq. 580 */ 581 if ((tp->t_state & TS_CARR_ON) == 0) { 582 error = EIO; 583 goto done; 584 } 585 if (flag & IO_NDELAY) { 586 /* adjust for data copied in but not written */ 587 uio->uio_resid += cc; 588 if (cnt == 0) 589 error = EWOULDBLOCK; 590 goto done; 591 } 592 error = tsleep_nsec(&tp->t_rawq.c_cf, TTOPRI | PCATCH, ttyout, INFSLP); 593 if (error == 0) 594 goto again; 595 596 interrupt: 597 /* adjust for data copied in but not written */ 598 uio->uio_resid += cc; 599 done: 600 if (bufcc) 601 explicit_bzero(buf, bufcc); 602 return (error); 603 } 604 605 int 606 ptcpoll(dev_t dev, int events, struct proc *p) 607 { 608 struct pt_softc *pti = pt_softc[minor(dev)]; 609 struct tty *tp = pti->pt_tty; 610 int revents = 0, s; 611 612 if (!ISSET(tp->t_state, TS_ISOPEN) && ISSET(tp->t_state, TS_CARR_ON)) 613 goto notopen; 614 615 if (events & (POLLIN | POLLRDNORM)) { 616 /* 617 * Need to protect access to t_outq 618 */ 619 s = spltty(); 620 if ((tp->t_outq.c_cc && !ISSET(tp->t_state, TS_TTSTOP)) || 621 ((pti->pt_flags & PF_PKT) && pti->pt_send) || 622 ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl)) 623 revents |= events & (POLLIN | POLLRDNORM); 624 splx(s); 625 } 626 /* NOTE: POLLHUP and POLLOUT/POLLWRNORM are mutually exclusive */ 627 if (!ISSET(tp->t_state, TS_CARR_ON)) { 628 revents |= POLLHUP; 629 } else if (events & (POLLOUT | POLLWRNORM)) { 630 if ((pti->pt_flags & PF_REMOTE) ? 631 (tp->t_canq.c_cc == 0) : 632 ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG(tp) - 2) || 633 (tp->t_canq.c_cc == 0 && ISSET(tp->t_lflag, ICANON)))) 634 revents |= events & (POLLOUT | POLLWRNORM); 635 } 636 if (events & (POLLPRI | POLLRDBAND)) { 637 /* If in packet or user control mode, check for data. */ 638 if (((pti->pt_flags & PF_PKT) && pti->pt_send) || 639 ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl)) 640 revents |= events & (POLLPRI | POLLRDBAND); 641 } 642 643 if (revents == 0) { 644 notopen: 645 if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) 646 selrecord(p, &pti->pt_selr); 647 if (events & (POLLOUT | POLLWRNORM)) 648 selrecord(p, &pti->pt_selw); 649 } 650 651 return (revents); 652 } 653 654 void 655 filt_ptcrdetach(struct knote *kn) 656 { 657 struct pt_softc *pti = (struct pt_softc *)kn->kn_hook; 658 int s; 659 660 s = spltty(); 661 klist_remove(&pti->pt_selr.si_note, kn); 662 splx(s); 663 } 664 665 int 666 filt_ptcread(struct knote *kn, long hint) 667 { 668 struct pt_softc *pti = (struct pt_softc *)kn->kn_hook; 669 struct tty *tp; 670 671 tp = pti->pt_tty; 672 kn->kn_data = 0; 673 674 if (kn->kn_sfflags & NOTE_OOB) { 675 /* If in packet or user control mode, check for data. */ 676 if (((pti->pt_flags & PF_PKT) && pti->pt_send) || 677 ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl)) { 678 kn->kn_fflags |= NOTE_OOB; 679 kn->kn_data = 1; 680 return (1); 681 } 682 return (0); 683 } 684 if (ISSET(tp->t_state, TS_ISOPEN)) { 685 if (!ISSET(tp->t_state, TS_TTSTOP)) 686 kn->kn_data = tp->t_outq.c_cc; 687 if (((pti->pt_flags & PF_PKT) && pti->pt_send) || 688 ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl)) 689 kn->kn_data++; 690 } 691 692 if (!ISSET(tp->t_state, TS_CARR_ON)) { 693 kn->kn_flags |= EV_EOF; 694 if (kn->kn_flags & __EV_POLL) 695 kn->kn_flags |= __EV_HUP; 696 return (1); 697 } 698 699 return (kn->kn_data > 0); 700 } 701 702 void 703 filt_ptcwdetach(struct knote *kn) 704 { 705 struct pt_softc *pti = (struct pt_softc *)kn->kn_hook; 706 int s; 707 708 s = spltty(); 709 klist_remove(&pti->pt_selw.si_note, kn); 710 splx(s); 711 } 712 713 int 714 filt_ptcwrite(struct knote *kn, long hint) 715 { 716 struct pt_softc *pti = (struct pt_softc *)kn->kn_hook; 717 struct tty *tp; 718 719 tp = pti->pt_tty; 720 kn->kn_data = 0; 721 722 if (ISSET(tp->t_state, TS_ISOPEN)) { 723 if (ISSET(pti->pt_flags, PF_REMOTE)) { 724 if (tp->t_canq.c_cc == 0) 725 kn->kn_data = tp->t_canq.c_cn; 726 } else if ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG(tp)-2) || 727 (tp->t_canq.c_cc == 0 && ISSET(tp->t_lflag, ICANON))) 728 kn->kn_data = tp->t_canq.c_cn - 729 (tp->t_rawq.c_cc + tp->t_canq.c_cc); 730 } 731 732 return (kn->kn_data > 0); 733 } 734 735 const struct filterops ptcread_filtops = { 736 .f_flags = FILTEROP_ISFD, 737 .f_attach = NULL, 738 .f_detach = filt_ptcrdetach, 739 .f_event = filt_ptcread, 740 }; 741 742 const struct filterops ptcwrite_filtops = { 743 .f_flags = FILTEROP_ISFD, 744 .f_attach = NULL, 745 .f_detach = filt_ptcwdetach, 746 .f_event = filt_ptcwrite, 747 }; 748 749 const struct filterops ptcexcept_filtops = { 750 .f_flags = FILTEROP_ISFD, 751 .f_attach = NULL, 752 .f_detach = filt_ptcrdetach, 753 .f_event = filt_ptcread, 754 }; 755 756 int 757 ptckqfilter(dev_t dev, struct knote *kn) 758 { 759 struct pt_softc *pti = pt_softc[minor(dev)]; 760 struct klist *klist; 761 int s; 762 763 switch (kn->kn_filter) { 764 case EVFILT_READ: 765 klist = &pti->pt_selr.si_note; 766 kn->kn_fop = &ptcread_filtops; 767 break; 768 case EVFILT_WRITE: 769 klist = &pti->pt_selw.si_note; 770 kn->kn_fop = &ptcwrite_filtops; 771 break; 772 case EVFILT_EXCEPT: 773 klist = &pti->pt_selr.si_note; 774 kn->kn_fop = &ptcexcept_filtops; 775 break; 776 default: 777 return (EINVAL); 778 } 779 780 kn->kn_hook = (caddr_t)pti; 781 782 s = spltty(); 783 klist_insert(klist, kn); 784 splx(s); 785 786 return (0); 787 } 788 789 struct tty * 790 ptytty(dev_t dev) 791 { 792 struct pt_softc *pti = pt_softc[minor(dev)]; 793 struct tty *tp = pti->pt_tty; 794 795 return (tp); 796 } 797 798 int 799 ptyioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) 800 { 801 struct pt_softc *pti = pt_softc[minor(dev)]; 802 struct tty *tp = pti->pt_tty; 803 u_char *cc = tp->t_cc; 804 int stop, error; 805 806 /* 807 * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG. 808 * ttywflush(tp) will hang if there are characters in the outq. 809 */ 810 if (cmd == TIOCEXT) { 811 /* 812 * When the EXTPROC bit is being toggled, we need 813 * to send an TIOCPKT_IOCTL if the packet driver 814 * is turned on. 815 */ 816 if (*(int *)data) { 817 if (pti->pt_flags & PF_PKT) { 818 pti->pt_send |= TIOCPKT_IOCTL; 819 ptcwakeup(tp, FREAD); 820 } 821 tp->t_lflag |= EXTPROC; 822 } else { 823 if ((tp->t_lflag & EXTPROC) && 824 (pti->pt_flags & PF_PKT)) { 825 pti->pt_send |= TIOCPKT_IOCTL; 826 ptcwakeup(tp, FREAD); 827 } 828 tp->t_lflag &= ~EXTPROC; 829 } 830 return(0); 831 } else if (cdevsw[major(dev)].d_open == ptcopen) 832 switch (cmd) { 833 834 case TIOCGPGRP: 835 /* 836 * We avoid calling ttioctl on the controller since, 837 * in that case, tp must be the controlling terminal. 838 */ 839 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0; 840 return (0); 841 842 case TIOCPKT: 843 if (*(int *)data) { 844 if (pti->pt_flags & PF_UCNTL) 845 return (EINVAL); 846 pti->pt_flags |= PF_PKT; 847 } else 848 pti->pt_flags &= ~PF_PKT; 849 return (0); 850 851 case TIOCUCNTL: 852 if (*(int *)data) { 853 if (pti->pt_flags & PF_PKT) 854 return (EINVAL); 855 pti->pt_flags |= PF_UCNTL; 856 } else 857 pti->pt_flags &= ~PF_UCNTL; 858 return (0); 859 860 case TIOCREMOTE: 861 if (*(int *)data) 862 pti->pt_flags |= PF_REMOTE; 863 else 864 pti->pt_flags &= ~PF_REMOTE; 865 ttyflush(tp, FREAD|FWRITE); 866 return (0); 867 868 case TIOCSETD: 869 case TIOCSETA: 870 case TIOCSETAW: 871 case TIOCSETAF: 872 ndflush(&tp->t_outq, tp->t_outq.c_cc); 873 break; 874 875 case TIOCSIG: 876 if (*(unsigned int *)data >= NSIG || 877 *(unsigned int *)data == 0) 878 return(EINVAL); 879 if ((tp->t_lflag & NOFLSH) == 0) 880 ttyflush(tp, FREAD|FWRITE); 881 pgsignal(tp->t_pgrp, *(unsigned int *)data, 1); 882 if ((*(unsigned int *)data == SIGINFO) && 883 ((tp->t_lflag & NOKERNINFO) == 0)) 884 ttyinfo(tp); 885 return (0); 886 887 case FIONREAD: 888 /* 889 * FIONREAD on the master side must return the amount 890 * in the output queue rather than the input. 891 */ 892 *(int *)data = tp->t_outq.c_cc; 893 return (0); 894 } 895 error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p); 896 if (error < 0) 897 error = ttioctl(tp, cmd, data, flag, p); 898 if (error < 0) { 899 /* 900 * Translate TIOCSBRK/TIOCCBRK to user mode ioctls to 901 * let the master interpret BREAK conditions. 902 */ 903 switch (cmd) { 904 case TIOCSBRK: 905 cmd = UIOCCMD(TIOCUCNTL_SBRK); 906 break; 907 case TIOCCBRK: 908 cmd = UIOCCMD(TIOCUCNTL_CBRK); 909 break; 910 default: 911 break; 912 } 913 if (pti->pt_flags & PF_UCNTL && 914 (cmd & ~0xff) == UIOCCMD(0)) { 915 if (cmd & 0xff) { 916 pti->pt_ucntl = (u_char)cmd; 917 ptcwakeup(tp, FREAD); 918 } 919 return (0); 920 } 921 error = ENOTTY; 922 } 923 /* 924 * If external processing and packet mode send ioctl packet. 925 */ 926 if ((tp->t_lflag & EXTPROC) && (pti->pt_flags & PF_PKT)) { 927 switch (cmd) { 928 case TIOCSETA: 929 case TIOCSETAW: 930 case TIOCSETAF: 931 pti->pt_send |= TIOCPKT_IOCTL; 932 ptcwakeup(tp, FREAD); 933 default: 934 break; 935 } 936 } 937 stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s')) && 938 CCEQ(cc[VSTART], CTRL('q')); 939 if (pti->pt_flags & PF_NOSTOP) { 940 if (stop) { 941 pti->pt_send &= ~TIOCPKT_NOSTOP; 942 pti->pt_send |= TIOCPKT_DOSTOP; 943 pti->pt_flags &= ~PF_NOSTOP; 944 ptcwakeup(tp, FREAD); 945 } 946 } else { 947 if (!stop) { 948 pti->pt_send &= ~TIOCPKT_DOSTOP; 949 pti->pt_send |= TIOCPKT_NOSTOP; 950 pti->pt_flags |= PF_NOSTOP; 951 ptcwakeup(tp, FREAD); 952 } 953 } 954 return (error); 955 } 956 957 /* 958 * Return pty-related information. 959 */ 960 int 961 sysctl_pty(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, 962 size_t newlen) 963 { 964 if (namelen != 1) 965 return (ENOTDIR); 966 967 switch (name[0]) { 968 default: 969 return (EOPNOTSUPP); 970 } 971 /* NOTREACHED */ 972 } 973 974 /* 975 * Check if a pty is free to use. 976 */ 977 static int 978 pty_isfree_locked(int minor) 979 { 980 struct pt_softc *pt = pt_softc[minor]; 981 982 return (pt == NULL || pt->pt_tty == NULL || 983 pt->pt_tty->t_oproc == NULL); 984 } 985 986 static int 987 pty_isfree(int minor) 988 { 989 int isfree; 990 991 rw_enter_read(&pt_softc_lock); 992 isfree = pty_isfree_locked(minor); 993 rw_exit_read(&pt_softc_lock); 994 return(isfree); 995 } 996 997 dev_t 998 pty_getfree(void) 999 { 1000 int i; 1001 1002 rw_enter_read(&pt_softc_lock); 1003 for (i = 0; i < npty; i++) { 1004 if (pty_isfree_locked(i)) 1005 break; 1006 } 1007 rw_exit_read(&pt_softc_lock); 1008 return (makedev(pts_major, i)); 1009 } 1010 1011 /* 1012 * Hacked up version of vn_open. We _only_ handle ptys and only open 1013 * them with FREAD|FWRITE and never deal with creat or stuff like that. 1014 * 1015 * We need it because we have to fake up root credentials to open the pty. 1016 */ 1017 static int 1018 ptm_vn_open(struct nameidata *ndp) 1019 { 1020 struct proc *p = ndp->ni_cnd.cn_proc; 1021 struct ucred *cred; 1022 struct vattr vattr; 1023 struct vnode *vp; 1024 int error; 1025 1026 if ((error = namei(ndp)) != 0) 1027 return (error); 1028 vp = ndp->ni_vp; 1029 if (vp->v_type != VCHR) { 1030 error = EINVAL; 1031 goto bad; 1032 } 1033 1034 /* 1035 * Get us a fresh cred with root privileges. 1036 */ 1037 cred = crget(); 1038 error = VOP_OPEN(vp, FREAD|FWRITE, cred, p); 1039 if (!error) { 1040 /* update atime/mtime */ 1041 VATTR_NULL(&vattr); 1042 getnanotime(&vattr.va_atime); 1043 vattr.va_mtime = vattr.va_atime; 1044 vattr.va_vaflags |= VA_UTIMES_NULL; 1045 (void)VOP_SETATTR(vp, &vattr, p->p_ucred, p); 1046 } 1047 crfree(cred); 1048 1049 if (error) 1050 goto bad; 1051 1052 vp->v_writecount++; 1053 1054 return (0); 1055 bad: 1056 vput(vp); 1057 return (error); 1058 } 1059 1060 void 1061 ptmattach(int n) 1062 { 1063 /* find the major and minor of the pty devices */ 1064 int i; 1065 1066 for (i = 0; i < nchrdev; i++) 1067 if (cdevsw[i].d_open == ptsopen) 1068 break; 1069 1070 if (i == nchrdev) 1071 panic("ptmattach: Can't find pty slave in cdevsw"); 1072 1073 pts_major = i; 1074 } 1075 1076 int 1077 ptmopen(dev_t dev, int flag, int mode, struct proc *p) 1078 { 1079 return(0); 1080 } 1081 1082 1083 int 1084 ptmclose(dev_t dev, int flag, int mode, struct proc *p) 1085 { 1086 return (0); 1087 } 1088 1089 int 1090 ptmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) 1091 { 1092 dev_t newdev, error; 1093 struct pt_softc * pti; 1094 struct nameidata cnd, snd; 1095 struct filedesc *fdp = p->p_fd; 1096 struct file *cfp = NULL, *sfp = NULL; 1097 int cindx, sindx; 1098 uid_t uid; 1099 gid_t gid; 1100 struct vattr vattr; 1101 struct ucred *cred; 1102 struct ptmget *ptm = (struct ptmget *)data; 1103 1104 switch (cmd) { 1105 case PTMGET: 1106 fdplock(fdp); 1107 /* Grab two filedescriptors. */ 1108 if ((error = falloc(p, &cfp, &cindx)) != 0) { 1109 fdpunlock(fdp); 1110 break; 1111 } 1112 if ((error = falloc(p, &sfp, &sindx)) != 0) { 1113 fdremove(fdp, cindx); 1114 closef(cfp, p); 1115 fdpunlock(fdp); 1116 break; 1117 } 1118 1119 retry: 1120 /* Find and open a free master pty. */ 1121 newdev = pty_getfree(); 1122 if ((error = check_pty(newdev))) 1123 goto bad; 1124 pti = pt_softc[minor(newdev)]; 1125 NDINIT(&cnd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE, 1126 pti->pty_pn, p); 1127 cnd.ni_pledge = PLEDGE_RPATH | PLEDGE_WPATH; 1128 if ((error = ptm_vn_open(&cnd)) != 0) { 1129 /* 1130 * Check if the master open failed because we lost 1131 * the race to grab it. 1132 */ 1133 if (error == EIO && !pty_isfree(minor(newdev))) 1134 goto retry; 1135 goto bad; 1136 } 1137 cfp->f_flag = FREAD|FWRITE; 1138 cfp->f_type = DTYPE_VNODE; 1139 cfp->f_ops = &vnops; 1140 cfp->f_data = (caddr_t) cnd.ni_vp; 1141 VOP_UNLOCK(cnd.ni_vp); 1142 1143 /* 1144 * Open the slave. 1145 * namei -> setattr -> unlock -> revoke -> vrele -> 1146 * namei -> open -> unlock 1147 * Three stage rocket: 1148 * 1. Change the owner and permissions on the slave. 1149 * 2. Revoke all the users of the slave. 1150 * 3. open the slave. 1151 */ 1152 NDINIT(&snd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE, 1153 pti->pty_sn, p); 1154 snd.ni_pledge = PLEDGE_RPATH | PLEDGE_WPATH; 1155 snd.ni_unveil = UNVEIL_READ | UNVEIL_WRITE; 1156 if ((error = namei(&snd)) != 0) 1157 goto bad; 1158 if ((snd.ni_vp->v_mount->mnt_flag & MNT_RDONLY) == 0) { 1159 gid = tty_gid; 1160 /* get real uid */ 1161 uid = p->p_ucred->cr_ruid; 1162 1163 VATTR_NULL(&vattr); 1164 vattr.va_uid = uid; 1165 vattr.va_gid = gid; 1166 vattr.va_mode = (S_IRUSR|S_IWUSR|S_IWGRP) & ALLPERMS; 1167 /* Get a fake cred to pretend we're root. */ 1168 cred = crget(); 1169 error = VOP_SETATTR(snd.ni_vp, &vattr, cred, p); 1170 crfree(cred); 1171 if (error) { 1172 vput(snd.ni_vp); 1173 goto bad; 1174 } 1175 } 1176 VOP_UNLOCK(snd.ni_vp); 1177 if (snd.ni_vp->v_usecount > 1 || 1178 (snd.ni_vp->v_flag & (VALIASED))) 1179 VOP_REVOKE(snd.ni_vp, REVOKEALL); 1180 1181 /* 1182 * The vnode is useless after the revoke, we need to 1183 * namei again. 1184 */ 1185 vrele(snd.ni_vp); 1186 1187 NDINIT(&snd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE, 1188 pti->pty_sn, p); 1189 snd.ni_pledge = PLEDGE_RPATH | PLEDGE_WPATH; 1190 snd.ni_unveil= UNVEIL_READ | UNVEIL_WRITE; 1191 /* now open it */ 1192 if ((error = ptm_vn_open(&snd)) != 0) 1193 goto bad; 1194 sfp->f_flag = FREAD|FWRITE; 1195 sfp->f_type = DTYPE_VNODE; 1196 sfp->f_ops = &vnops; 1197 sfp->f_data = (caddr_t) snd.ni_vp; 1198 VOP_UNLOCK(snd.ni_vp); 1199 1200 /* now, put the indexen and names into struct ptmget */ 1201 ptm->cfd = cindx; 1202 ptm->sfd = sindx; 1203 memcpy(ptm->cn, pti->pty_pn, sizeof(pti->pty_pn)); 1204 memcpy(ptm->sn, pti->pty_sn, sizeof(pti->pty_sn)); 1205 1206 /* insert files now that we've passed all errors */ 1207 fdinsert(fdp, cindx, 0, cfp); 1208 fdinsert(fdp, sindx, 0, sfp); 1209 fdpunlock(fdp); 1210 FRELE(cfp, p); 1211 FRELE(sfp, p); 1212 break; 1213 default: 1214 error = EINVAL; 1215 break; 1216 } 1217 return (error); 1218 bad: 1219 fdremove(fdp, cindx); 1220 closef(cfp, p); 1221 fdremove(fdp, sindx); 1222 closef(sfp, p); 1223 fdpunlock(fdp); 1224 return (error); 1225 } 1226