1 /* pty.c - pseudo terminal driver Author: Kees J. Bot 2 * 30 Dec 1995 3 * PTYs can be seen as a bidirectional pipe with TTY 4 * input and output processing. For example a simple rlogin session: 5 * 6 * keyboard -> rlogin -> in.rld -> /dev/ptypX -> /dev/ttypX -> shell 7 * shell -> /dev/ttypX -> /dev/ptypX -> in.rld -> rlogin -> screen 8 * 9 * This file takes care of copying data between the tty/pty device pairs and 10 * the open/read/write/close calls on the pty devices. The TTY task takes 11 * care of the input and output processing (interrupt, backspace, raw I/O, 12 * etc.) using the pty_slave_read() and pty_slave_write() functions as the 13 * "keyboard" and "screen" functions of the ttypX devices. 14 * Be careful when reading this code, the terms "reading" and "writing" are 15 * used both for the tty (slave) and the pty (master) end of the pseudo tty. 16 * Writes to one end are to be read at the other end and vice-versa. 17 * 18 * In addition to the above, PTY service now also supports Unix98 pseudo- 19 * terminal pairs, thereby allowing non-root users to allocate pseudoterminals. 20 * It requires the presence for PTYFS for this, and supports only old-style 21 * ptys when PTYFS is not running. For Unix98 ptys, the general idea is that a 22 * userland program opens a pty master by opening /dev/ptmx through the use of 23 * posxix_openpt(3). A slave node is allocated on PTYFS when the program calls 24 * grantpt(3) on the master. The program can then obtain the path name for the 25 * slave end through ptsname(3), and open the slave end using this path. 26 * 27 * Implementation-wise, the Unix98 and non-Unix98 pseudoterminals share the 28 * same pool of data structures, but use different ranges of minor numbers. 29 * Access to the two types may not be mixed, and thus, some parts of the code 30 * have checks to make sure a traditional slave is not opened for a master 31 * allocated through /dev/ptmx, etcetera. 32 */ 33 34 #include <minix/drivers.h> 35 #include <paths.h> 36 #include <termios.h> 37 #include <assert.h> 38 #include <sys/termios.h> 39 #include <signal.h> 40 #include "tty.h" 41 #include "ptyfs.h" 42 43 /* Device node attributes used for Unix98 slave nodes. */ 44 #define UNIX98_MODE (S_IFCHR | 0620) /* crw--w---- */ 45 46 #define UNIX98_MASTER(index) (UNIX98_MINOR + (index) * 2) 47 #define UNIX98_SLAVE(index) (UNIX98_MINOR + (index) * 2 + 1) 48 49 /* PTY bookkeeping structure, one per pty/tty pair. */ 50 typedef struct pty { 51 tty_t *tty; /* associated TTY structure */ 52 char state; /* flags: busy, closed, ... */ 53 54 /* Read call on master (/dev/ptypX). */ 55 endpoint_t rdcaller; /* process making the call, or NONE if none */ 56 cdev_id_t rdid; /* ID of suspended read request */ 57 cp_grant_id_t rdgrant; /* grant for reader's address space */ 58 size_t rdleft; /* # bytes yet to be read */ 59 size_t rdcum; /* # bytes written so far */ 60 61 /* Write call to master (/dev/ptypX). */ 62 endpoint_t wrcaller; /* process making the call, or NONE if none*/ 63 cdev_id_t wrid; /* ID of suspended write request */ 64 cp_grant_id_t wrgrant; /* grant for writer's address space */ 65 size_t wrleft; /* # bytes yet to be written */ 66 size_t wrcum; /* # bytes written so far */ 67 68 /* Output buffer. */ 69 int ocount; /* # characters in the buffer */ 70 char *ohead, *otail; /* head and tail of the circular buffer */ 71 char obuf[TTY_OUT_BYTES]; 72 /* buffer for bytes going to the pty reader */ 73 74 /* select() data. */ 75 unsigned int select_ops; /* Which operations do we want to know about? */ 76 endpoint_t select_proc; /* Who wants to know about it? */ 77 devminor_t select_minor; /* Which minor was being selected on? */ 78 } pty_t; 79 80 #define TTY_ACTIVE 0x01 /* tty is open/active */ 81 #define PTY_ACTIVE 0x02 /* pty is open/active */ 82 #define TTY_CLOSED 0x04 /* tty side has closed down */ 83 #define PTY_CLOSED 0x08 /* pty side has closed down */ 84 #define PTY_UNIX98 0x10 /* pty pair is Unix98 */ 85 #define PTY_PKTMODE 0x20 /* pty side is in packet mode (TIOCPKT) */ 86 87 static pty_t pty_table[NR_PTYS]; /* PTY bookkeeping */ 88 89 static void pty_start(pty_t *pp); 90 static void pty_finish(pty_t *pp); 91 92 static int pty_master_open(devminor_t minor, int access, 93 endpoint_t user_endpt); 94 static int pty_master_close(devminor_t minor); 95 static ssize_t pty_master_read(devminor_t minor, u64_t position, 96 endpoint_t endpt, cp_grant_id_t grant, size_t size, int flags, 97 cdev_id_t id); 98 static ssize_t pty_master_write(devminor_t minor, u64_t position, 99 endpoint_t endpt, cp_grant_id_t grant, size_t size, int flags, 100 cdev_id_t id); 101 static int pty_master_ioctl(devminor_t minor, unsigned long request, 102 endpoint_t endpt, cp_grant_id_t grant, int flags, 103 endpoint_t user_endpt, cdev_id_t id); 104 static int pty_master_cancel(devminor_t minor, endpoint_t endpt, cdev_id_t id); 105 static int pty_master_select(devminor_t minor, unsigned int ops, 106 endpoint_t endpt); 107 108 static struct chardriver pty_master_tab = { 109 .cdr_open = pty_master_open, 110 .cdr_close = pty_master_close, 111 .cdr_read = pty_master_read, 112 .cdr_write = pty_master_write, 113 .cdr_ioctl = pty_master_ioctl, 114 .cdr_cancel = pty_master_cancel, 115 .cdr_select = pty_master_select 116 }; 117 118 /*===========================================================================* 119 * get_free_pty * 120 *===========================================================================*/ 121 static tty_t *get_free_pty(void) 122 { 123 /* Return a pointer to a free tty structure, or NULL if no tty is free. */ 124 tty_t *tp; 125 pty_t *pp; 126 127 for (tp = &tty_table[0]; tp < &tty_table[NR_PTYS]; tp++) { 128 pp = tp->tty_priv; 129 130 if (!(pp->state & (PTY_ACTIVE | TTY_ACTIVE))) 131 return tp; 132 } 133 134 return NULL; 135 } 136 137 /*===========================================================================* 138 * pty_master_open * 139 *===========================================================================*/ 140 static int pty_master_open(devminor_t minor, int UNUSED(access), 141 endpoint_t UNUSED(user_endpt)) 142 { 143 tty_t *tp; 144 pty_t *pp; 145 int r; 146 147 if (minor == PTMX_MINOR) { 148 /* /dev/ptmx acts as a cloning device. We return a free PTY master and 149 * mark it as a UNIX98 type. 150 */ 151 if ((tp = get_free_pty()) == NULL) 152 return EAGAIN; /* POSIX says this is the right error code */ 153 154 /* The following call has two purposes. First, we check right here 155 * whether PTYFS is running at all; if not, the PTMX device cannot be 156 * opened at all and userland can fall back to other allocation 157 * methods right away. Second, in the exceptional case that the PTY 158 * service is restarted while PTYFS keeps running, PTYFS may expose 159 * stale slave nodes, which are a security hole if not removed as soon 160 * as a new PTY pair is allocated. 161 */ 162 if (ptyfs_clear(tp->tty_index) != OK) 163 return EAGAIN; 164 165 pp = tp->tty_priv; 166 pp->state |= PTY_UNIX98; 167 168 minor = UNIX98_MASTER(tp->tty_index); 169 170 r = CDEV_CLONED | minor; 171 } else { 172 /* There is no way to open Unix98 masters directly, except by messing 173 * with mknod. We disallow such tricks altogether, and thus, the rest 174 * of the code deals with opening a non-Unix98 master only. 175 */ 176 if (minor < PTYPX_MINOR || minor >= PTYPX_MINOR + NR_PTYS) 177 return EIO; 178 179 if ((tp = line2tty(minor)) == NULL) 180 return ENXIO; 181 pp = tp->tty_priv; 182 183 /* For non-Unix98 PTYs, we allow the slave to be opened before the 184 * master, but the master may be opened only once. This is how userland 185 * is able to find a free non-Unix98 PTY pair. 186 */ 187 if (pp->state & PTY_ACTIVE) 188 return EIO; 189 assert(!(pp->state & PTY_UNIX98)); 190 191 r = OK; 192 } 193 194 pp->state |= PTY_ACTIVE; 195 196 pp->rdcum = 0; 197 pp->wrcum = 0; 198 199 return r; 200 } 201 202 /*===========================================================================* 203 * pty_reset * 204 *===========================================================================*/ 205 static void pty_reset(tty_t *tp) 206 { 207 /* Both sides of a PTY pair have been closed. Clean up its state. */ 208 pty_t *pp; 209 210 pp = tp->tty_priv; 211 212 /* For Unix98 pairs, clean up the Unix98 slave node. It may never have been 213 * allocated, but we don't care. Ignore failures altogether. 214 */ 215 if (pp->state & PTY_UNIX98) 216 (void)ptyfs_clear(tp->tty_index); 217 218 pp->state = 0; 219 } 220 221 /*===========================================================================* 222 * pty_master_close * 223 *===========================================================================*/ 224 static int pty_master_close(devminor_t minor) 225 { 226 tty_t *tp; 227 pty_t *pp; 228 229 if ((tp = line2tty(minor)) == NULL) 230 return ENXIO; 231 pp = tp->tty_priv; 232 233 if ((pp->state & (TTY_ACTIVE | TTY_CLOSED)) != TTY_ACTIVE) { 234 pty_reset(tp); 235 } else { 236 pp->state |= PTY_CLOSED; 237 tp->tty_termios.c_ospeed = B0; /* cause EOF on slave side */ 238 sigchar(tp, SIGHUP, 1); 239 } 240 241 return OK; 242 } 243 244 /*===========================================================================* 245 * pty_master_read * 246 *===========================================================================*/ 247 static ssize_t pty_master_read(devminor_t minor, u64_t UNUSED(position), 248 endpoint_t endpt, cp_grant_id_t grant, size_t size, int flags, 249 cdev_id_t id) 250 { 251 tty_t *tp; 252 pty_t *pp; 253 ssize_t r; 254 255 if ((tp = line2tty(minor)) == NULL) 256 return ENXIO; 257 pp = tp->tty_priv; 258 259 /* Check, store information on the reader, do I/O. */ 260 if (pp->state & TTY_CLOSED) 261 return 0; /* EOF */ 262 263 if (pp->rdcaller != NONE || pp->rdleft != 0 || pp->rdcum != 0) 264 return EIO; 265 266 if (size <= 0) 267 return EINVAL; 268 269 pp->rdcaller = endpt; 270 pp->rdid = id; 271 pp->rdgrant = grant; 272 pp->rdleft = size; 273 pty_start(pp); 274 275 handle_events(tp); 276 277 if (pp->rdleft == 0) { 278 pp->rdcaller = NONE; 279 return EDONTREPLY; /* already done */ 280 } 281 282 if (flags & CDEV_NONBLOCK) { 283 r = pp->rdcum > 0 ? pp->rdcum : EAGAIN; 284 pp->rdleft = pp->rdcum = 0; 285 pp->rdcaller = NONE; 286 return r; 287 } 288 289 return EDONTREPLY; /* do suspend */ 290 } 291 292 /*===========================================================================* 293 * pty_master_write * 294 *===========================================================================*/ 295 static ssize_t pty_master_write(devminor_t minor, u64_t UNUSED(position), 296 endpoint_t endpt, cp_grant_id_t grant, size_t size, int flags, 297 cdev_id_t id) 298 { 299 tty_t *tp; 300 pty_t *pp; 301 ssize_t r; 302 303 if ((tp = line2tty(minor)) == NULL) 304 return ENXIO; 305 pp = tp->tty_priv; 306 307 /* Check, store information on the writer, do I/O. */ 308 if (pp->state & TTY_CLOSED) 309 return EIO; 310 311 if (pp->wrcaller != NONE || pp->wrleft != 0 || pp->wrcum != 0) 312 return EIO; 313 314 if (size <= 0) 315 return EINVAL; 316 317 pp->wrcaller = endpt; 318 pp->wrid = id; 319 pp->wrgrant = grant; 320 pp->wrleft = size; 321 322 handle_events(tp); 323 324 if (pp->wrleft == 0) { 325 pp->wrcaller = NONE; 326 return EDONTREPLY; /* already done */ 327 } 328 329 if (flags & CDEV_NONBLOCK) { 330 r = pp->wrcum > 0 ? pp->wrcum : EAGAIN; 331 pp->wrleft = pp->wrcum = 0; 332 pp->wrcaller = NONE; 333 return r; 334 } 335 336 return EDONTREPLY; /* do suspend */ 337 } 338 339 /*===========================================================================* 340 * pty_master_ioctl * 341 *===========================================================================*/ 342 static int pty_master_ioctl(devminor_t minor, unsigned long request, 343 endpoint_t endpt, cp_grant_id_t grant, int flags, 344 endpoint_t user_endpt, cdev_id_t id) 345 { 346 tty_t *tp; 347 pty_t *pp; 348 uid_t uid; 349 struct ptmget pm; 350 size_t len; 351 int r, val; 352 353 if ((tp = line2tty(minor)) == NULL) 354 return ENXIO; 355 pp = tp->tty_priv; 356 357 /* Some IOCTLs are for the master side only. */ 358 switch (request) { 359 case TIOCGRANTPT: /* grantpt(3) */ 360 if (!(pp->state & PTY_UNIX98)) 361 break; 362 363 if ((int)(uid = getnuid(user_endpt)) == -1) 364 return EACCES; 365 if (tty_gid == -1) { 366 printf("PTY: no tty group ID given at startup\n"); 367 return EACCES; 368 } 369 370 /* Create or update the slave node. */ 371 if (ptyfs_set(tp->tty_index, UNIX98_MODE, uid, tty_gid, 372 makedev(PTY_MAJOR, UNIX98_SLAVE(tp->tty_index))) != OK) 373 return EACCES; 374 375 return OK; 376 377 case TIOCPTSNAME: /* ptsname(3) */ 378 if (!(pp->state & PTY_UNIX98)) 379 break; 380 381 /* Since pm.sn is 16 bytes, we can have up to a million slaves. */ 382 memset(&pm, 0, sizeof(pm)); 383 384 strlcpy(pm.sn, _PATH_DEV_PTS, sizeof(pm.sn)); 385 len = strlen(pm.sn); 386 387 if (ptyfs_name(tp->tty_index, &pm.sn[len], sizeof(pm.sn) - len) != OK) 388 return EINVAL; 389 390 return sys_safecopyto(endpt, grant, 0, (vir_bytes)&pm, sizeof(pm)); 391 392 case TIOCPKT: 393 r = sys_safecopyfrom(endpt, grant, 0, (vir_bytes)&val, sizeof(val)); 394 if (r != OK) 395 return r; 396 397 if (val) 398 pp->state |= PTY_PKTMODE; 399 else 400 pp->state &= ~PTY_PKTMODE; 401 402 return OK; 403 } 404 405 /* TODO: historically, all IOCTLs on the master are processed as if issued on 406 * the slave end. Make sure that this can not cause problems, in particular 407 * with blocking IOCTLs. 408 */ 409 return tty_ioctl(minor, request, endpt, grant, flags, user_endpt, id); 410 } 411 412 /*===========================================================================* 413 * pty_master_cancel * 414 *===========================================================================*/ 415 static int pty_master_cancel(devminor_t minor, endpoint_t endpt, cdev_id_t id) 416 { 417 tty_t *tp; 418 pty_t *pp; 419 int r; 420 421 if ((tp = line2tty(minor)) == NULL) 422 return ENXIO; 423 pp = tp->tty_priv; 424 425 if (pp->rdcaller == endpt && pp->rdid == id) { 426 /* Cancel a read from a PTY. */ 427 r = pp->rdcum > 0 ? pp->rdcum : EINTR; 428 pp->rdleft = pp->rdcum = 0; 429 pp->rdcaller = NONE; 430 return r; 431 } 432 433 if (pp->wrcaller == endpt && pp->wrid == id) { 434 /* Cancel a write to a PTY. */ 435 r = pp->wrcum > 0 ? pp->wrcum : EINTR; 436 pp->wrleft = pp->wrcum = 0; 437 pp->wrcaller = NONE; 438 return r; 439 } 440 441 /* Request not found. */ 442 return EDONTREPLY; 443 } 444 445 /*===========================================================================* 446 * select_try_pty * 447 *===========================================================================*/ 448 static int select_try_pty(tty_t *tp, int ops) 449 { 450 pty_t *pp = tp->tty_priv; 451 int r = 0; 452 453 if (ops & CDEV_OP_WR) { 454 /* Write won't block on error. */ 455 if (pp->state & TTY_CLOSED) r |= CDEV_OP_WR; 456 else if (pp->wrleft != 0 || pp->wrcum != 0) r |= CDEV_OP_WR; 457 else if (tp->tty_incount < buflen(tp->tty_inbuf)) r |= CDEV_OP_WR; 458 } 459 460 if (ops & CDEV_OP_RD) { 461 /* Read won't block on error. */ 462 if (pp->state & TTY_CLOSED) r |= CDEV_OP_RD; 463 else if (pp->rdleft != 0 || pp->rdcum != 0) r |= CDEV_OP_RD; 464 else if (pp->ocount > 0) r |= CDEV_OP_RD; /* Actual data. */ 465 } 466 467 return r; 468 } 469 470 /*===========================================================================* 471 * select_retry_pty * 472 *===========================================================================*/ 473 void select_retry_pty(tty_t *tp) 474 { 475 pty_t *pp = tp->tty_priv; 476 int r; 477 478 /* See if the pty side of a pty is ready to return a select. */ 479 if (pp->select_ops && (r = select_try_pty(tp, pp->select_ops))) { 480 chardriver_reply_select(pp->select_proc, pp->select_minor, r); 481 pp->select_ops &= ~r; 482 } 483 } 484 485 /*===========================================================================* 486 * pty_master_select * 487 *===========================================================================*/ 488 static int pty_master_select(devminor_t minor, unsigned int ops, 489 endpoint_t endpt) 490 { 491 tty_t *tp; 492 pty_t *pp; 493 int ready_ops, watch; 494 495 if ((tp = line2tty(minor)) == NULL) 496 return ENXIO; 497 pp = tp->tty_priv; 498 499 watch = (ops & CDEV_NOTIFY); 500 ops &= (CDEV_OP_RD | CDEV_OP_WR | CDEV_OP_ERR); 501 502 ready_ops = select_try_pty(tp, ops); 503 504 ops &= ~ready_ops; 505 if (ops && watch) { 506 pp->select_ops |= ops; 507 pp->select_proc = endpt; 508 pp->select_minor = minor; 509 } 510 511 return ready_ops; 512 } 513 514 /*===========================================================================* 515 * do_pty * 516 *===========================================================================*/ 517 void do_pty(message *m_ptr, int ipc_status) 518 { 519 /* Process a request for a PTY master (/dev/ptypX) device. */ 520 521 chardriver_process(&pty_master_tab, m_ptr, ipc_status); 522 } 523 524 /*===========================================================================* 525 * pty_slave_write * 526 *===========================================================================*/ 527 static int pty_slave_write(tty_t *tp, int try) 528 { 529 /* (*dev_write)() routine for PTYs. Transfer bytes from the writer on 530 * /dev/ttypX to the output buffer. 531 */ 532 pty_t *pp = tp->tty_priv; 533 int count, ocount, s; 534 535 /* PTY closed down? */ 536 if (pp->state & PTY_CLOSED) { 537 if (try) return 1; 538 if (tp->tty_outleft > 0) { 539 chardriver_reply_task(tp->tty_outcaller, tp->tty_outid, EIO); 540 tp->tty_outleft = tp->tty_outcum = 0; 541 tp->tty_outcaller = NONE; 542 } 543 return 0; 544 } 545 546 /* While there is something to do. */ 547 for (;;) { 548 ocount = buflen(pp->obuf) - pp->ocount; 549 if (try) return (ocount > 0); 550 count = bufend(pp->obuf) - pp->ohead; 551 if (count > ocount) count = ocount; 552 if (count > tp->tty_outleft) count = tp->tty_outleft; 553 if (count == 0 || tp->tty_inhibited) 554 break; 555 556 /* Copy from user space to the PTY output buffer. */ 557 if (tp->tty_outcaller == KERNEL) { 558 /* We're trying to print on kernel's behalf */ 559 memcpy(pp->ohead, (void *) tp->tty_outgrant + tp->tty_outcum, 560 count); 561 } else { 562 if ((s = sys_safecopyfrom(tp->tty_outcaller, tp->tty_outgrant, 563 tp->tty_outcum, (vir_bytes) pp->ohead, 564 count)) != OK) { 565 break; 566 } 567 } 568 569 /* Perform output processing on the output buffer. */ 570 out_process(tp, pp->obuf, pp->ohead, bufend(pp->obuf), &count, &ocount); 571 if (count == 0) break; 572 573 /* Assume echoing messed up by output. */ 574 tp->tty_reprint = TRUE; 575 576 /* Bookkeeping. */ 577 pp->ocount += ocount; 578 if ((pp->ohead += ocount) >= bufend(pp->obuf)) 579 pp->ohead -= buflen(pp->obuf); 580 pty_start(pp); 581 582 tp->tty_outcum += count; 583 if ((tp->tty_outleft -= count) == 0) { 584 /* Output is finished, reply to the writer. */ 585 chardriver_reply_task(tp->tty_outcaller, tp->tty_outid, 586 tp->tty_outcum); 587 tp->tty_outcum = 0; 588 tp->tty_outcaller = NONE; 589 } 590 } 591 pty_finish(pp); 592 return 1; 593 } 594 595 /*===========================================================================* 596 * pty_slave_echo * 597 *===========================================================================*/ 598 static void pty_slave_echo(tty_t *tp, int c) 599 { 600 /* Echo one character. (Like pty_write, but only one character, optionally.) */ 601 602 pty_t *pp = tp->tty_priv; 603 int count, ocount; 604 605 ocount = buflen(pp->obuf) - pp->ocount; 606 if (ocount == 0) return; /* output buffer full */ 607 count = 1; 608 *pp->ohead = c; /* add one character */ 609 610 out_process(tp, pp->obuf, pp->ohead, bufend(pp->obuf), &count, &ocount); 611 if (count == 0) return; 612 613 pp->ocount += ocount; 614 if ((pp->ohead += ocount) >= bufend(pp->obuf)) pp->ohead -= buflen(pp->obuf); 615 pty_start(pp); 616 } 617 618 /*===========================================================================* 619 * pty_start * 620 *===========================================================================*/ 621 static void pty_start(pty_t *pp) 622 { 623 /* Transfer bytes written to the output buffer to the PTY reader. */ 624 int count; 625 char c; 626 627 /* While there are things to do. */ 628 for (;;) { 629 count = bufend(pp->obuf) - pp->otail; 630 if (count > pp->ocount) count = pp->ocount; 631 if (count == 0 || pp->rdleft == 0) break; 632 633 /* If there is output at all, and packet mode is enabled, then prepend 634 * the output with a zero byte. This is absolutely minimal "support" 635 * for the TIOCPKT receipt mode to get telnetd(8) going. Implementing 636 * full support for all the TIOCPKT bits will require more work. 637 */ 638 if (pp->rdcum == 0 && (pp->state & PTY_PKTMODE)) { 639 c = 0; 640 if (sys_safecopyto(pp->rdcaller, pp->rdgrant, 0, (vir_bytes)&c, 641 sizeof(c)) != OK) 642 break; 643 644 pp->rdcum++; 645 pp->rdleft--; 646 } 647 648 if (count > pp->rdleft) count = pp->rdleft; 649 if (count == 0) break; 650 651 /* Copy from the output buffer to the readers address space. */ 652 if (sys_safecopyto(pp->rdcaller, pp->rdgrant, pp->rdcum, 653 (vir_bytes)pp->otail, count) != OK) 654 break; 655 656 /* Bookkeeping. */ 657 pp->ocount -= count; 658 if ((pp->otail += count) == bufend(pp->obuf)) pp->otail = pp->obuf; 659 pp->rdcum += count; 660 pp->rdleft -= count; 661 } 662 } 663 664 /*===========================================================================* 665 * pty_finish * 666 *===========================================================================*/ 667 static void pty_finish(pty_t *pp) 668 { 669 /* Finish the read request of a PTY reader if there is at least one byte 670 * transferred. 671 */ 672 673 if (pp->rdcum > 0) { 674 chardriver_reply_task(pp->rdcaller, pp->rdid, pp->rdcum); 675 pp->rdleft = pp->rdcum = 0; 676 pp->rdcaller = NONE; 677 } 678 } 679 680 /*===========================================================================* 681 * pty_slave_read * 682 *===========================================================================*/ 683 static int pty_slave_read(tty_t *tp, int try) 684 { 685 /* Offer bytes from the PTY writer for input on the TTY. (Do it one byte at 686 * a time, 99% of the writes will be for one byte, so no sense in being smart.) 687 */ 688 pty_t *pp = tp->tty_priv; 689 char c; 690 691 if (pp->state & PTY_CLOSED) { 692 if (try) return 1; 693 if (tp->tty_inleft > 0) { 694 chardriver_reply_task(tp->tty_incaller, tp->tty_inid, 695 tp->tty_incum); 696 tp->tty_inleft = tp->tty_incum = 0; 697 tp->tty_incaller = NONE; 698 } 699 return 1; 700 } 701 702 if (try) { 703 if (pp->wrleft > 0) 704 return 1; 705 return 0; 706 } 707 708 while (pp->wrleft > 0) { 709 int s; 710 711 /* Transfer one character to 'c'. */ 712 if ((s = sys_safecopyfrom(pp->wrcaller, pp->wrgrant, pp->wrcum, 713 (vir_bytes) &c, 1)) != OK) { 714 printf("pty: safecopy failed (error %d)\n", s); 715 break; 716 } 717 718 /* Input processing. */ 719 if (in_process(tp, &c, 1) == 0) break; 720 721 /* PTY writer bookkeeping. */ 722 pp->wrcum++; 723 if (--pp->wrleft == 0) { 724 chardriver_reply_task(pp->wrcaller, pp->wrid, pp->wrcum); 725 pp->wrcum = 0; 726 pp->wrcaller = NONE; 727 } 728 } 729 730 return 0; 731 } 732 733 /*===========================================================================* 734 * pty_slave_mayopen * 735 *===========================================================================*/ 736 static int pty_slave_mayopen(tty_t *tp, devminor_t line) 737 { 738 /* Check if the user is not mixing Unix98 and non-Unix98 terminal ends. */ 739 pty_t *pp; 740 int unix98_line, unix98_pty; 741 742 pp = tp->tty_priv; 743 744 /* A non-Unix98 slave may be opened even if the corresponding master is not 745 * opened yet, but PTY_UNIX98 is always clear for free ptys. A Unix98 slave 746 * may not be opened before its master, but this should not occur anyway. 747 */ 748 unix98_line = (line >= UNIX98_MINOR && line < UNIX98_MINOR + NR_PTYS * 2); 749 unix98_pty = !!(pp->state & PTY_UNIX98); 750 751 return (unix98_line == unix98_pty); 752 } 753 754 /*===========================================================================* 755 * pty_slave_open * 756 *===========================================================================*/ 757 static int pty_slave_open(tty_t *tp, int UNUSED(try)) 758 { 759 /* The tty side has been opened. */ 760 pty_t *pp = tp->tty_priv; 761 762 /* TTY_ACTIVE may already be set, which would indicate that the slave is 763 * reopened after being fully closed while the master is still open. In that 764 * case TTY_CLOSED will also be set, so clear that one. 765 */ 766 pp->state |= TTY_ACTIVE; 767 pp->state &= ~TTY_CLOSED; 768 769 return 0; 770 } 771 772 /*===========================================================================* 773 * pty_slave_close * 774 *===========================================================================*/ 775 static int pty_slave_close(tty_t *tp, int UNUSED(try)) 776 { 777 /* The tty side has closed, so shut down the pty side. */ 778 pty_t *pp = tp->tty_priv; 779 780 if (!(pp->state & PTY_ACTIVE)) return 0; 781 782 if (pp->rdleft > 0) { 783 chardriver_reply_task(pp->rdcaller, pp->rdid, pp->rdcum); 784 pp->rdleft = pp->rdcum = 0; 785 pp->rdcaller = NONE; 786 } 787 788 if (pp->wrleft > 0) { 789 chardriver_reply_task(pp->wrcaller, pp->wrid, pp->wrcum); 790 pp->wrleft = pp->wrcum = 0; 791 pp->wrcaller = NONE; 792 } 793 794 if (pp->state & PTY_CLOSED) pty_reset(tp); 795 else pp->state |= TTY_CLOSED; 796 797 return 0; 798 } 799 800 /*===========================================================================* 801 * pty_slave_icancel * 802 *===========================================================================*/ 803 static int pty_slave_icancel(tty_t *tp, int UNUSED(try)) 804 { 805 /* Discard waiting input. */ 806 pty_t *pp = tp->tty_priv; 807 808 if (pp->wrleft > 0) { 809 chardriver_reply_task(pp->wrcaller, pp->wrid, pp->wrcum + pp->wrleft); 810 pp->wrcum = pp->wrleft = 0; 811 pp->wrcaller = NONE; 812 } 813 814 return 0; 815 } 816 817 /*===========================================================================* 818 * pty_slave_ocancel * 819 *===========================================================================*/ 820 static int pty_slave_ocancel(tty_t *tp, int UNUSED(try)) 821 { 822 /* Drain the output buffer. */ 823 pty_t *pp = tp->tty_priv; 824 825 pp->ocount = 0; 826 pp->otail = pp->ohead; 827 828 return 0; 829 } 830 831 /*===========================================================================* 832 * pty_init * 833 *===========================================================================*/ 834 void pty_init(tty_t *tp) 835 { 836 pty_t *pp; 837 int line; 838 839 /* Associate PTY and TTY structures. */ 840 line = tp - tty_table; 841 pp = tp->tty_priv = &pty_table[line]; 842 pp->tty = tp; 843 pp->select_ops = 0; 844 pp->rdcaller = NONE; 845 pp->wrcaller = NONE; 846 847 /* Set up output queue. */ 848 pp->ohead = pp->otail = pp->obuf; 849 850 /* Fill in TTY function hooks. */ 851 tp->tty_devread = pty_slave_read; 852 tp->tty_devwrite = pty_slave_write; 853 tp->tty_echo = pty_slave_echo; 854 tp->tty_icancel = pty_slave_icancel; 855 tp->tty_ocancel = pty_slave_ocancel; 856 tp->tty_mayopen = pty_slave_mayopen; 857 tp->tty_open = pty_slave_open; 858 tp->tty_close = pty_slave_close; 859 tp->tty_select_ops = 0; 860 } 861