![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to state.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / libexec / telnetd|
Return to state.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / libexec / telnetd |
1.1 ! root 1: /* ! 2: * Copyright (c) 1989 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted provided ! 6: * that: (1) source distributions retain this entire copyright notice and ! 7: * comment, and (2) distributions including binaries display the following ! 8: * acknowledgement: ``This product includes software developed by the ! 9: * University of California, Berkeley and its contributors'' in the ! 10: * documentation or other materials provided with the distribution and in ! 11: * all advertising materials mentioning features or use of this software. ! 12: * Neither the name of the University nor the names of its contributors may ! 13: * be used to endorse or promote products derived from this software without ! 14: * specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: */ ! 19: ! 20: #ifndef lint ! 21: static char sccsid[] = "@(#)state.c 5.7 (Berkeley) 6/28/90"; ! 22: #endif /* not lint */ ! 23: ! 24: #include "telnetd.h" ! 25: ! 26: char doopt[] = { IAC, DO, '%', 'c', 0 }; ! 27: char dont[] = { IAC, DONT, '%', 'c', 0 }; ! 28: char will[] = { IAC, WILL, '%', 'c', 0 }; ! 29: char wont[] = { IAC, WONT, '%', 'c', 0 }; ! 30: int not42 = 1; ! 31: ! 32: /* ! 33: * Buffer for sub-options, and macros ! 34: * for suboptions buffer manipulations ! 35: */ ! 36: char subbuffer[100], *subpointer= subbuffer, *subend= subbuffer; ! 37: ! 38: #define SB_CLEAR() subpointer = subbuffer; ! 39: #define SB_TERM() { subend = subpointer; SB_CLEAR(); } ! 40: #define SB_ACCUM(c) if (subpointer < (subbuffer+sizeof subbuffer)) { \ ! 41: *subpointer++ = (c); \ ! 42: } ! 43: #define SB_GET() ((*subpointer++)&0xff) ! 44: #define SB_EOF() (subpointer >= subend) ! 45: #define SB_LEN() (subend - subpointer) ! 46: ! 47: ! 48: ! 49: /* ! 50: * State for recv fsm ! 51: */ ! 52: #define TS_DATA 0 /* base state */ ! 53: #define TS_IAC 1 /* look for double IAC's */ ! 54: #define TS_CR 2 /* CR-LF ->'s CR */ ! 55: #define TS_SB 3 /* throw away begin's... */ ! 56: #define TS_SE 4 /* ...end's (suboption negotiation) */ ! 57: #define TS_WILL 5 /* will option negotiation */ ! 58: #define TS_WONT 6 /* wont " */ ! 59: #define TS_DO 7 /* do " */ ! 60: #define TS_DONT 8 /* dont " */ ! 61: ! 62: telrcv() ! 63: { ! 64: register int c; ! 65: static int state = TS_DATA; ! 66: #if defined(CRAY2) && defined(UNICOS5) ! 67: char *opfrontp = pfrontp; ! 68: #endif ! 69: ! 70: while (ncc > 0) { ! 71: if ((&ptyobuf[BUFSIZ] - pfrontp) < 2) ! 72: break; ! 73: c = *netip++ & 0377, ncc--; ! 74: switch (state) { ! 75: ! 76: case TS_CR: ! 77: state = TS_DATA; ! 78: /* Strip off \n or \0 after a \r */ ! 79: if ((c == 0) || (c == '\n')) { ! 80: break; ! 81: } ! 82: /* FALL THROUGH */ ! 83: ! 84: case TS_DATA: ! 85: if (c == IAC) { ! 86: state = TS_IAC; ! 87: break; ! 88: } ! 89: /* ! 90: * We now map \r\n ==> \r for pragmatic reasons. ! 91: * Many client implementations send \r\n when ! 92: * the user hits the CarriageReturn key. ! 93: * ! 94: * We USED to map \r\n ==> \n, since \r\n says ! 95: * that we want to be in column 1 of the next ! 96: * printable line, and \n is the standard ! 97: * unix way of saying that (\r is only good ! 98: * if CRMOD is set, which it normally is). ! 99: */ ! 100: if ((c == '\r') && his_state_is_wont(TELOPT_BINARY)) { ! 101: /* ! 102: * If we are operating in linemode, ! 103: * convert to local end-of-line. ! 104: */ ! 105: if ((linemode) && (ncc > 0)&&('\n' == *netip)) { ! 106: netip++; ncc--; ! 107: c = '\n'; ! 108: } else { ! 109: state = TS_CR; ! 110: } ! 111: } ! 112: *pfrontp++ = c; ! 113: break; ! 114: ! 115: case TS_IAC: ! 116: gotiac: switch (c) { ! 117: ! 118: /* ! 119: * Send the process on the pty side an ! 120: * interrupt. Do this with a NULL or ! 121: * interrupt char; depending on the tty mode. ! 122: */ ! 123: case IP: ! 124: #ifdef DIAGNOSTICS ! 125: if (diagnostic & TD_OPTIONS) ! 126: printoption("td: recv IAC", c); ! 127: #endif /* DIAGNOSTICS */ ! 128: interrupt(); ! 129: break; ! 130: ! 131: case BREAK: ! 132: #ifdef DIAGNOSTICS ! 133: if (diagnostic & TD_OPTIONS) ! 134: printoption("td: recv IAC", c); ! 135: #endif /* DIAGNOSTICS */ ! 136: sendbrk(); ! 137: break; ! 138: ! 139: /* ! 140: * Are You There? ! 141: */ ! 142: case AYT: ! 143: #ifdef DIAGNOSTICS ! 144: if (diagnostic & TD_OPTIONS) ! 145: printoption("td: recv IAC", c); ! 146: #endif /* DIAGNOSTICS */ ! 147: (void) strcpy(nfrontp, "\r\n[Yes]\r\n"); ! 148: nfrontp += 9; ! 149: break; ! 150: ! 151: /* ! 152: * Abort Output ! 153: */ ! 154: case AO: ! 155: { ! 156: #ifdef DIAGNOSTICS ! 157: if (diagnostic & TD_OPTIONS) ! 158: printoption("td: recv IAC", c); ! 159: #endif /* DIAGNOSTICS */ ! 160: ptyflush(); /* half-hearted */ ! 161: init_termbuf(); ! 162: ! 163: if (slctab[SLC_AO].sptr && ! 164: *slctab[SLC_AO].sptr != (cc_t)-1) { ! 165: *pfrontp++ = ! 166: (unsigned char)*slctab[SLC_AO].sptr; ! 167: } ! 168: ! 169: netclear(); /* clear buffer back */ ! 170: *nfrontp++ = IAC; ! 171: *nfrontp++ = DM; ! 172: neturg = nfrontp-1; /* off by one XXX */ ! 173: #ifdef DIAGNOSTICS ! 174: if (diagnostic & TD_OPTIONS) ! 175: printoption("td: send IAC", DM); ! 176: #endif /* DIAGNOSTICS */ ! 177: break; ! 178: } ! 179: ! 180: /* ! 181: * Erase Character and ! 182: * Erase Line ! 183: */ ! 184: case EC: ! 185: case EL: ! 186: { ! 187: cc_t ch; ! 188: ! 189: #ifdef DIAGNOSTICS ! 190: if (diagnostic & TD_OPTIONS) ! 191: printoption("td: recv IAC", c); ! 192: #endif /* DIAGNOSTICS */ ! 193: ptyflush(); /* half-hearted */ ! 194: init_termbuf(); ! 195: if (c == EC) ! 196: ch = *slctab[SLC_EC].sptr; ! 197: else ! 198: ch = *slctab[SLC_EL].sptr; ! 199: if (ch != (cc_t)-1) ! 200: *pfrontp++ = (unsigned char)ch; ! 201: break; ! 202: } ! 203: ! 204: /* ! 205: * Check for urgent data... ! 206: */ ! 207: case DM: ! 208: #ifdef DIAGNOSTICS ! 209: if (diagnostic & TD_OPTIONS) ! 210: printoption("td: recv IAC", c); ! 211: #endif /* DIAGNOSTICS */ ! 212: SYNCHing = stilloob(net); ! 213: settimer(gotDM); ! 214: break; ! 215: ! 216: ! 217: /* ! 218: * Begin option subnegotiation... ! 219: */ ! 220: case SB: ! 221: state = TS_SB; ! 222: SB_CLEAR(); ! 223: continue; ! 224: ! 225: case WILL: ! 226: state = TS_WILL; ! 227: continue; ! 228: ! 229: case WONT: ! 230: state = TS_WONT; ! 231: continue; ! 232: ! 233: case DO: ! 234: state = TS_DO; ! 235: continue; ! 236: ! 237: case DONT: ! 238: state = TS_DONT; ! 239: continue; ! 240: case EOR: ! 241: if (his_state_is_will(TELOPT_EOR)) ! 242: doeof(); ! 243: break; ! 244: ! 245: /* ! 246: * Handle RFC 10xx Telnet linemode option additions ! 247: * to command stream (EOF, SUSP, ABORT). ! 248: */ ! 249: case xEOF: ! 250: doeof(); ! 251: break; ! 252: ! 253: case SUSP: ! 254: sendsusp(); ! 255: break; ! 256: ! 257: case ABORT: ! 258: sendbrk(); ! 259: break; ! 260: ! 261: case IAC: ! 262: *pfrontp++ = c; ! 263: break; ! 264: } ! 265: state = TS_DATA; ! 266: break; ! 267: ! 268: case TS_SB: ! 269: if (c == IAC) { ! 270: state = TS_SE; ! 271: } else { ! 272: SB_ACCUM(c); ! 273: } ! 274: break; ! 275: ! 276: case TS_SE: ! 277: if (c != SE) { ! 278: if (c != IAC) { ! 279: /* ! 280: * bad form of suboption negotiation. ! 281: * handle it in such a way as to avoid ! 282: * damage to local state. Parse ! 283: * suboption buffer found so far, ! 284: * then treat remaining stream as ! 285: * another command sequence. ! 286: */ ! 287: #ifdef DIAGNOSTICS ! 288: SB_ACCUM(IAC); ! 289: SB_ACCUM(c); ! 290: subpointer -= 2; ! 291: #endif ! 292: SB_TERM(); ! 293: suboption(); ! 294: state = TS_IAC; ! 295: goto gotiac; ! 296: } ! 297: SB_ACCUM(c); ! 298: state = TS_SB; ! 299: } else { ! 300: #ifdef DIAGNOSTICS ! 301: SB_ACCUM(IAC); ! 302: SB_ACCUM(SE); ! 303: subpointer -= 2; ! 304: #endif ! 305: SB_TERM(); ! 306: suboption(); /* handle sub-option */ ! 307: state = TS_DATA; ! 308: } ! 309: break; ! 310: ! 311: case TS_WILL: ! 312: willoption(c); ! 313: state = TS_DATA; ! 314: continue; ! 315: ! 316: case TS_WONT: ! 317: wontoption(c); ! 318: state = TS_DATA; ! 319: continue; ! 320: ! 321: case TS_DO: ! 322: dooption(c); ! 323: state = TS_DATA; ! 324: continue; ! 325: ! 326: case TS_DONT: ! 327: dontoption(c); ! 328: state = TS_DATA; ! 329: continue; ! 330: ! 331: default: ! 332: syslog(LOG_ERR, "telnetd: panic state=%d\n", state); ! 333: printf("telnetd: panic state=%d\n", state); ! 334: exit(1); ! 335: } ! 336: } ! 337: #if defined(CRAY2) && defined(UNICOS5) ! 338: if (!linemode) { ! 339: char xptyobuf[BUFSIZ+NETSLOP]; ! 340: char xbuf2[BUFSIZ]; ! 341: register char *cp; ! 342: int n = pfrontp - opfrontp, oc; ! 343: bcopy(opfrontp, xptyobuf, n); ! 344: pfrontp = opfrontp; ! 345: pfrontp += term_input(xptyobuf, pfrontp, n, BUFSIZ+NETSLOP, ! 346: xbuf2, &oc, BUFSIZ); ! 347: for (cp = xbuf2; oc > 0; --oc) ! 348: if ((*nfrontp++ = *cp++) == IAC) ! 349: *nfrontp++ = IAC; ! 350: } ! 351: #endif /* defined(CRAY2) && defined(UNICOS5) */ ! 352: } /* end of telrcv */ ! 353: ! 354: /* ! 355: * The will/wont/do/dont state machines are based on Dave Borman's ! 356: * Telnet option processing state machine. ! 357: * ! 358: * These correspond to the following states: ! 359: * my_state = the last negotiated state ! 360: * want_state = what I want the state to go to ! 361: * want_resp = how many requests I have sent ! 362: * All state defaults are negative, and resp defaults to 0. ! 363: * ! 364: * When initiating a request to change state to new_state: ! 365: * ! 366: * if ((want_resp == 0 && new_state == my_state) || want_state == new_state) { ! 367: * do nothing; ! 368: * } else { ! 369: * want_state = new_state; ! 370: * send new_state; ! 371: * want_resp++; ! 372: * } ! 373: * ! 374: * When receiving new_state: ! 375: * ! 376: * if (want_resp) { ! 377: * want_resp--; ! 378: * if (want_resp && (new_state == my_state)) ! 379: * want_resp--; ! 380: * } ! 381: * if ((want_resp == 0) && (new_state != want_state)) { ! 382: * if (ok_to_switch_to new_state) ! 383: * want_state = new_state; ! 384: * else ! 385: * want_resp++; ! 386: * send want_state; ! 387: * } ! 388: * my_state = new_state; ! 389: * ! 390: * Note that new_state is implied in these functions by the function itself. ! 391: * will and do imply positive new_state, wont and dont imply negative. ! 392: * ! 393: * Finally, there is one catch. If we send a negative response to a ! 394: * positive request, my_state will be the positive while want_state will ! 395: * remain negative. my_state will revert to negative when the negative ! 396: * acknowlegment arrives from the peer. Thus, my_state generally tells ! 397: * us not only the last negotiated state, but also tells us what the peer ! 398: * wants to be doing as well. It is important to understand this difference ! 399: * as we may wish to be processing data streams based on our desired state ! 400: * (want_state) or based on what the peer thinks the state is (my_state). ! 401: * ! 402: * This all works fine because if the peer sends a positive request, the data ! 403: * that we receive prior to negative acknowlegment will probably be affected ! 404: * by the positive state, and we can process it as such (if we can; if we ! 405: * can't then it really doesn't matter). If it is that important, then the ! 406: * peer probably should be buffering until this option state negotiation ! 407: * is complete. ! 408: * ! 409: */ ! 410: send_do(option, init) ! 411: int option, init; ! 412: { ! 413: if (init) { ! 414: if ((do_dont_resp[option] == 0 && his_state_is_will(option)) || ! 415: his_want_state_is_will(option)) ! 416: return; ! 417: /* ! 418: * Special case for TELOPT_TM: We send a DO, but pretend ! 419: * that we sent a DONT, so that we can send more DOs if ! 420: * we want to. ! 421: */ ! 422: if (option == TELOPT_TM) ! 423: set_his_want_state_wont(option); ! 424: else ! 425: set_his_want_state_will(option); ! 426: do_dont_resp[option]++; ! 427: } ! 428: (void) sprintf(nfrontp, doopt, option); ! 429: nfrontp += sizeof (dont) - 2; ! 430: #ifdef DIAGNOSTICS ! 431: /* ! 432: * Report sending option to other side. ! 433: */ ! 434: if (diagnostic & TD_OPTIONS) { ! 435: printoption("td: send do", option); ! 436: } ! 437: #endif /* DIAGNOSTICS */ ! 438: } ! 439: ! 440: willoption(option) ! 441: int option; ! 442: { ! 443: int changeok = 0; ! 444: ! 445: /* ! 446: * process input from peer. ! 447: */ ! 448: ! 449: #ifdef DIAGNOSTICS ! 450: /* ! 451: * Report receiving option from other side. ! 452: */ ! 453: if (diagnostic & TD_OPTIONS) { ! 454: printoption("td: recv will", option); ! 455: } ! 456: #endif /* DIAGNOSTICS */ ! 457: ! 458: if (do_dont_resp[option]) { ! 459: do_dont_resp[option]--; ! 460: if (do_dont_resp[option] && his_state_is_will(option)) ! 461: do_dont_resp[option]--; ! 462: } ! 463: if (do_dont_resp[option] == 0) { ! 464: if (his_want_state_is_wont(option)) { ! 465: switch (option) { ! 466: ! 467: case TELOPT_BINARY: ! 468: init_termbuf(); ! 469: tty_binaryin(1); ! 470: set_termbuf(); ! 471: changeok++; ! 472: break; ! 473: ! 474: case TELOPT_ECHO: ! 475: /* ! 476: * See comments below for more info. ! 477: */ ! 478: not42 = 0; /* looks like a 4.2 system */ ! 479: break; ! 480: ! 481: case TELOPT_TM: ! 482: #if defined(LINEMODE) && defined(KLUDGELINEMODE) ! 483: /* ! 484: * This telnetd implementation does not really ! 485: * support timing marks, it just uses them to ! 486: * support the kludge linemode stuff. If we ! 487: * receive a will or wont TM in response to our ! 488: * do TM request that may have been sent to ! 489: * determine kludge linemode support, process ! 490: * it, otherwise TM should get a negative ! 491: * response back. ! 492: */ ! 493: /* ! 494: * Handle the linemode kludge stuff. ! 495: * If we are not currently supporting any ! 496: * linemode at all, then we assume that this ! 497: * is the client telling us to use kludge ! 498: * linemode in response to our query. Set the ! 499: * linemode type that is to be supported, note ! 500: * that the client wishes to use linemode, and ! 501: * eat the will TM as though it never arrived. ! 502: */ ! 503: if (lmodetype < KLUDGE_LINEMODE) { ! 504: lmodetype = KLUDGE_LINEMODE; ! 505: clientstat(TELOPT_LINEMODE, WILL, 0); ! 506: send_wont(TELOPT_SGA, 1); ! 507: } ! 508: #endif /* defined(LINEMODE) && defined(KLUDGELINEMODE) */ ! 509: /* ! 510: * We never respond to a WILL TM, and ! 511: * we leave the state WONT. ! 512: */ ! 513: return; ! 514: ! 515: case TELOPT_LFLOW: ! 516: /* ! 517: * If we are going to support flow control ! 518: * option, then don't worry peer that we can't ! 519: * change the flow control characters. ! 520: */ ! 521: slctab[SLC_XON].defset.flag &= ~SLC_LEVELBITS; ! 522: slctab[SLC_XON].defset.flag |= SLC_DEFAULT; ! 523: slctab[SLC_XOFF].defset.flag &= ~SLC_LEVELBITS; ! 524: slctab[SLC_XOFF].defset.flag |= SLC_DEFAULT; ! 525: case TELOPT_TTYPE: ! 526: case TELOPT_SGA: ! 527: case TELOPT_NAWS: ! 528: case TELOPT_TSPEED: ! 529: case TELOPT_XDISPLOC: ! 530: case TELOPT_ENVIRON: ! 531: changeok++; ! 532: break; ! 533: ! 534: #ifdef LINEMODE ! 535: case TELOPT_LINEMODE: ! 536: /* ! 537: * Local processing of 'will linemode' should ! 538: * occur after placing 'do linemode' in the data ! 539: * stream, because we may wish to send other ! 540: * linemode related messages. So, we duplicate ! 541: * the other three lines of code here, and then ! 542: * return. ! 543: */ ! 544: set_his_want_state_will(option); ! 545: send_do(option, 0); ! 546: set_his_state_will(option); ! 547: # ifdef KLUDGELINEMODE ! 548: /* ! 549: * Note client's desire to use linemode. ! 550: */ ! 551: lmodetype = REAL_LINEMODE; ! 552: # endif /* KLUDGELINEMODE */ ! 553: clientstat(TELOPT_LINEMODE, WILL, 0); ! 554: return; ! 555: #endif /* LINEMODE */ ! 556: ! 557: default: ! 558: break; ! 559: } ! 560: if (changeok) { ! 561: set_his_want_state_will(option); ! 562: send_do(option, 0); ! 563: } else { ! 564: do_dont_resp[option]++; ! 565: send_dont(option, 0); ! 566: } ! 567: } else { ! 568: /* ! 569: * Option processing that should happen when ! 570: * we receive conformation of a change in ! 571: * state that we had requested. ! 572: */ ! 573: switch (option) { ! 574: case TELOPT_ECHO: ! 575: not42 = 0; /* looks like a 4.2 system */ ! 576: /* ! 577: * Egads, he responded "WILL ECHO". Turn ! 578: * it off right now! ! 579: */ ! 580: send_dont(option, 1); ! 581: /* ! 582: * "WILL ECHO". Kludge upon kludge! ! 583: * A 4.2 client is now echoing user input at ! 584: * the tty. This is probably undesireable and ! 585: * it should be stopped. The client will ! 586: * respond WONT TM to the DO TM that we send to ! 587: * check for kludge linemode. When the WONT TM ! 588: * arrives, linemode will be turned off and a ! 589: * change propogated to the pty. This change ! 590: * will cause us to process the new pty state ! 591: * in localstat(), which will notice that ! 592: * linemode is off and send a WILL ECHO ! 593: * so that we are properly in character mode and ! 594: * all is well. ! 595: */ ! 596: break; ! 597: #ifdef LINEMODE ! 598: case TELOPT_LINEMODE: ! 599: # ifdef KLUDGELINEMODE ! 600: /* ! 601: * Note client's desire to use linemode. ! 602: */ ! 603: lmodetype = REAL_LINEMODE; ! 604: # endif /* KLUDGELINEMODE */ ! 605: clientstat(TELOPT_LINEMODE, WILL, 0); ! 606: #endif /* LINEMODE */ ! 607: } ! 608: } ! 609: } ! 610: set_his_state_will(option); ! 611: } /* end of willoption */ ! 612: ! 613: send_dont(option, init) ! 614: int option, init; ! 615: { ! 616: if (init) { ! 617: if ((do_dont_resp[option] == 0 && his_state_is_wont(option)) || ! 618: his_want_state_is_wont(option)) ! 619: return; ! 620: set_his_want_state_wont(option); ! 621: do_dont_resp[option]++; ! 622: } ! 623: (void) sprintf(nfrontp, dont, option); ! 624: nfrontp += sizeof (doopt) - 2; ! 625: #ifdef DIAGNOSTICS ! 626: /* ! 627: * Report sending option to other side. ! 628: */ ! 629: if (diagnostic & TD_OPTIONS) { ! 630: printoption("td: send dont", option); ! 631: } ! 632: #endif /* DIAGNOSTICS */ ! 633: } ! 634: ! 635: wontoption(option) ! 636: int option; ! 637: { ! 638: /* ! 639: * Process client input. ! 640: */ ! 641: ! 642: #ifdef DIAGNOSTICS ! 643: /* ! 644: * Report receiving option from other side. ! 645: */ ! 646: if (diagnostic & TD_OPTIONS) { ! 647: printoption("td: recv wont", option); ! 648: } ! 649: #endif /* DIAGNOSTICS */ ! 650: ! 651: if (do_dont_resp[option]) { ! 652: do_dont_resp[option]--; ! 653: if (do_dont_resp[option] && his_state_is_wont(option)) ! 654: do_dont_resp[option]--; ! 655: } ! 656: if (do_dont_resp[option] == 0) { ! 657: if (his_want_state_is_will(option)) { ! 658: /* it is always ok to change to negative state */ ! 659: switch (option) { ! 660: case TELOPT_ECHO: ! 661: not42 = 1; /* doesn't seem to be a 4.2 system */ ! 662: break; ! 663: ! 664: case TELOPT_BINARY: ! 665: init_termbuf(); ! 666: tty_binaryin(0); ! 667: set_termbuf(); ! 668: break; ! 669: ! 670: #ifdef LINEMODE ! 671: case TELOPT_LINEMODE: ! 672: # ifdef KLUDGELINEMODE ! 673: /* ! 674: * If real linemode is supported, then client is ! 675: * asking to turn linemode off. ! 676: */ ! 677: if (lmodetype != REAL_LINEMODE) ! 678: break; ! 679: lmodetype = KLUDGE_LINEMODE; ! 680: # endif /* KLUDGELINEMODE */ ! 681: clientstat(TELOPT_LINEMODE, WONT, 0); ! 682: break; ! 683: #endif LINEMODE ! 684: ! 685: case TELOPT_TM: ! 686: /* ! 687: * If we get a WONT TM, and had sent a DO TM, ! 688: * don't respond with a DONT TM, just leave it ! 689: * as is. Short circut the state machine to ! 690: * achive this. ! 691: */ ! 692: set_his_want_state_wont(TELOPT_TM); ! 693: return; ! 694: ! 695: case TELOPT_LFLOW: ! 696: /* ! 697: * If we are not going to support flow control ! 698: * option, then let peer know that we can't ! 699: * change the flow control characters. ! 700: */ ! 701: slctab[SLC_XON].defset.flag &= ~SLC_LEVELBITS; ! 702: slctab[SLC_XON].defset.flag |= SLC_CANTCHANGE; ! 703: slctab[SLC_XOFF].defset.flag &= ~SLC_LEVELBITS; ! 704: slctab[SLC_XOFF].defset.flag |= SLC_CANTCHANGE; ! 705: break; ! 706: ! 707: /* ! 708: * For options that we might spin waiting for ! 709: * sub-negotiation, if the client turns off the ! 710: * option rather than responding to the request, ! 711: * we have to treat it here as if we got a response ! 712: * to the sub-negotiation, (by updating the timers) ! 713: * so that we'll break out of the loop. ! 714: */ ! 715: case TELOPT_TTYPE: ! 716: settimer(ttypesubopt); ! 717: break; ! 718: ! 719: case TELOPT_TSPEED: ! 720: settimer(tspeedsubopt); ! 721: break; ! 722: ! 723: case TELOPT_XDISPLOC: ! 724: settimer(xdisplocsubopt); ! 725: break; ! 726: ! 727: case TELOPT_ENVIRON: ! 728: settimer(environsubopt); ! 729: break; ! 730: ! 731: default: ! 732: break; ! 733: } ! 734: set_his_want_state_wont(option); ! 735: if (his_state_is_will(option)) ! 736: send_dont(option, 0); ! 737: } else { ! 738: switch (option) { ! 739: case TELOPT_TM: ! 740: #if defined(LINEMODE) && defined(KLUDGELINEMODE) ! 741: if (lmodetype < REAL_LINEMODE) { ! 742: lmodetype = NO_LINEMODE; ! 743: clientstat(TELOPT_LINEMODE, WONT, 0); ! 744: send_will(TELOPT_SGA, 1); ! 745: /*@*/ send_will(TELOPT_ECHO, 1); ! 746: } ! 747: #endif /* defined(LINEMODE) && defined(KLUDGELINEMODE) */ ! 748: default: ! 749: break; ! 750: } ! 751: } ! 752: } ! 753: set_his_state_wont(option); ! 754: ! 755: } /* end of wontoption */ ! 756: ! 757: send_will(option, init) ! 758: int option, init; ! 759: { ! 760: if (init) { ! 761: if ((will_wont_resp[option] == 0 && my_state_is_will(option))|| ! 762: my_want_state_is_will(option)) ! 763: return; ! 764: set_my_want_state_will(option); ! 765: will_wont_resp[option]++; ! 766: } ! 767: (void) sprintf(nfrontp, will, option); ! 768: nfrontp += sizeof (doopt) - 2; ! 769: #ifdef DIAGNOSTICS ! 770: /* ! 771: * Report sending option to other side. ! 772: */ ! 773: if (diagnostic & TD_OPTIONS) { ! 774: printoption("td: send will", option); ! 775: } ! 776: #endif /* DIAGNOSTICS */ ! 777: } ! 778: ! 779: dooption(option) ! 780: int option; ! 781: { ! 782: int changeok = 0; ! 783: ! 784: /* ! 785: * Process client input. ! 786: */ ! 787: ! 788: #ifdef DIAGNOSTICS ! 789: /* ! 790: * Report receiving option from other side. ! 791: */ ! 792: if (diagnostic & TD_OPTIONS) { ! 793: printoption("td: recv do", option); ! 794: } ! 795: #endif /* DIAGNOSTICS */ ! 796: ! 797: if (will_wont_resp[option]) { ! 798: will_wont_resp[option]--; ! 799: if (will_wont_resp[option] && my_state_is_will(option)) ! 800: will_wont_resp[option]--; ! 801: } ! 802: if ((will_wont_resp[option] == 0) && (my_want_state_is_wont(option))) { ! 803: switch (option) { ! 804: case TELOPT_ECHO: ! 805: #ifdef LINEMODE ! 806: if (lmodetype == NO_LINEMODE) { ! 807: #endif ! 808: init_termbuf(); ! 809: tty_setecho(1); ! 810: set_termbuf(); ! 811: #ifdef LINEMODE ! 812: } ! 813: #endif ! 814: changeok++; ! 815: break; ! 816: ! 817: case TELOPT_BINARY: ! 818: init_termbuf(); ! 819: tty_binaryout(1); ! 820: set_termbuf(); ! 821: changeok++; ! 822: break; ! 823: ! 824: case TELOPT_SGA: ! 825: #if defined(LINEMODE) && defined(KLUDGELINEMODE) ! 826: /* ! 827: * If kludge linemode is in use, then we must ! 828: * process an incoming do SGA for linemode ! 829: * purposes. ! 830: */ ! 831: if (lmodetype == KLUDGE_LINEMODE) { ! 832: /* ! 833: * Receipt of "do SGA" in kludge ! 834: * linemode is the peer asking us to ! 835: * turn off linemode. Make note of ! 836: * the request. ! 837: */ ! 838: clientstat(TELOPT_LINEMODE, WONT, 0); ! 839: /* ! 840: * If linemode did not get turned off ! 841: * then don't tell peer that we did. ! 842: * Breaking here forces a wont SGA to ! 843: * be returned. ! 844: */ ! 845: if (linemode) ! 846: break; ! 847: } ! 848: #endif /* defined(LINEMODE) && defined(KLUDGELINEMODE) */ ! 849: changeok++; ! 850: break; ! 851: ! 852: case TELOPT_STATUS: ! 853: changeok++; ! 854: break; ! 855: ! 856: case TELOPT_TM: ! 857: /* ! 858: * Special case for TM. We send a WILL, but ! 859: * pretend we sent a WONT. ! 860: */ ! 861: send_will(option, 0); ! 862: set_my_want_state_wont(option); ! 863: set_my_state_wont(option); ! 864: return; ! 865: ! 866: case TELOPT_LINEMODE: ! 867: case TELOPT_TTYPE: ! 868: case TELOPT_NAWS: ! 869: case TELOPT_TSPEED: ! 870: case TELOPT_LFLOW: ! 871: case TELOPT_XDISPLOC: ! 872: case TELOPT_ENVIRON: ! 873: default: ! 874: break; ! 875: } ! 876: if (changeok) { ! 877: set_my_want_state_will(option); ! 878: send_will(option, 0); ! 879: } else { ! 880: will_wont_resp[option]++; ! 881: send_wont(option, 0); ! 882: } ! 883: } ! 884: set_my_state_will(option); ! 885: ! 886: } /* end of dooption */ ! 887: ! 888: send_wont(option, init) ! 889: int option, init; ! 890: { ! 891: if (init) { ! 892: if ((will_wont_resp[option] == 0 && my_state_is_wont(option)) || ! 893: my_want_state_is_wont(option)) ! 894: return; ! 895: set_my_want_state_wont(option); ! 896: will_wont_resp[option]++; ! 897: } ! 898: (void) sprintf(nfrontp, wont, option); ! 899: nfrontp += sizeof (wont) - 2; ! 900: #ifdef DIAGNOSTICS ! 901: /* ! 902: * Report sending option to other side. ! 903: */ ! 904: if (diagnostic & TD_OPTIONS) { ! 905: printoption("td: send wont", option); ! 906: } ! 907: #endif /* DIAGNOSTICS */ ! 908: } ! 909: ! 910: dontoption(option) ! 911: int option; ! 912: { ! 913: /* ! 914: * Process client input. ! 915: */ ! 916: #ifdef DIAGNOSTICS ! 917: /* ! 918: * Report receiving option from other side. ! 919: */ ! 920: if (diagnostic & TD_OPTIONS) { ! 921: printoption("td: recv dont", option); ! 922: } ! 923: #endif /* DIAGNOSTICS */ ! 924: ! 925: if (will_wont_resp[option]) { ! 926: will_wont_resp[option]--; ! 927: if (will_wont_resp[option] && my_state_is_wont(option)) ! 928: will_wont_resp[option]--; ! 929: } ! 930: if ((will_wont_resp[option] == 0) && (my_want_state_is_will(option))) { ! 931: switch (option) { ! 932: case TELOPT_BINARY: ! 933: init_termbuf(); ! 934: tty_binaryout(0); ! 935: set_termbuf(); ! 936: break; ! 937: ! 938: case TELOPT_ECHO: /* we should stop echoing */ ! 939: #ifdef LINEMODE ! 940: if (lmodetype == NO_LINEMODE) { ! 941: #endif ! 942: init_termbuf(); ! 943: tty_setecho(0); ! 944: set_termbuf(); ! 945: #ifdef LINEMODE ! 946: } ! 947: #endif ! 948: break; ! 949: ! 950: case TELOPT_SGA: ! 951: #if defined(LINEMODE) && defined(KLUDGELINEMODE) ! 952: /* ! 953: * If kludge linemode is in use, then we ! 954: * must process an incoming do SGA for ! 955: * linemode purposes. ! 956: */ ! 957: if (lmodetype == KLUDGE_LINEMODE) { ! 958: /* ! 959: * The client is asking us to turn ! 960: * linemode on. ! 961: */ ! 962: clientstat(TELOPT_LINEMODE, WILL, 0); ! 963: /* ! 964: * If we did not turn line mode on, ! 965: * then what do we say? Will SGA? ! 966: * This violates design of telnet. ! 967: * Gross. Very Gross. ! 968: */ ! 969: } ! 970: #endif /* defined(LINEMODE) && defined(KLUDGELINEMODE) */ ! 971: ! 972: default: ! 973: break; ! 974: } ! 975: ! 976: set_my_want_state_wont(option); ! 977: if (my_state_is_will(option)) ! 978: send_wont(option, 0); ! 979: } ! 980: set_my_state_wont(option); ! 981: ! 982: } /* end of dontoption */ ! 983: ! 984: /* ! 985: * suboption() ! 986: * ! 987: * Look at the sub-option buffer, and try to be helpful to the other ! 988: * side. ! 989: * ! 990: * Currently we recognize: ! 991: * ! 992: * Terminal type is ! 993: * Linemode ! 994: * Window size ! 995: * Terminal speed ! 996: */ ! 997: suboption() ! 998: { ! 999: register int subchar; ! 1000: extern void unsetenv(); ! 1001: ! 1002: #ifdef DIAGNOSTICS ! 1003: /* ! 1004: * Report receiving option from other side. ! 1005: */ ! 1006: if (diagnostic & TD_OPTIONS) { ! 1007: netflush(); /* get rid of anything waiting to go out */ ! 1008: printsub("td: recv", subpointer, SB_LEN()+2); ! 1009: } ! 1010: #endif DIAGNOSTIC ! 1011: subchar = SB_GET(); ! 1012: switch (subchar) { ! 1013: case TELOPT_TSPEED: { ! 1014: register int xspeed, rspeed; ! 1015: ! 1016: if (his_state_is_wont(TELOPT_TSPEED)) /* Ignore if option disabled */ ! 1017: break; ! 1018: ! 1019: settimer(tspeedsubopt); ! 1020: ! 1021: if (SB_EOF() || SB_GET() != TELQUAL_IS) ! 1022: return; ! 1023: ! 1024: xspeed = atoi(subpointer); ! 1025: ! 1026: while (SB_GET() != ',' && !SB_EOF()); ! 1027: if (SB_EOF()) ! 1028: return; ! 1029: ! 1030: rspeed = atoi(subpointer); ! 1031: clientstat(TELOPT_TSPEED, xspeed, rspeed); ! 1032: ! 1033: break; ! 1034: ! 1035: } /* end of case TELOPT_TSPEED */ ! 1036: ! 1037: case TELOPT_TTYPE: { /* Yaaaay! */ ! 1038: static char terminalname[41]; ! 1039: ! 1040: if (his_state_is_wont(TELOPT_TTYPE)) /* Ignore if option disabled */ ! 1041: break; ! 1042: settimer(ttypesubopt); ! 1043: ! 1044: if (SB_GET() != TELQUAL_IS) { ! 1045: return; /* ??? XXX but, this is the most robust */ ! 1046: } ! 1047: ! 1048: terminaltype = terminalname; ! 1049: ! 1050: while ((terminaltype < (terminalname + sizeof terminalname-1)) && ! 1051: !SB_EOF()) { ! 1052: register int c; ! 1053: ! 1054: c = SB_GET(); ! 1055: if (isupper(c)) { ! 1056: c = tolower(c); ! 1057: } ! 1058: *terminaltype++ = c; /* accumulate name */ ! 1059: } ! 1060: *terminaltype = 0; ! 1061: terminaltype = terminalname; ! 1062: break; ! 1063: } /* end of case TELOPT_TTYPE */ ! 1064: ! 1065: case TELOPT_NAWS: { ! 1066: register int xwinsize, ywinsize; ! 1067: ! 1068: if (his_state_is_wont(TELOPT_NAWS)) /* Ignore if option disabled */ ! 1069: break; ! 1070: ! 1071: if (SB_EOF()) ! 1072: return; ! 1073: xwinsize = SB_GET() << 8; ! 1074: if (SB_EOF()) ! 1075: return; ! 1076: xwinsize |= SB_GET(); ! 1077: if (SB_EOF()) ! 1078: return; ! 1079: ywinsize = SB_GET() << 8; ! 1080: if (SB_EOF()) ! 1081: return; ! 1082: ywinsize |= SB_GET(); ! 1083: clientstat(TELOPT_NAWS, xwinsize, ywinsize); ! 1084: ! 1085: break; ! 1086: ! 1087: } /* end of case TELOPT_NAWS */ ! 1088: ! 1089: #ifdef LINEMODE ! 1090: case TELOPT_LINEMODE: { ! 1091: register int request; ! 1092: ! 1093: if (his_state_is_wont(TELOPT_LINEMODE)) /* Ignore if option disabled */ ! 1094: break; ! 1095: /* ! 1096: * Process linemode suboptions. ! 1097: */ ! 1098: if (SB_EOF()) break; /* garbage was sent */ ! 1099: request = SB_GET(); /* get will/wont */ ! 1100: if (SB_EOF()) break; /* another garbage check */ ! 1101: ! 1102: if (request == LM_SLC) { /* SLC is not preceeded by WILL or WONT */ ! 1103: /* ! 1104: * Process suboption buffer of slc's ! 1105: */ ! 1106: start_slc(1); ! 1107: do_opt_slc(subpointer, subend - subpointer); ! 1108: end_slc(0); ! 1109: ! 1110: } else if (request == LM_MODE) { ! 1111: useeditmode = SB_GET(); /* get mode flag */ ! 1112: clientstat(LM_MODE, 0, 0); ! 1113: } ! 1114: ! 1115: switch (SB_GET()) { /* what suboption? */ ! 1116: case LM_FORWARDMASK: ! 1117: /* ! 1118: * According to spec, only server can send request for ! 1119: * forwardmask, and client can only return a positive response. ! 1120: * So don't worry about it. ! 1121: */ ! 1122: ! 1123: default: ! 1124: break; ! 1125: } ! 1126: break; ! 1127: } /* end of case TELOPT_LINEMODE */ ! 1128: #endif ! 1129: case TELOPT_STATUS: { ! 1130: int mode; ! 1131: ! 1132: mode = SB_GET(); ! 1133: switch (mode) { ! 1134: case TELQUAL_SEND: ! 1135: if (my_state_is_will(TELOPT_STATUS)) ! 1136: send_status(); ! 1137: break; ! 1138: ! 1139: case TELQUAL_IS: ! 1140: break; ! 1141: ! 1142: default: ! 1143: break; ! 1144: } ! 1145: break; ! 1146: } /* end of case TELOPT_STATUS */ ! 1147: ! 1148: case TELOPT_XDISPLOC: { ! 1149: if (SB_EOF() || SB_GET() != TELQUAL_IS) ! 1150: return; ! 1151: settimer(xdisplocsubopt); ! 1152: subpointer[SB_LEN()] = '\0'; ! 1153: setenv("DISPLAY", subpointer, 1); ! 1154: break; ! 1155: } /* end of case TELOPT_XDISPLOC */ ! 1156: ! 1157: case TELOPT_ENVIRON: { ! 1158: register int c; ! 1159: register char *cp, *varp, *valp; ! 1160: ! 1161: if (SB_EOF()) ! 1162: return; ! 1163: c = SB_GET(); ! 1164: if (c == TELQUAL_IS) ! 1165: settimer(environsubopt); ! 1166: else if (c != TELQUAL_INFO) ! 1167: return; ! 1168: ! 1169: while (!SB_EOF() && SB_GET() != ENV_VAR) ! 1170: ; ! 1171: ! 1172: if (SB_EOF()) ! 1173: return; ! 1174: ! 1175: cp = varp = subpointer; ! 1176: valp = 0; ! 1177: ! 1178: while (!SB_EOF()) { ! 1179: switch (c = SB_GET()) { ! 1180: case ENV_VALUE: ! 1181: *cp = '\0'; ! 1182: cp = valp = subpointer; ! 1183: break; ! 1184: ! 1185: case ENV_VAR: ! 1186: *cp = '\0'; ! 1187: if (valp) ! 1188: setenv(varp, valp, 1); ! 1189: else ! 1190: unsetenv(varp); ! 1191: cp = varp = subpointer; ! 1192: valp = 0; ! 1193: break; ! 1194: ! 1195: case ENV_ESC: ! 1196: if (SB_EOF()) ! 1197: break; ! 1198: c = SB_GET(); ! 1199: /* FALL THROUGH */ ! 1200: default: ! 1201: *cp++ = c; ! 1202: break; ! 1203: } ! 1204: } ! 1205: *cp = '\0'; ! 1206: if (valp) ! 1207: setenv(varp, valp, 1); ! 1208: else ! 1209: unsetenv(varp); ! 1210: break; ! 1211: } /* end of case TELOPT_ENVIRON */ ! 1212: ! 1213: default: ! 1214: break; ! 1215: } /* end of switch */ ! 1216: ! 1217: } /* end of suboption */ ! 1218: ! 1219: #define ADD(c) *ncp++ = c; ! 1220: #define ADD_DATA(c) { *ncp++ = c; if (c == SE) *ncp++ = c; } ! 1221: send_status() ! 1222: { ! 1223: unsigned char statusbuf[256]; ! 1224: register unsigned char *ncp; ! 1225: register unsigned char i; ! 1226: ! 1227: ncp = statusbuf; ! 1228: ! 1229: netflush(); /* get rid of anything waiting to go out */ ! 1230: ! 1231: ADD(IAC); ! 1232: ADD(SB); ! 1233: ADD(TELOPT_STATUS); ! 1234: ADD(TELQUAL_IS); ! 1235: ! 1236: for (i = 0; i < NTELOPTS; i++) { ! 1237: if (my_state_is_will(i)) { ! 1238: ADD(WILL); ! 1239: ADD_DATA(i); ! 1240: if (i == IAC) ! 1241: ADD(IAC); ! 1242: } ! 1243: if (his_state_is_will(i)) { ! 1244: ADD(DO); ! 1245: ADD_DATA(i); ! 1246: if (i == IAC) ! 1247: ADD(IAC); ! 1248: } ! 1249: } ! 1250: ! 1251: #ifdef LINEMODE ! 1252: if (his_state_is_will(TELOPT_LINEMODE)) { ! 1253: unsigned char *cp, *cpe; ! 1254: int len; ! 1255: ! 1256: ADD(SB); ! 1257: ADD(TELOPT_LINEMODE); ! 1258: ADD(LM_MODE); ! 1259: ADD_DATA(editmode); ! 1260: if (editmode == IAC) ! 1261: ADD(IAC); ! 1262: ADD(SE); ! 1263: ! 1264: ADD(SB); ! 1265: ADD(TELOPT_LINEMODE); ! 1266: ADD(LM_SLC); ! 1267: start_slc(0); ! 1268: send_slc(); ! 1269: len = end_slc(&cp); ! 1270: for (cpe = cp + len; cp < cpe; cp++) ! 1271: ADD_DATA(*cp); ! 1272: ADD(SE); ! 1273: } ! 1274: #endif /* LINEMODE */ ! 1275: ! 1276: ADD(IAC); ! 1277: ADD(SE); ! 1278: ! 1279: writenet(statusbuf, ncp - statusbuf); ! 1280: netflush(); /* Send it on its way */ ! 1281: #ifdef DIAGNOSTICS ! 1282: /* ! 1283: * Report sending status suboption. ! 1284: */ ! 1285: if (diagnostic & TD_OPTIONS) { ! 1286: printsub("td: send", statusbuf, ncp - statusbuf); ! 1287: netflush(); /* Send it on its way */ ! 1288: } ! 1289: #endif DIAGNOSTIC ! 1290: } ! 1291: ! 1292: #ifdef NO_SETENV ! 1293: #include "setenv.c" ! 1294: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.