1 /* $OpenBSD: tty_pty.c,v 1.109 2021/10/22 15:11:32 mpi 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 int filt_ptcexcept(struct knote *, long); 111 112 static struct pt_softc **ptyarralloc(int); 113 static int check_pty(int); 114 115 static gid_t tty_gid = TTY_GID; 116 117 void ptydevname(int, struct pt_softc *); 118 dev_t pty_getfree(void); 119 120 void ptmattach(int); 121 int ptmopen(dev_t, int, int, struct proc *); 122 int ptmclose(dev_t, int, int, struct proc *); 123 int ptmioctl(dev_t, u_long, caddr_t, int, struct proc *p); 124 static int ptm_vn_open(struct nameidata *); 125 126 void 127 ptydevname(int minor, struct pt_softc *pti) 128 { 129 char buf[11] = "/dev/XtyXX"; 130 int i, j; 131 132 i = minor / (sizeof(TTY_SUFFIX) - 1); 133 j = minor % (sizeof(TTY_SUFFIX) - 1); 134 if (i >= sizeof(TTY_LETTERS) - 1) { 135 pti->pty_pn[0] = '\0'; 136 pti->pty_sn[0] = '\0'; 137 return; 138 } 139 buf[5] = 'p'; 140 buf[8] = TTY_LETTERS[i]; 141 buf[9] = TTY_SUFFIX[j]; 142 memcpy(pti->pty_pn, buf, sizeof(buf)); 143 buf[5] = 't'; 144 memcpy(pti->pty_sn, buf, sizeof(buf)); 145 } 146 147 /* 148 * Allocate and zero array of nelem elements. 149 */ 150 struct pt_softc ** 151 ptyarralloc(int nelem) 152 { 153 struct pt_softc **pt; 154 155 pt = mallocarray(nelem, sizeof(struct pt_softc *), M_DEVBUF, 156 M_WAITOK|M_ZERO); 157 return pt; 158 } 159 160 /* 161 * Check if the minor is correct and ensure necessary structures 162 * are properly allocated. 163 */ 164 int 165 check_pty(int dev) 166 { 167 struct pt_softc *pti; 168 int minor = minor(dev); 169 170 rw_enter_write(&pt_softc_lock); 171 if (minor >= npty) { 172 struct pt_softc **newpt; 173 int newnpty; 174 175 /* check if the requested pty can be granted */ 176 if (minor >= maxptys) 177 goto limit_reached; 178 179 /* grow pty array by powers of two, up to maxptys */ 180 for (newnpty = npty; newnpty <= minor; newnpty *= 2) 181 ; 182 183 if (newnpty > maxptys) 184 newnpty = maxptys; 185 newpt = ptyarralloc(newnpty); 186 187 memcpy(newpt, pt_softc, npty * sizeof(struct pt_softc *)); 188 free(pt_softc, M_DEVBUF, npty * sizeof(struct pt_softc *)); 189 pt_softc = newpt; 190 npty = newnpty; 191 } 192 193 /* 194 * If the entry is not yet allocated, allocate one. 195 */ 196 if (!pt_softc[minor]) { 197 pti = malloc(sizeof(struct pt_softc), M_DEVBUF, 198 M_WAITOK|M_ZERO); 199 pti->pt_tty = ttymalloc(1000000); 200 pti->pt_tty->t_dev = dev; 201 ptydevname(minor, pti); 202 pt_softc[minor] = pti; 203 } 204 rw_exit_write(&pt_softc_lock); 205 return (0); 206 limit_reached: 207 rw_exit_write(&pt_softc_lock); 208 tablefull("pty"); 209 return (ENXIO); 210 } 211 212 /* 213 * Establish n (or default if n is 1) ptys in the system. 214 */ 215 void 216 ptyattach(int n) 217 { 218 /* maybe should allow 0 => none? */ 219 if (n <= 1) 220 n = NPTY_MIN; 221 pt_softc = ptyarralloc(n); 222 npty = n; 223 224 /* 225 * If we have pty, we need ptm too. 226 */ 227 ptmattach(1); 228 } 229 230 int 231 ptsopen(dev_t dev, int flag, int devtype, struct proc *p) 232 { 233 struct pt_softc *pti; 234 struct tty *tp; 235 int error; 236 237 if ((error = check_pty(dev))) 238 return (error); 239 240 pti = pt_softc[minor(dev)]; 241 tp = pti->pt_tty; 242 if ((tp->t_state & TS_ISOPEN) == 0) { 243 tp->t_state |= TS_WOPEN; 244 ttychars(tp); /* Set up default chars */ 245 tp->t_iflag = TTYDEF_IFLAG; 246 tp->t_oflag = TTYDEF_OFLAG; 247 tp->t_lflag = TTYDEF_LFLAG; 248 tp->t_cflag = TTYDEF_CFLAG; 249 tp->t_ispeed = tp->t_ospeed = B115200; 250 ttsetwater(tp); /* would be done in xxparam() */ 251 } else if (tp->t_state & TS_XCLUDE && suser(p) != 0) 252 return (EBUSY); 253 if (tp->t_oproc) /* Ctrlr still around. */ 254 tp->t_state |= TS_CARR_ON; 255 while ((tp->t_state & TS_CARR_ON) == 0) { 256 tp->t_state |= TS_WOPEN; 257 if (flag & FNONBLOCK) 258 break; 259 error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH, ttopen); 260 if (error) 261 return (error); 262 } 263 error = (*linesw[tp->t_line].l_open)(dev, tp, p); 264 ptcwakeup(tp, FREAD|FWRITE); 265 return (error); 266 } 267 268 int 269 ptsclose(dev_t dev, int flag, int mode, struct proc *p) 270 { 271 struct pt_softc *pti = pt_softc[minor(dev)]; 272 struct tty *tp = pti->pt_tty; 273 int error; 274 275 error = (*linesw[tp->t_line].l_close)(tp, flag, p); 276 error |= ttyclose(tp); 277 ptcwakeup(tp, FREAD|FWRITE); 278 return (error); 279 } 280 281 int 282 ptsread(dev_t dev, struct uio *uio, int flag) 283 { 284 struct proc *p = curproc; 285 struct process *pr = p->p_p; 286 struct pt_softc *pti = pt_softc[minor(dev)]; 287 struct tty *tp = pti->pt_tty; 288 int error = 0; 289 290 again: 291 if (pti->pt_flags & PF_REMOTE) { 292 while (isbackground(pr, tp)) { 293 if (sigismasked(p, 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_locked(&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 (ISSET(tp->t_state, TS_ISOPEN)) { 675 if (!ISSET(tp->t_state, TS_TTSTOP)) 676 kn->kn_data = tp->t_outq.c_cc; 677 if (((pti->pt_flags & PF_PKT) && pti->pt_send) || 678 ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl)) 679 kn->kn_data++; 680 } 681 682 if (!ISSET(tp->t_state, TS_CARR_ON)) { 683 kn->kn_flags |= EV_EOF; 684 if (kn->kn_flags & __EV_POLL) 685 kn->kn_flags |= __EV_HUP; 686 return (1); 687 } 688 689 return (kn->kn_data > 0); 690 } 691 692 void 693 filt_ptcwdetach(struct knote *kn) 694 { 695 struct pt_softc *pti = (struct pt_softc *)kn->kn_hook; 696 int s; 697 698 s = spltty(); 699 klist_remove_locked(&pti->pt_selw.si_note, kn); 700 splx(s); 701 } 702 703 int 704 filt_ptcwrite(struct knote *kn, long hint) 705 { 706 struct pt_softc *pti = (struct pt_softc *)kn->kn_hook; 707 struct tty *tp; 708 709 tp = pti->pt_tty; 710 kn->kn_data = 0; 711 712 if (ISSET(tp->t_state, TS_ISOPEN)) { 713 if (ISSET(pti->pt_flags, PF_REMOTE)) { 714 if (tp->t_canq.c_cc == 0) 715 kn->kn_data = tp->t_canq.c_cn; 716 } else if ((tp->t_rawq.c_cc + tp->t_canq.c_cc < TTYHOG(tp)-2) || 717 (tp->t_canq.c_cc == 0 && ISSET(tp->t_lflag, ICANON))) 718 kn->kn_data = tp->t_canq.c_cn - 719 (tp->t_rawq.c_cc + tp->t_canq.c_cc); 720 } 721 722 return (kn->kn_data > 0); 723 } 724 725 int 726 filt_ptcexcept(struct knote *kn, long hint) 727 { 728 struct pt_softc *pti = (struct pt_softc *)kn->kn_hook; 729 struct tty *tp; 730 731 tp = pti->pt_tty; 732 733 if (kn->kn_sfflags & NOTE_OOB) { 734 /* If in packet or user control mode, check for data. */ 735 if (((pti->pt_flags & PF_PKT) && pti->pt_send) || 736 ((pti->pt_flags & PF_UCNTL) && pti->pt_ucntl)) { 737 kn->kn_fflags |= NOTE_OOB; 738 kn->kn_data = 1; 739 return (1); 740 } 741 return (0); 742 } 743 if (!ISSET(tp->t_state, TS_CARR_ON)) { 744 kn->kn_flags |= EV_EOF; 745 if (kn->kn_flags & __EV_POLL) 746 kn->kn_flags |= __EV_HUP; 747 return (1); 748 } 749 750 return (0); 751 } 752 753 const struct filterops ptcread_filtops = { 754 .f_flags = FILTEROP_ISFD, 755 .f_attach = NULL, 756 .f_detach = filt_ptcrdetach, 757 .f_event = filt_ptcread, 758 }; 759 760 const struct filterops ptcwrite_filtops = { 761 .f_flags = FILTEROP_ISFD, 762 .f_attach = NULL, 763 .f_detach = filt_ptcwdetach, 764 .f_event = filt_ptcwrite, 765 }; 766 767 const struct filterops ptcexcept_filtops = { 768 .f_flags = FILTEROP_ISFD, 769 .f_attach = NULL, 770 .f_detach = filt_ptcrdetach, 771 .f_event = filt_ptcexcept, 772 }; 773 774 int 775 ptckqfilter(dev_t dev, struct knote *kn) 776 { 777 struct pt_softc *pti = pt_softc[minor(dev)]; 778 struct klist *klist; 779 int s; 780 781 switch (kn->kn_filter) { 782 case EVFILT_READ: 783 klist = &pti->pt_selr.si_note; 784 kn->kn_fop = &ptcread_filtops; 785 break; 786 case EVFILT_WRITE: 787 klist = &pti->pt_selw.si_note; 788 kn->kn_fop = &ptcwrite_filtops; 789 break; 790 case EVFILT_EXCEPT: 791 klist = &pti->pt_selr.si_note; 792 kn->kn_fop = &ptcexcept_filtops; 793 break; 794 default: 795 return (EINVAL); 796 } 797 798 kn->kn_hook = (caddr_t)pti; 799 800 s = spltty(); 801 klist_insert_locked(klist, kn); 802 splx(s); 803 804 return (0); 805 } 806 807 struct tty * 808 ptytty(dev_t dev) 809 { 810 struct pt_softc *pti = pt_softc[minor(dev)]; 811 struct tty *tp = pti->pt_tty; 812 813 return (tp); 814 } 815 816 int 817 ptyioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) 818 { 819 struct pt_softc *pti = pt_softc[minor(dev)]; 820 struct tty *tp = pti->pt_tty; 821 u_char *cc = tp->t_cc; 822 int stop, error; 823 824 /* 825 * IF CONTROLLER STTY THEN MUST FLUSH TO PREVENT A HANG. 826 * ttywflush(tp) will hang if there are characters in the outq. 827 */ 828 if (cmd == TIOCEXT) { 829 /* 830 * When the EXTPROC bit is being toggled, we need 831 * to send an TIOCPKT_IOCTL if the packet driver 832 * is turned on. 833 */ 834 if (*(int *)data) { 835 if (pti->pt_flags & PF_PKT) { 836 pti->pt_send |= TIOCPKT_IOCTL; 837 ptcwakeup(tp, FREAD); 838 } 839 tp->t_lflag |= EXTPROC; 840 } else { 841 if ((tp->t_lflag & EXTPROC) && 842 (pti->pt_flags & PF_PKT)) { 843 pti->pt_send |= TIOCPKT_IOCTL; 844 ptcwakeup(tp, FREAD); 845 } 846 tp->t_lflag &= ~EXTPROC; 847 } 848 return(0); 849 } else if (cdevsw[major(dev)].d_open == ptcopen) 850 switch (cmd) { 851 852 case TIOCGPGRP: 853 /* 854 * We avoid calling ttioctl on the controller since, 855 * in that case, tp must be the controlling terminal. 856 */ 857 *(int *)data = tp->t_pgrp ? tp->t_pgrp->pg_id : 0; 858 return (0); 859 860 case TIOCPKT: 861 if (*(int *)data) { 862 if (pti->pt_flags & PF_UCNTL) 863 return (EINVAL); 864 pti->pt_flags |= PF_PKT; 865 } else 866 pti->pt_flags &= ~PF_PKT; 867 return (0); 868 869 case TIOCUCNTL: 870 if (*(int *)data) { 871 if (pti->pt_flags & PF_PKT) 872 return (EINVAL); 873 pti->pt_flags |= PF_UCNTL; 874 } else 875 pti->pt_flags &= ~PF_UCNTL; 876 return (0); 877 878 case TIOCREMOTE: 879 if (*(int *)data) 880 pti->pt_flags |= PF_REMOTE; 881 else 882 pti->pt_flags &= ~PF_REMOTE; 883 ttyflush(tp, FREAD|FWRITE); 884 return (0); 885 886 case TIOCSETD: 887 case TIOCSETA: 888 case TIOCSETAW: 889 case TIOCSETAF: 890 ndflush(&tp->t_outq, tp->t_outq.c_cc); 891 break; 892 893 case TIOCSIG: 894 if (*(unsigned int *)data >= NSIG || 895 *(unsigned int *)data == 0) 896 return(EINVAL); 897 if ((tp->t_lflag & NOFLSH) == 0) 898 ttyflush(tp, FREAD|FWRITE); 899 pgsignal(tp->t_pgrp, *(unsigned int *)data, 1); 900 if ((*(unsigned int *)data == SIGINFO) && 901 ((tp->t_lflag & NOKERNINFO) == 0)) 902 ttyinfo(tp); 903 return (0); 904 905 case FIONREAD: 906 /* 907 * FIONREAD on the master side must return the amount 908 * in the output queue rather than the input. 909 */ 910 *(int *)data = tp->t_outq.c_cc; 911 return (0); 912 } 913 error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p); 914 if (error < 0) 915 error = ttioctl(tp, cmd, data, flag, p); 916 if (error < 0) { 917 /* 918 * Translate TIOCSBRK/TIOCCBRK to user mode ioctls to 919 * let the master interpret BREAK conditions. 920 */ 921 switch (cmd) { 922 case TIOCSBRK: 923 cmd = UIOCCMD(TIOCUCNTL_SBRK); 924 break; 925 case TIOCCBRK: 926 cmd = UIOCCMD(TIOCUCNTL_CBRK); 927 break; 928 default: 929 break; 930 } 931 if (pti->pt_flags & PF_UCNTL && 932 (cmd & ~0xff) == UIOCCMD(0)) { 933 if (cmd & 0xff) { 934 pti->pt_ucntl = (u_char)cmd; 935 ptcwakeup(tp, FREAD); 936 } 937 return (0); 938 } 939 error = ENOTTY; 940 } 941 /* 942 * If external processing and packet mode send ioctl packet. 943 */ 944 if ((tp->t_lflag & EXTPROC) && (pti->pt_flags & PF_PKT)) { 945 switch (cmd) { 946 case TIOCSETA: 947 case TIOCSETAW: 948 case TIOCSETAF: 949 pti->pt_send |= TIOCPKT_IOCTL; 950 ptcwakeup(tp, FREAD); 951 default: 952 break; 953 } 954 } 955 stop = (tp->t_iflag & IXON) && CCEQ(cc[VSTOP], CTRL('s')) && 956 CCEQ(cc[VSTART], CTRL('q')); 957 if (pti->pt_flags & PF_NOSTOP) { 958 if (stop) { 959 pti->pt_send &= ~TIOCPKT_NOSTOP; 960 pti->pt_send |= TIOCPKT_DOSTOP; 961 pti->pt_flags &= ~PF_NOSTOP; 962 ptcwakeup(tp, FREAD); 963 } 964 } else { 965 if (!stop) { 966 pti->pt_send &= ~TIOCPKT_DOSTOP; 967 pti->pt_send |= TIOCPKT_NOSTOP; 968 pti->pt_flags |= PF_NOSTOP; 969 ptcwakeup(tp, FREAD); 970 } 971 } 972 return (error); 973 } 974 975 /* 976 * Return pty-related information. 977 */ 978 int 979 sysctl_pty(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, 980 size_t newlen) 981 { 982 if (namelen != 1) 983 return (ENOTDIR); 984 985 switch (name[0]) { 986 default: 987 return (EOPNOTSUPP); 988 } 989 /* NOTREACHED */ 990 } 991 992 /* 993 * Check if a pty is free to use. 994 */ 995 static int 996 pty_isfree_locked(int minor) 997 { 998 struct pt_softc *pt = pt_softc[minor]; 999 1000 return (pt == NULL || pt->pt_tty == NULL || 1001 pt->pt_tty->t_oproc == NULL); 1002 } 1003 1004 static int 1005 pty_isfree(int minor) 1006 { 1007 int isfree; 1008 1009 rw_enter_read(&pt_softc_lock); 1010 isfree = pty_isfree_locked(minor); 1011 rw_exit_read(&pt_softc_lock); 1012 return(isfree); 1013 } 1014 1015 dev_t 1016 pty_getfree(void) 1017 { 1018 int i; 1019 1020 rw_enter_read(&pt_softc_lock); 1021 for (i = 0; i < npty; i++) { 1022 if (pty_isfree_locked(i)) 1023 break; 1024 } 1025 rw_exit_read(&pt_softc_lock); 1026 return (makedev(pts_major, i)); 1027 } 1028 1029 /* 1030 * Hacked up version of vn_open. We _only_ handle ptys and only open 1031 * them with FREAD|FWRITE and never deal with creat or stuff like that. 1032 * 1033 * We need it because we have to fake up root credentials to open the pty. 1034 */ 1035 static int 1036 ptm_vn_open(struct nameidata *ndp) 1037 { 1038 struct proc *p = ndp->ni_cnd.cn_proc; 1039 struct ucred *cred; 1040 struct vattr vattr; 1041 struct vnode *vp; 1042 int error; 1043 1044 if ((error = namei(ndp)) != 0) 1045 return (error); 1046 vp = ndp->ni_vp; 1047 if (vp->v_type != VCHR) { 1048 error = EINVAL; 1049 goto bad; 1050 } 1051 1052 /* 1053 * Get us a fresh cred with root privileges. 1054 */ 1055 cred = crget(); 1056 error = VOP_OPEN(vp, FREAD|FWRITE, cred, p); 1057 if (!error) { 1058 /* update atime/mtime */ 1059 VATTR_NULL(&vattr); 1060 getnanotime(&vattr.va_atime); 1061 vattr.va_mtime = vattr.va_atime; 1062 vattr.va_vaflags |= VA_UTIMES_NULL; 1063 (void)VOP_SETATTR(vp, &vattr, p->p_ucred, p); 1064 } 1065 crfree(cred); 1066 1067 if (error) 1068 goto bad; 1069 1070 vp->v_writecount++; 1071 1072 return (0); 1073 bad: 1074 vput(vp); 1075 return (error); 1076 } 1077 1078 void 1079 ptmattach(int n) 1080 { 1081 /* find the major and minor of the pty devices */ 1082 int i; 1083 1084 for (i = 0; i < nchrdev; i++) 1085 if (cdevsw[i].d_open == ptsopen) 1086 break; 1087 1088 if (i == nchrdev) 1089 panic("ptmattach: Can't find pty slave in cdevsw"); 1090 1091 pts_major = i; 1092 } 1093 1094 int 1095 ptmopen(dev_t dev, int flag, int mode, struct proc *p) 1096 { 1097 return(0); 1098 } 1099 1100 1101 int 1102 ptmclose(dev_t dev, int flag, int mode, struct proc *p) 1103 { 1104 return (0); 1105 } 1106 1107 int 1108 ptmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) 1109 { 1110 dev_t newdev; 1111 struct pt_softc * pti; 1112 struct nameidata cnd, snd; 1113 struct filedesc *fdp = p->p_fd; 1114 struct file *cfp = NULL, *sfp = NULL; 1115 int cindx, sindx, error; 1116 uid_t uid; 1117 gid_t gid; 1118 struct vattr vattr; 1119 struct ucred *cred; 1120 struct ptmget *ptm = (struct ptmget *)data; 1121 1122 switch (cmd) { 1123 case PTMGET: 1124 fdplock(fdp); 1125 /* Grab two filedescriptors. */ 1126 if ((error = falloc(p, &cfp, &cindx)) != 0) { 1127 fdpunlock(fdp); 1128 break; 1129 } 1130 if ((error = falloc(p, &sfp, &sindx)) != 0) { 1131 fdremove(fdp, cindx); 1132 fdpunlock(fdp); 1133 closef(cfp, p); 1134 break; 1135 } 1136 fdpunlock(fdp); 1137 1138 retry: 1139 /* Find and open a free master pty. */ 1140 newdev = pty_getfree(); 1141 if ((error = check_pty(newdev))) 1142 goto bad; 1143 pti = pt_softc[minor(newdev)]; 1144 NDINIT(&cnd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE, 1145 pti->pty_pn, p); 1146 cnd.ni_pledge = PLEDGE_RPATH | PLEDGE_WPATH; 1147 if ((error = ptm_vn_open(&cnd)) != 0) { 1148 /* 1149 * Check if the master open failed because we lost 1150 * the race to grab it. 1151 */ 1152 if (error == EIO && !pty_isfree(minor(newdev))) 1153 goto retry; 1154 goto bad; 1155 } 1156 cfp->f_flag = FREAD|FWRITE; 1157 cfp->f_type = DTYPE_VNODE; 1158 cfp->f_ops = &vnops; 1159 cfp->f_data = (caddr_t) cnd.ni_vp; 1160 VOP_UNLOCK(cnd.ni_vp); 1161 1162 /* 1163 * Open the slave. 1164 * namei -> setattr -> unlock -> revoke -> vrele -> 1165 * namei -> open -> unlock 1166 * Three stage rocket: 1167 * 1. Change the owner and permissions on the slave. 1168 * 2. Revoke all the users of the slave. 1169 * 3. open the slave. 1170 */ 1171 NDINIT(&snd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE, 1172 pti->pty_sn, p); 1173 snd.ni_pledge = PLEDGE_RPATH | PLEDGE_WPATH; 1174 snd.ni_unveil = UNVEIL_READ | UNVEIL_WRITE; 1175 if ((error = namei(&snd)) != 0) 1176 goto bad; 1177 if ((snd.ni_vp->v_mount->mnt_flag & MNT_RDONLY) == 0) { 1178 gid = tty_gid; 1179 /* get real uid */ 1180 uid = p->p_ucred->cr_ruid; 1181 1182 VATTR_NULL(&vattr); 1183 vattr.va_uid = uid; 1184 vattr.va_gid = gid; 1185 vattr.va_mode = (S_IRUSR|S_IWUSR|S_IWGRP) & ALLPERMS; 1186 /* Get a fake cred to pretend we're root. */ 1187 cred = crget(); 1188 error = VOP_SETATTR(snd.ni_vp, &vattr, cred, p); 1189 crfree(cred); 1190 if (error) { 1191 vput(snd.ni_vp); 1192 goto bad; 1193 } 1194 } 1195 VOP_UNLOCK(snd.ni_vp); 1196 if (snd.ni_vp->v_usecount > 1 || 1197 (snd.ni_vp->v_flag & (VALIASED))) 1198 VOP_REVOKE(snd.ni_vp, REVOKEALL); 1199 1200 /* 1201 * The vnode is useless after the revoke, we need to 1202 * namei again. 1203 */ 1204 vrele(snd.ni_vp); 1205 1206 NDINIT(&snd, LOOKUP, NOFOLLOW|LOCKLEAF, UIO_SYSSPACE, 1207 pti->pty_sn, p); 1208 snd.ni_pledge = PLEDGE_RPATH | PLEDGE_WPATH; 1209 snd.ni_unveil= UNVEIL_READ | UNVEIL_WRITE; 1210 /* now open it */ 1211 if ((error = ptm_vn_open(&snd)) != 0) 1212 goto bad; 1213 sfp->f_flag = FREAD|FWRITE; 1214 sfp->f_type = DTYPE_VNODE; 1215 sfp->f_ops = &vnops; 1216 sfp->f_data = (caddr_t) snd.ni_vp; 1217 VOP_UNLOCK(snd.ni_vp); 1218 1219 /* now, put the indexen and names into struct ptmget */ 1220 ptm->cfd = cindx; 1221 ptm->sfd = sindx; 1222 memcpy(ptm->cn, pti->pty_pn, sizeof(pti->pty_pn)); 1223 memcpy(ptm->sn, pti->pty_sn, sizeof(pti->pty_sn)); 1224 1225 /* insert files now that we've passed all errors */ 1226 fdplock(fdp); 1227 fdinsert(fdp, cindx, 0, cfp); 1228 fdinsert(fdp, sindx, 0, sfp); 1229 fdpunlock(fdp); 1230 FRELE(cfp, p); 1231 FRELE(sfp, p); 1232 break; 1233 default: 1234 error = EINVAL; 1235 break; 1236 } 1237 return (error); 1238 bad: 1239 fdplock(fdp); 1240 fdremove(fdp, cindx); 1241 fdremove(fdp, sindx); 1242 fdpunlock(fdp); 1243 closef(cfp, p); 1244 closef(sfp, p); 1245 return (error); 1246 } 1247