开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
telnet.c
资源名称：socks5.zip　[点击查看]
上传用户：sddyfurun
上传日期：2007-01-04
资源大小：525k
文件大小：55k
源码类别：

代理服务器

开发平台：

Unix_Linux

telnet.c：源码内容
  1. /* Copyright (c) 1988, 1990, 1993                                            */
  2. /* The Regents of the University of California.  All rights reserved.        */
  3. /*                                                                           */
  4. /* Redistribution and use in source and binary forms, with or without        */
  5. /* modification, are permitted provided that the following conditions        */
  6. /* are met:                                                                  */
  7. /* 1. Redistributions of source code must retain the above copyright         */
  8. /* notice, this list of conditions and the following disclaimer.             */
  9. /* 2. Redistributions in binary form must reproduce the above copyright      */
  10. /* notice, this list of conditions and the following disclaimer in the       */
  11. /* documentation and/or other materials provided with the distribution.      */
  12. /* 3. All advertising materials mentioning features or use of this           */
  13. /* software must display the following acknowledgement:                      */
  14. /*   This product includes software developed by the University of           */
  15. /*   California, Berkeley and its contributors.                              */
  16. /* 4. 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        */
  23. /* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE */
  24. /* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR       */
  25. /* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF      */
  26. /* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS  */
  27. /* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN   */
  28. /* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)   */
  29. /* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF    */
  30. /* THE POSSIBILITY OF SUCH DAMAGE.                                           */
  32. #ifdef SHOW_SCCSIDS
  33. static char sccsid[] = "@(#)telnet.c 8.4 (Berkeley) 5/30/95";
  34. #endif
  36. #include <sys/types.h>
  37. #include <signal.h>
  38. #include <arpa/telnet.h>
  39. #include <ctype.h>
  41. #include "ring.h"
  42. #include "defines.h"
  43. #include "externs.h"
  44. #include "types.h"
  45. #include "general.h"
  47. #define strip(x) ((my_want_state_is_wont(TELOPT_BINARY)) ? ((x)&0x7f) : (x))
  49. static unsigned char subbuffer[SUBBUFSIZE],
  50. *subpointer, *subend;  /* buffer for sub-options */
  51. #define SB_CLEAR() subpointer = subbuffer;
  52. #define SB_TERM() { subend = subpointer; SB_CLEAR(); }
  53. #define SB_ACCUM(c) if (subpointer < (subbuffer+sizeof subbuffer)) { 
  54. *subpointer++ = (c); 
  55. }
  57. #define SB_GET() ((*subpointer++)&0xff)
  58. #define SB_PEEK() ((*subpointer)&0xff)
  59. #define SB_EOF() (subpointer >= subend)
  60. #define SB_LEN() (subend - subpointer)
  62. char options[256]; /* The combined options */
  63. char do_dont_resp[256];
  64. char will_wont_resp[256];
  66. int
  67. eight = 0,
  68. autologin = 0, /* Autologin anyone? */
  69. skiprc = 0,
  70. connected,
  71. showoptions,
  72. In3270, /* Are we in 3270 mode? */
  73. ISend, /* trying to send network data in */
  74. debug = 0,
  75. crmod,
  76. netdata, /* Print out network data flow */
  77. crlf, /* Should 'r' be mapped to <CR><LF> (or <CR><NUL>)? */
  78. #ifdef TN3270
  79. noasynchtty = 0,/* User specified "-noasynch" on command line */
  80. noasynchnet = 0,/* User specified "-noasynch" on command line */
  81. askedSGA = 0, /* We have talked about suppress go ahead */
  82. #endif /* defined(TN3270) */
  83. telnetport,
  84. SYNCHing, /* we are in TELNET SYNCH mode */
  85. flushout, /* flush output */
  86. autoflush = 0, /* flush output when interrupting? */
  87. autosynch, /* send interrupt characters with SYNCH? */
  88. localflow, /* we handle flow control locally */
  89. restartany, /* if flow control enabled, restart on any character */
  90. localchars, /* we recognize interrupt/quit */
  91. donelclchars, /* the user has set "localchars" */
  92. donebinarytoggle, /* the user has put us in binary */
  93. dontlecho, /* do we suppress local echoing right now? */
  94. globalmode;
  96. char *prompt = 0;
  98. cc_t escape;
  99. cc_t rlogin;
  100. #ifdef KLUDGELINEMODE
  101. cc_t echoc;
  102. #endif
  104. /*
  105.  * Telnet receiver states for fsm
  106.  */
  107. #define TS_DATA 0
  108. #define TS_IAC 1
  109. #define TS_WILL 2
  110. #define TS_WONT 3
  111. #define TS_DO 4
  112. #define TS_DONT 5
  113. #define TS_CR 6
  114. #define TS_SB 7 /* sub-option collection */
  115. #define TS_SE 8 /* looking for sub-option end */
  117. static int telrcv_state;
  118. #ifdef OLD_ENVIRON
  119. unsigned char telopt_environ = TELOPT_NEW_ENVIRON;
  120. #else
  121. # define telopt_environ TELOPT_NEW_ENVIRON
  122. #endif
  124. jmp_buf toplevel, peerdied;
  126. int flushline;
  127. int linemode;
  129. #ifdef KLUDGELINEMODE
  130. int kludgelinemode = 1;
  131. #endif
  133. /*
  134.  * The following are some clocks used to decide how to interpret
  135.  * the relationship between various variables.
  136.  */
  138. Clocks clocks;
  140. #ifdef notdef
  141. Modelist modelist[] = {
  142. { "telnet command mode", COMMAND_LINE },
  143. { "character-at-a-time mode", 0 },
  144. { "character-at-a-time mode (local echo)", LOCAL_ECHO|LOCAL_CHARS },
  145. { "line-by-line mode (remote echo)", LINE | LOCAL_CHARS },
  146. { "line-by-line mode", LINE | LOCAL_ECHO | LOCAL_CHARS },
  147. { "line-by-line mode (local echoing suppressed)", LINE | LOCAL_CHARS },
  148. { "3270 mode", 0 },
  149. };
  150. #endif
  153. /*
  154.  * Initialize telnet environment.
  155.  */
  157. void init_telnet() {
  158.     env_init();
  160.     SB_CLEAR();
  161.     ClearArray(options);
  163.     connected = In3270 = ISend = localflow = donebinarytoggle = 0;
  164.     restartany = -1;
  166.     SYNCHing = 0;
  168.     /* Don't change NetTrace */
  170.     escape = CONTROL(']');
  171.     rlogin = _POSIX_VDISABLE;
  172. #ifdef KLUDGELINEMODE
  173.     echoc = CONTROL('E');
  174. #endif
  176.     flushline = 1;
  177.     telrcv_state = TS_DATA;
  178. }
  181. #ifdef notdef
  182. #include <varargs.h>
  184. /*VARARGS*/
  185. static void printring(va_alist) va_dcl {
  186.     char buffer[100], char *ptr, char *format, char *string;
  187.     Ring *ring;
  188.     va_list ap;
  189.     int i;
  191.     va_start(ap);
  193.     ring   = va_arg(ap, Ring *);
  194.     format = va_arg(ap, char *);
  195.     ptr    = buffer;
  197.     while ((i = *format++) != 0) {
  198. if (i == '%') {
  199.     i = *format++;
  200.     switch (i) {
  201.     case 'c':
  202. *ptr++ = va_arg(ap, int);
  203. break;
  204.     case 's':
  205. string = va_arg(ap, char *);
  206. ring_supply_data(ring, buffer, ptr-buffer);
  207. ring_supply_data(ring, string, strlen(string));
  208. ptr = buffer;
  209. break;
  210.     case 0:
  211. ExitString("printring: trailing %%.n", 1);
  212. /*NOTREACHED*/
  213.     default:
  214. ExitString("printring: unknown format character.n", 1);
  215. /*NOTREACHED*/
  216.     }
  217. } else {
  218.     *ptr++ = i;
  219. }
  220.     }
  221.     ring_supply_data(ring, buffer, ptr-buffer);
  222. }
  223. #endif
  225. /* These routines are in charge of sending option negotiations               */
  226. /* to the other side.                                                        */
  227. /*                                                                           */
  228. /* The basic idea is that we send the negotiation if either side             */
  229. /* is in disagreement as to what the current state should be.                */
  230. void send_do(register int c, register int init) {
  231.     if (init) {
  232. if (((do_dont_resp[c] == 0) && my_state_is_do(c)) || my_want_state_is_do(c)) return;
  233. set_my_want_state_do(c);
  234. do_dont_resp[c]++;
  235.     }
  237.     NET2ADD(IAC, DO);
  238.     NETADD(c);
  240.     printoption("SENT", DO, c);
  241. }
  243. void send_dont(register int c, register int init) {
  244.     if (init) {
  245. if (((do_dont_resp[c] == 0) && my_state_is_dont(c)) || my_want_state_is_dont(c)) return;
  246. set_my_want_state_dont(c);
  247. do_dont_resp[c]++;
  248.     }
  250.     NET2ADD(IAC, DONT);
  251.     NETADD(c);
  253.     printoption("SENT", DONT, c);
  254. }
  256. void send_will(register int c, register int init) {
  257.     if (init) {
  258. if (((will_wont_resp[c] == 0) && my_state_is_will(c)) || my_want_state_is_will(c)) return;
  259. set_my_want_state_will(c);
  260. will_wont_resp[c]++;
  261.     }
  263.     NET2ADD(IAC, WILL);
  264.     NETADD(c);
  266.     printoption("SENT", WILL, c);
  267. }
  269. void send_wont(register int c, register int init) {
  270.     if (init) {
  271. if (((will_wont_resp[c] == 0) && my_state_is_wont(c)) || my_want_state_is_wont(c)) return;
  272. set_my_want_state_wont(c);
  273. will_wont_resp[c]++;
  274.     }
  276.     NET2ADD(IAC, WONT);
  277.     NETADD(c);
  279.     printoption("SENT", WONT, c);
  280. }
  282. void willoption(int option) {
  283.     int new_state_ok = 0;
  285.     if (do_dont_resp[option]) {
  286. --do_dont_resp[option];
  287. if (do_dont_resp[option] && my_state_is_do(option))
  288.     --do_dont_resp[option];
  289.     }
  290.     
  291.     if ((do_dont_resp[option] == 0) && my_want_state_is_dont(option)) {
  292. switch (option) {
  293.     case TELOPT_ECHO:
  294. #ifdef TN3270
  295. /* The following is a pain in the rear-end.  Various IBM     */
  296. /* servers (some versions of Wiscnet, possibly Fibronics     */
  297. /* Spartacus, and who knows who else) will NOT allow us to   */
  298. /* send "DO SGA" too early in the setup proceedings.  On the */
  299. /* other hand, 4.2 servers (telnetd) won't set SGA           */
  300. /* correctly. So, we are stuck.  Empirically (but, based on  */
  301. /* a VERY small sample), the IBM servers don't send out      */
  302. /* anything about ECHO, so we postpone our sending "DO SGA"  */
  303. /* until we see "WILL ECHO" (which 4.2 servers DO send).     */
  304. {
  305.     if (askedSGA == 0) {
  306. askedSGA = 1;
  307. if (my_want_state_is_dont(TELOPT_SGA))
  308.     send_do(TELOPT_SGA, 1);
  309.     }
  310. }
  311.         /* Fall through */
  312.     case TELOPT_EOR:
  313. #endif
  314.     case TELOPT_BINARY:
  315.     case TELOPT_SGA:
  316. settimer(modenegotiated);
  317. /* FALL THROUGH */
  318.     case TELOPT_STATUS:
  319. new_state_ok = 1;
  320. break;
  321.     case TELOPT_TM:
  322. if (flushout) flushout = 0;
  323. /* Special case for TM.  If we get back a WILL, pretend we   */
  324. /* got back a WONT.                                          */
  325. set_my_want_state_dont(option);
  326. set_my_state_dont(option);
  327. return; /* Never reply to TM will's/wont's   */
  328.     case TELOPT_LINEMODE:
  329.     default:
  330. break;
  331. }
  333. if (new_state_ok) {
  334.     set_my_want_state_do(option);
  335.     send_do(option, 0);
  336.     setconnmode(0); /* possibly set new tty mode         */
  337. } else {
  338.     do_dont_resp[option]++;
  339.     send_dont(option, 0);
  340. }
  341.     }
  343.     set_my_state_do(option);
  344. }
  346. void wontoption(int option) {
  347.     if (do_dont_resp[option]) {
  348. --do_dont_resp[option];
  349. if (do_dont_resp[option] && my_state_is_dont(option))
  350.     --do_dont_resp[option];
  351.     }
  353.     if ((do_dont_resp[option] == 0) && my_want_state_is_do(option)) {
  354.     switch (option) {
  355. #ifdef KLUDGELINEMODE
  356. case TELOPT_SGA:
  357.     if (!kludgelinemode) break;
  358.     /* FALL THROUGH */
  359. #endif
  360. case TELOPT_ECHO:
  361.     settimer(modenegotiated);
  362.     break;
  363. case TELOPT_TM:
  364.     if (flushout) flushout = 0;
  365.     set_my_want_state_dont(option);
  366.     set_my_state_dont(option);
  367.     return; /* Never reply to TM will's/wont's   */
  368. default:
  369.     break;
  370.     }
  372.     set_my_want_state_dont(option);
  374.     if (my_state_is_do(option)) send_dont(option, 0);
  375.     setconnmode(0); /* Set new tty mode                  */
  376.     } else if (option == TELOPT_TM) {
  377. /* Special case for TM.  */
  378. if (flushout) flushout = 0;
  379. set_my_want_state_dont(option);
  380.     }
  382.     set_my_state_dont(option);
  383. }
  385. static void dooption(int option) {
  386.     int new_state_ok = 0;
  388.     if (will_wont_resp[option]) {
  389. --will_wont_resp[option];
  390. if (will_wont_resp[option] && my_state_is_will(option))
  391.     --will_wont_resp[option];
  392.     }
  394.     if (will_wont_resp[option] == 0) {
  395. if (my_want_state_is_wont(option)) {
  396.     switch (option) {
  397. case TELOPT_TM:
  398.     /* Special case for TM.  We send a WILL, but pretend we  */
  399.     /* sent WONT.                                            */
  400.     send_will(option, 0);
  401.     set_my_want_state_wont(TELOPT_TM);
  402.     set_my_state_wont(TELOPT_TM);
  403.     return;
  404. #ifdef TN3270
  405. case TELOPT_EOR: /* end of record */
  406. #endif
  407. case TELOPT_BINARY: /* binary mode */
  408. case TELOPT_NAWS: /* window size */
  409. case TELOPT_TSPEED: /* terminal speed */
  410. case TELOPT_LFLOW: /* local flow control */
  411. case TELOPT_TTYPE: /* terminal type option */
  412. case TELOPT_SGA: /* no big deal */
  413.     new_state_ok = 1;
  414.     break;
  415. case TELOPT_NEW_ENVIRON: /* New environment variable option */
  416. #ifdef OLD_ENVIRON
  417.     if (my_state_is_will(TELOPT_OLD_ENVIRON)) send_wont(TELOPT_OLD_ENVIRON, 1); /* turn off the old */
  418.     goto env_common;
  419. case TELOPT_OLD_ENVIRON: /* Old environment variable option */
  420.     if (my_state_is_will(TELOPT_NEW_ENVIRON)) break; /* Don't enable if new one is in use! */
  421.     env_common:
  422.     telopt_environ = option;
  423. #endif
  424.     new_state_ok = 1;
  425.     break;
  426. case TELOPT_XDISPLOC: /* X Display location */
  427.     if (env_getvalue((unsigned char *)"DISPLAY")) new_state_ok = 1;
  428.     break;
  429. case TELOPT_LINEMODE:
  430. #ifdef KLUDGELINEMODE
  431.     kludgelinemode = 0;
  432.     send_do(TELOPT_SGA, 1);
  433. #endif
  434.     set_my_want_state_will(TELOPT_LINEMODE);
  435.     send_will(option, 0);
  436.     set_my_state_will(TELOPT_LINEMODE);
  437.     slc_init();
  438.     return;
  439. case TELOPT_ECHO: /* We're never going to echo... */
  440. default:
  441.     break;
  442.     }
  444.     if (new_state_ok) {
  445. set_my_want_state_will(option);
  446. send_will(option, 0);
  447. setconnmode(0); /* Set new tty mode */
  448.     } else {
  449. will_wont_resp[option]++;
  450. send_wont(option, 0);
  451.     }
  452. } else {
  453.     /* Handle options that need more things done after the other     */
  454.     /* side has acknowledged the option.                             */
  455.     switch (option) {
  456. case TELOPT_LINEMODE:
  457. #ifdef KLUDGELINEMODE
  458.     kludgelinemode = 0;
  459.     send_do(TELOPT_SGA, 1);
  460. #endif
  461.     set_my_state_will(option);
  462.     slc_init();
  463.     send_do(TELOPT_SGA, 0);
  464.     return;
  465.     }
  466. }
  467.     }
  469.     set_my_state_will(option);
  470. }
  472. static void dontoption(int option) {
  473.     if (will_wont_resp[option]) {
  474. --will_wont_resp[option];
  475. if (will_wont_resp[option] && my_state_is_wont(option))
  476.     --will_wont_resp[option];
  477.     }
  479.     if ((will_wont_resp[option] == 0) && my_want_state_is_will(option)) {
  480. switch (option) {
  481.     case TELOPT_LINEMODE:
  482. linemode = 0; /* put us back to the default state */
  483. break;
  484. #ifdef OLD_ENVIRON
  485.     case TELOPT_NEW_ENVIRON:
  486. /* The new environ option wasn't recognized, try the old     */
  487. send_will(TELOPT_OLD_ENVIRON, 1);
  488. telopt_environ = TELOPT_OLD_ENVIRON;
  489. break;
  490. #endif
  491. }
  493. /* we always accept a DONT */
  494. set_my_want_state_wont(option);
  495. if (my_state_is_will(option)) send_wont(option, 0);
  496. setconnmode(0); /* Set new tty mode */
  497.     }
  499.     set_my_state_wont(option);
  500. }
  502. static int is_unique(register char *name, register char **as, register char **ae) {
  503.     register char **ap;
  504.     register int n;
  506.     n = strlen(name) + 1;
  507.     for (ap = as; ap < ae; ap++)
  508. if (strncasecmp(*ap, name, n) == 0)
  509.     return 0;
  510.     return 1;
  511. }
  513. /* Given a buffer returned by tgetent(), this routine will turn              */
  514. /* the pipe seperated list of names in the buffer into an array              */
  515. /* of pointers to null terminated names.  We toss out any bad,               */
  516. /* duplicate, or verbose names (names with spaces).                          */
  517. /*                                                                           */
  518. static char *name_unknown = "UNKNOWN";
  519. static char *unknown[] = { 0, 0 };
  521. char ** mklist(char *buf, char *name) {
  522.     register char c, *cp, **argvp, *cp2, **argv, **avt;
  523.     register int n;
  525.     if (name) {
  526. if ((int)strlen(name) > 40) {
  527.     name = 0;
  528.     unknown[0] = name_unknown;
  529. } else {
  530.     unknown[0] = name;
  531.     upcase(name);
  532. }
  533.     } else {
  534. unknown[0] = name_unknown;
  535.     }
  537.     /* Count up the number of names.                                         */
  538.     for (n = 1, cp = buf; *cp && *cp != ':'; cp++) {
  539. if (*cp == '|') n++;
  540.     }
  542.     /* Allocate an array to put the name pointers into                       */
  543.     argv = (char **)malloc((n+3)*sizeof(char *));
  544.     if (argv == 0) return(unknown);
  546.     /* Fill up the array of pointers to names.                               */
  547.     *argv = 0;
  548.     argvp = argv+1;
  549.     n = 0;
  551.     for (cp = cp2 = buf; (c = *cp);  cp++) {
  552. if (c == '|' || c == ':') {
  553.     *cp++ = '';
  554.     /* Skip entries that have spaces or are over 40 characters long. */
  555.     /* If this is our environment name, then put it up front.        */
  556.     /* Otherwise, as long as this is not a duplicate name (case      */
  557.     /* insensitive) add it to the list.                              */
  558.     if (n || (cp - cp2 > 41)) ;
  559.     else if (name && (strncasecmp(name, cp2, cp-cp2) == 0)) *argv = cp2;
  560.     else if (is_unique(cp2, argv+1, argvp)) *argvp++ = cp2;
  562.     if (c == ':') break;
  563.     /* Skip multiple delimiters. Reset cp2 to the beginning of the   */
  564.     /* next name. Reset n, the flag for names with spaces.           */
  565.     while ((c = *cp) == '|') cp++;
  566.     cp2 = cp;
  567.     n = 0;
  568. }
  570. /* Skip entries with spaces or non-ascii values.  Convert lower case */
  571. /* letters to upper case.                                            */
  572. if ((c == ' ') || !isascii(c)) n = 1;
  573. else if (islower(c)) *cp = toupper(c);
  574.     }
  576.     /* Check for an old V6 2 character name.  If the second name points to   */
  577.     /* the beginning of the buffer, and is only 2 characters long, move it   */
  578.     /* to the end of the array.                                              */
  579.     if ((argv[1] == buf) && (strlen(argv[1]) == 2)) {
  580. for (--argvp, avt = &argv[1]; avt < argvp; avt++) *avt = *(avt+1);
  581. *argvp++ = buf;
  582.     }
  584.     /* Duplicate last name, for TTYPE option, and null terminate the array.  */
  585.     /* If we didn't find a match on our terminal name, put that name at the  */
  586.     /* beginning.                                                                    */
  587.     cp = *(argvp-1);
  588.     *argvp++ = cp;
  589.     *argvp = 0;
  590.     
  591.     if (*argv == 0) {
  592. if (name) *argv = name;
  593. else for (--argvp, avt = argv; avt < argvp; avt++) *avt = *(avt+1);
  594.     }
  595.     if (*argv) return(argv);
  596.     else return(unknown);
  597. }
  599. #ifndef HAVE_SETUPTERM
  600. extern int tgetent(char *, char *);
  601. char termbuf[1024];
  603. /*ARGSUSED*/
  604. int setupterm(char *tname, int fd, int *errp) {
  605.     if (tgetent(termbuf, tname) == 1) {
  606. termbuf[1023] = '';
  607. if (errp) *errp = 1;
  608. return(0);
  609.     }
  611.     if (errp) *errp = 0;
  612.     return(-1);
  613. }
  614. #else
  615. #define termbuf ttytype
  616. extern char ttytype[];
  617. #endif
  619. int resettermname = 1;
  621. char *gettermname() {
  622.     static char **tnamep = 0;
  623.     static char **next;
  624.     char *tname;
  625.     int err;
  627.     if (resettermname) {
  628. resettermname = 0;
  630. if (tnamep && tnamep != unknown) free(tnamep);
  632. if ((tname = (char *)env_getvalue((unsigned char *)"TERM")) && (setupterm(tname, 1, &err) == 0)) {
  633.     tnamep = mklist(termbuf, tname);
  634. } else {
  635.     if (tname && ((int)strlen(tname) <= 40)) {
  636. unknown[0] = tname;
  637. upcase(tname);
  638.     } else {
  639. unknown[0] = name_unknown;
  640.     }
  642.     tnamep = unknown;
  643. }
  645. next = tnamep;
  646.     }
  648.     if (*next == 0) next = tnamep;
  649.     return(*next++);
  650. }
  652. /* suboption()                                                               */
  653. /*                                                                           */
  654. /* Look at the sub-option buffer, and try to be helpful to the other         */
  655. /* side.                                                                     */
  656. /*                                                                           */
  657. /* Currently we recognize:                                                   */
  658. /*                                                                           */
  659. /* Terminal type, send request.                                              */
  660. /* Terminal speed (send request).                                            */
  661. /* Local flow control (is request).                                          */
  662. /* Linemode                                                                  */
  664. static void suboption() {
  665.     unsigned char subchar;
  667.     printsub('<', subbuffer, SB_LEN()+2);
  668.     switch (subchar = SB_GET()) {
  669. case TELOPT_TTYPE:
  670.     if (my_want_state_is_wont(TELOPT_TTYPE))
  671. return;
  672.     if (SB_EOF() || SB_GET() != TELQUAL_SEND) {
  673. return;
  674.     } else {
  675. unsigned char temp[50];
  676. char *name;
  677. int len;
  679. #ifdef TN3270
  680. if (tn3270_ttype()) {
  681.     return;
  682. }
  683. #endif
  684. name = gettermname();
  685. len = strlen(name) + 4 + 2;
  687. if (len < NETROOM()) {
  688.     sprintf((char *)temp, "%c%c%c%c%s%c%c", IAC, SB, TELOPT_TTYPE, TELQUAL_IS, name, IAC, SE);
  689.     ring_supply_data(&netoring, temp, len);
  690.     printsub('>', &temp[2], len-2);
  691. } else {
  692.     ExitString("No room in buffer for terminal type.n", 1);
  693.     /*NOTREACHED*/
  694. }
  695.     }
  696.     break;
  697. case TELOPT_TSPEED:
  698.     if (my_want_state_is_wont(TELOPT_TSPEED)) return;
  699.     if (SB_EOF()) return;
  701.     if (SB_GET() == TELQUAL_SEND) {
  702. long ospeed, ispeed;
  703. unsigned char temp[50];
  704. int len;
  706. TerminalSpeeds(&ispeed, &ospeed);
  708. sprintf((char *)temp, "%c%c%c%c%d,%d%c%c", IAC, SB, TELOPT_TSPEED, TELQUAL_IS, (int)ospeed, (int)ispeed, IAC, SE);
  709. len = strlen((char *)temp+4) + 4; /* temp[3] is 0 ... */
  711. if (len < NETROOM()) {
  712.     ring_supply_data(&netoring, temp, len);
  713.     printsub('>', temp+2, len - 2);
  714. }
  715. /*@*/     else printf("lm_will: not enough room in buffern");
  716.     }
  717.     break;
  718. case TELOPT_LFLOW:
  719.     if (my_want_state_is_wont(TELOPT_LFLOW)) return;
  720.     if (SB_EOF()) return;
  721.     switch(SB_GET()) {
  722. case LFLOW_RESTART_ANY:
  723.     restartany = 1;
  724.     break;
  725. case LFLOW_RESTART_XON:
  726.     restartany = 0;
  727.     break;
  728. case LFLOW_ON:
  729.     localflow = 1;
  730.     break;
  731. case LFLOW_OFF:
  732.     localflow = 0;
  733.     break;
  734. default:
  735.     return;
  736.     }
  738.     setcommandmode();
  739.     setconnmode(0);
  740.     break;
  741. case TELOPT_LINEMODE:
  742.     if (my_want_state_is_wont(TELOPT_LINEMODE)) return;
  743.     if (SB_EOF()) return;
  744.     switch (SB_GET()) {
  745. case WILL:
  746.     lm_will(subpointer, SB_LEN());
  747.     break;
  748. case WONT:
  749.     lm_wont(subpointer, SB_LEN());
  750.     break;
  751. case DO:
  752.     lm_do(subpointer, SB_LEN());
  753.     break;
  754. case DONT:
  755.     lm_dont(subpointer, SB_LEN());
  756.     break;
  757. case LM_SLC:
  758.     slc(subpointer, SB_LEN());
  759.     break;
  760. case LM_MODE:
  761.     lm_mode(subpointer, SB_LEN(), 0);
  762.     break;
  763. default:
  764.     break;
  765.     }
  766.     break;
  767. #ifdef OLD_ENVIRON
  768. case TELOPT_OLD_ENVIRON:
  769. #endif
  770. case TELOPT_NEW_ENVIRON:
  771.     if (SB_EOF()) return;
  772.     switch(SB_PEEK()) {
  773. case TELQUAL_IS:
  774. case TELQUAL_INFO:
  775.     if (my_want_state_is_dont(subchar)) return;
  776.     break;
  777. case TELQUAL_SEND:
  778.     if (my_want_state_is_wont(subchar)) return;
  779.     break;
  780. default:
  781.     return;
  782.     }
  783.     env_opt(subpointer, SB_LEN());
  784.     break;
  785. case TELOPT_XDISPLOC:
  786.     if (my_want_state_is_wont(TELOPT_XDISPLOC)) return;
  787.     if (SB_EOF()) return;
  789.     if (SB_GET() == TELQUAL_SEND) {
  790. unsigned char temp[50], *dp;
  791. int len;
  793. if ((dp = env_getvalue((unsigned char *)"DISPLAY")) == NULL) {
  794.     /* Something happened, we no longer have a DISPLAY       */
  795.     /* variable.  So, turn off the option.                   */
  796.     send_wont(TELOPT_XDISPLOC, 1);
  797.     break;
  798. }
  800. sprintf((char *)temp, "%c%c%c%c%s%c%c", IAC, SB, TELOPT_XDISPLOC, TELQUAL_IS, dp, IAC, SE);
  801. len = strlen((char *)temp+4) + 4; /* temp[3] is 0 ... */
  803. if (len < NETROOM()) {
  804.     ring_supply_data(&netoring, temp, len);
  805.     printsub('>', temp+2, len - 2);
  806. }
  807. /*@*/     else printf("lm_will: not enough room in buffern");
  808.     }
  809.     break;
  811. default:
  812.     break;
  813.     }
  814. }
  816. static unsigned char str_lm[] = { IAC, SB, TELOPT_LINEMODE, 0, 0, IAC, SE };
  818.     void
  819. lm_will(cmd, len)
  820.     unsigned char *cmd;
  821.     int len;
  822. {
  823.     if (len < 1) {
  824. /*@*/ printf("lm_will: no command!!!n"); /* Should not happen... */
  825. return;
  826.     }
  827.     switch(cmd[0]) {
  828.     case LM_FORWARDMASK: /* We shouldn't ever get this... */
  829.     default:
  830. str_lm[3] = DONT;
  831. str_lm[4] = cmd[0];
  832. if (NETROOM() > sizeof(str_lm)) {
  833.     ring_supply_data(&netoring, str_lm, sizeof(str_lm));
  834.     printsub('>', &str_lm[2], sizeof(str_lm)-2);
  835. }
  836. /*@*/ else printf("lm_will: not enough room in buffern");
  837. break;
  838.     }
  839. }
  841.     void
  842. lm_wont(cmd, len)
  843.     unsigned char *cmd;
  844.     int len;
  845. {
  846.     if (len < 1) {
  847. /*@*/ printf("lm_wont: no command!!!n"); /* Should not happen... */
  848. return;
  849.     }
  850.     switch(cmd[0]) {
  851.     case LM_FORWARDMASK: /* We shouldn't ever get this... */
  852.     default:
  853. /* We are always DONT, so don't respond */
  854. return;
  855.     }
  856. }
  858.     void
  859. lm_do(cmd, len)
  860.     unsigned char *cmd;
  861.     int len;
  862. {
  863.     if (len < 1) {
  864. /*@*/ printf("lm_do: no command!!!n"); /* Should not happen... */
  865. return;
  866.     }
  867.     switch(cmd[0]) {
  868.     case LM_FORWARDMASK:
  869.     default:
  870. str_lm[3] = WONT;
  871. str_lm[4] = cmd[0];
  872. if (NETROOM() > sizeof(str_lm)) {
  873.     ring_supply_data(&netoring, str_lm, sizeof(str_lm));
  874.     printsub('>', &str_lm[2], sizeof(str_lm)-2);
  875. }
  876. /*@*/ else printf("lm_do: not enough room in buffern");
  877. break;
  878.     }
  879. }
  881.     void
  882. lm_dont(cmd, len)
  883.     unsigned char *cmd;
  884.     int len;
  885. {
  886.     if (len < 1) {
  887. /*@*/ printf("lm_dont: no command!!!n"); /* Should not happen... */
  888. return;
  889.     }
  890.     switch(cmd[0]) {
  891.     case LM_FORWARDMASK:
  892.     default:
  893. /* we are always WONT, so don't respond */
  894. break;
  895.     }
  896. }
  898. static unsigned char str_lm_mode[] = {
  899. IAC, SB, TELOPT_LINEMODE, LM_MODE, 0, IAC, SE
  900. };
  902. void
  903. lm_mode(cmd, len, init)
  904. unsigned char *cmd;
  905. int len, init;
  906. {
  907. if (len != 1)
  908. return;
  909. if ((linemode&MODE_MASK&~MODE_ACK) == *cmd)
  910. return;
  911. if (*cmd&MODE_ACK)
  912. return;
  913. linemode = *cmd&(MODE_MASK&~MODE_ACK);
  914. str_lm_mode[4] = linemode;
  915. if (!init)
  916.     str_lm_mode[4] |= MODE_ACK;
  917. if (NETROOM() > sizeof(str_lm_mode)) {
  918.     ring_supply_data(&netoring, str_lm_mode, sizeof(str_lm_mode));
  919.     printsub('>', &str_lm_mode[2], sizeof(str_lm_mode)-2);
  920. }
  921. /*@*/ else printf("lm_mode: not enough room in buffern");
  922. setconnmode(0); /* set changed mode */
  923. }
  927. /*
  928.  * slc()
  929.  * Handle special character suboption of LINEMODE.
  930.  */
  932. struct spc {
  933. cc_t val;
  934. cc_t *valp;
  935. char flags; /* Current flags & level */
  936. char mylevel; /* Maximum level & flags */
  937. } spc_data[NSLC+1];
  939. #define SLC_IMPORT 0
  940. #define SLC_EXPORT 1
  941. #define SLC_RVALUE 2
  942. static int slc_mode = SLC_EXPORT;
  944. void
  945. slc_init()
  946. {
  947. register struct spc *spcp;
  949. localchars = 1;
  950. for (spcp = spc_data; spcp < &spc_data[NSLC+1]; spcp++) {
  951. spcp->val = 0;
  952. spcp->valp = 0;
  953. spcp->flags = spcp->mylevel = SLC_NOSUPPORT;
  954. }
  956. #define initfunc(func, flags) { 
  957. spcp = &spc_data[func]; 
  958. if ((spcp->valp = tcval(func))) { 
  959.     spcp->val = *spcp->valp; 
  960.     spcp->mylevel = SLC_VARIABLE|flags; 
  961. } else { 
  962.     spcp->val = 0; 
  963.     spcp->mylevel = SLC_DEFAULT; 
  964. } 
  965.     }
  967. initfunc(SLC_SYNCH, 0);
  968. /* No BRK */
  969. initfunc(SLC_AO, 0);
  970. initfunc(SLC_AYT, 0);
  971. /* No EOR */
  972. initfunc(SLC_ABORT, SLC_FLUSHIN|SLC_FLUSHOUT);
  973. initfunc(SLC_EOF, 0);
  974. #ifndef SYSV_TERMIO
  975. initfunc(SLC_SUSP, SLC_FLUSHIN);
  976. #endif
  977. initfunc(SLC_EC, 0);
  978. initfunc(SLC_EL, 0);
  979. #ifndef SYSV_TERMIO
  980. initfunc(SLC_EW, 0);
  981. initfunc(SLC_RP, 0);
  982. initfunc(SLC_LNEXT, 0);
  983. #endif
  984. initfunc(SLC_XON, 0);
  985. initfunc(SLC_XOFF, 0);
  986. #ifdef SYSV_TERMIO
  987. spc_data[SLC_XON].mylevel = SLC_CANTCHANGE;
  988. spc_data[SLC_XOFF].mylevel = SLC_CANTCHANGE;
  989. #endif
  990. initfunc(SLC_FORW1, 0);
  991. #ifdef USE_TERMIO
  992. initfunc(SLC_FORW2, 0);
  993. /* No FORW2 */
  994. #endif
  996. initfunc(SLC_IP, SLC_FLUSHIN|SLC_FLUSHOUT);
  997. #undef initfunc
  999. if (slc_mode == SLC_EXPORT)
  1000. slc_export();
  1001. else
  1002. slc_import(1);
  1004. }
  1006.     void
  1007. slcstate()
  1008. {
  1009.     printf("Special characters are %s valuesn",
  1010. slc_mode == SLC_IMPORT ? "remote default" :
  1011. slc_mode == SLC_EXPORT ? "local" :
  1012.  "remote");
  1013. }
  1015.     void
  1016. slc_mode_export()
  1017. {
  1018.     slc_mode = SLC_EXPORT;
  1019.     if (my_state_is_will(TELOPT_LINEMODE))
  1020. slc_export();
  1021. }
  1023.     void
  1024. slc_mode_import(def)
  1025.     int def;
  1026. {
  1027.     slc_mode = def ? SLC_IMPORT : SLC_RVALUE;
  1028.     if (my_state_is_will(TELOPT_LINEMODE))
  1029. slc_import(def);
  1030. }
  1032. unsigned char slc_import_val[] = {
  1033. IAC, SB, TELOPT_LINEMODE, LM_SLC, 0, SLC_VARIABLE, 0, IAC, SE
  1034. };
  1035. unsigned char slc_import_def[] = {
  1036. IAC, SB, TELOPT_LINEMODE, LM_SLC, 0, SLC_DEFAULT, 0, IAC, SE
  1037. };
  1039.     void
  1040. slc_import(def)
  1041.     int def;
  1042. {
  1043.     if (NETROOM() > sizeof(slc_import_val)) {
  1044. if (def) {
  1045.     ring_supply_data(&netoring, slc_import_def, sizeof(slc_import_def));
  1046.     printsub('>', &slc_import_def[2], sizeof(slc_import_def)-2);
  1047. } else {
  1048.     ring_supply_data(&netoring, slc_import_val, sizeof(slc_import_val));
  1049.     printsub('>', &slc_import_val[2], sizeof(slc_import_val)-2);
  1050. }
  1051.     }
  1052. /*@*/ else printf("slc_import: not enough roomn");
  1053. }
  1055.     void
  1056. slc_export()
  1057. {
  1058.     register struct spc *spcp;
  1060.     TerminalDefaultChars();
  1062.     slc_start_reply();
  1063.     for (spcp = &spc_data[1]; spcp < &spc_data[NSLC+1]; spcp++) {
  1064. if (spcp->mylevel != SLC_NOSUPPORT) {
  1065.     if (spcp->val == (cc_t)(_POSIX_VDISABLE))
  1066. spcp->flags = SLC_NOSUPPORT;
  1067.     else
  1068. spcp->flags = spcp->mylevel;
  1069.     if (spcp->valp)
  1070. spcp->val = *spcp->valp;
  1071.     slc_add_reply(spcp - spc_data, spcp->flags, spcp->val);
  1072. }
  1073.     }
  1074.     slc_end_reply();
  1075.     (void)slc_update();
  1076.     setconnmode(1); /* Make sure the character values are set */
  1077. }
  1079. void
  1080. slc(cp, len)
  1081. register unsigned char *cp;
  1082. int len;
  1083. {
  1084. register struct spc *spcp;
  1085. register int func,level;
  1087. slc_start_reply();
  1089. for (; len >= 3; len -=3, cp +=3) {
  1091. func = cp[SLC_FUNC];
  1093. if (func == 0) {
  1094. /*
  1095.  * Client side: always ignore 0 function.
  1096.  */
  1097. continue;
  1098. }
  1099. if (func > NSLC) {
  1100. if ((cp[SLC_FLAGS] & SLC_LEVELBITS) != SLC_NOSUPPORT)
  1101. slc_add_reply(func, SLC_NOSUPPORT, 0);
  1102. continue;
  1103. }
  1105. spcp = &spc_data[func];
  1107. level = cp[SLC_FLAGS]&(SLC_LEVELBITS|SLC_ACK);
  1109. if ((cp[SLC_VALUE] == (unsigned char)spcp->val) &&
  1110.     ((level&SLC_LEVELBITS) == (spcp->flags&SLC_LEVELBITS))) {
  1111. continue;
  1112. }
  1114. if (level == (SLC_DEFAULT|SLC_ACK)) {
  1115. /*
  1116.  * This is an error condition, the SLC_ACK
  1117.  * bit should never be set for the SLC_DEFAULT
  1118.  * level.  Our best guess to recover is to
  1119.  * ignore the SLC_ACK bit.
  1120.  */
  1121. cp[SLC_FLAGS] &= ~SLC_ACK;
  1122. }
  1124. if (level == ((spcp->flags&SLC_LEVELBITS)|SLC_ACK)) {
  1125. spcp->val = (cc_t)cp[SLC_VALUE];
  1126. spcp->flags = cp[SLC_FLAGS]; /* include SLC_ACK */
  1127. continue;
  1128. }
  1130. level &= ~SLC_ACK;
  1132. if (level <= (spcp->mylevel&SLC_LEVELBITS)) {
  1133. spcp->flags = cp[SLC_FLAGS]|SLC_ACK;
  1134. spcp->val = (cc_t)cp[SLC_VALUE];
  1135. }
  1136. if (level == SLC_DEFAULT) {
  1137. if ((spcp->mylevel&SLC_LEVELBITS) != SLC_DEFAULT)
  1138. spcp->flags = spcp->mylevel;
  1139. else
  1140. spcp->flags = SLC_NOSUPPORT;
  1141. }
  1142. slc_add_reply(func, spcp->flags, spcp->val);
  1143. }
  1144. slc_end_reply();
  1145. if (slc_update())
  1146. setconnmode(1); /* set the  new character values */
  1147. }
  1149.     void
  1150. slc_check()
  1151. {
  1152.     register struct spc *spcp;
  1154.     slc_start_reply();
  1155.     for (spcp = &spc_data[1]; spcp < &spc_data[NSLC+1]; spcp++) {
  1156. if (spcp->valp && spcp->val != *spcp->valp) {
  1157.     spcp->val = *spcp->valp;
  1158.     if (spcp->val == (cc_t)(_POSIX_VDISABLE))
  1159. spcp->flags = SLC_NOSUPPORT;
  1160.     else
  1161. spcp->flags = spcp->mylevel;
  1162.     slc_add_reply(spcp - spc_data, spcp->flags, spcp->val);
  1163. }
  1164.     }
  1165.     slc_end_reply();
  1166.     setconnmode(1);
  1167. }
  1170. unsigned char slc_reply[128];
  1171. unsigned char *slc_replyp;
  1173. void
  1174. slc_start_reply()
  1175. {
  1176. slc_replyp = slc_reply;
  1177. *slc_replyp++ = IAC;
  1178. *slc_replyp++ = SB;
  1179. *slc_replyp++ = TELOPT_LINEMODE;
  1180. *slc_replyp++ = LM_SLC;
  1181. }
  1183. void
  1184. slc_add_reply(func, flags, value)
  1185. unsigned char func;
  1186. unsigned char flags;
  1187. cc_t value;
  1188. {
  1189. if ((*slc_replyp++ = func) == IAC)
  1190. *slc_replyp++ = IAC;
  1191. if ((*slc_replyp++ = flags) == IAC)
  1192. *slc_replyp++ = IAC;
  1193. if ((*slc_replyp++ = (unsigned char)value) == IAC)
  1194. *slc_replyp++ = IAC;
  1195. }
  1197.     void
  1198. slc_end_reply()
  1199. {
  1200.     register int len;
  1202.     *slc_replyp++ = IAC;
  1203.     *slc_replyp++ = SE;
  1204.     len = slc_replyp - slc_reply;
  1205.     if (len <= 6)
  1206. return;
  1207.     if (NETROOM() > len) {
  1208. ring_supply_data(&netoring, slc_reply, slc_replyp - slc_reply);
  1209. printsub('>', &slc_reply[2], slc_replyp - slc_reply - 2);
  1210.     }
  1211. /*@*/else printf("slc_end_reply: not enough roomn");
  1212. }
  1214. int
  1215. slc_update()
  1216. {
  1217. register struct spc *spcp;
  1218. int need_update = 0;
  1220. for (spcp = &spc_data[1]; spcp < &spc_data[NSLC+1]; spcp++) {
  1221. if (!(spcp->flags&SLC_ACK))
  1222. continue;
  1223. spcp->flags &= ~SLC_ACK;
  1224. if (spcp->valp && (*spcp->valp != spcp->val)) {
  1225. *spcp->valp = spcp->val;
  1226. need_update = 1;
  1227. }
  1228. }
  1229. return(need_update);
  1230. }
  1232. #ifdef OLD_ENVIRON
  1233. # ifdef ENV_HACK
  1234. /*
  1235.  * Earlier version of telnet/telnetd from the BSD code had
  1236.  * the definitions of VALUE and VAR reversed.  To ensure
  1237.  * maximum interoperability, we assume that the server is
  1238.  * an older BSD server, until proven otherwise.  The newer
  1239.  * BSD servers should be able to handle either definition,
  1240.  * so it is better to use the wrong values if we don't
  1241.  * know what type of server it is.
  1242.  */
  1243. int env_auto = 1;
  1244. int old_env_var = OLD_ENV_VAR;
  1245. int old_env_value = OLD_ENV_VALUE;
  1246. # else
  1247. #  define old_env_var OLD_ENV_VAR
  1248. #  define old_env_value OLD_ENV_VALUE
  1249. # endif
  1250. #endif
  1252. void
  1253. env_opt(buf, len)
  1254. register unsigned char *buf;
  1255. register int len;
  1256. {
  1257. register unsigned char *ep = 0, *epc = 0;
  1258. register int i;
  1260. switch(buf[0]&0xff) {
  1261. case TELQUAL_SEND:
  1262. env_opt_start();
  1263. if (len == 1) {
  1264. env_opt_add(NULL);
  1265. } else for (i = 1; i < len; i++) {
  1266. switch (buf[i]&0xff) {
  1267. #ifdef OLD_ENVIRON
  1268. case OLD_ENV_VAR:
  1269. # ifdef ENV_HACK
  1270. if (telopt_environ == TELOPT_OLD_ENVIRON
  1271.     && env_auto) {
  1272. /* Server has the same definitions */
  1273. old_env_var = OLD_ENV_VAR;
  1274. old_env_value = OLD_ENV_VALUE;
  1275. }
  1276. /* FALL THROUGH */
  1277. # endif
  1278. case OLD_ENV_VALUE:
  1279. /*
  1280.  * Although OLD_ENV_VALUE is not legal, we will
  1281.  * still recognize it, just in case it is an
  1282.  * old server that has VAR & VALUE mixed up...
  1283.  */
  1284. /* FALL THROUGH */
  1285. #else
  1286. case NEW_ENV_VAR:
  1287. #endif
  1288. case ENV_USERVAR:
  1289. if (ep) {
  1290. *epc = 0;
  1291. env_opt_add(ep);
  1292. }
  1293. ep = epc = &buf[i+1];
  1294. break;
  1295. case ENV_ESC:
  1296. i++;
  1297. /*FALL THROUGH*/
  1298. default:
  1299. if (epc)
  1300. *epc++ = buf[i];
  1301. break;
  1302. }
  1303. }
  1304. if (ep) {
  1305. *epc = 0;
  1306. env_opt_add(ep);
  1307. }
  1308. env_opt_end(1);
  1309. break;
  1311. case TELQUAL_IS:
  1312. case TELQUAL_INFO:
  1313. /* Ignore for now.  We shouldn't get it anyway. */
  1314. break;
  1316. default:
  1317. break;
  1318. }
  1319. }
  1321. #define OPT_REPLY_SIZE 256
  1322. unsigned char *opt_reply;
  1323. unsigned char *opt_replyp;
  1324. unsigned char *opt_replyend;
  1326. void
  1327. env_opt_start()
  1328. {
  1329. if (opt_reply)
  1330. opt_reply = (unsigned char *)realloc(opt_reply, OPT_REPLY_SIZE);
  1331. else
  1332. opt_reply = (unsigned char *)malloc(OPT_REPLY_SIZE);
  1333. if (opt_reply == NULL) {
  1334. /*@*/ printf("env_opt_start: malloc()/realloc() failed!!!n");
  1335. opt_reply = opt_replyp = opt_replyend = NULL;
  1336. return;
  1337. }
  1338. opt_replyp = opt_reply;
  1339. opt_replyend = opt_reply + OPT_REPLY_SIZE;
  1340. *opt_replyp++ = IAC;
  1341. *opt_replyp++ = SB;
  1342. *opt_replyp++ = telopt_environ;
  1343. *opt_replyp++ = TELQUAL_IS;
  1344. }
  1346. void
  1347. env_opt_start_info()
  1348. {
  1349. env_opt_start();
  1350. if (opt_replyp)
  1351.     opt_replyp[-1] = TELQUAL_INFO;
  1352. }
  1354. void
  1355. env_opt_add(ep)
  1356. register unsigned char *ep;
  1357. {
  1358. register unsigned char *vp, c;
  1360. if (opt_reply == NULL) /*XXX*/
  1361. return; /*XXX*/
  1363. if (ep == NULL || *ep == '') {
  1364. /* Send user defined variables first. */
  1365. env_default(1, 0);
  1366. while ((ep = env_default(0, 0)))
  1367. env_opt_add(ep);
  1369. /* Now add the list of well know variables.  */
  1370. env_default(1, 1);
  1371. while ((ep = env_default(0, 1)))
  1372. env_opt_add(ep);
  1373. return;
  1374. }
  1375. vp = env_getvalue(ep);
  1376. if (opt_replyp + (vp ? strlen((char *)vp) : 0) +
  1377. strlen((char *)ep) + 6 > opt_replyend)
  1378. {
  1379. register int len;
  1380. opt_replyend += OPT_REPLY_SIZE;
  1381. len = opt_replyend - opt_reply;
  1382. opt_reply = (unsigned char *)realloc(opt_reply, len);
  1383. if (opt_reply == NULL) {
  1384. /*@*/ printf("env_opt_add: realloc() failed!!!n");
  1385. opt_reply = opt_replyp = opt_replyend = NULL;
  1386. return;
  1387. }
  1388. opt_replyp = opt_reply + len - (opt_replyend - opt_replyp);
  1389. opt_replyend = opt_reply + len;
  1390. }
  1391. if (opt_welldefined((char *)ep))
  1392. #ifdef OLD_ENVIRON
  1393. if (telopt_environ == TELOPT_OLD_ENVIRON)
  1394. *opt_replyp++ = old_env_var;
  1395. else
  1396. #endif
  1397. *opt_replyp++ = NEW_ENV_VAR;
  1398. else
  1399. *opt_replyp++ = ENV_USERVAR;
  1400. for (;;) {
  1401.     while ((c = *ep++)) {
  1402. switch(c&0xff) {
  1403. case IAC:
  1404. *opt_replyp++ = IAC;
  1405. break;
  1406. case NEW_ENV_VAR:
  1407. case NEW_ENV_VALUE:
  1408. case ENV_ESC:
  1409. case ENV_USERVAR:
  1410. *opt_replyp++ = ENV_ESC;
  1411. break;
  1412. }
  1413. *opt_replyp++ = c;
  1414. }
  1415.     if ((ep = vp)) {
  1416. #ifdef OLD_ENVIRON
  1417. if (telopt_environ == TELOPT_OLD_ENVIRON)
  1418. *opt_replyp++ = old_env_value;
  1419. else
  1420. #endif
  1421. *opt_replyp++ = NEW_ENV_VALUE;
  1422. vp = NULL;
  1423. } else
  1424. break;
  1425. }
  1426. }
  1428. int
  1429. opt_welldefined(ep)
  1430. char *ep;
  1431. {
  1432. if ((strcmp(ep, "USER") == 0) ||
  1433.     (strcmp(ep, "DISPLAY") == 0) ||
  1434.     (strcmp(ep, "PRINTER") == 0) ||
  1435.     (strcmp(ep, "SYSTEMTYPE") == 0) ||
  1436.     (strcmp(ep, "JOB") == 0) ||
  1437.     (strcmp(ep, "ACCT") == 0))
  1438. return(1);
  1439. return(0);
  1440. }
  1441. void
  1442. env_opt_end(emptyok)
  1443. register int emptyok;
  1444. {
  1445. register int len;
  1447. len = opt_replyp - opt_reply + 2;
  1448. if (emptyok || len > 6) {
  1449. *opt_replyp++ = IAC;
  1450. *opt_replyp++ = SE;
  1451. if (NETROOM() > len) {
  1452. ring_supply_data(&netoring, opt_reply, len);
  1453. printsub('>', &opt_reply[2], len - 2);
  1454. }
  1455. /*@*/ else printf("slc_end_reply: not enough roomn");
  1456. }
  1457. if (opt_reply) {
  1458. free(opt_reply);
  1459. opt_reply = opt_replyp = opt_replyend = NULL;
  1460. }
  1461. }
  1465.     int
  1466. telrcv()
  1467. {
  1468.     register int c;
  1469.     register int scc;
  1470.     register unsigned char *sbp;
  1471.     int count;
  1472.     int returnValue = 0;
  1474.     scc = 0;
  1475.     count = 0;
  1476.     while (TTYROOM() > 2) {
  1477. if (scc == 0) {
  1478.     if (count) {
  1479. ring_consumed(&netiring, count);
  1480. returnValue = 1;
  1481. count = 0;
  1482.     }
  1483.     sbp = netiring.consume;
  1484.     scc = ring_full_consecutive(&netiring);
  1485.     if (scc == 0) {
  1486. /* No more data coming in */
  1487. break;
  1488.     }
  1489. }
  1491. c = *sbp++ & 0xff, scc--; count++;
  1493. switch (telrcv_state) {
  1495. case TS_CR:
  1496.     telrcv_state = TS_DATA;
  1497.     if (c == '') {
  1498. break; /* Ignore  after CR */
  1499.     }
  1500.     else if ((c == 'n') && my_want_state_is_dont(TELOPT_ECHO) && !crmod) {
  1501. TTYADD(c);
  1502. break;
  1503.     }
  1504.     /* Else, fall through */
  1506. case TS_DATA:
  1507.     if (c == IAC) {
  1508. telrcv_state = TS_IAC;
  1509. break;
  1510.     }
  1511. #ifdef TN3270
  1512.     if (In3270) {
  1513. *Ifrontp++ = c;
  1514. while (scc > 0) {
  1515.     c = *sbp++ & 0377, scc--; count++;
  1516.     if (c == IAC) {
  1517. telrcv_state = TS_IAC;
  1518. break;
  1519.     }
  1520.     *Ifrontp++ = c;
  1521. }
  1522.     } else
  1523. #     endif /* defined(TN3270) */
  1524.     /*
  1525.      * The 'crmod' hack (see following) is needed
  1526.      * since we can't * set CRMOD on output only.
  1527.      * Machines like MULTICS like to send r without
  1528.      * n; since we must turn off CRMOD to get proper
  1529.      * input, the mapping is done here (sigh).
  1530.      */
  1531.     if ((c == 'r') && my_want_state_is_dont(TELOPT_BINARY)) {
  1532. if (scc > 0) {
  1533.     c = *sbp&0xff;
  1534.     if (c == 0) {
  1535. sbp++, scc--; count++;
  1536. /* a "true" CR */
  1537. TTYADD('r');
  1538.     } else if (my_want_state_is_dont(TELOPT_ECHO) &&
  1539. (c == 'n')) {
  1540. sbp++, scc--; count++;
  1541. TTYADD('n');
  1542.     } else {
  1544. TTYADD('r');
  1545. if (crmod) {
  1546. TTYADD('n');
  1547. }
  1548.     }
  1549. } else {
  1550.     telrcv_state = TS_CR;
  1551.     TTYADD('r');
  1552.     if (crmod) {
  1553.     TTYADD('n');
  1554.     }
  1555. }
  1556.     } else {
  1557. TTYADD(c);
  1558.     }
  1559.     continue;
  1561. case TS_IAC:
  1562. process_iac:
  1563.     switch (c) {
  1565.     case WILL:
  1566. telrcv_state = TS_WILL;
  1567. continue;
  1569.     case WONT:
  1570. telrcv_state = TS_WONT;
  1571. continue;
  1573.     case DO:
  1574. telrcv_state = TS_DO;
  1575. continue;
  1577.     case DONT:
  1578. telrcv_state = TS_DONT;
  1579. continue;
  1581.     case DM:
  1582.     /*
  1583.      * We may have missed an urgent notification,
  1584.      * so make sure we flush whatever is in the
  1585.      * buffer currently.
  1586.      */
  1587. printoption("RCVD", IAC, DM);
  1588. SYNCHing = 1;
  1589. (void) ttyflush(1);
  1590. SYNCHing = stilloob();
  1591. settimer(gotDM);
  1592. break;
  1594.     case SB:
  1595. SB_CLEAR();
  1596. telrcv_state = TS_SB;
  1597. continue;
  1599. #ifdef TN3270
  1600.     case EOR:
  1601. if (In3270) {
  1602.     if (Ibackp == Ifrontp) {
  1603. Ibackp = Ifrontp = Ibuf;
  1604. ISend = 0; /* should have been! */
  1605.     } else {
  1606. Ibackp += DataFromNetwork(Ibackp, Ifrontp-Ibackp, 1);
  1607. ISend = 1;
  1608.     }
  1609. }
  1610. printoption("RCVD", IAC, EOR);
  1611. break;
  1612. #     endif /* defined(TN3270) */
  1614.     case IAC:
  1615. #ifndef TN3270
  1616. TTYADD(IAC);
  1617. #     else /* !defined(TN3270) */
  1618. if (In3270) {
  1619.     *Ifrontp++ = IAC;
  1620. } else {
  1621.     TTYADD(IAC);
  1622. }
  1623. #     endif /* !defined(TN3270) */
  1624. break;
  1626.     case NOP:
  1627.     case GA:
  1628.     default:
  1629. printoption("RCVD", IAC, c);
  1630. break;
  1631.     }
  1632.     telrcv_state = TS_DATA;
  1633.     continue;
  1635. case TS_WILL:
  1636.     printoption("RCVD", WILL, c);
  1637.     willoption(c);
  1638.     SetIn3270();
  1639.     telrcv_state = TS_DATA;
  1640.     continue;
  1642. case TS_WONT:
  1643.     printoption("RCVD", WONT, c);
  1644.     wontoption(c);
  1645.     SetIn3270();
  1646.     telrcv_state = TS_DATA;
  1647.     continue;
  1649. case TS_DO:
  1650.     printoption("RCVD", DO, c);
  1651.     dooption(c);
  1652.     SetIn3270();
  1653.     if (c == TELOPT_NAWS) {
  1654. sendnaws();
  1655.     } else if (c == TELOPT_LFLOW) {
  1656. localflow = 1;
  1657. setcommandmode();
  1658. setconnmode(0);
  1659.     }
  1660.     telrcv_state = TS_DATA;
  1661.     continue;
  1663. case TS_DONT:
  1664.     printoption("RCVD", DONT, c);
  1665.     dontoption(c);
  1666.     flushline = 1;
  1667.     setconnmode(0); /* set new tty mode (maybe) */
  1668.     SetIn3270();
  1669.     telrcv_state = TS_DATA;
  1670.     continue;
  1672. case TS_SB:
  1673.     if (c == IAC) {
  1674. telrcv_state = TS_SE;
  1675.     } else {
  1676. SB_ACCUM(c);
  1677.     }
  1678.     continue;
  1680. case TS_SE:
  1681.     if (c != SE) {
  1682. if (c != IAC) {
  1683.     /*
  1684.      * This is an error.  We only expect to get
  1685.      * "IAC IAC" or "IAC SE".  Several things may
  1686.      * have happend.  An IAC was not doubled, the
  1687.      * IAC SE was left off, or another option got
  1688.      * inserted into the suboption are all possibilities.
  1689.      * If we assume that the IAC was not doubled,
  1690.      * and really the IAC SE was left off, we could
  1691.      * get into an infinate loop here.  So, instead,
  1692.      * we terminate the suboption, and process the
  1693.      * partial suboption if we can.
  1694.      */
  1695.     SB_ACCUM(IAC);
  1696.     SB_ACCUM(c);
  1697.     subpointer -= 2;
  1698.     SB_TERM();
  1700.     printoption("In SUBOPTION processing, RCVD", IAC, c);
  1701.     suboption(); /* handle sub-option */
  1702.     SetIn3270();
  1703.     telrcv_state = TS_IAC;
  1704.     goto process_iac;
  1705. }
  1706. SB_ACCUM(c);
  1707. telrcv_state = TS_SB;
  1708.     } else {
  1709. SB_ACCUM(IAC);
  1710. SB_ACCUM(SE);
  1711. subpointer -= 2;
  1712. SB_TERM();
  1713. suboption(); /* handle sub-option */
  1714. SetIn3270();
  1715. telrcv_state = TS_DATA;
  1716.     }
  1717. }
  1718.     }
  1719.     if (count)
  1720. ring_consumed(&netiring, count);
  1721.     return returnValue||count;
  1722. }
  1724. static int bol = 1, local = 0;
  1726.     int
  1727. rlogin_susp()
  1728. {
  1729.     if (local) {
  1730. local = 0;
  1731. bol = 1;
  1732. command(0, "zn", 2);
  1733. return(1);
  1734.     }
  1735.     return(0);
  1736. }
  1738.     static int
  1739. telsnd()
  1740. {
  1741.     int tcc;
  1742.     int count;
  1743.     int returnValue = 0;
  1744.     unsigned char *tbp;
  1746.     tcc = 0;
  1747.     count = 0;
  1748.     while (NETROOM() > 2) {
  1749. register int sc;
  1750. register int c;
  1752. if (tcc == 0) {
  1753.     if (count) {
  1754. ring_consumed(&ttyiring, count);
  1755. returnValue = 1;
  1756. count = 0;
  1757.     }
  1758.     tbp = ttyiring.consume;
  1759.     tcc = ring_full_consecutive(&ttyiring);
  1760.     if (tcc == 0) {
  1761. break;
  1762.     }
  1763. }
  1764. c = *tbp++ & 0xff, sc = strip(c), tcc--; count++;
  1765. if (rlogin != _POSIX_VDISABLE) {
  1766. if (bol) {
  1767. bol = 0;
  1768. if (sc == rlogin) {
  1769. local = 1;
  1770. continue;
  1771. }
  1772. } else if (local) {
  1773. local = 0;
  1774. if (sc == '.' || c == termEofChar) {
  1775. bol = 1;
  1776. command(0, "closen", 6);
  1777. continue;
  1778. }
  1779. if (sc == termSuspChar) {
  1780. bol = 1;
  1781. command(0, "zn", 2);
  1782. continue;
  1783. }
  1784. if (sc == escape) {
  1785. command(0, (char *)tbp, tcc);
  1786. bol = 1;
  1787. count += tcc;
  1788. tcc = 0;
  1789. flushline = 1;
  1790. break;
  1791. }
  1792. if (sc != rlogin) {
  1793. ++tcc;
  1794. --tbp;
  1795. --count;
  1796. c = sc = rlogin;
  1797. }
  1798. }
  1799. if ((sc == 'n') || (sc == 'r'))
  1800. bol = 1;
  1801. } else if (sc == escape) {
  1802.     /*
  1803.      * Double escape is a pass through of a single escape character.
  1804.      */
  1805.     if (tcc && strip(*tbp) == escape) {
  1806. tbp++;
  1807. tcc--;
  1808. count++;
  1809. bol = 0;
  1810.     } else {
  1811. command(0, (char *)tbp, tcc);
  1812. bol = 1;
  1813. count += tcc;
  1814. tcc = 0;
  1815. flushline = 1;
  1816. break;
  1817.     }
  1818. } else
  1819.     bol = 0;
  1820. #ifdef KLUDGELINEMODE
  1821. if (kludgelinemode && (globalmode&MODE_EDIT) && (sc == echoc)) {
  1822.     if (tcc > 0 && strip(*tbp) == echoc) {
  1823. tcc--; tbp++; count++;
  1824.     } else {
  1825. dontlecho = !dontlecho;
  1826. settimer(echotoggle);
  1827. setconnmode(0);
  1828. flushline = 1;
  1829. break;
  1830.     }
  1831. }
  1832. #endif
  1833. if (MODE_LOCAL_CHARS(globalmode)) {
  1834.     if (TerminalSpecialChars(sc) == 0) {
  1835. bol = 1;
  1836. break;
  1837.     }
  1838. }
  1839. if (my_want_state_is_wont(TELOPT_BINARY)) {
  1840.     switch (c) {
  1841.     case 'n':
  1842.     /*
  1843.      * If we are in CRMOD mode (r ==> n)
  1844.      * on our local machine, then probably
  1845.      * a newline (unix) is CRLF (TELNET).
  1846.      */
  1847. if (MODE_LOCAL_CHARS(globalmode)) {
  1848.     NETADD('r');
  1849. }
  1850. NETADD('n');
  1851. bol = flushline = 1;
  1852. break;
  1853.     case 'r':
  1854. if (!crlf) {
  1855.     NET2ADD('r', '');
  1856. } else {
  1857.     NET2ADD('r', 'n');
  1858. }
  1859. bol = flushline = 1;
  1860. break;
  1861.     case IAC:
  1862. NET2ADD(IAC, IAC);
  1863. break;
  1864.     default:
  1865. NETADD(c);
  1866. break;
  1867.     }
  1868. } else if (c == IAC) {
  1869.     NET2ADD(IAC, IAC);
  1870. } else {
  1871.     NETADD(c);
  1872. }
  1873.     }
  1874.     if (count)
  1875. ring_consumed(&ttyiring, count);
  1876.     return returnValue||count; /* Non-zero if we did anything */
  1877. }
  1879. /*
  1880.  * Scheduler()
  1881.  *
  1882.  * Try to do something.
  1883.  *
  1884.  * If we do something useful, return 1; else return 0.
  1885.  *
  1886.  */
  1889.     int
  1890. Scheduler(block)
  1891.     int block; /* should we block in the select ? */
  1892. {
  1893. /* One wants to be a bit careful about setting returnValue
  1894.  * to one, since a one implies we did some useful work,
  1895.  * and therefore probably won't be called to block next
  1896.  * time (TN3270 mode only).
  1897.  */
  1898.     int returnValue;
  1899.     int netin, netout, netex, ttyin, ttyout;
  1901.     /* Decide which rings should be processed */
  1903.     netout = ring_full_count(&netoring) &&
  1904.     (flushline ||
  1905. (my_want_state_is_wont(TELOPT_LINEMODE)
  1906. #ifdef KLUDGELINEMODE
  1907. && (!kludgelinemode || my_want_state_is_do(TELOPT_SGA))
  1908. #endif
  1909. ) ||
  1910. my_want_state_is_will(TELOPT_BINARY));
  1911.     ttyout = ring_full_count(&ttyoring);
  1913. #ifdef TN3270
  1914.     ttyin = ring_empty_count(&ttyiring) && (shell_active == 0);
  1915. #else /* defined(TN3270) */
  1916.     ttyin = ring_empty_count(&ttyiring);
  1917. #endif /* defined(TN3270) */
  1919. #ifdef TN3270
  1920.     netin = ring_empty_count(&netiring);
  1921. #   else /* !defined(TN3270) */
  1922.     netin = !ISend && ring_empty_count(&netiring);
  1923. #   endif /* !defined(TN3270) */
  1925.     netex = !SYNCHing;
  1927.     /* If we have seen a signal recently, reset things */
  1928. #ifdef TN3270 
  1929.     if (HaveInput) {
  1930. HaveInput = 0;
  1931. (void) signal(SIGIO, inputAvailable);
  1932.     }
  1933. #endif /* defined(TN3270) */
  1935.     /* Call to system code to process rings */
  1937.     returnValue = process_rings(netin, netout, netex, ttyin, ttyout, !block);
  1939.     /* Now, look at the input rings, looking for work to do. */
  1941.     if (ring_full_count(&ttyiring)) {
  1942. #ifdef TN3270
  1943. if (In3270) {
  1944.     int c;
  1946.     c = DataFromTerminal(ttyiring.consume,
  1947. ring_full_consecutive(&ttyiring));
  1948.     if (c) {
  1949. returnValue = 1;
  1950. ring_consumed(&ttyiring, c);
  1951.     }
  1952. } else {
  1953. #   endif /* defined(TN3270) */
  1954.     returnValue |= telsnd();
  1955. #ifdef TN3270
  1956. }
  1957. #   endif /* defined(TN3270) */
  1958.     }
  1960.     if (ring_full_count(&netiring)) {
  1961. #ifndef TN3270
  1962. returnValue |= telrcv();
  1963. # else /* !defined(TN3270) */
  1964. returnValue = Push3270();
  1965. # endif /* !defined(TN3270) */
  1966.     }
  1967.     return returnValue;
  1968. }
  1970. /*
  1971.  * Select from tty and network...
  1972.  */
  1973.     void
  1974. telnet(user)
  1975.     char *user;
  1976. {
  1977.     sys_telnet_init();
  1979. #ifndef TN3270
  1980.     if (telnetport) {
  1981. send_do(TELOPT_SGA, 1);
  1982. send_will(TELOPT_TTYPE, 1);
  1983. send_will(TELOPT_NAWS, 1);
  1984. send_will(TELOPT_TSPEED, 1);
  1985. send_will(TELOPT_LFLOW, 1);
  1986. send_will(TELOPT_LINEMODE, 1);
  1987. send_will(TELOPT_NEW_ENVIRON, 1);
  1988. send_do(TELOPT_STATUS, 1);
  1989. if (env_getvalue((unsigned char *)"DISPLAY"))
  1990.     send_will(TELOPT_XDISPLOC, 1);
  1991. if (eight)
  1992.     tel_enter_binary(eight);
  1993.     }
  1994. #   endif /* !defined(TN3270) */
  1996. #ifndef TN3270
  1997.     for (;;) {
  1998. int schedValue;
  2000. while ((schedValue = Scheduler(0)) != 0) {
  2001.     if (schedValue == -1) {
  2002. setcommandmode();
  2003. return;
  2004.     }
  2005. }
  2007. if (Scheduler(1) == -1) {
  2008.     setcommandmode();
  2009.     return;
  2010. }
  2011.     }
  2012. #   else /* !defined(TN3270) */
  2013.     for (;;) {
  2014. int schedValue;
  2016. while (!In3270 && !shell_active) {
  2017.     if (Scheduler(1) == -1) {
  2018. setcommandmode();
  2019. return;
  2020.     }
  2021. }
  2023. while ((schedValue = Scheduler(0)) != 0) {
  2024.     if (schedValue == -1) {
  2025. setcommandmode();
  2026. return;
  2027.     }
  2028. }
  2029. /* If there is data waiting to go out to terminal, don't
  2030.  * schedule any more data for the terminal.
  2031.  */
  2032. if (ring_full_count(&ttyoring)) {
  2033.     schedValue = 1;
  2034. } else {
  2035.     if (shell_active) {
  2036. if (shell_continue() == 0) {
  2037.     ConnectScreen();
  2038. }
  2039.     } else if (In3270) {
  2040. schedValue = DoTerminalOutput();
  2041.     }
  2042. }
  2043. if (schedValue && (shell_active == 0)) {
  2044.     if (Scheduler(1) == -1) {
  2045. setcommandmode();
  2046. return;
  2047.     }
  2048. }
  2049.     }
  2050. #   endif /* !defined(TN3270) */
  2051. }
  2053. #if 0 /* XXX - this not being in is a bug */
  2054. /*
  2055.  * nextitem()
  2056.  *
  2057.  * Return the address of the next "item" in the TELNET data
  2058.  * stream.  This will be the address of the next character if
  2059.  * the current address is a user data character, or it will
  2060.  * be the address of the character following the TELNET command
  2061.  * if the current address is a TELNET IAC ("I Am a Command")
  2062.  * character.
  2063.  */
  2065.     static char *
  2066. nextitem(current)
  2067.     char *current;
  2068. {
  2069.     if ((*current&0xff) != IAC) {
  2070. return current+1;
  2071.     }
  2072.     switch (*(current+1)&0xff) {
  2073.     case DO:
  2074.     case DONT:
  2075.     case WILL:
  2076.     case WONT:
  2077. return current+3;
  2078.     case SB: /* loop forever looking for the SE */
  2079. {
  2080.     register char *look = current+2;
  2082.     for (;;) {
  2083. if ((*look++&0xff) == IAC) {
  2084.     if ((*look++&0xff) == SE) {
  2085. return look;
  2086.     }
  2087. }
  2088.     }
  2089. }
  2090.     default:
  2091. return current+2;
  2092.     }
  2093. }
  2094. #endif /* 0 */
  2096. /*
  2097.  * netclear()
  2098.  *
  2099.  * We are about to do a TELNET SYNCH operation.  Clear
  2100.  * the path to the network.
  2101.  *
  2102.  * Things are a bit tricky since we may have sent the first
  2103.  * byte or so of a previous TELNET command into the network.
  2104.  * So, we have to scan the network buffer from the beginning
  2105.  * until we are up to where we want to be.
  2106.  *
  2107.  * A side effect of what we do, just to keep things
  2108.  * simple, is to clear the urgent data pointer.  The principal
  2109.  * caller should be setting the urgent data pointer AFTER calling
  2110.  * us in any case.
  2111.  */
  2113.     static void
  2114. netclear()
  2115. {
  2116. #if 0 /* XXX */
  2117.     register char *thisitem, *next;
  2118.     char *good;
  2119. #define wewant(p) ((nfrontp > p) && ((*p&0xff) == IAC) && 
  2120. ((*(p+1)&0xff) != EC) && ((*(p+1)&0xff) != EL))
  2122.     thisitem = netobuf;
  2124.     while ((next = nextitem(thisitem)) <= netobuf.send) {
  2125. thisitem = next;
  2126.     }
  2128.     /* Now, thisitem is first before/at boundary. */
  2130.     good = netobuf; /* where the good bytes go */
  2132.     while (netoring.add > thisitem) {
  2133. if (wewant(thisitem)) {
  2134.     int length;
  2136.     next = thisitem;
  2137.     do {
  2138. next = nextitem(next);
  2139.     } while (wewant(next) && (nfrontp > next));
  2140.     length = next-thisitem;
  2141.     memmove(good, thisitem, length);
  2142.     good += length;
  2143.     thisitem = next;
  2144. } else {
  2145.     thisitem = nextitem(thisitem);
  2146. }
  2147.     }
  2149. #endif /* 0 */
  2150. }
  2152. /*
  2153.  * These routines add various telnet commands to the data stream.
  2154.  */
  2156.     static void
  2157. doflush()
  2158. {
  2159.     NET2ADD(IAC, DO);
  2160.     NETADD(TELOPT_TM);
  2161.     flushline = 1;
  2162.     flushout = 1;
  2163.     (void) ttyflush(1); /* Flush/drop output */
  2164.     /* do printoption AFTER flush, otherwise the output gets tossed... */
  2165.     printoption("SENT", DO, TELOPT_TM);
  2166. }
  2168.     void
  2169. xmitAO()
  2170. {
  2171.     NET2ADD(IAC, AO);
  2172.     printoption("SENT", IAC, AO);
  2173.     if (autoflush) {
  2174. doflush();
  2175.     }
  2176. }
  2179.     void
  2180. xmitEL()
  2181. {
  2182.     NET2ADD(IAC, EL);
  2183.     printoption("SENT", IAC, EL);
  2184. }
  2186.     void
  2187. xmitEC()
  2188. {
  2189.     NET2ADD(IAC, EC);
  2190.     printoption("SENT", IAC, EC);
  2191. }
  2194.     int
  2195. dosynch()
  2196. {
  2197.     netclear(); /* clear the path to the network */
  2198.     NETADD(IAC);
  2199.     setneturg();
  2200.     NETADD(DM);
  2201.     printoption("SENT", IAC, DM);
  2202.     return 1;
  2203. }
  2205. int want_status_response = 0;
  2207.     int
  2208. get_status()
  2209. {
  2210.     unsigned char tmp[16];
  2211.     register unsigned char *cp;
  2213.     if (my_want_state_is_dont(TELOPT_STATUS)) {
  2214. printf("Remote side does not support STATUS optionn");
  2215. return 0;
  2216.     }
  2217.     cp = tmp;
  2219.     *cp++ = IAC;
  2220.     *cp++ = SB;
  2221.     *cp++ = TELOPT_STATUS;
  2222.     *cp++ = TELQUAL_SEND;
  2223.     *cp++ = IAC;
  2224.     *cp++ = SE;
  2225.     if (NETROOM() >= cp - tmp) {
  2226. ring_supply_data(&netoring, tmp, cp-tmp);
  2227. printsub('>', tmp+2, cp - tmp - 2);
  2228.     }
  2229.     ++want_status_response;
  2230.     return 1;
  2231. }
  2233.     void
  2234. intp()
  2235. {
  2236.     NET2ADD(IAC, IP);
  2237.     printoption("SENT", IAC, IP);
  2238.     flushline = 1;
  2239.     if (autoflush) {
  2240. doflush();
  2241.     }
  2242.     if (autosynch) {
  2243. dosynch();
  2244.     }
  2245. }
  2247.     void
  2248. sendbrk()
  2249. {
  2250.     NET2ADD(IAC, BREAK);
  2251.     printoption("SENT", IAC, BREAK);
  2252.     flushline = 1;
  2253.     if (autoflush) {
  2254. doflush();
  2255.     }
  2256.     if (autosynch) {
  2257. dosynch();
  2258.     }
  2259. }
  2261.     void
  2262. sendabort()
  2263. {
  2264.     NET2ADD(IAC, ABORT);
  2265.     printoption("SENT", IAC, ABORT);
  2266.     flushline = 1;
  2267.     if (autoflush) {
  2268. doflush();
  2269.     }
  2270.     if (autosynch) {
  2271. dosynch();
  2272.     }
  2273. }
  2275.     void
  2276. sendsusp()
  2277. {
  2278.     NET2ADD(IAC, SUSP);
  2279.     printoption("SENT", IAC, SUSP);
  2280.     flushline = 1;
  2281.     if (autoflush) {
  2282. doflush();
  2283.     }
  2284.     if (autosynch) {
  2285. dosynch();
  2286.     }
  2287. }
  2289.     void
  2290. sendeof()
  2291. {
  2292.     NET2ADD(IAC, xEOF);
  2293.     printoption("SENT", IAC, xEOF);
  2294. }
  2296.     void
  2297. sendayt()
  2298. {
  2299.     NET2ADD(IAC, AYT);
  2300.     printoption("SENT", IAC, AYT);
  2301. }
  2303. /*
  2304.  * Send a window size update to the remote system.
  2305.  */
  2307.     void
  2308. sendnaws()
  2309. {
  2310.     long rows, cols;
  2311.     unsigned char tmp[16];
  2312.     register unsigned char *cp;
  2314.     if (my_state_is_wont(TELOPT_NAWS))
  2315. return;
  2317. #define PUTSHORT(cp, x) { if ((*cp++ = ((x)>>8)&0xff) == IAC) *cp++ = IAC; 
  2318.     if ((*cp++ = ((x))&0xff) == IAC) *cp++ = IAC; }
  2320.     if (TerminalWindowSize(&rows, &cols) == 0) { /* Failed */
  2321. return;
  2322.     }
  2324.     cp = tmp;
  2326.     *cp++ = IAC;
  2327.     *cp++ = SB;
  2328.     *cp++ = TELOPT_NAWS;
  2329.     PUTSHORT(cp, cols);
  2330.     PUTSHORT(cp, rows);
  2331.     *cp++ = IAC;
  2332.     *cp++ = SE;
  2333.     if (NETROOM() >= cp - tmp) {
  2334. ring_supply_data(&netoring, tmp, cp-tmp);
  2335. printsub('>', tmp+2, cp - tmp - 2);
  2336.     }
  2337. }
  2339.     void
  2340. tel_enter_binary(rw)
  2341.     int rw;
  2342. {
  2343.     if (rw&1)
  2344. send_do(TELOPT_BINARY, 1);
  2345.     if (rw&2)
  2346. send_will(TELOPT_BINARY, 1);
  2347. }
  2349.     void
  2350. tel_leave_binary(rw)
  2351.     int rw;
  2352. {
  2353.     if (rw&1)
  2354. send_dont(TELOPT_BINARY, 1);
  2355.     if (rw&2)
  2356. send_wont(TELOPT_BINARY, 1);
  2357. }