![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to telnetd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / inet / etc|
Return to telnetd.c CVS log | Up to [Research Unix] / researchv8dc / cmd / inet / etc |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)telnetd.c 4.26 (Berkeley) 83/08/06"; ! 3: #endif ! 4: ! 5: /* ! 6: * Stripped-down telnet server. ! 7: */ ! 8: #include <stdio.h> ! 9: #include <sys/param.h> ! 10: #include <sys/types.h> ! 11: #include <sys/stat.h> ! 12: ! 13: #include <errno.h> ! 14: #include <pwd.h> ! 15: #include <signal.h> ! 16: #include <sgtty.h> ! 17: #include <stdio.h> ! 18: #include <wait.h> ! 19: #include <sys/inet/in.h> ! 20: #include <sys/ttyld.h> ! 21: #include <sys/stream.h> ! 22: #include "config.h" ! 23: #include "telnet.h" ! 24: ! 25: #define BELL '\07' ! 26: #define DEBUG if (debug) ! 27: ! 28: /* option settings (remote and local) */ ! 29: static char hisopts[256]; ! 30: static char myopts[256]; ! 31: ! 32: /* formats for option messages */ ! 33: static char doopt[] = { IAC, DO, '%', 'c', 0 }; ! 34: static char dont[] = { IAC, DONT, '%', 'c', 0 }; ! 35: static char will[] = { IAC, WILL, '%', 'c', 0 }; ! 36: static char wont[] = { IAC, WONT, '%', 'c', 0 }; ! 37: ! 38: static int ptno; /* number of the pt */ ! 39: static int ptfd, netfd; /* fd's to pt and tcp */ ! 40: static int done; /* true if session is to be ended */ ! 41: static int debug; /* true if debugging is to be output */ ! 42: static struct sgttyb ptb; /* result of an IOCGETP on the pt */ ! 43: static struct tchars ptt; /* result of an IOCGETC on the pt */ ! 44: ! 45: /* predefined */ ! 46: static reapchild(); ! 47: static catchint(); ! 48: ! 49: /* imported */ ! 50: extern char **environ; ! 51: extern int errno; ! 52: extern char *strrchr(), *strchr(); ! 53: ! 54: ! 55: /* ! 56: * The following macros and routines are used to ! 57: * manage the I/O buffers. They're a cross between ! 58: * stream buffers and standard I/O. ! 59: */ ! 60: struct buffer { ! 61: char *b_rp; /* read pointer */ ! 62: char *b_wp; /* write pointer */ ! 63: char b_buf[BUFSIZ]; /* the buffer */ ! 64: }; ! 65: struct buffer ptibuf, *ptin = &ptibuf; ! 66: struct buffer ptobuf, *ptout = &ptobuf; ! 67: struct buffer netibuf, *netin = &netibuf; ! 68: struct buffer netobuf, *netout = &netobuf; ! 69: ! 70: #define binit(bp) (bp->b_rp = bp->b_wp = bp->b_buf) ! 71: #define bytes_filled(bp) (bp->b_wp - bp->b_rp) ! 72: #define space_left(bp) (bp->b_buf+sizeof(bp->b_buf) - bp->b_wp) ! 73: #define bput(bp, c) (*(bp->b_wp++) = c) ! 74: #define bget(bp) (*(bp->b_rp++) & 0377) ! 75: ! 76: /* read whatever the buffer can take */ ! 77: static int ! 78: bread(bp, fd) ! 79: struct buffer *bp; ! 80: int fd; ! 81: { ! 82: int cc; ! 83: ! 84: /* normalize the buffer */ ! 85: if (bytes_filled(bp) == 0) ! 86: bp->b_rp = bp->b_wp = bp->b_buf; ! 87: ! 88: /* fill it */ ! 89: cc = read(fd, bp->b_wp, space_left(bp)); ! 90: if (cc > 0) ! 91: bp->b_wp += cc; ! 92: return cc; ! 93: } ! 94: ! 95: /* read at most n bytes */ ! 96: static int ! 97: breadn(bp, fd, n) ! 98: struct buffer *bp; ! 99: int fd, n; ! 100: { ! 101: int cc; ! 102: ! 103: /* normalize the buffer */ ! 104: if (bytes_filled(bp) == 0) ! 105: bp->b_rp = bp->b_wp = bp->b_buf; ! 106: if (n > space_left(bp)) ! 107: n = space_left(bp); ! 108: ! 109: /* fill it */ ! 110: cc = read(fd, bp->b_wp, n); ! 111: if (cc > 0) ! 112: bp->b_wp += cc; ! 113: return cc; ! 114: } ! 115: ! 116: /* empty the buffer */ ! 117: static int ! 118: bwrite(bp, fd) ! 119: struct buffer *bp; ! 120: int fd; ! 121: { ! 122: int cc; ! 123: ! 124: ! 125: cc = write(fd, bp->b_rp, bytes_filled(bp)); ! 126: ! 127: /* normalize the buffer */ ! 128: if (cc == bytes_filled(bp)) ! 129: binit(bp); ! 130: return cc; ! 131: } ! 132: static int ! 133: bputs(bp, s) ! 134: struct buffer *bp; ! 135: char *s; ! 136: { ! 137: while (*s) ! 138: bput(bp, *s++); ! 139: } ! 140: ! 141: /* ! 142: * Establish a tcp socket and fork off a process for each connection. ! 143: */ ! 144: main(argc, argv) ! 145: char *argv[]; ! 146: { ! 147: int pid; ! 148: int f, dev; ! 149: unsigned long faddr; ! 150: int myport, fport; ! 151: struct in_service *sp; ! 152: ! 153: sp = in_service("telnet", "tcp", 0); ! 154: if (sp == 0) { ! 155: fprintf(stderr, "telnetd: tcp/telnet: unknown service\n"); ! 156: exit(1); ! 157: } ! 158: myport = sp->port; ! 159: argc--, argv++; ! 160: if (argc > 0 && !strcmp(*argv, "-d")) { ! 161: debug++; ! 162: argc--, argv++; ! 163: } ! 164: signal(SIGPIPE, SIG_IGN); ! 165: signal(SIGHUP, SIG_IGN); ! 166: ! 167: do { ! 168: f = tcp_sock(); ! 169: if (f < 0) { ! 170: perror("telnetd: socket");; ! 171: sleep(5); ! 172: continue; ! 173: } ! 174: if (tcp_listen(f, myport, 0, 0) < 0) { ! 175: close(f); ! 176: f = -1; ! 177: sleep(30); ! 178: continue; ! 179: } ! 180: } while (f < 0); ! 181: ! 182: signal(SIGCHLD, reapchild); ! 183: for (;;) { ! 184: int s; ! 185: ! 186: s = tcp_accept(f, &faddr, &fport, &dev); ! 187: if (s < 0) { ! 188: if (errno == EINTR) ! 189: continue; ! 190: perror("telnetd: accept"); ! 191: sleep(1); ! 192: continue; ! 193: } ! 194: switch(fork()) { ! 195: case -1: ! 196: printf("Out of processes\n"); ! 197: break; ! 198: case 0: ! 199: doit(s, faddr, fport, dev); ! 200: exit(0); ! 201: } ! 202: close(s); ! 203: } ! 204: /*NOTREACHED*/ ! 205: } ! 206: ! 207: static ! 208: reapchild() ! 209: { ! 210: union wait status; ! 211: ! 212: while (wait3(&status, WNOHANG, 0) > 0) ! 213: ; ! 214: } ! 215: ! 216: char *envinit[] = { "TERM=network", 0 }; ! 217: ! 218: /* ! 219: * Get a pt. Put a login on one side and a telnet receiver on ! 220: * the other. ! 221: */ ! 222: static ! 223: doit(f, faddr, fport, dev) ! 224: int f; ! 225: unsigned long faddr; ! 226: { ! 227: char *host, *in_ntoa(), *ptname(); ! 228: int pfd[2]; ! 229: # define TERMEND pfd[0] ! 230: # define PROCEND pfd[1] ! 231: extern int tty_ld, mesg_ld; ! 232: ! 233: /* get a pt pair */ ! 234: if ((ptno = ptpipe(pfd)) < 0) ! 235: fatalperror(f, "out of pts", errno); ! 236: ! 237: host = (char *)in_host(faddr); ! 238: if (host == 0) ! 239: host = in_ntoa(faddr); ! 240: DEBUG fprintf(stderr, "telnet from %s: login on %s\n", host, ptname(ptno)); ! 241: DEBUG fprintf(stderr, "telnetd pid = %d\n", getpid()); ! 242: ! 243: ! 244: /* get the pt's characteristics */ ! 245: ioctl(PROCEND, TIOCGETC, &ptt); ! 246: ioctl(PROCEND, TIOCGETP, &ptb); ! 247: ! 248: /* make it really look like a terminal */ ! 249: ioctl(TERMEND, FIOPUSHLD, (struct sgttyb *)&mesg_ld); ! 250: ioctl(PROCEND, FIOPUSHLD, (struct sgttyb *)&tty_ld); ! 251: ! 252: /* prepare for the death of a child */ ! 253: signal(SIGCHLD, catchint); ! 254: switch (fork()) { ! 255: case -1: ! 256: fatalperror(f, "fork", errno); ! 257: case 0: ! 258: /* a process which is the remote login */ ! 259: getty(PROCEND); ! 260: default: ! 261: /* the protocol process */ ! 262: close(PROCEND); ! 263: netfd = f; ! 264: ptfd = TERMEND; ! 265: telnet(); ! 266: } ! 267: ! 268: /*NOTREACHED*/ ! 269: } ! 270: ! 271: static ! 272: fatal(f, msg) ! 273: int f; ! 274: char *msg; ! 275: { ! 276: char buf[BUFSIZ]; ! 277: ! 278: (void) sprintf(buf, "telnetd: %s.\n", msg); ! 279: (void) write(f, buf, strlen(buf)); ! 280: exit(1); ! 281: } ! 282: ! 283: static ! 284: fatalperror(f, msg, errno) ! 285: int f; ! 286: char *msg; ! 287: int errno; ! 288: { ! 289: char buf[BUFSIZ]; ! 290: extern char *sys_errlist[]; ! 291: ! 292: (void) sprintf(buf, "%s: %s", msg, sys_errlist[errno]); ! 293: fatal(f, buf); ! 294: } ! 295: ! 296: static ! 297: terminate(s) ! 298: char *s; ! 299: { ! 300: DEBUG fprintf(stderr, "session on %s terminated because of %s\n", ! 301: ptname(ptno), s); ! 302: done = 1; ! 303: } ! 304: ! 305: /* loop on input from the pt and the network */ ! 306: static ! 307: telnet() ! 308: { ! 309: register int c; ! 310: int n; ! 311: fd_set ibits, obits; ! 312: ! 313: binit(ptin); ! 314: binit(ptout); ! 315: binit(netin); ! 316: binit(netout); ! 317: ! 318: /* Request to do remote echo. */ ! 319: dooption(TELOPT_ECHO); ! 320: myopts[TELOPT_ECHO] = 1; ! 321: ! 322: while(!done) { ! 323: FD_ZERO(ibits); ! 324: FD_ZERO(obits); ! 325: ! 326: /* process anything sitting in the input buffers */ ! 327: if (bytes_filled(ptin) > 0) ! 328: ptprocess(); ! 329: if (bytes_filled(netin) > 0) ! 330: netprocess(); ! 331: ! 332: /* select for read only if there's room to read into */ ! 333: if (space_left(netin) > 0) ! 334: FD_SET(netfd, ibits); ! 335: if (space_left(ptin) > 0) ! 336: FD_SET(ptfd, ibits); ! 337: ! 338: /* select for write only if there's something to write */ ! 339: if (bytes_filled(ptout) > 0) ! 340: FD_SET(ptfd, obits); ! 341: if (bytes_filled(netout) > 0) ! 342: FD_SET(netfd, obits); ! 343: ! 344: n = select(NOFILE, &ibits, &obits, 100000); ! 345: if (n < 0) ! 346: break; ! 347: else if (n == 0) ! 348: continue; ! 349: ! 350: /* fill input buffers */ ! 351: if (FD_ISSET(netfd, ibits)) ! 352: netrcv(); ! 353: if (FD_ISSET(ptfd, ibits)) ! 354: ptrcv(); ! 355: ! 356: /* flush output buffers */ ! 357: if (FD_ISSET(netfd, obits) && bytes_filled(netout) > 0) ! 358: netflush(); ! 359: if (FD_ISSET(ptfd, obits) && bytes_filled(ptout) > 0) ! 360: ptflush(); ! 361: } ! 362: rmut(); ! 363: close(netfd); ! 364: close(ptfd); ! 365: exit(0); ! 366: } ! 367: ! 368: struct mesg { ! 369: short type; ! 370: short size; ! 371: }; ! 372: static struct mesg m; ! 373: ! 374: /* read from the pt */ ! 375: static ! 376: ptrcv() ! 377: { ! 378: /* get the header if we don't already have one */ ! 379: if (m.size <= 0) ! 380: if (read(ptfd, &m, sizeof(m)) != sizeof(m)) { ! 381: terminate("pt read"); ! 382: return; ! 383: } ! 384: switch(m.type) { ! 385: case M_HANGUP: ! 386: terminate("pt hangup"); ! 387: break; ! 388: case M_DATA: ! 389: datamesg(); ! 390: break; ! 391: case M_IOCTL: ! 392: ioctlmesg(); ! 393: break; ! 394: case M_IOCACK: ! 395: fprintf(stderr, "IOCACK\n"); ! 396: flushmesg(); ! 397: break; ! 398: case M_IOCNAK: ! 399: fprintf(stderr, "IOCNAK\n"); ! 400: flushmesg(); ! 401: break; ! 402: default: ! 403: othermesg(); ! 404: break; ! 405: } ! 406: } ! 407: ! 408: /* flush a message from the pt */ ! 409: static ! 410: flushmesg() ! 411: { ! 412: union stmsg s; ! 413: int cc; ! 414: ! 415: /* flush it */ ! 416: while (m.size > 0) { ! 417: fprintf(stderr, "flush\n"); ! 418: cc = read(ptfd, &s, sizeof(s)); ! 419: if (cc < 0) { ! 420: terminate("pt read"); ! 421: return; ! 422: } ! 423: m.size -= cc; ! 424: } ! 425: } ! 426: ! 427: /* handle an ioctl message from the pt */ ! 428: static ! 429: ioctlmesg() ! 430: { ! 431: struct mesg rm; ! 432: union stmsg s; ! 433: int cc; ! 434: ! 435: rm.size = m.size; ! 436: if (m.size > 0) { ! 437: cc = read(ptfd, &s, sizeof(s)); ! 438: if (cc < 0) { ! 439: terminate("pt read"); ! 440: return; ! 441: } ! 442: m.size -= cc; ! 443: } ! 444: rm.type = M_IOCACK; ! 445: switch (s.ioc0.com) { ! 446: ! 447: case TIOCSETN: ! 448: case TIOCSETP: ! 449: ptb = s.ioc1.sb; ! 450: rm.size = 0; ! 451: break; ! 452: ! 453: case TIOCGETP: ! 454: s.ioc1.sb.sg_ispeed = B9600; ! 455: s.ioc1.sb.sg_ospeed = B9600; ! 456: ptb = s.ioc1.sb; ! 457: break; ! 458: ! 459: default: ! 460: rm.type = M_IOCNAK; ! 461: rm.size = 0; ! 462: break; ! 463: } ! 464: if (write(ptfd, &rm, sizeof(rm)) != sizeof(rm)) { ! 465: terminate("pt write"); ! 466: return; ! 467: } ! 468: if (rm.size > 0) ! 469: if (write(ptfd, &s, rm.size) != rm.size) { ! 470: terminate("pt write"); ! 471: return; ! 472: } ! 473: ! 474: flushmesg(); ! 475: } ! 476: ! 477: /* read bytes from the pt and write to the network connection */ ! 478: static ! 479: datamesg() ! 480: { ! 481: int cc; ! 482: ! 483: cc = breadn(ptin, ptfd, m.size); ! 484: if (cc < 0) ! 485: terminate("pt read"); ! 486: else ! 487: m.size -= cc; ! 488: } ! 489: ! 490: /* handle an unrecognized type of message */ ! 491: static ! 492: othermesg() ! 493: { ! 494: struct mesg rm; ! 495: char buf[132]; ! 496: int rcc, wcc; ! 497: ! 498: wcc = write(ptfd, &m, sizeof(m)); ! 499: if (wcc != sizeof(m)) { ! 500: terminate("pt write"); ! 501: return; ! 502: } ! 503: while (m.size > 0) { ! 504: rcc = read(ptfd, buf, sizeof(buf)); ! 505: if (rcc < 0) { ! 506: terminate("pt read"); ! 507: return; ! 508: } ! 509: wcc = write(ptfd, buf, rcc); ! 510: if (wcc != rcc) { ! 511: terminate("pt write"); ! 512: return; ! 513: } ! 514: m.size -= rcc; ! 515: } ! 516: } ! 517: ! 518: /* set pt mode */ ! 519: static ! 520: mode(on, off) ! 521: int on, off; ! 522: { ! 523: ptflush(); ! 524: ptb.sg_flags |= on; ! 525: ptb.sg_flags &= ~off; ! 526: if(ioctl(ptfd, TIOCSETP, &ptb)<0) ! 527: terminate("setting mode of pt"); ! 528: } ! 529: ! 530: /* flush the pt's output buffer */ ! 531: ptflush() ! 532: { ! 533: struct mesg rm; ! 534: ! 535: rm.type = M_DATA; ! 536: rm.size = bytes_filled(ptout); ! 537: if (rm.size > 0) { ! 538: if (write(ptfd, &rm, sizeof(rm)) < sizeof(rm)) ! 539: terminate("pt write"); ! 540: else if (bwrite(ptout, ptfd) <= 0) ! 541: terminate("pt write"); ! 542: } ! 543: } ! 544: ! 545: /* process bytes from the pt */ ! 546: static ! 547: ptprocess() ! 548: { ! 549: register int c; ! 550: ! 551: while(bytes_filled(ptin) && space_left(netout) > 1) { ! 552: c = bget(ptin); ! 553: if (c == IAC) ! 554: bput(netout, c); ! 555: bput(netout, c); ! 556: } ! 557: } ! 558: ! 559: /* read bytes from the net */ ! 560: static ! 561: netrcv() ! 562: { ! 563: if (bread(netin, netfd) < 0) ! 564: terminate("net read"); ! 565: } ! 566: ! 567: /* flush the netwrk's output buffer */ ! 568: netflush() ! 569: { ! 570: if (bwrite(netout, netfd) < 0) ! 571: terminate("net write"); ! 572: } ! 573: ! 574: /* ! 575: * State for recv fsm ! 576: */ ! 577: #define TS_DATA 0 /* base state */ ! 578: #define TS_IAC 1 /* look for double IAC's */ ! 579: #define TS_CR 2 /* CR-LF ->'s CR */ ! 580: #define TS_BEGINNEG 3 /* throw away begin's... */ ! 581: #define TS_ENDNEG 4 /* ...end's (suboption negotiation) */ ! 582: #define TS_WILL 5 /* will option negotiation */ ! 583: #define TS_WONT 6 /* wont " */ ! 584: #define TS_DO 7 /* do " */ ! 585: #define TS_DONT 8 /* dont " */ ! 586: ! 587: static ! 588: netprocess() ! 589: { ! 590: static int state = TS_DATA; ! 591: register int c; ! 592: char buf[10]; ! 593: ! 594: while (bytes_filled(netin)) { ! 595: c = bget(netin); ! 596: switch (state) { ! 597: ! 598: case TS_DATA: ! 599: if (c == IAC) { ! 600: state = TS_IAC; ! 601: break; ! 602: } ! 603: bput(ptout, c); ! 604: if (!myopts[TELOPT_BINARY] && c == '\r') ! 605: state = TS_CR; ! 606: break; ! 607: ! 608: case TS_CR: ! 609: if (c && c != '\n') ! 610: bput(ptout, c); ! 611: state = TS_DATA; ! 612: break; ! 613: ! 614: case TS_IAC: ! 615: switch (c) { ! 616: ! 617: /* ! 618: * Send the process on the pty side an ! 619: * interrupt. Do this with a NULL or ! 620: * interrupt char; depending on the tty mode. ! 621: */ ! 622: case BREAK: ! 623: case IP: ! 624: interrupt(); ! 625: break; ! 626: ! 627: /* ! 628: * Are You There? ! 629: */ ! 630: case AYT: ! 631: bput(ptout, BELL); ! 632: break; ! 633: ! 634: /* ! 635: * Erase Character and ! 636: * Erase Line ! 637: */ ! 638: case EC: ! 639: case EL: ! 640: ptflush(); ! 641: bput(ptout, (c == EC) ? ptb.sg_erase : ptb.sg_kill); ! 642: break; ! 643: ! 644: /* ! 645: * Check for urgent data... ! 646: */ ! 647: case DM: ! 648: break; ! 649: ! 650: /* ! 651: * Begin option subnegotiation... ! 652: */ ! 653: case SB: ! 654: state = TS_BEGINNEG; ! 655: continue; ! 656: ! 657: case WILL: ! 658: case WONT: ! 659: case DO: ! 660: case DONT: ! 661: state = TS_WILL + (c - WILL); ! 662: continue; ! 663: ! 664: case IAC: ! 665: bput(ptout, c); ! 666: break; ! 667: } ! 668: state = TS_DATA; ! 669: break; ! 670: ! 671: case TS_BEGINNEG: ! 672: if (c == IAC) ! 673: state = TS_ENDNEG; ! 674: break; ! 675: ! 676: case TS_ENDNEG: ! 677: state = c == SE ? TS_DATA : TS_BEGINNEG; ! 678: break; ! 679: ! 680: case TS_WILL: ! 681: if (!hisopts[c]) ! 682: willoption(c); ! 683: state = TS_DATA; ! 684: continue; ! 685: ! 686: case TS_WONT: ! 687: if (hisopts[c]) ! 688: wontoption(c); ! 689: state = TS_DATA; ! 690: continue; ! 691: ! 692: case TS_DO: ! 693: if (!myopts[c]) ! 694: dooption(c); ! 695: state = TS_DATA; ! 696: continue; ! 697: ! 698: case TS_DONT: ! 699: if (myopts[c]) { ! 700: myopts[c] = 0; ! 701: sprintf(buf, wont, c); ! 702: bputs(netout, buf); ! 703: } ! 704: state = TS_DATA; ! 705: continue; ! 706: ! 707: default: ! 708: printf("telnetd: panic state=%d\n", state); ! 709: exit(1); ! 710: } ! 711: } ! 712: } ! 713: ! 714: static ! 715: willoption(option) ! 716: int option; ! 717: { ! 718: char *fmt; ! 719: char buf[10]; ! 720: ! 721: switch (option) { ! 722: ! 723: case TELOPT_BINARY: ! 724: mode(RAW, 0); ! 725: goto common; ! 726: ! 727: case TELOPT_ECHO: ! 728: mode(0, ECHO|CRMOD); ! 729: /*FALL THRU*/ ! 730: ! 731: case TELOPT_SGA: ! 732: common: ! 733: hisopts[option] = 1; ! 734: fmt = doopt; ! 735: break; ! 736: ! 737: case TELOPT_TM: ! 738: fmt = dont; ! 739: break; ! 740: ! 741: default: ! 742: fmt = dont; ! 743: break; ! 744: } ! 745: sprintf(buf, fmt, option); ! 746: bputs(netout, buf); ! 747: } ! 748: ! 749: static ! 750: wontoption(option) ! 751: int option; ! 752: { ! 753: char *fmt; ! 754: char buf[10]; ! 755: ! 756: switch (option) { ! 757: ! 758: case TELOPT_ECHO: ! 759: mode(ECHO|CRMOD, 0); ! 760: goto common; ! 761: ! 762: case TELOPT_BINARY: ! 763: mode(0, RAW); ! 764: /*FALL THRU*/ ! 765: ! 766: case TELOPT_SGA: ! 767: common: ! 768: hisopts[option] = 0; ! 769: fmt = dont; ! 770: break; ! 771: ! 772: default: ! 773: fmt = dont; ! 774: } ! 775: sprintf(buf, fmt, option); ! 776: bputs(netout, buf); ! 777: } ! 778: ! 779: static ! 780: dooption(option) ! 781: int option; ! 782: { ! 783: char *fmt; ! 784: char buf[10]; ! 785: ! 786: switch (option) { ! 787: ! 788: case TELOPT_TM: ! 789: fmt = wont; ! 790: break; ! 791: ! 792: case TELOPT_ECHO: ! 793: mode(ECHO|CRMOD, 0); ! 794: goto common; ! 795: ! 796: case TELOPT_BINARY: ! 797: mode(RAW, 0); ! 798: /*FALL THRU*/ ! 799: ! 800: case TELOPT_SGA: ! 801: common: ! 802: fmt = will; ! 803: break; ! 804: ! 805: default: ! 806: fmt = wont; ! 807: break; ! 808: } ! 809: sprintf(buf, fmt, option); ! 810: bputs(netout, buf); ! 811: } ! 812: ! 813: /* ! 814: * Send interrupt to process on other side of pty. ! 815: * If it is in raw mode, just write NULL; ! 816: * otherwise, write intr char. ! 817: */ ! 818: static ! 819: interrupt() ! 820: { ! 821: ptflush(); ! 822: ioctl(ptfd, TIOCGETC, &ptt); ! 823: bput(ptout, ptb.sg_flags & RAW ? '\0' : ptt.t_intrc); ! 824: } ! 825: ! 826: static ! 827: catchint() ! 828: { ! 829: terminate("child death"); ! 830: } ! 831: ! 832: #include <utmp.h> ! 833: ! 834: struct utmp wtmp; ! 835: char wtmpf[] = "/usr/adm/wtmp"; ! 836: char utmp[] = "/etc/utmp"; ! 837: #define SCPYN(a, b) strncpy(a, b, sizeof (a)) ! 838: #define SCMPN(a, b) strncmp(a, b, sizeof (a)) ! 839: ! 840: static ! 841: rmut() ! 842: { ! 843: register f; ! 844: int found = 0; ! 845: char *line, *dev; ! 846: ! 847: dev = ptname(ptno); ! 848: line = dev + 5; ! 849: ! 850: DEBUG fprintf(stderr, "closing connection on %s\n", line); ! 851: ! 852: f = open(utmp, 2); ! 853: if (f >= 0) { ! 854: while(read(f, (char *)&wtmp, sizeof (wtmp)) == sizeof (wtmp)) { ! 855: if (SCMPN(wtmp.ut_line, line) || wtmp.ut_name[0]==0) ! 856: continue; ! 857: lseek(f, -(long)sizeof (wtmp), 1); ! 858: SCPYN(wtmp.ut_name, ""); ! 859: time(&wtmp.ut_time); ! 860: write(f, (char *)&wtmp, sizeof (wtmp)); ! 861: found++; ! 862: } ! 863: close(f); ! 864: } ! 865: if (found) { ! 866: f = open(wtmpf, 1); ! 867: if (f >= 0) { ! 868: SCPYN(wtmp.ut_line, line); ! 869: SCPYN(wtmp.ut_name, ""); ! 870: time(&wtmp.ut_time); ! 871: lseek(f, (long)0, 2); ! 872: write(f, (char *)&wtmp, sizeof (wtmp)); ! 873: close(f); ! 874: } ! 875: } ! 876: chown(dev, 0, 0); ! 877: chmod(dev, 0666); ! 878: } ! 879: ! 880: static ! 881: getty(f) ! 882: { ! 883: int i; ! 884: struct sgttyb b; ! 885: char banner[128]; ! 886: ! 887: ioctl(f, TIOCSPGRP, 0); ! 888: signal(SIGTERM, SIG_DFL) ; ! 889: signal(SIGPIPE, SIG_DFL) ; ! 890: signal(SIGQUIT, SIG_DFL) ; ! 891: signal(SIGINT, SIG_DFL) ; ! 892: signal(SIGALRM, SIG_DFL) ; ! 893: signal(SIGHUP, SIG_DFL) ; ! 894: signal(SIGCHLD, SIG_DFL) ; ! 895: close(0) ; ! 896: close(1) ; ! 897: close(2) ; ! 898: close(3) ; ! 899: dup(f) ; ! 900: dup(f) ; ! 901: dup(f) ; ! 902: dup(f); /* for /dev/tty */ ! 903: for (i=4; i<NOFILE; i++) ! 904: close(i) ; ! 905: ioctl(0, TIOCGETP, &b); ! 906: b.sg_flags |= CRMOD|XTABS|ANYP|ECHO; ! 907: b.sg_erase = '#'; ! 908: b.sg_kill = '@'; ! 909: ioctl(0, TIOCSETP, &b); ! 910: sprintf(banner, "%s (%s) ", whoami(), strrchr(ptname(ptno), '/')+1); ! 911: write (netfd, banner, strlen(banner)); ! 912: execl(LOGIN, "login", 0); ! 913: fatalperror(2, LOGIN, errno); ! 914: exit(1); ! 915: ! 916: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.