home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / ckv201.zip / ckctel.c < prev    next >
C/C++ Source or Header  |  2002-01-31  |  300KB  |  8,897 lines
  1. char *cktelv = "Telnet support, 8.0.246, 25 Jan 2002";
  2. #define CKCTEL_C
  3.  
  4. int sstelnet = 0;                       /* Do server-side Telnet negotiation */
  5.  
  6. /*  C K C T E L  --  Telnet support  */
  7.  
  8. /*
  9.   Authors:
  10.     Telnet protocol by Frank da Cruz and Jeffrey Altman.
  11.     Telnet Forward X by Jeffrey Altman
  12.     Telnet START_TLS support by Jeffrey Altman
  13.     Telnet AUTH and ENCRYPT support by Jeffrey Altman
  14.     Telnet COMPORT support by Jeffrey Altman
  15.     Telnet NEW-ENVIRONMENT support by Jeffrey Altman
  16.     Telnet NAWS support by Frank da Cruz and Jeffrey Altman
  17.     Telnet TERMTYPE support by Jeffrey Altman
  18.     Telnet KERMIT support by Jeffrey Altman
  19.     Other contributions as indicated in the code.
  20.  
  21.   Copyright (C) 1985, 2002,
  22.     Trustees of Columbia University in the City of New York.
  23.     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  24.     copyright text in the ckcmai.c module for disclaimer and permissions.
  25. */
  26.  
  27. /*
  28.   NOTE TO CONTRIBUTORS: This file, and all the other shared (ckc and cku)
  29.   C-Kermit source files, must be compatible with C preprocessors that support
  30.   only #ifdef, #else, #endif, #define, and #undef.  Please do not use #if,
  31.   logical operators, or other preprocessor features in this module.  Also,
  32.   don't use any ANSI C constructs except within #ifdef CK_ANSIC..#endif.
  33. */
  34.  
  35. #include "ckcsym.h"
  36. #include "ckcdeb.h"
  37.  
  38. #ifdef TNCODE
  39. #include "ckcker.h"
  40. #define TELCMDS                         /* to define name array */
  41. #define TELOPTS                         /* to define name array */
  42. #define SLC_NAMES                       /* to define name array */
  43. #define ENCRYPT_NAMES
  44. #define AUTH_NAMES
  45. #define TELOPT_STATES
  46. #define TELOPT_MODES
  47. #define TNC_NAMES
  48. #include "ckcnet.h"
  49. #include "ckctel.h"
  50. #ifdef CK_SSL
  51. #include "ck_ssl.h"
  52. #endif /* CK_SSL */
  53.  
  54. #ifndef NOTERM
  55. #ifdef OS2                              /* For terminal type name string */
  56. #include "ckuusr.h"
  57. #ifndef NT
  58. #include <os2.h>
  59. #undef COMMENT
  60. #endif /* NT */
  61. #include "ckocon.h"
  62. extern int tt_type, max_tt;
  63. extern struct tt_info_rec tt_info[];
  64. extern char ttname[];
  65. #endif /* OS2 */
  66. #endif /* NOTERM */
  67.  
  68. #ifdef OS2
  69. #include <assert.h>
  70. #ifdef NT
  71. #include <setjmpex.h>
  72. #else /* NT */
  73. #include <setjmp.h>
  74. #endif /* NT */
  75. #include <signal.h>
  76. #include "ckcsig.h"
  77. #include "ckosyn.h"
  78. #endif /* OS2 */
  79.  
  80. #ifdef CK_NAWS                          /* Negotiate About Window Size */
  81. #ifdef RLOGCODE
  82. _PROTOTYP( int rlog_naws, (void) );
  83. #endif /* RLOGCODE */
  84. #endif /* CK_NAWS */
  85.  
  86. int tn_init = 0;                        /* Telnet protocol initialized flag */
  87. int tn_begun = 0;                       /* Telnet protocol started flag */
  88. static int tn_first = 1;                /* First time init flag */
  89. extern int tn_exit;                     /* Exit on disconnect */
  90. extern int inserver;                    /* Running as IKSD */
  91. char *tn_term = NULL;                   /* Terminal type override */
  92.  
  93. #ifdef CK_SNDLOC
  94. char *tn_loc = NULL;                    /* Location override */
  95. #endif /* CK_SNDLOC */
  96. int tn_nlm = TNL_CRLF;                  /* Telnet CR -> CR LF mode */
  97. int tn_b_nlm = TNL_CR;                  /* Telnet Binary CR RAW mode */
  98. int tn_b_meu = 0;                       /* Telnet Binary ME means U too */
  99. int tn_b_ume = 0;                       /* Telnet Binary U means ME too */
  100. int tn_wait_flg = 1;                    /* Telnet Wait for Negotiations */
  101. int tn_infinite = 0;                    /* Telnet Bug Infinite-Loop-Check */
  102. int tn_rem_echo = 1;                    /* We will echo if WILL ECHO */
  103. int tn_b_xfer = 0;                      /* Telnet Binary for Xfers? */
  104. int tn_sb_bug = 1;                      /* Telnet BUG - SB w/o WILL or DO */
  105. int tn_no_encrypt_xfer = 0;             /* Turn off Telnet Encrypt? */
  106. int tn_delay_sb = 1;                    /* Delay SBs until safe */
  107. int tn_auth_how = TN_AUTH_HOW_ANY;
  108. int tn_auth_enc = TN_AUTH_ENC_ANY;
  109. int tn_deb = 0;                         /* Telnet Debug mode */
  110. int tn_sfu = 0;                         /* Microsoft SFU compatibility */
  111. #ifdef CK_FORWARD_X
  112. char * tn_fwdx_xauthority = NULL;       /* Xauthority File */
  113. int    fwdx_no_encrypt = 0;             /* Forward-X requires encryption */
  114. #endif /* CK_FORWARD_X */
  115.  
  116. #ifdef OS2
  117. int ttnum = -1;                         /* Last Telnet Terminal Type sent */
  118. int ttnumend = 0;                       /* Has end of list been found */
  119. #endif /* OS2 */
  120.  
  121. char tn_msg[TN_MSG_LEN];                /* Telnet data can be rather long */
  122. char hexbuf[TN_MSG_LEN];
  123. char tn_msg_out[TN_MSG_LEN];
  124. #ifdef CK_FORWARD_X
  125. char fwdx_msg_out[TN_MSG_LEN];
  126. #endif /* CK_FORWARD_X */
  127.  
  128. /*
  129.   In order to prevent an infinite telnet negotiation loop we maintain a
  130.   count of the number of times the same telnet negotiation message is
  131.   sent. When this count hits MAXTNCNT, we do not send any more of the
  132.   message. The count is stored in the tncnts[][] array.
  133.  
  134.   The tncnts[][] array is indexed by negotiation option (SUPPRESS GO AHEAD,
  135.   TERMINAL TYPE, NAWS, etc. - see the tnopts[] array) and the four
  136.   negotiation message types (WILL, WONT, DO, DONT).  All telnet negotiations
  137.   are kept track of in this way.
  138.  
  139.   The count for a message is zeroed when the "opposite" message is sent.
  140.   WILL is the opposite of WONT, and DO is the opposite of DONT.
  141.   For example sending "WILL SGA" increments tncnts[TELOPT_SGA][0]
  142.   and zeroes tncnts[TELOPT_SGA][1].
  143.  
  144.   The code that does this is in tn_sopt().
  145.  
  146.   rogersh@fsj.co.jp, 18/3/1995
  147.  
  148.   8/16/1998 - with the recent rewrite of the telnet state machine I don't
  149.   think this code is necessary anymore.  However, it can't do any harm so
  150.   I am leaving it in.    - Jeff
  151.  
  152.   12/28/1998 - all references to tncnts[] must be done with TELOPT_INDEX(opt)
  153.   because the Telnet option list is no longer contiguous.  We also must
  154.   allocate NTELOPTS + 1 because the TELOPT_INDEX() macro returns NTELOPTS
  155.   for an invalid option number.
  156. */
  157.  
  158. #define MAXTNCNT 4      /* Permits 4 intermediate telnet firewalls/gateways */
  159.  
  160. char tncnts[NTELOPTS+1][4];             /* Counts */
  161. char tnopps[4] = { 1,0,3,2 };           /* Opposites */
  162.  
  163. #ifdef CK_ENVIRONMENT
  164. #ifdef CK_FORWARD_X
  165. #define TSBUFSIZ 2056
  166. #else /* CK_FORWARD_X */
  167. #define TSBUFSIZ 1024
  168. #endif /* CK_FORWARD_X */
  169. char tn_env_acct[64];
  170. char tn_env_disp[64];
  171. char tn_env_job[64];
  172. char tn_env_prnt[64];
  173. char tn_env_sys[64];
  174. char * tn_env_uservar[8][2];
  175. int tn_env_flg = 1;
  176. #else /* CK_ENVIRONMENT */
  177. #define TSBUFSIZ 41
  178. int tn_env_flg = 0;
  179. #endif /* CK_ENVIRONMENT */
  180.  
  181. #ifndef NOSIGWINCH
  182. #ifdef CK_NAWS                          /* Window size business */
  183. #ifdef UNIX
  184. #include <signal.h>
  185. #endif /* UNIX */
  186. #endif /* CK_NAWS */
  187. #endif /* NOSIGWINCH */
  188.  
  189. CHAR sb[TSBUFSIZ];                      /* Buffer - incoming subnegotiations */
  190. CHAR sb_out[TSBUFSIZ];                  /* Buffer - outgoing subnegotiations */
  191.  
  192. int tn_duplex = 1;                      /* Local echo */
  193.  
  194. extern char uidbuf[];                   /* User ID buffer */
  195. extern int quiet, ttnet, ttnproto, debses, what, duplex, oldplex, local;
  196. extern int seslog, sessft, whyclosed;
  197. #ifdef OS2
  198. #ifndef NOTERM
  199. extern int tt_rows[], tt_cols[];
  200. extern int tt_status[VNUM];
  201. extern int scrninitialized[];
  202. #endif /* NOTERM */
  203. #else /* OS2 */
  204. extern int tt_rows, tt_cols;            /* Everybody has this */
  205. #endif /* OS2 */
  206. extern int cmd_cols, cmd_rows;
  207. extern char namecopy[];
  208. extern char myipaddr[];             /* Global copy of my IP address */
  209.  
  210. int sw_armed = 0;                       /* SIGWINCH armed flag */
  211.  
  212. #ifndef NOSIGWINCH
  213. #ifdef CK_NAWS                          /* Window size business */
  214. #ifdef SIGWINCH
  215. #ifdef UNIX
  216.  
  217. SIGTYP
  218. winchh(foo) int foo; {
  219.     int x = 0;
  220. #ifdef CK_TTYFD
  221. #ifndef VMS
  222.     extern int ttyfd;
  223. #endif /* VMS */
  224. #endif /* CK_TTYFD */
  225.     debug(F100,"SIGWINCH caught","",0);
  226.     signal(SIGWINCH,winchh);            /* Re-arm the signal */
  227. #ifdef CK_TTYFD
  228.     if
  229. #ifdef VMS
  230.       (vmsttyfd() == -1)
  231. #else
  232.       (ttyfd == -1)
  233. #endif /* VMS */
  234. #else
  235.       (!local)
  236. #endif /* CK_TTYFD */
  237.         return;
  238.  
  239.     x = ttgwsiz();                      /* Get new window size */
  240. /*
  241.   This should be OK.  It might seem that sending this from
  242.   interrupt level could interfere with another TELNET IAC string
  243.   that was in the process of being sent.  But we always send
  244.   TELNET strings with a single write(), which should prevent mixups.
  245. */
  246.     if (x > 0 && tt_rows > 0 && tt_cols > 0) {
  247.         tn_snaws();
  248. #ifdef RLOGCODE
  249.         rlog_naws();
  250. #endif /* RLOGCODE */
  251.     }
  252.     return;
  253. }
  254. #endif /* UNIX */
  255. #endif /* SIGWINCH */
  256. #endif /* CK_NAWS */
  257. #endif /* NOSIGWINCH */
  258.  
  259. #ifndef TELOPT_MACRO
  260. int
  261. telopt_index(opt) int opt; {
  262.     if (opt >= 0 && opt <= TELOPT_STDERR)
  263.       return(opt);
  264.     else if (opt >= TELOPT_PRAGMA_LOGON && opt <= TELOPT_PRAGMA_HEARTBEAT)
  265.       return(opt-88);
  266.     else if (opt == TELOPT_IBM_SAK)
  267.       return(opt-147);
  268.     else
  269.       return(NTELOPTS);
  270. }
  271.  
  272. int
  273. telopt_ok(opt) int opt; {
  274.     return((opt >= TELOPT_BINARY && opt <= TELOPT_STDERR) ||
  275.            (opt >= TELOPT_PRAGMA_LOGON && opt <= TELOPT_PRAGMA_HEARTBEAT) ||
  276.            (opt == TELOPT_IBM_SAK));
  277. }
  278.  
  279. CHAR *
  280. telopt(opt) int opt; {
  281.     if (telopt_ok(opt))
  282.       return((CHAR *)telopts[telopt_index(opt)]);
  283.     else
  284.       return((CHAR *)"UNKNOWN");
  285. }
  286.  
  287. int
  288. telopt_mode_ok(opt) int opt; {
  289.     return((unsigned int)(opt) <= TN_NG_MU);
  290. }
  291.  
  292. CHAR *
  293. telopt_mode(opt) int opt; {
  294.     if (telopt_mode_ok(opt))
  295.       return((CHAR *)telopt_modes[opt-TN_NG_RF]);
  296.     else
  297.       return((CHAR *)"UNKNOWN");
  298. }
  299. #endif /* TELOPT_MACRO */
  300.  
  301. static int
  302. tn_outst(notquiet) int notquiet; {
  303.     int outstanding = 0;
  304.     int x = 0;
  305. #ifdef CK_ENCRYPTION
  306.     int e = 0;
  307.     int d = 0;
  308. #endif /* CK_ENCRYPTION */
  309.  
  310.     if (tn_wait_flg) {
  311.         for (x = TELOPT_FIRST; x <= TELOPT_LAST; x++) {
  312.             if (TELOPT_OK(x)) {
  313.                 if (TELOPT_UNANSWERED_WILL(x)) {
  314.                     if ( notquiet )
  315.                       printf("?Telnet waiting for response to WILL %s\r\n",
  316.                              TELOPT(x));
  317.                     debug(F111,"tn_outst","unanswered WILL",x);
  318.                     outstanding = 1;
  319.                     if ( !notquiet )
  320.                       break;
  321.                 }
  322.                 if (TELOPT_UNANSWERED_DO(x)) {
  323.                     if ( notquiet )
  324.                       printf("?Telnet waiting for response to DO %s\r\n",
  325.                              TELOPT(x));
  326.                     debug(F111,"tn_outst","unanswered DO",x);
  327.                     outstanding = 1;
  328.                     if ( !notquiet )
  329.                       break;
  330.                 }
  331.                 if (TELOPT_UNANSWERED_WONT(x)) {
  332.                     if ( notquiet )
  333.                       printf("?Telnet waiting for response to WONT %s\r\n",
  334.                              TELOPT(x));
  335.                     debug(F111,"tn_outst","unanswered WONT",x);
  336.                     outstanding = 1;
  337.                     if ( !notquiet )
  338.                       break;
  339.                 }
  340.                 if (TELOPT_UNANSWERED_DONT(x)) {
  341.                     if ( notquiet )
  342.                       printf("?Telnet waiting for response to DONT %s\r\n",
  343.                              TELOPT(x));
  344.                     debug(F111,"tn_outst","unanswered DONT",x);
  345.                     outstanding = 1;
  346.                     if ( !notquiet )
  347.                       break;
  348.                 }
  349.                 if (TELOPT_UNANSWERED_SB(x)) {
  350.                     if ( notquiet )
  351.                       printf("?Telnet waiting for response to SB %s\r\n",
  352.                              TELOPT(x));
  353.                     debug(F111,"tn_outst","unanswered SB",x);
  354.                     outstanding = 1;
  355.                     if ( !notquiet )
  356.                       break;
  357.                 }
  358.             }
  359.         }
  360. #ifdef CK_AUTHENTICATION
  361.         if (ck_tn_auth_in_progress()) {
  362.             if (TELOPT_ME(TELOPT_AUTHENTICATION)) {
  363.                 if (notquiet)
  364.                   printf("?Telnet waiting for WILL %s subnegotiation\r\n",
  365.                          TELOPT(TELOPT_AUTHENTICATION));
  366.                 debug(F111,
  367.                       "tn_outst",
  368.                       "ME authentication in progress",
  369.                       TELOPT_AUTHENTICATION
  370.                       );
  371.                 outstanding = 1;
  372.             } else if (TELOPT_U(TELOPT_AUTHENTICATION)) {
  373.                 if (notquiet)
  374.                   printf("?Telnet waiting for DO %s subnegotiation\r\n",
  375.                          TELOPT(TELOPT_AUTHENTICATION));
  376.                 debug(F111,
  377.                       "tn_outst",
  378.                       "U authentication in progress",
  379.                       TELOPT_AUTHENTICATION
  380.                       );
  381.                 outstanding = 1;
  382.             }
  383.         }
  384. #endif /* CK_AUTHENTICATION */
  385. #ifdef CK_ENCRYPTION
  386.         if (!outstanding) {
  387.             e = ck_tn_encrypting();
  388.             d = ck_tn_decrypting();
  389.             if (TELOPT_ME(TELOPT_ENCRYPTION)) {
  390.                 if (TELOPT_SB(TELOPT_ENCRYPTION).encrypt.stop && e ||
  391.                     !TELOPT_SB(TELOPT_ENCRYPTION).encrypt.stop && !e
  392.                     ) {
  393.                     if ( notquiet )
  394.                       printf("?Telnet waiting for WILL %s subnegotiation\r\n",
  395.                              TELOPT(TELOPT_ENCRYPTION));
  396.                     debug(F111,
  397.                           "tn_outst",
  398.                           "encryption mode switch",
  399.                           TELOPT_ENCRYPTION
  400.                           );
  401.                     outstanding = 1;
  402.                 }
  403.             }
  404.             if (TELOPT_U(TELOPT_ENCRYPTION)) {
  405.                 if (TELOPT_SB(TELOPT_ENCRYPTION).encrypt.stop && d ||
  406.                     !TELOPT_SB(TELOPT_ENCRYPTION).encrypt.stop && !d
  407.                     ) {
  408.                     if ( notquiet )
  409.                       printf("?Telnet waiting for DO %s subnegotiation\r\n",
  410.                              TELOPT(TELOPT_ENCRYPTION));
  411.                     debug(F111,
  412.                           "tn_outst",
  413.                           "decryption mode switch",
  414.                            TELOPT_ENCRYPTION
  415.                           );
  416.                     outstanding = 1;
  417.                 }
  418.             }
  419.         }
  420. #endif /* CK_ENCRYPTION */
  421.     } /* if (tn_wait_flg) */
  422.  
  423. #ifdef IKS_OPTION
  424.     /* Even if we are not waiting for Telnet options we must wait for */
  425.     /* Kermit Telnet Subnegotiations if we have sent a request to the */
  426.     /* other guy.  Otherwise we will get out of sync.                 */
  427.     if (!outstanding) {
  428.         if (TELOPT_U(TELOPT_KERMIT) &&
  429.             (TELOPT_SB(TELOPT_KERMIT).kermit.me_req_start ||
  430.              TELOPT_SB(TELOPT_KERMIT).kermit.me_req_stop ||
  431.              !TELOPT_SB(TELOPT_KERMIT).kermit.sop)
  432.             ) {
  433.             if ( notquiet )
  434.               printf("?Telnet waiting for SB %s negotiation\r\n",
  435.                      TELOPT(TELOPT_KERMIT));
  436.             debug(F111,"tn_outst","U kermit in progress",TELOPT_KERMIT);
  437.             outstanding = 1;
  438.         }
  439.     }
  440. #endif /* IKS_OPTION */
  441.  
  442. #ifdef TN_COMPORT
  443.     if (!outstanding) {
  444.         if (TELOPT_ME(TELOPT_COMPORT) &&
  445.              TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb) {
  446.             if (notquiet)
  447.               printf("?Telnet waiting for SB %s negotiation\r\n",
  448.                      TELOPT(TELOPT_COMPORT));
  449.             debug(F111,"tn_outst","ComPort SB in progress",TELOPT_COMPORT);
  450.             outstanding = 1;
  451.         }
  452.     }
  453. #endif /* TN_COMPORT */
  454.     return(outstanding);
  455. }
  456.  
  457. int
  458. istncomport() {
  459. #ifdef TN_COMPORT
  460.     if (!local) return(0);
  461.     if (ttnet != NET_TCPB) return(0);
  462.     if (ttnproto != NP_TELNET) return(0);
  463.     if (TELOPT_ME(TELOPT_COMPORT))
  464.       return(1);
  465.     else
  466. #endif /* TN_COMPORT */
  467.       return(0);
  468. }
  469.  
  470. /* tn_wait() -- Wait for response to Telnet negotiation. */
  471. /*
  472.   Wait for up to <timeout> seconds for the response to arrive.
  473.   Place all non-telnet data into Telnet Wait Buffer.
  474.   If response does arrive return 1, else return 0.
  475. */
  476. #ifndef TN_WAIT_BUF_SZ
  477. #define TN_WAIT_BUF_SZ 4096
  478. #endif /* TN_WAIT_BUF_SZ */
  479. static char tn_wait_buf[TN_WAIT_BUF_SZ];
  480. static int  tn_wait_idx = 0;
  481. #ifndef TN_TIMEOUT
  482. #define TN_TIMEOUT 120
  483. #endif /* TN_TIMEOUT */
  484. static int tn_wait_tmo = TN_TIMEOUT;
  485.  
  486. #ifdef CKSPINNER
  487. VOID
  488. prtwait(state) int state; {
  489.     switch (state % 4) {
  490.       case 0:
  491.         printf("/");
  492.         break;
  493.       case 1:
  494.         printf("-");
  495.         break;
  496.       case 2:
  497.         printf("\\");
  498.         break;
  499.       case 3:
  500.         printf("|");
  501.         break;
  502.     }
  503. }
  504. #endif /* CKSPINNER */
  505.  
  506. static int nflag = 0;
  507.  
  508. int
  509. #ifdef CK_ANSIC
  510. tn_wait(char * where)
  511. #else
  512. tn_wait(where) char * where;
  513. #endif /* CK_ANSIC */
  514. /* tn_wait */ {
  515.     extern int ckxech, local;
  516.     int ch = 0, count = 0;
  517. #ifndef NOHINTS
  518.     int nohintgiven = 1;
  519.     extern int hints;
  520. #endif /* NOHINTS */
  521.     int outstanding;
  522.  
  523.     rtimer();
  524.  
  525.     debug(F110,"tn_wait waiting for",where,0);
  526.     tn_wait_tmo = TN_TIMEOUT;
  527.     debug(F111,"tn_wait","timeout",tn_wait_tmo);
  528.     outstanding = tn_outst(0);
  529.  
  530.     /* The following is meant to be !(||).  We only want to return */
  531.     /* immediately if both the tn_wait_flg && tn_outst() are false */
  532.     if (!(outstanding || tn_wait_flg))  /* If no need to wait */
  533.       return(1);                        /* Don't. */
  534.  
  535.     if (tn_deb || debses) tn_debug("<wait for outstanding negotiations>");
  536.  
  537. #ifdef CKSPINNER
  538.     if (!sstelnet && !quiet)
  539.         prtwait(0);
  540. #endif /* CKSPINNER */
  541.  
  542.     /* Wait up to TN_TIMEOUT sec for responses to outstanding telnet negs */
  543.     do {
  544. #ifdef NTSIG
  545.         ck_ih();
  546. #endif /* NTSIG */
  547.         ch = ttinc(1);
  548.         if (ch == -1) {                 /* Timed out */
  549.             if (!sstelnet && !quiet) {  /* Let user know... */
  550. #ifdef CKSPINNER
  551.                 printf("\b");
  552.                 prtwait(gtimer());
  553. #else
  554.                 if (nflag == 0) {
  555.                     printf(" Negotiations.");
  556.                     nflag++;
  557.                 }
  558.                 if (nflag > 0) {
  559.                     printf(".");
  560.                     nflag++;
  561.                     fflush(stdout);
  562.                 }
  563. #endif /* CKSPINNER */
  564.             }
  565.         } else if (ch < -1) {
  566.             printf("\r\n?Connection closed by peer.\r\n");
  567.             if (tn_deb || debses) tn_debug("<connection closed by peer>");
  568.             return(-1);
  569.         } else
  570.         switch (ch) {
  571.           case IAC:
  572. #ifdef CKSPINNER
  573.             if (!sstelnet && !quiet)
  574.               printf("\b");
  575. #endif /* CKSPINNER */
  576.             ch = tn_doop((CHAR)(ch & 0xff),inserver?ckxech:duplex,ttinc);
  577. #ifdef CKSPINNER
  578.             if (!sstelnet && !quiet) {
  579.                 prtwait(gtimer());
  580.             }
  581. #endif /* CKSPINNER */
  582.             debug(F101,"tn_wait tn_doop","",ch);
  583.             switch (ch) {
  584.               case 1:
  585.                 duplex = 1;             /* Turn on echoing */
  586.                 if (inserver)
  587.                   ckxech = 1;
  588.                 break;
  589.               case 2:
  590.                 duplex = 0;             /* Turn off echoing */
  591.                 if (inserver)
  592.                   ckxech = 0;
  593.                 break;
  594.               case 3:
  595.                 tn_wait_buf[tn_wait_idx++] = IAC;
  596.                 break;
  597.               case 4:                   /* IKS event */
  598.               case 6:                   /* Logout */
  599.                 break;
  600.               case -1:
  601.                 printf("?Telnet Option negotiation error.\n");
  602.                 if (tn_deb || debses)
  603.                   tn_debug("<Telnet Option negotiation error>");
  604.                 return(-1);
  605.               case -2:
  606.                 printf("?Connection closed by peer.\n");
  607.                 if (tn_deb || debses) tn_debug("<Connection closed by peer>");
  608.                 return(-2);
  609.               default:
  610.                 if (ch < 0) {
  611.                   if (tn_deb || debses) tn_debug("<Unknown connection error>");
  612.                   return(ch);
  613.                 }
  614.             } /* switch */
  615.             break;
  616.           default:
  617. #ifdef CKSPINNER
  618.             if (!sstelnet && !quiet) {
  619.                 printf("\b");
  620.                 prtwait(gtimer());
  621.             }
  622. #endif /* CKSPINNER */
  623.             tn_wait_buf[tn_wait_idx++] = (CHAR)(ch & 0xff);
  624.         } /* switch */
  625.  
  626.         outstanding = tn_outst(0);
  627.  
  628.         if ( outstanding && ch != IAC ) {
  629.             int timer = gtimer();
  630.             if ( timer > tn_wait_tmo ) {
  631.                 if (!sstelnet) {
  632.                     printf(
  633.                     "\r\n?Telnet Protocol Timeout - connection closed\r\n");
  634.                     if (tn_deb || debses)
  635.                         tn_debug(
  636.                         "<telnet protocol timeout - connection closed>");
  637.                     tn_outst(1);
  638.                 }
  639.                 /* if we do not close the connection, then we will block */
  640.                 /* the next time we hit a wait.  and if we don't we will */
  641.                 /* do the wrong thing if the host sends 0xFF and does    */
  642.                 /* not intend it to be an IAC.                           */
  643.                 ttclos(0);
  644.                 whyclosed = WC_TELOPT;
  645.                 return(-1);
  646.             }
  647. #ifndef NOHINTS
  648.             else if ( hints && timer > 30 && nohintgiven && !inserver ) {
  649. #ifdef CKSPINNER
  650.                                 printf("\b");
  651. #else /* CKSPINNER */
  652.                                 printf("\r\n");
  653. #endif /* CKSPINNER */
  654.       printf("*************************\r\n");
  655.         printf("The Telnet %s is not sending required responses.\r\n\r\n",
  656.                 sstelnet?"client":"server");
  657.       tn_outst(1);
  658.       printf("\nYou can continue to wait or you can cancel with Ctrl-C.\r\n");
  659.       printf("In case the Telnet server never responds as required,\r\n");
  660.       printf("you can try connecting to this host with TELNET /NOWAIT.\r\n");
  661.       printf("Use SET HINTS OFF to suppress further hints.\r\n");
  662.       printf("*************************\r\n");
  663.       nohintgiven = 0;
  664.             }
  665. #endif /* NOHINTS */
  666.         }
  667.     } while ((tn_wait_idx < TN_WAIT_BUF_SZ) &&
  668.               (outstanding && (count = ttchk()) >= 0) /* (count not used) */
  669.               );
  670.  
  671.     if (tn_wait_idx == TN_WAIT_BUF_SZ) {
  672.       if (tn_deb || debses) tn_debug("<Telnet Wait Buffer filled>");
  673.       return(0);
  674.     }
  675.  
  676.     if (!sstelnet && !quiet) {
  677. #ifdef CKSPINNER
  678.         printf("\b \b");
  679. #else
  680.         if (nflag > 0) {
  681.             printf(" (OK)\n");
  682.             nflag = -1;
  683.         }
  684. #endif /* CKSPINNER */
  685.     }
  686.     if (tn_deb || debses) tn_debug("<no outstanding negotiations>");
  687.     return(0);
  688. }
  689.  
  690. /* Push data from the Telnet Wait Buffer into the I/O Queue */
  691. /* Return 1 on success                                      */
  692.  
  693. int
  694. tn_push() {
  695. #ifdef NETLEBUF
  696.     extern int tt_push_inited;
  697. #endif /* NETLEBUF */
  698.     if (tn_wait_idx) {
  699.         hexdump((CHAR *)"tn_push",tn_wait_buf,tn_wait_idx);
  700. #ifdef NETLEBUF
  701.         if (!tt_push_inited)            /* Local handling */
  702.           le_init();
  703.         le_puts((CHAR *)tn_wait_buf,tn_wait_idx);
  704. #else                                   /* External handling... */
  705. #ifdef OS2                              /* K95 has its own way */
  706.         le_puts((CHAR *)tn_wait_buf,tn_wait_idx);
  707. #else
  708. #ifdef TTLEBUF                          /* UNIX, etc */
  709.         le_puts((CHAR *)tn_wait_buf,tn_wait_idx);
  710. #else
  711. /*
  712.   If you see this message in AOS/VS, OS-9, VOS, etc, you need to copy
  713.   the #ifdef TTLEBUF..#endif code from ckutio.c to the corresponding
  714.   places in your ck?tio.c module.
  715. */
  716.         printf("tn_push called but not implemented - data lost.\n");
  717. #endif /* TTLEBUF */
  718. #endif /* OS2 */
  719. #endif /* NETLEBUF */
  720.         tn_wait_idx = 0;
  721.     }
  722.     tn_wait_tmo = TN_TIMEOUT;           /* Reset wait timer stats */
  723.     return(1);
  724. }
  725.  
  726. /*  T N _ S O P T  */
  727. /*
  728.    Sends a telnet option, avoids loops.
  729.    Returns 1 if command was sent, 0 if not, -1 on error.
  730. */
  731. int
  732. tn_sopt(cmd,opt) int cmd, opt; {        /* TELNET SEND OPTION */
  733.     CHAR buf[5];
  734.     char msg[128];
  735.     int rc;
  736.  
  737.     if (ttnet != NET_TCPB) return(-1);  /* Must be TCP/IP */
  738.     if (ttnproto != NP_TELNET) return(-1); /* Must be telnet protocol */
  739.     if (!TELCMD_OK(cmd)) return(-1);
  740.     if (TELOPT_OK(opt)) {
  741.         if (cmd == DO && TELOPT_UNANSWERED_DO(opt)) return(0);
  742.         if (cmd == WILL && TELOPT_UNANSWERED_WILL(opt)) return(0);
  743.         if (cmd == DONT && TELOPT_UNANSWERED_DONT(opt)) return(0);
  744.         if (cmd == WONT && TELOPT_UNANSWERED_WONT(opt)) return(0);
  745.     }
  746. #ifdef CK_SSL
  747.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  748.         return(0);
  749.     }
  750. #endif /* CK_SSL */
  751.  
  752.     if (cmd == DO && opt == TELOPT_AUTHENTICATION)
  753.       buf[0] = 0;
  754.  
  755.     if (tn_infinite && TELOPT_OK(opt)) { /* See comment above about   */
  756.         int index = TELOPT_INDEX(opt);   /* preventing infinite loops */
  757.         int m = cmd - WILL;
  758.  
  759.         if (tncnts[index][m] > MAXTNCNT) {
  760. #ifdef DEBUG
  761.             if (tn_deb || debses || deblog) {
  762.                 ckmakmsg(msg,sizeof(msg),
  763.                            "TELNET negotiation loop ",
  764.                            TELCMD(cmd), " ",
  765.                            TELOPT(opt));
  766.                 debug(F101,msg,"",opt);
  767.                 if (tn_deb || debses) tn_debug(msg);
  768.             }
  769. #endif /* DEBUG */
  770.             return(0);
  771.         }
  772.         tncnts[index][m]++;
  773.         tncnts[index][tnopps[m]] = 0;
  774.     }
  775.     buf[0] = (CHAR) IAC;
  776.     buf[1] = (CHAR) (cmd & 0xff);
  777.     buf[2] = (CHAR) (opt & 0xff);
  778.     buf[3] = (CHAR) 0;
  779. #ifdef DEBUG
  780.     if ((tn_deb || debses || deblog) && cmd != SB)
  781.         ckmakmsg(msg,sizeof(msg),"TELNET SENT ",TELCMD(cmd)," ",
  782.                   TELOPT(opt));
  783. #endif /* DEBUG */
  784. #ifdef OS2
  785.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  786. #endif
  787.     debug(F101,msg,"",opt);
  788.     if ((tn_deb || debses) && cmd != SB)
  789.       tn_debug(msg);
  790.     rc = (ttol(buf,3) < 3);
  791. #ifdef OS2
  792.     ReleaseTelnetMutex();
  793. #endif
  794.     if (rc)
  795.         return(-1);
  796.  
  797.  
  798.     if (TELOPT_OK(opt)) {
  799.         if (cmd == DONT && TELOPT_UNANSWERED_DO(opt))
  800.           TELOPT_UNANSWERED_DO(opt) = 0;
  801.         if (cmd == WONT && TELOPT_UNANSWERED_WILL(opt))
  802.           TELOPT_UNANSWERED_WILL(opt) = 0;
  803.         if (cmd == DO && TELOPT_UNANSWERED_DONT(opt))
  804.           TELOPT_UNANSWERED_DONT(opt) = 0;
  805.         if (cmd == WILL && TELOPT_UNANSWERED_WONT(opt))
  806.           TELOPT_UNANSWERED_WONT(opt) = 0;
  807.     }
  808.     return(1);
  809. }
  810.  
  811. /* Send a telnet sub-option */
  812. /* Returns 1 if command was sent, 0 if not, -1 on error */
  813.  
  814. int
  815. tn_ssbopt(opt,sub,data,len) int opt, sub; CHAR * data; int len; {
  816.     CHAR buf[256];
  817.     int n,m,rc;
  818.  
  819.     if (ttnet != NET_TCPB) return(0);   /* Must be TCP/IP */
  820.     if (ttnproto != NP_TELNET) return(0); /* Must be telnet protocol */
  821.     if (!TELOPT_OK(opt)) return(-1);
  822.     if (len < 0 || len > 250) {
  823.         debug(F111,"Unable to Send TELNET SB - data too long","len",len);
  824.         return(-1);                     /* Data too long */
  825.     }
  826. #ifdef CK_SSL
  827.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  828.         if (ttchk() < 0)
  829.           return(-1);
  830.         else
  831.           return(1);
  832.     }
  833. #endif /* CK_SSL */
  834.  
  835.     if (!data) len = 0;
  836.  
  837.     buf[0] = (CHAR) IAC;
  838.     buf[1] = (CHAR) (SB & 0xff);
  839.     buf[2] = (CHAR) (opt & 0xff);
  840.     buf[3] = (CHAR) (sub & 0xff);
  841.     if (data && len > 0) {
  842.         memcpy(&buf[4],data,len);
  843.     }
  844.     buf[4+len] = (CHAR) IAC;
  845.     buf[5+len] = (CHAR) SE;
  846.  
  847. #ifdef DEBUG
  848.     if (tn_deb || debses || deblog) {
  849.         if (opt == TELOPT_START_TLS && sub == 1)
  850.           ckmakmsg(tn_msg_out,TN_MSG_LEN,"TELNET SENT SB ",
  851.                     TELOPT(opt)," FOLLOWS IAC SE",NULL);
  852.         else if (opt == TELOPT_TTYPE && sub == 1)
  853.           ckmakmsg(tn_msg_out,TN_MSG_LEN,"TELNET SENT SB ", TELOPT(opt),
  854.                     " SEND IAC SE",NULL);
  855.         else if (opt == TELOPT_TTYPE && sub == 0)
  856.           ckmakxmsg(tn_msg_out,TN_MSG_LEN,"TELNET SENT SB ",TELOPT(opt)," IS ",
  857.                     (char *)data," IAC SE",NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  858.         else if (opt == TELOPT_NEWENVIRON) {
  859.             int i, quote;
  860.             ckmakmsg(tn_msg_out,TN_MSG_LEN,"TELNET SENT SB ",
  861.                      TELOPT(TELOPT_NEWENVIRON)," ",
  862.                      sub == TELQUAL_SEND ? "SEND" :
  863.                      sub == TELQUAL_IS ? "IS" :
  864.                      sub == TELQUAL_INFO ?"INFO" : "UNKNOWN" );
  865.             for (i = 0, quote = 0; i < len; i++) {
  866.                 if (quote) {
  867.                     sprintf(hexbuf,"%02x",data[i]); /* safe but ugly */
  868.                     ckstrncat(tn_msg_out,hexbuf,TN_MSG_LEN);
  869.                     quote = 0;
  870.                 } else {
  871.                     switch (data[i]) {
  872.                       case TEL_ENV_USERVAR:
  873.                         ckstrncat(tn_msg_out," USERVAR ",TN_MSG_LEN);
  874.                         break;
  875.                       case TEL_ENV_VAR:
  876.                         ckstrncat(tn_msg_out," VAR ",TN_MSG_LEN);
  877.                         break;
  878.                       case TEL_ENV_VALUE:
  879.                         ckstrncat(tn_msg_out," VALUE ",TN_MSG_LEN);
  880.                         break;
  881.                       case TEL_ENV_ESC:
  882.                         ckstrncat(tn_msg_out," ESC ",TN_MSG_LEN);
  883.                         quote = 1;
  884.                         break;
  885.                       case IAC:
  886.                         ckstrncat(tn_msg_out," IAC ",TN_MSG_LEN);
  887.                         break;
  888.                       default:
  889.                         sprintf(hexbuf,"%c",data[i]); /* safe but ugly */
  890.                         ckstrncat(tn_msg_out,hexbuf,TN_MSG_LEN);
  891.                     }
  892.                 }
  893.             }
  894.             ckstrncat(tn_msg_out," IAC SE",TN_MSG_LEN);
  895.         } else {
  896.             sprintf(hexbuf,"%02x",sub);             /* safe but ugly */
  897.             ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  898.                       "TELNET SENT SB ",TELOPT(opt),
  899.                       " ",
  900.                       hexbuf,
  901.                       " <data> IAC SE",
  902.                        NULL,NULL,NULL,NULL,NULL,NULL,NULL
  903.                       );
  904.         }
  905.     }
  906. #endif /* DEBUG */
  907. #ifdef OS2
  908.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  909. #endif /* OS2 */
  910. #ifdef DEBUG
  911.     debug(F101,tn_msg_out,"",opt);
  912.     if (tn_deb || debses)
  913.       tn_debug(tn_msg_out);
  914. #endif /* DEBUG */
  915.     rc = (ttol(buf,6+len) < 6+len);
  916. #ifdef OS2
  917.     ReleaseTelnetMutex();
  918. #endif
  919.  
  920.     if (rc)
  921.       return(-1);
  922.     return(1);
  923. }
  924.  
  925. /*
  926.   tn_flui() -- Processes all waiting data for Telnet commands.
  927.   All non-Telnet data is to be stored into the Telnet Wait Buffer.
  928.   Returns 1 on success.
  929. */
  930. int
  931. tn_flui() {
  932.     extern int ckxech;
  933.     int x = 0;
  934.  
  935.     /* Wait up to 5 sec for responses to outstanding telnet negotiations */
  936.     while (x >= 0 && ttchk() > 0  && tn_wait_idx < TN_WAIT_BUF_SZ) {
  937.         x = ttinc(1);
  938.         switch (x) {
  939.           case IAC:
  940.             x = tn_doop((CHAR)(x & 0xff),inserver?ckxech:duplex,ttinc);
  941.             debug(F101,"tn_flui tn_doop","",x);
  942.             switch (x) {
  943.               case 1:                   /* Turn on echoing */
  944.                 duplex = 1;
  945.                 if (inserver)
  946.                   ckxech = 1;
  947.                 break;
  948.               case 2:                   /* Turn off echoing */
  949.                 duplex = 0;
  950.                 if (inserver)
  951.                   ckxech = 0;
  952.                 break;
  953.               case 3:
  954.                 tn_wait_buf[tn_wait_idx++] = IAC;
  955.                 break;
  956.               case 4:                   /* IKS event */
  957.               case 6:                   /* Logout */
  958.                 break;
  959.             }
  960.             break;
  961.           default:
  962.             if (x >= 0)
  963.               tn_wait_buf[tn_wait_idx++] = x;
  964.         }
  965.     }
  966.     return(1);
  967. }
  968.  
  969. unsigned char *
  970. tn_get_display()
  971. {
  972.     char * disp = NULL;
  973.     static char tmploc[256];
  974.  
  975.     /* Must compute the DISPLAY string we are going to send to the host */
  976.     /* If one is not assigned, do not send a string unless the user has */
  977.     /* explicitedly requested we try to send one via X-Display Location */
  978.     /* But do not send a string at all if FORWARD_X is in use.          */
  979.  
  980.     debug(F110,"tn_get_display() myipaddr",myipaddr,0);
  981. #ifdef CK_ENVIRONMENT
  982.     debug(F110,"tn_get_display() tn_env_disp",tn_env_disp,0);
  983.     if (tn_env_disp[0]) {
  984.         int colon = ckindex(":",tn_env_disp,0,0,1);
  985.         if ( !colon ) {
  986.             ckmakmsg(tmploc,256,myipaddr,":",tn_env_disp,NULL);
  987.             disp = tmploc;
  988.         } else if ( ckindex("localhost:",tn_env_disp,0,0,0) ||
  989.                     ckindex("unix:",tn_env_disp,0,0,0) ||
  990.                     ckindex("127.0.0.1:",tn_env_disp,0,0,0) ||
  991.                     !ckstrcmp("0:",tn_env_disp,2,1) ||
  992.                     tn_env_disp[0] == ':' ) {
  993.             ckmakmsg(tmploc,256,myipaddr,":",&tn_env_disp[colon],NULL);
  994.             disp = tmploc;
  995.         } else
  996.             disp = tn_env_disp;
  997.     }
  998.     else
  999. #endif /* CK_ENVIRONMENT */
  1000.         if (TELOPT_ME(TELOPT_XDISPLOC) ||
  1001.               TELOPT_U(TELOPT_FORWARD_X)) {
  1002.         ckmakmsg(tmploc,256,myipaddr,":0.0",NULL,NULL);
  1003.         disp = tmploc;
  1004.     }
  1005.     debug(F110,"tn_get_display() returns",disp,0);
  1006.     return((CHAR *)disp);
  1007. }
  1008.  
  1009. #ifdef CK_FORWARD_X
  1010. static Xauth fake_xauth = {0,0,NULL,0,NULL,0,NULL,0,NULL};
  1011. static Xauth *real_xauth=NULL;
  1012.  
  1013. /*
  1014.  * Author:  Jim Fulton, MIT X Consortium
  1015.  *
  1016.  * fwdx_parse_displayname -
  1017.  * display a display string up into its component parts
  1018.  */
  1019. #ifdef UNIX
  1020. #define UNIX_CONNECTION "unix"
  1021. #define UNIX_CONNECTION_LENGTH 4
  1022. #endif
  1023.  
  1024. /*
  1025.  * private utility routines
  1026.  */
  1027.  
  1028. static int
  1029. #ifdef CK_ANSIC
  1030. XmuGetHostname (char *buf, int maxlen)
  1031. #else
  1032. XmuGetHostname (buf, maxlen)
  1033.     char *buf;
  1034.     int maxlen;
  1035. #endif /* CK_ANSIC */
  1036. {
  1037.     int len;
  1038.  
  1039. #ifdef NEED_UTSNAME
  1040.     /*
  1041.      * same host name crock as in server and xinit.
  1042.      */
  1043.     struct utsname name;
  1044.  
  1045.     uname (&name);
  1046.     len = strlen (name.nodename);
  1047.     if (len >= maxlen) len = maxlen - 1;
  1048.     strncpy (buf, name.nodename, len);
  1049.     buf[len] = '\0';
  1050. #else
  1051.     buf[0] = '\0';
  1052.     (void) gethostname (buf, maxlen);
  1053.     buf [maxlen - 1] = '\0';
  1054.     len = strlen(buf);
  1055. #endif /* hpux */
  1056.     return len;
  1057. }
  1058.  
  1059. static char *
  1060. #ifdef CK_ANSIC
  1061. copystring (char *src, int len)
  1062. #else
  1063. copystring (src, len)
  1064.     char *src;
  1065.     int len;
  1066. #endif /* CK_ANSIC */
  1067. {
  1068.     char *cp;
  1069.  
  1070.     if (!src && len != 0) return NULL;
  1071.     cp = malloc (len + 1);
  1072.     if (cp) {
  1073.         if (src) strncpy (cp, src, len);
  1074.         cp[len] = '\0';
  1075.     }
  1076.     return cp;
  1077. }
  1078.  
  1079. static char *
  1080. #ifdef CK_ANSIC
  1081. get_local_hostname (char *buf, int maxlen)
  1082. #else
  1083. get_local_hostname (buf, maxlen)
  1084.     char *buf;
  1085.     int maxlen;
  1086. #endif
  1087. {
  1088.     buf[0] = '\0';
  1089.     (void) XmuGetHostname (buf, maxlen);
  1090.     return (buf[0] ? buf : NULL);
  1091. }
  1092.  
  1093. #ifndef UNIX
  1094. static char *
  1095. copyhostname ()
  1096. {
  1097.     char buf[256];
  1098.  
  1099.     return (get_local_hostname (buf, sizeof buf) ?
  1100.             copystring (buf, strlen (buf)) : NULL);
  1101. }
  1102. #endif
  1103.  
  1104.  
  1105. int
  1106. #ifdef CK_ANSIC
  1107. fwdx_parse_displayname (char *displayname, int *familyp, char **hostp,
  1108.                         int *dpynump, int *scrnump, char **restp)
  1109. #else
  1110. fwdx_parse_displayname (displayname, familyp, hostp, dpynump, scrnump, restp)
  1111.     char *displayname;
  1112.     int *familyp;                       /* return */
  1113.     char **hostp;                       /* return */
  1114.     int *dpynump, *scrnump;             /* return */
  1115.     char **restp;                       /* return */
  1116. #endif /* CK_ANSIC */
  1117. {
  1118.     char *ptr;                          /* work variables */
  1119.     int len;                            /* work variable */
  1120.     int family = -1;                    /* value to be returned */
  1121.     char *host = NULL;                  /* must free if set and error return */
  1122.     int dpynum = -1;                    /* value to be returned */
  1123.     int scrnum = 0;                     /* value to be returned */
  1124.     char *rest = NULL;                  /* must free if set and error return */
  1125.     int dnet = 0;                       /* if 1 then using DECnet */
  1126.  
  1127.                                         /* check the name */
  1128.     if (!displayname || !displayname[0])
  1129.         return 0;
  1130.                                         /* must have at least :number */
  1131.     ptr = (char *)strchr(displayname, ':');
  1132.     if (!ptr || !ptr[1]) return 0;
  1133.     if (ptr[1] == ':') {
  1134.         if (ptr[2] == '\0') return 0;
  1135.         dnet = 1;
  1136.     }
  1137.  
  1138.     /*
  1139.      * get the host string; if none is given, use the most effiecient path
  1140.      */
  1141.  
  1142.     len = (ptr - displayname);  /* length of host name */
  1143.     if (len == 0) {                     /* choose most efficient path */
  1144. #ifdef UNIX
  1145.         host = copystring (UNIX_CONNECTION, UNIX_CONNECTION_LENGTH);
  1146.         family = FamilyLocal;
  1147. #else
  1148.         if (dnet) {
  1149.             host = copystring ("0", 1);
  1150.             family = FamilyDECnet;
  1151.         } else {
  1152.             host = copyhostname ();
  1153.             family = FamilyInternet;
  1154.         }
  1155. #endif
  1156.     } else {
  1157.         host = copystring (displayname, len);
  1158.         if (dnet) {
  1159.             family = dnet;
  1160.         } else {
  1161. #ifdef UNIX
  1162.             if (host && strcmp (host, UNIX_CONNECTION) == 0)
  1163.               family = FamilyLocal;
  1164.             else
  1165. #endif
  1166.               family = FamilyInternet;
  1167.         }
  1168.     }
  1169.  
  1170.     if (!host) return 0;
  1171.  
  1172.  
  1173.     /*
  1174.      * get the display number; we know that there is something after the
  1175.      * colon (or colons) from above.  note that host is now set and must
  1176.      * be freed if there is an error.
  1177.      */
  1178.  
  1179.     if (dnet) ptr++;                    /* skip the extra DECnet colon */
  1180.     ptr++;                              /* move to start of display num */
  1181.     {
  1182.         register char *cp;
  1183.  
  1184.         for (cp = ptr; *cp && isascii(*cp) && isdigit(*cp); cp++) ;
  1185.         len = (cp - ptr);
  1186.                                         /* check present and valid follow */
  1187.         if (len == 0 || (*cp && *cp != '.')) {
  1188.             free (host);
  1189.             return 0;
  1190.         }
  1191.  
  1192.         dpynum = atoi (ptr);            /* it will handle num. as well */
  1193.         ptr = cp;
  1194.     }
  1195.  
  1196.     /*
  1197.      * now get screen number if given; ptr may point to nul at this point
  1198.      */
  1199.     if (ptr[0] == '.') {
  1200.         register char *cp;
  1201.  
  1202.         ptr++;
  1203.         for (cp = ptr; *cp && isascii(*cp) && isdigit(*cp); cp++) ;
  1204.         len = (cp - ptr);
  1205.         if (len == 0 || (*cp && *cp != '.')) {  /* all prop name */
  1206.             free (host);
  1207.             return 0;
  1208.         }
  1209.  
  1210.         scrnum = atoi (ptr);            /* it will handle num. as well */
  1211.         ptr = cp;
  1212.     }
  1213.  
  1214.     /*
  1215.      * and finally, get any additional stuff that might be following the
  1216.      * the screen number; ptr must point to a period if there is anything
  1217.      */
  1218.  
  1219.     if (ptr[0] == '.') {
  1220.         ptr++;
  1221.         len = strlen (ptr);
  1222.         if (len > 0) {
  1223.             rest = copystring (ptr, len);
  1224.             if (!rest) {
  1225.                 free (host);
  1226.                 return 1;
  1227.             }
  1228.         }
  1229.     }
  1230.  
  1231.     /*
  1232.      * and we are done!
  1233.      */
  1234.  
  1235.     if ( familyp )
  1236.         *familyp = family;
  1237.     if ( hostp )
  1238.         *hostp = host;
  1239.     else
  1240.         free(host);
  1241.     if ( dpynump )
  1242.         *dpynump = dpynum;
  1243.     if ( scrnump )
  1244.         *scrnump = scrnum;
  1245.     if ( restp )
  1246.         *restp = rest;
  1247.     else
  1248.         free(rest);
  1249.     return 1;
  1250. }
  1251.  
  1252.  
  1253. int
  1254. #ifdef CK_ANSIC
  1255. fwdx_tn_sb( unsigned char * sb, int n )
  1256. #else
  1257. fwdx_tn_sb( sb, n ) unsigned char * sb; int n;
  1258. #endif /* CK_ANSIC */
  1259. {
  1260.     unsigned short hchannel, nchannel;
  1261.     unsigned char * p;
  1262.     int i;
  1263.     int rc = -1;
  1264.  
  1265.     /* check to ensure we have negotiated Forward X */
  1266.     if ( sstelnet && !TELOPT_ME(TELOPT_FORWARD_X) ||
  1267.          !sstelnet && !TELOPT_U(TELOPT_FORWARD_X) ) {
  1268.         debug(F100,"fwdx_tn_sb() not negotiated","",0);
  1269.         return(0);
  1270.     }
  1271.  
  1272. #ifdef CK_SSL
  1273.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  1274.         return(0);
  1275.     }
  1276. #endif /* CK_SSL */
  1277.  
  1278.     switch (sb[0]) {
  1279.     case FWDX_SCREEN:
  1280.         if (sstelnet && n == 4)
  1281.             rc = fwdx_create_listen_socket(sb[1]);
  1282.         break;
  1283.     case FWDX_OPEN:
  1284.         if ( !sstelnet && n >= 5 ) {
  1285.             p = (unsigned char *) &nchannel;
  1286.             i = 1;
  1287.             /* IAC quoting has been stripped in tn_sb() */
  1288.             p[0] = sb[i++];
  1289.             p[1] = sb[i++];
  1290.             hchannel = ntohs(nchannel);
  1291.             rc = fwdx_open_client_channel(hchannel);
  1292.             if ( rc < 0 ) {
  1293.                 /* Failed; Send CLOSE channel */
  1294.                 fwdx_send_close(hchannel);
  1295.                 rc = 0;         /* Do not consider this to be a telnet error */
  1296.             }
  1297. #ifdef NT
  1298.             if ( !TELOPT_SB(TELOPT_FORWARD_X).forward_x.thread_started ) {
  1299.                 ckThreadBegin( &fwdx_thread,32655, 0, FALSE, 0 ) ;
  1300.                 TELOPT_SB(TELOPT_FORWARD_X).forward_x.thread_started = 1;
  1301.             }
  1302. #endif /* NT */
  1303.         }
  1304.         break;
  1305.     case FWDX_CLOSE:
  1306.         p = (unsigned char *) &nchannel;
  1307.         i = 1;
  1308.         /* IAC quoting has been stripped in tn_sb() */
  1309.         p[0] = sb[i++];
  1310.         p[1] = sb[i++];
  1311.         hchannel = ntohs(nchannel);
  1312.         fwdx_close_channel(hchannel);
  1313.         rc = 0; /* no errors when closing */
  1314.         break;
  1315.     case FWDX_DATA:
  1316.         p = (unsigned char *) &nchannel;
  1317.         i = 1;
  1318.         /* IAC quoting has been stripped in tn_sb() */
  1319.         p[0] = sb[i++];
  1320.         p[1] = sb[i++];
  1321.         hchannel = ntohs(nchannel);
  1322.         rc = fwdx_send_xauth_to_xserver(hchannel,(char *)&sb[3],n-5);
  1323.         if ( rc >= 0 && n-5-rc > 0) {
  1324.             rc = fwdx_write_data_to_channel(hchannel,(char *)&sb[3+rc],n-5-rc);
  1325.             if ( rc < 0 ) {
  1326.                 /* Failed; Send CLOSE channel */
  1327.                 rc = fwdx_send_close(hchannel);
  1328.             }
  1329.         }
  1330.         break;
  1331.     case FWDX_OPTIONS:
  1332.         if ( sstelnet ) {
  1333. #ifndef FWDX_SERVER
  1334.             rc = 0;
  1335. #else
  1336.             rc = fwdx_server_accept_options((char*)&sb[2],n-3);
  1337. #endif
  1338.         } else {
  1339.             rc = fwdx_client_reply_options((char *)&sb[2],n-3);
  1340.             if ( rc >= 0 ) {
  1341.                 rc = tn_sndfwdx();
  1342.             }
  1343.         }
  1344.         break;
  1345.     case FWDX_OPT_DATA:
  1346.         switch ( sb[1] ) {
  1347.         default:
  1348.             rc = 0;             /* we don't recognize, not an error */
  1349.         }
  1350.         break;
  1351.  
  1352.     case FWDX_XOFF:
  1353.     case FWDX_XON:
  1354.         if ( !sstelnet ) {
  1355.             p = (unsigned char *) &nchannel;
  1356.             i = 1;
  1357.             /* IAC quoting has been stripped in tn_sb() */
  1358.             p[0] = sb[i++];
  1359.             p[1] = sb[i++];
  1360.             hchannel = ntohs(nchannel);
  1361.             TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[hchannel].suspend =
  1362.                 (sb[0] == FWDX_XOFF);
  1363.             rc = 0;
  1364.         }
  1365.         break;
  1366.     }
  1367.     return(rc < 0 ? -1 : 0);
  1368. }
  1369.  
  1370. int
  1371. #ifdef CK_ANSIC
  1372. fwdx_send_xauth_to_xserver(int channel, unsigned char * data, int len)
  1373. #else
  1374. fwdx_send_xauth_to_xserver(channel, data, len)
  1375.     int channel; unsigned char * data; int len;
  1376. #endif /* CK_ANSIC */
  1377. {
  1378.     int name_len, data_len, i;
  1379.  
  1380.     for (i = 0; i < MAXFWDX ; i++) {
  1381.         if (TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[i].id == channel)
  1382.             break;
  1383.     }
  1384.     if ( i == MAXFWDX )
  1385.         goto auth_err;
  1386.  
  1387.     if (!TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[i].need_to_send_xauth)
  1388.         return(0);
  1389.  
  1390.     if (len < 12)
  1391.         goto auth_err;
  1392.  
  1393.     /* Parse the lengths of variable-length fields. */
  1394.     if (data[0] == 0x42) {              /* byte order MSB first. */
  1395.         /* Xauth packets appear to always have this format */
  1396.         if ( data[1] != 0x00 ||
  1397.              data[2] != 0x00 ||
  1398.              data[3] != 0x0B ||
  1399.              data[4] != 0x00 ||
  1400.              data[5] != 0x00 )
  1401.             goto auth_err;
  1402.  
  1403.         name_len = (data[6] << 8) + data[7];
  1404.         data_len = (data[8] << 8) + data[9];
  1405.     } else if (data[0] == 0x6c) {       /* Byte order LSB first. */
  1406.         /* Xauth packets appear to always have this format */
  1407.         if ( data[1] != 0x00 ||
  1408.              data[2] != 0x0B ||
  1409.              data[3] != 0x00 ||
  1410.              data[4] != 0x00 ||
  1411.              data[5] != 0x00 )
  1412.             goto auth_err;
  1413.  
  1414.         name_len = data[6] + (data[7] << 8);
  1415.         data_len = data[8] + (data[9] << 8);
  1416.     } else {
  1417.         /* bad byte order byte */
  1418.         goto auth_err;
  1419.     }
  1420.  
  1421.     /* Check if the whole packet is in buffer. */
  1422.     if (len < 12 + ((name_len + 3) & ~3) + ((data_len + 3) & ~3))
  1423.         goto auth_err;
  1424.     /* If the Telnet Server allows a real Xauth message to be sent */
  1425.     /* Then let the message be processed by the Xserver.           */
  1426.     if (name_len + data_len > 0) {
  1427.        TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[i].need_to_send_xauth = 0;
  1428.        return(0);
  1429.     }
  1430.     else
  1431.     /* If an empty Xauth message was received.  We are going to   */
  1432.     /* send our own Xauth message using the real Xauth data.  And */
  1433.     /* then send any other data in the buffer.                    */
  1434.     {
  1435.         int c, err, dpynum, scrnum, family, sb_len;
  1436.         char *display, *host = NULL, *rest = NULL;
  1437.         unsigned char *sb, *p;
  1438.  
  1439.         /* parse the local DISPLAY env var */
  1440.         display = getenv("DISPLAY");
  1441.         if ( !display )
  1442.             display = "127.0.0.1:0.0";
  1443.  
  1444.         if (fwdx_parse_displayname(display,
  1445.                                    &family, &host, &dpynum, &scrnum, &rest)) {
  1446.             char * disp_no = ckitoa(dpynum);    /* should be unsigned */
  1447.             if (family == FamilyLocal) {
  1448.                 /* call with address = "<local host name>" */
  1449.                 char address[300] = "localhost";
  1450.                 gethostname(address, sizeof(address) - 1);
  1451.                 real_xauth = XauGetAuthByAddr(family,
  1452.                                               strlen(address),
  1453.                                               address,
  1454.                                               strlen(disp_no),
  1455.                                               disp_no, 0, NULL);
  1456.             }
  1457.             else if (family == FamilyInternet) {
  1458.                 /* call with address = 4 bytes numeric ip addr (MSB) */
  1459.                 struct hostent *hi;
  1460.                 if (hi = gethostbyname(host))
  1461.                     real_xauth = XauGetAuthByAddr(family, 4,
  1462.                                                   hi->h_addr, strlen(disp_no),
  1463.                                                   disp_no, 0, NULL);
  1464.             }
  1465.         }
  1466.         if (host) free(host);
  1467.         if (rest) free(rest);
  1468.         if (!real_xauth) {
  1469.     TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[i].need_to_send_xauth = 0;
  1470.             return(0);
  1471.         }
  1472.  
  1473.         if (!strncmp(real_xauth->name,
  1474.                      "MIT-MAGIC-COOKIE-1",
  1475.                      real_xauth->name_length)) {
  1476.             char msg[64];
  1477.  
  1478.             name_len = real_xauth->name_length;
  1479.             data_len = 16;
  1480.  
  1481.             if ( data[0] == 0x42 ) {
  1482.                 msg[0] = 0x42; /* MSB order */
  1483.                 msg[1] = msg[2] = 0;
  1484.                 msg[3] = 0x0B;
  1485.                 msg[4] = msg[5] = 0;
  1486.                 msg[6] = (name_len >> 8);
  1487.                 msg[7] = (name_len & 0xFF);
  1488.                 msg[8] = (data_len >> 8);
  1489.                 msg[9] = (data_len & 0xFF);
  1490.             } else {
  1491.                 msg[0] = 0x6c; /* LSB order */
  1492.                 msg[1] = 0;
  1493.                 msg[2] = 0x0B;
  1494.                 msg[3] = msg[4] = msg[5] = 0;
  1495.                 msg[6] = (name_len & 0xFF);
  1496.                 msg[7] = (name_len >> 8);
  1497.                 msg[8] = (data_len & 0xFF);
  1498.                 msg[9] = (data_len >> 8);
  1499.             }
  1500.             msg[10] = msg[11] = 0;
  1501.             memcpy(&msg[12],real_xauth->name,18);
  1502.             msg[30] = msg[31] = 0;
  1503.             memcpy(&msg[32],real_xauth->data,16);
  1504.  
  1505.             if (fwdx_write_data_to_channel(channel,(char *)msg,48) < 0) {
  1506.   TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[i].need_to_send_xauth = 0;
  1507.                 return(-1);
  1508.             } else {
  1509.   TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[i].need_to_send_xauth = 0;
  1510.                 return(12);
  1511.             }
  1512.         } else {
  1513.   TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[i].need_to_send_xauth = 0;
  1514.             return(0);        /* we do not know how to handle this type yet */
  1515.         }
  1516.     }
  1517.  
  1518.   auth_err:
  1519.         debug(F100,"fwdx_send_xauth_to_xserver error","",0);
  1520.     return(-1);
  1521. }
  1522.  
  1523.  
  1524. #ifdef COMMENT
  1525. int
  1526. #ifdef CK_ANSIC
  1527. fwdx_authorize_channel(int channel, unsigned char * data, int len)
  1528. #else
  1529. fwdx_authorize_channel(channel, data, len)
  1530.     int channel; unsigned char * data; int len;
  1531. #endif /* CK_ANSIC */
  1532. {
  1533.     /* XXX maybe we should have some retry handling if not the whole first
  1534.     * authorization packet arrives complete
  1535.     */
  1536.     if ( !TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[channel].authorized ) {
  1537.         int name_len, data_len;
  1538.  
  1539.         if (len < 12)
  1540.             goto auth_err;
  1541.  
  1542.         /* Parse the lengths of variable-length fields. */
  1543.         if (data[0] == 0x42) {          /* byte order MSB first. */
  1544.             /* Xauth packets appear to always have this format */
  1545.             if ( data[1] != 0x00 ||
  1546.                  data[2] != 0x00 ||
  1547.                  data[3] != 0x0B ||
  1548.                  data[4] != 0x00 ||
  1549.                  data[5] != 0x00 )
  1550.                 goto auth_err;
  1551.  
  1552.             name_len = (data[6] << 8) + data[7];
  1553.             data_len = (data[8] << 8) + data[9];
  1554.         } else if (data[0] == 0x6c) {   /* Byte order LSB first. */
  1555.             /* Xauth packets appear to always have this format */
  1556.             if ( data[1] != 0x00 ||
  1557.                  data[2] != 0x0B ||
  1558.                  data[3] != 0x00 ||
  1559.                  data[4] != 0x00 ||
  1560.                  data[5] != 0x00 )
  1561.                 goto auth_err;
  1562.  
  1563.             name_len = data[6] + (data[7] << 8);
  1564.             data_len = data[8] + (data[9] << 8);
  1565.         } else {
  1566.             /* bad byte order byte */
  1567.             goto auth_err;
  1568.         }
  1569.         /* Check if authentication protocol matches. */
  1570.         if (name_len != fake_xauth.name_length ||
  1571.              memcmp(data + 12, fake_xauth.name, name_len) != 0) {
  1572.             /* connection uses different authentication protocol */
  1573.             goto auth_err;
  1574.         }
  1575.         /* Check if authentication data matches our fake data. */
  1576.         if (data_len != fake_xauth.data_length ||
  1577.              memcmp(data + 12 + ((name_len + 3) & ~3),
  1578.                      fake_xauth.data, fake_xauth.data_length) != 0) {
  1579.             /* auth data does not match fake data */
  1580.             goto auth_err;
  1581.         }
  1582.         /* substitute the fake data with real data if we have any */
  1583.         if (real_xauth && real_xauth->data)
  1584.             memcpy(data + 12 + ((name_len + 3) & ~3),
  1585.                    real_xauth->data, data_len);
  1586.  
  1587.         TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[channel].authorized = 1;
  1588.     }
  1589.     return(0);
  1590.   auth_err:
  1591.     return(-1);
  1592. }
  1593. #endif /* COMMENT */
  1594.  
  1595. int
  1596. #ifdef CK_ANSIC
  1597. fwdx_send_close(int channel)
  1598. #else
  1599. fwdx_send_close(channel) int channel;
  1600. #endif /* CK_ANSIC */
  1601. {
  1602.     unsigned short nchannel;
  1603.     int i,rc;
  1604.     CHAR * p;
  1605.  
  1606. #ifdef CK_SSL
  1607.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  1608.         return(0);
  1609.     }
  1610. #endif /* CK_SSL */
  1611.  
  1612.     nchannel = htons(channel);
  1613.     p = (unsigned char *) &nchannel;
  1614.  
  1615.     i = 0;
  1616.     sb_out[i++] = (CHAR) IAC;               /* I Am a Command */
  1617.     sb_out[i++] = (CHAR) SB;                /* Subnegotiation */
  1618.     sb_out[i++] = TELOPT_FORWARD_X;         /* Forward X */
  1619.     sb_out[i++] = FWDX_CLOSE;               /* Open */
  1620.     sb_out[i++] = p[0];                     /* First Byte of Channel */
  1621.     if ( p[0] == IAC )
  1622.         sb_out[i++] = IAC;
  1623.     sb_out[i++] = p[1];                     /* Second Byte of Channel */
  1624.     if ( p[1] == IAC )
  1625.         sb_out[i++] = IAC;
  1626.     sb_out[i++] = (CHAR) IAC;               /* End of Subnegotiation */
  1627.     sb_out[i++] = (CHAR) SE;                /* marked by IAC SE */
  1628. #ifdef DEBUG
  1629.     if (deblog || tn_deb || debses) {
  1630.         ckmakxmsg(fwdx_msg_out,TN_MSG_LEN,"TELNET SENT SB ",
  1631.                   TELOPT(TELOPT_FORWARD_X),
  1632.                   " CLOSE CHANNEL=",ckitoa(channel)," IAC SE",
  1633.                   NULL,NULL,NULL,NULL,NULL,NULL,NULL
  1634.                   );
  1635.     }
  1636. #endif /* DEBUG */
  1637. #ifdef OS2
  1638.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1639. #endif
  1640. #ifdef DEBUG
  1641.     debug(F100,fwdx_msg_out,"",0);
  1642.     if (tn_deb || debses) tn_debug(fwdx_msg_out);
  1643. #endif /* DEBUG */
  1644.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  1645. #ifdef OS2
  1646.     ReleaseTelnetMutex();
  1647. #endif
  1648.     if (rc)
  1649.       return(-1);
  1650.     return(0);
  1651. }
  1652.  
  1653. int
  1654. #ifdef CK_ANSIC
  1655. fwdx_send_open(int channel)
  1656. #else /* CK_ANSIC */
  1657. fwdx_send_open(channel) int channel;
  1658. #endif /* CK_ANSIC */
  1659. {
  1660.     unsigned short nchannel;
  1661.     int i, rc;
  1662.     CHAR * p;
  1663.  
  1664. #ifdef CK_SSL
  1665.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  1666.         return(0);
  1667.     }
  1668. #endif /* CK_SSL */
  1669.  
  1670.     nchannel = htons(channel);
  1671.     p = (unsigned char *) &nchannel;
  1672.  
  1673.     i = 0;
  1674.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  1675.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  1676.     sb_out[i++] = TELOPT_FORWARD_X;           /* Forward X */
  1677.     sb_out[i++] = FWDX_OPEN;                  /* Open */
  1678.     sb_out[i++] = p[0];                       /* First Byte of Channel */
  1679.     if ( p[0] == IAC )
  1680.         sb_out[i++] = IAC;
  1681.     sb_out[i++] = p[1];                       /* Second Byte of Channel */
  1682.     if ( p[1] == IAC )
  1683.         sb_out[i++] = IAC;
  1684.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  1685.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  1686. #ifdef DEBUG
  1687.     if (deblog || tn_deb || debses) {
  1688.         ckmakxmsg(fwdx_msg_out,TN_MSG_LEN,"TELNET SENT SB ",
  1689.                   TELOPT(TELOPT_FORWARD_X),
  1690.                   " OPEN CHANNEL=",ckitoa(channel)," IAC SE",
  1691.                   NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  1692.     }
  1693. #endif /* DEBUG */
  1694. #ifdef OS2
  1695.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1696. #endif
  1697. #ifdef DEBUG
  1698.     debug(F100,fwdx_msg_out,"",0);
  1699.     if (tn_deb || debses) tn_debug(fwdx_msg_out);
  1700. #endif /* DEBUG */
  1701.     rc = (ttol((CHAR *)sb_out,i) < 0);        /* Send it. */
  1702. #ifdef OS2
  1703.     ReleaseTelnetMutex();
  1704. #endif
  1705.     if (rc)
  1706.       return(-1);
  1707.     return(0);
  1708. }
  1709.  
  1710. int
  1711. #ifdef CK_ANSIC
  1712. fwdx_client_reply_options(char *opts, int n)
  1713. #else
  1714. fwdx_client_reply_options(opts, n) char *opts; int n;
  1715. #endif /* CK_ANSIC */
  1716. {
  1717.     int i,j,rc;
  1718.  
  1719. #ifdef CK_SSL
  1720.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  1721.         return(0);
  1722.     }
  1723. #endif /* CK_SSL */
  1724.  
  1725.     i = 0;
  1726.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  1727.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  1728.     sb_out[i++] = TELOPT_FORWARD_X;           /* Forward X */
  1729.     sb_out[i++] = FWDX_OPTIONS;               /* Options */
  1730.  
  1731.     /* Look for the options we recognize and will support for this session */
  1732.     /* and reply with their bytes set                                      */
  1733.     for (j=0; j<n; j++,i++) {
  1734.         sb_out[i] = FWDX_OPT_NONE;          /* Add zero byte - no options */
  1735. #ifdef COMMENT
  1736.         /* If we had any options to support, this is how we would do it */
  1737.         if ( j == 0 ) {
  1738.             if (opts[j] & FWDX_OPT_XXXX) {
  1739.                 /* set flag to remember option is in use */
  1740.                 flag = 1;
  1741.                 sb_out[i] |= FWDX_OPT_XXXX;
  1742.             }
  1743.         }
  1744. #endif /* COMMENT */
  1745.     }
  1746.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  1747.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  1748. #ifdef DEBUG
  1749.     if (deblog || tn_deb || debses) {
  1750.         ckmakxmsg(fwdx_msg_out,TN_MSG_LEN,"TELNET SENT SB ",
  1751.                   TELOPT(TELOPT_FORWARD_X),
  1752.                   " OPTIONS ",ckctox(sb_out[4],1)," IAC SE",
  1753.                   NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  1754.     }
  1755. #endif /* DEBUG */
  1756. #ifdef OS2
  1757.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1758. #endif
  1759. #ifdef DEBUG
  1760.     debug(F100,fwdx_msg_out,"",0);
  1761.     if (tn_deb || debses) tn_debug(fwdx_msg_out);
  1762. #endif /* DEBUG */
  1763.     rc = (ttol((CHAR *)sb_out,i) < 0);        /* Send it. */
  1764. #ifdef OS2
  1765.     ReleaseTelnetMutex();
  1766. #endif
  1767.     if (rc)
  1768.       return(-1);
  1769.     return(0);
  1770. }
  1771.  
  1772.  
  1773. int
  1774. fwdx_send_options() {
  1775.     int i, rc;
  1776.  
  1777. #ifdef CK_SSL
  1778.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  1779.         return(0);
  1780.     }
  1781. #endif /* CK_SSL */
  1782.  
  1783.     i = 0;
  1784.     sb_out[i++] = (CHAR) IAC;               /* I Am a Command */
  1785.     sb_out[i++] = (CHAR) SB;                /* Subnegotiation */
  1786.     sb_out[i++] = TELOPT_FORWARD_X;         /* Forward X */
  1787.     sb_out[i++] = FWDX_OPTIONS;             /* Options */
  1788.     sb_out[i]   = FWDX_OPT_NONE;
  1789.     /* activate options here */
  1790.     i++;
  1791.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  1792.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  1793.  
  1794. #ifdef DEBUG
  1795.     if (deblog || tn_deb || debses) {
  1796.         ckmakmsg(fwdx_msg_out,TN_MSG_LEN,"TELNET SENT SB ",
  1797.                  TELOPT(TELOPT_FORWARD_X),
  1798.                  " OPTIONS 00 IAC SE",NULL);
  1799.     }
  1800. #endif /* DEBUG */
  1801. #ifdef OS2
  1802.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1803. #endif
  1804. #ifdef DEBUG
  1805.     debug(F100,fwdx_msg_out,"",0);
  1806.     if (tn_deb || debses) tn_debug(fwdx_msg_out);
  1807. #endif /* DEBUG */
  1808.     rc = (ttol((CHAR *)sb_out,i) < 0);        /* Send it. */
  1809. #ifdef OS2
  1810.     ReleaseTelnetMutex();
  1811. #endif
  1812.     if (rc)
  1813.       return(-1);
  1814.     return(0);
  1815. }
  1816.  
  1817. int
  1818. #ifdef CK_ANSIC
  1819. fwdx_send_data_from_channel(int channel, char * data, int len)
  1820. #else
  1821. fwdx_send_data_from_channel(channel, data, len)
  1822.     int channel; char * data; int len;
  1823. #endif
  1824. {
  1825.     unsigned short nchannel;
  1826.     /* static */ CHAR sb_priv[2048];
  1827.     CHAR * p;
  1828.     int i, j, j_sav, rc;
  1829.     unsigned int tmp;
  1830.  
  1831.     debug(F111,"fwdx_send_data_from_channel()","channel",channel);
  1832.  
  1833. #ifdef CK_SSL
  1834.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  1835.         return(0);
  1836.     }
  1837. #endif /* CK_SSL */
  1838.  
  1839.     nchannel = htons(channel);
  1840.     p = (unsigned char *) &nchannel;
  1841.  
  1842.     j = 0;
  1843.     sb_priv[j++] = (CHAR) IAC;                 /* I Am a Command */
  1844.     sb_priv[j++] = (CHAR) SB;                  /* Subnegotiation */
  1845.     sb_priv[j++] = TELOPT_FORWARD_X;           /* Forward X */
  1846.     sb_priv[j++] = FWDX_DATA;                  /* Data */
  1847.     sb_priv[j++] = p[0];                       /* First Byte of Channel */
  1848.     if ( p[0] == IAC )
  1849.         sb_priv[j++] = IAC;
  1850.     sb_priv[j++] = p[1];                       /* Second Byte of Channel */
  1851.     if ( p[1] == IAC )
  1852.         sb_priv[j++] = IAC;
  1853.     j_sav = j;
  1854.  
  1855.     for (i = 0; i < len; i++) {
  1856.         tmp = (unsigned int)data[i];
  1857.         if ( tmp == IAC ) {
  1858.             sb_priv[j++] = IAC;
  1859.             sb_priv[j++] = IAC;
  1860.         } else {
  1861.             sb_priv[j++] = tmp;
  1862.         }
  1863.         if ( j >= 2045 && (i < len-1) ) {
  1864.             sb_priv[j++] = (CHAR) IAC;  /* End of Subnegotiation */
  1865.             sb_priv[j++] = (CHAR) SE;   /* marked by IAC SE */
  1866.  
  1867. #ifdef DEBUG
  1868.             if (deblog || tn_deb || debses) {
  1869.                 ckmakxmsg( fwdx_msg_out,TN_MSG_LEN,"TELNET SENT SB ",
  1870.                            TELOPT(TELOPT_FORWARD_X),
  1871.                            " DATA CHANNEL=",ckitoa(channel)," ",
  1872.                            NULL,NULL,NULL,NULL,NULL,NULL,NULL );
  1873.                 tn_hex(fwdx_msg_out,TN_MSG_LEN,&sb_priv[j_sav],j-(j_sav+2));
  1874.                 ckstrncat(fwdx_msg_out," IAC SE",TN_MSG_LEN);
  1875.             }
  1876. #endif /* DEBUG */
  1877. #ifdef OS2
  1878.             RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1879. #endif
  1880. #ifdef DEBUG
  1881.             debug(F100,fwdx_msg_out,"",0);
  1882.             if (tn_deb || debses) tn_debug(fwdx_msg_out);
  1883. #endif /* DEBUG */
  1884.             rc = (ttol(sb_priv,j) < 0);                /* Send it. */
  1885. #ifdef OS2
  1886.             ReleaseTelnetMutex();
  1887. #endif
  1888.             if (rc) {
  1889.                 debug(F110,"fwdx_send_data_from_channel()","ttol() failed",0);
  1890.                 return(-1);
  1891.             }
  1892.  
  1893.             j = 0;
  1894.             sb_priv[j++] = (CHAR) IAC;                 /* I Am a Command */
  1895.             sb_priv[j++] = (CHAR) SB;                  /* Subnegotiation */
  1896.             sb_priv[j++] = TELOPT_FORWARD_X;           /* Forward X */
  1897.             sb_priv[j++] = FWDX_DATA;                  /* Data */
  1898.             sb_priv[j++] = p[0];                       /* First Byte of Channel */
  1899.             if ( p[0] == IAC )
  1900.                 sb_priv[j++] = IAC;
  1901.             sb_priv[j++] = p[1];                       /* Second Byte of Channel */
  1902.             if ( p[1] == IAC )
  1903.                 sb_priv[j++] = IAC;
  1904.         }
  1905.     }
  1906.  
  1907.     sb_priv[j++] = (CHAR) IAC;                 /* End of Subnegotiation */
  1908.     sb_priv[j++] = (CHAR) SE;                  /* marked by IAC SE */
  1909.  
  1910. #ifdef DEBUG
  1911.     if (deblog || tn_deb || debses) {
  1912.         ckmakxmsg( fwdx_msg_out,TN_MSG_LEN,
  1913.                    "TELNET SENT SB ",TELOPT(TELOPT_FORWARD_X),
  1914.                    " DATA ",ckctox(p[0],1)," ",ckctox(p[1],1)," ",
  1915.                    NULL,NULL,NULL,NULL,NULL);
  1916.         tn_hex(fwdx_msg_out,TN_MSG_LEN,&sb_priv[6],j-8);
  1917.         ckstrncat(fwdx_msg_out," IAC SE",TN_MSG_LEN);
  1918.     }
  1919. #endif /* DEBUG */
  1920. #ifdef OS2
  1921.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  1922. #endif
  1923. #ifdef DEBUG
  1924.     debug(F100,fwdx_msg_out,"",0);
  1925.     if (tn_deb || debses) tn_debug(fwdx_msg_out);
  1926. #endif /* DEBUG */
  1927.     rc = (ttol(sb_priv,j) < 0);                /* Send it. */
  1928. #ifdef OS2
  1929.     ReleaseTelnetMutex();
  1930. #endif
  1931.     if ( rc ) {
  1932.         debug(F110,"fwdx_send_data_from_channel()","ttol() failed",0);
  1933.         return(-1);
  1934.     }
  1935.  
  1936.  
  1937.     return(0);
  1938. }
  1939.  
  1940. static unsigned char *
  1941. #ifdef CK_ANSIC
  1942. fwdx_add_quoted_twobyte(unsigned char *p, unsigned short twobyte)
  1943. #else
  1944. fwdx_add_quoted_twobyte(p, twobyte)
  1945.     unsigned char *p; unsigned short twobyte;
  1946. #endif /* CK_ANSIC */
  1947. /* adds the IAC quoted (MSB) representation of 'channel' at buffer pointer 'p',
  1948.  * returning pointer to new buffer position. NO OVERFLOW CHECK!
  1949.  */
  1950. {
  1951.     *p++ = (unsigned char)((twobyte >> 8) & 0xFF);
  1952.     if (*(p - 1) == 0xFF)
  1953.         *p++ = 0xFF;
  1954.     *p++ = (unsigned char)(twobyte & 0xFF);
  1955.     if (*(p - 1) == 0xFF)
  1956.         *p++ = 0xFF;
  1957.     return p;
  1958. }
  1959.  
  1960. int
  1961. #ifdef CK_ANSIC
  1962. fwdx_create_fake_xauth(char *name, int name_len, int data_len)
  1963. #else
  1964. fwdx_create_fake_xauth(name, name_len, data_len)
  1965.     char *name; int name_len; int data_len;
  1966. #endif /* CK_ANSIC */
  1967. {
  1968.     char stackdata[256];
  1969.     unsigned int c, n;
  1970.  
  1971.     if (!name_len || !data_len)
  1972.         return 1;
  1973.     fake_xauth.name = malloc(name_len);
  1974.     fake_xauth.data = malloc(data_len);
  1975.     if (!fake_xauth.name || !fake_xauth.data)
  1976.         return 2;
  1977.     fake_xauth.name_length = name_len;
  1978.     memcpy(fake_xauth.name, name, name_len);
  1979.     fake_xauth.data_length = data_len;
  1980.  
  1981.     /* try to make a random unsigned int to feed srand() */
  1982.     c = time(NULL);
  1983.     c *= getpid();
  1984.     for (n = 0; n < sizeof(stackdata); n++)
  1985.         c += stackdata[n];
  1986.     srand((unsigned int)c);
  1987.     for (c = 0; c < data_len; c++)
  1988.         fake_xauth.data[c] = (unsigned char)rand();
  1989.     return 0;
  1990. }
  1991.  
  1992. #ifdef COMMENT
  1993. /* No longer used */
  1994. int
  1995. fwdx_send_xauth(void)
  1996. {
  1997.     int c, err, dpynum, family, sb_len, rc;
  1998.     char *display, *host = NULL;
  1999.     unsigned char *sb_priv, *p;
  2000.  
  2001.     /* parse the local DISPLAY env var */
  2002.     if (!(display = tn_get_display()))
  2003.         return (-1);
  2004.     if (fwdx_parse_displayname(display, &family, &host, &dpynum, NULL, NULL)) {
  2005.         char * disp_no = ckitoa(dpynum);
  2006.         if (family == FamilyLocal) {
  2007.             /* call with address = "<local host name>" */
  2008.             char address[300] = "localhost";
  2009.             gethostname(address, sizeof(address) - 1);
  2010.             real_xauth = XauGetAuthByAddr(family,
  2011.                                           strlen(address),
  2012.                                           address,
  2013.                                           strlen(disp_no),
  2014.                                           disp_no, 0, NULL
  2015.                                           );
  2016.         }
  2017.         else if (family == FamilyInternet) {
  2018.             /* call with address = 4 bytes numeric ip addr (MSB) */
  2019.             struct hostent *hi;
  2020.             if (hi = gethostbyname(host))
  2021.                 real_xauth = XauGetAuthByAddr(family, 4,
  2022.                                               hi->h_addr,
  2023.                                               strlen(disp_no),
  2024.                                               disp_no, 0, NULL
  2025.                                               );
  2026.         }
  2027.     }
  2028.     if (host) {
  2029.         free(host);
  2030.         host = NULL;
  2031.     }
  2032.     if (real_xauth)
  2033.         err = fwdx_create_fake_xauth(real_xauth->name,
  2034.                                      real_xauth->name_length,
  2035.                                      real_xauth->data_length
  2036.                                      );
  2037.     else
  2038.       err = fwdx_create_fake_xauth("MIT-MAGIC-COOKIE-1",
  2039.                                    strlen("MIT-MAGIC-COOKIE-1"), 16);
  2040.     if (err)
  2041.         return(-1);
  2042.  
  2043.     /* allocate memory for the SB block, alloc for worst case              */
  2044.     /* the following sprintf() calls are safe due to length checking       */
  2045.     /* buffer is twice as big as the input just in case every byte was IAC */
  2046.     sb_len = 5 + 2 + 2 + fake_xauth.name_length + fake_xauth.data_length + 2;
  2047.     if (!(sb_priv = malloc(2 * sb_len)))
  2048.         return(-1);
  2049.     p = sb_priv;
  2050.     sprintf(p, "%c%c%c%c%c", IAC, SB, TELOPT_FORWARD_X,
  2051.             FWDX_OPT_DATA, FWDX_OPT_XAUTH);
  2052.     p += 5;
  2053.     p = fwdx_add_quoted_twobyte(p, fake_xauth.name_length);
  2054.     p = fwdx_add_quoted_twobyte(p, fake_xauth.data_length);
  2055.     for (c = 0; c < fake_xauth.name_length; c++) {
  2056.         *p++ = fake_xauth.name[c];
  2057.         if ((unsigned char)fake_xauth.name[c] == 0xFF)
  2058.             *p++ = 0xFF;
  2059.     }
  2060.     for (c = 0; c < fake_xauth.data_length; c++) {
  2061.         *p++ = fake_xauth.data[c];
  2062.         if ((unsigned char)fake_xauth.data[c] == 0xFF)
  2063.             *p++ = 0xFF;
  2064.     }
  2065.     sprintf(p, "%c%c", IAC, SE);
  2066.     p += 2;
  2067.  
  2068. #ifdef DEBUG
  2069.     if (deblog || tn_deb || debses) {
  2070.         sprintf(fwdx_msg_out,"TELNET SENT SB %s OPTION_DATA XAUTH ",
  2071.                  TELOPT(TELOPT_FORWARD_X));
  2072.         tn_hex(fwdx_msg_out,TN_MSG_LEN,&sb_priv[5],(p-sb_priv)-7);
  2073.         ckstrncat(fwdx_msg_out," IAC SE",TN_MSG_LEN);
  2074.     }
  2075. #endif /* DEBUG */
  2076.  
  2077.     /* Add Telnet Debug info here */
  2078. #ifdef OS2
  2079.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  2080. #endif
  2081. #ifdef DEBUG
  2082.     debug(F100,fwdx_msg_out,"",0);
  2083.     if (tn_deb || debses) tn_debug(fwdx_msg_out);
  2084. #endif /* DEBUG */
  2085.     rc = ( ttol(sb_priv,p-sb_priv) < 0 );                /* Send it. */
  2086. #ifdef OS2
  2087.     ReleaseTelnetMutex();
  2088. #endif
  2089.     if (rc) {
  2090.         debug(F110,"fwdx_send_xauth()","ttol() failed",0);
  2091.         return(-1);
  2092.     }
  2093.  
  2094.  
  2095.     free(sb_priv);
  2096.     return(0);
  2097. }
  2098. #endif /* COMMENT */
  2099. #ifdef FWDX_SERVER
  2100. /* Only if we ever become a server - not yet ported to Kermit   */
  2101. /* And even so most of this code does not belong in this module */
  2102.  
  2103. int
  2104. fwdx_write_xauthfile(void)
  2105. {
  2106.     int dpynum, scrnum, family;
  2107.     char myhost[300], *host, *rest = NULL;
  2108.     FILE *file;
  2109.     struct sockaddr_in saddr;
  2110.     struct hostent *hi;
  2111.  
  2112.     if (!fwdx_display && !fwdx_xauthfile)
  2113.         return 1;
  2114.     if (!parse_displayname(fwdx_display,
  2115.                            &family, &host, &dpynum, &scrnum, &rest))
  2116.         return 2;
  2117.     if (rest) free(rest);
  2118.     if (host) free(host);
  2119.     if (family != FamilyInternet)
  2120.         return 3; /* every thing but FamilyInternet is unexpected */
  2121.  
  2122.     /* X connections to localhost:1 is actually treated as local unix sockets,
  2123.      * see the 'xauth' man page.
  2124.      */
  2125.     xauth.family = FamilyLocal;
  2126.     if (gethostname(myhost, sizeof(myhost) - 1))
  2127.         return 5;
  2128.     xauth.address_length = strlen(myhost);
  2129.     if (!(xauth.address = malloc(xauth.address_length)))
  2130.         return 5;
  2131.     memcpy(xauth.address, myhost, xauth.address_length);
  2132.  
  2133.     /* the display number is written as a string, not numeric */
  2134.     if (!(xauth.number = malloc(6)))
  2135.         return 6;
  2136.     snprintf(xauth.number, 5, "%u", dpynum);
  2137.     xauth.number_length = strlen(xauth.number);
  2138.     if (!(file = fopen(fwdx_xauthfile, "wb")))
  2139.         return 7;
  2140.     if (!XauWriteAuth(file, &xauth))
  2141.         return 8;
  2142.     fclose(file);
  2143.     setenv("XAUTHORITY", fwdx_xauthfile, 1);
  2144.     return 0;
  2145. }
  2146.  
  2147. int
  2148. fwdx_setup_xauth(unsigned char *sp, int len)
  2149. /* called with 'len' xauth bytes, starting at 'sp'
  2150.  * the data format is: <uint16 name_length> <uint16 data_length> <name> <data>
  2151.  */
  2152. {
  2153.     int xauthfd;
  2154.  
  2155.     if (!fwdx_options[FWDX_OPT_XAUTH])
  2156.         return 1;
  2157.     if (len < 4)
  2158.         return 2;
  2159.  
  2160.     /* setup the xauth struct */
  2161.     xauth.name_length = (sp[0] << 8) + sp[1];
  2162.     xauth.data_length = (sp[2] << 8) + sp[3];
  2163.     if (len != 4 + xauth.name_length + xauth.data_length)
  2164.         return 3;
  2165.     xauth.name = malloc(xauth.name_length);
  2166.     xauth.data = malloc(xauth.data_length);
  2167.     if (!xauth.name || !xauth.data)
  2168.         return 4;
  2169.     memcpy(xauth.name, sp + 4, xauth.name_length);
  2170.     memcpy(xauth.data, sp + 4 + xauth.name_length, xauth.data_length);
  2171.  
  2172.     /* Setup to always have a local .Xauthority. */
  2173.     fwdx_xauthfile = malloc(MAXPATHLEN+1);
  2174.     snprintf(fwdx_xauthfile, MAXPATHLEN, "/tmp/XauthXXXXXX");
  2175.     if ((xauthfd = mkstemp(fwdx_xauthfile)) != -1)
  2176.         /* we change file ownership later, when we know who is to be owner! */
  2177.         close(xauthfd);
  2178.     else {
  2179.         free(fwdx_xauthfile);
  2180.         fwdx_xauthfile = NULL;
  2181.         return 5;
  2182.     }
  2183. /* Must have the subshell's new DISPLAY env var to write xauth to xauthfile */
  2184.     if (fwdx_display)
  2185.         if (fwdx_write_xauthfile())
  2186.             return 6;
  2187.  
  2188.     return 0;
  2189. }
  2190.  
  2191. void fwdx_set_xauthfile_owner(int uid)
  2192. {
  2193.     struct passwd *pwd;
  2194.  
  2195.     if (!fwdx_xauthfile || !(pwd = getpwuid(uid)))
  2196.         return;
  2197.     chown(fwdx_xauthfile, pwd->pw_uid, pwd->pw_gid);
  2198. }
  2199.  
  2200. int
  2201. fwdx_server_accept_options(unsigned char *sp, int len)
  2202. /* called with 'len' option bytes, starting at 'sp' */
  2203. {
  2204.     int c;
  2205.  
  2206.     for (c = 0; c < len-2; c++) {
  2207.         if (c == 0) {
  2208.             if (sp[c] & FWDX_OPT_XAUTH)
  2209.                 flag = 1;
  2210.         }
  2211.     }
  2212.     return(0);
  2213. }
  2214. #endif /* FWDX_SERVER */
  2215. #endif /* CK_FORWARD_X */
  2216.  
  2217. #ifdef IKS_OPTION
  2218. /*
  2219.   iks_wait() -- Wait for an IKS subnegotiation response.
  2220.   sb - is either KERMIT_REQ_START or KERMIT_REQ_STOP depending on the desired
  2221.        state of the peer's Kermit server.
  2222.   flushok - specifies whether it is ok to throw away non-Telnet data
  2223.        if so, then we call ttflui() instead of tn_flui().
  2224.   Returns:
  2225.    1 if the desired state is achieved or if it is unknown.
  2226.    0 if the desired state is not achieved.
  2227. */
  2228. int
  2229. #ifdef CK_ANSIC
  2230. iks_wait(int sb, int flushok)
  2231. #else /* CK_ANSIC */
  2232. iks_wait(sb,flushok) int sb; int flushok;
  2233. #endif /* CK_ANSIC */
  2234. {
  2235.     int tn_wait_save = tn_wait_flg;
  2236.     int x;
  2237.  
  2238.     if (TELOPT_U(TELOPT_KERMIT)) {
  2239.         switch (sb) {
  2240.           case KERMIT_REQ_START:
  2241.             debug(F111,
  2242.                   "iks_wait KERMIT_REQ_START",
  2243.                   "u_start",
  2244.                   TELOPT_SB(TELOPT_KERMIT).kermit.u_start
  2245.                   );
  2246.             tn_siks(KERMIT_REQ_START);
  2247.             tn_wait_flg = 1;            /* Kermit Option MUST wait */
  2248.             do {
  2249.                 if (flushok)
  2250.                   tn_wait_idx = 0;
  2251.                 x = tn_wait("iks_wait() me_iks_req_start");
  2252.             } while (x == 0 && flushok && tn_wait_idx == TN_WAIT_BUF_SZ);
  2253.             tn_wait_flg = tn_wait_save;
  2254.             if (flushok)
  2255.               tn_wait_idx = 0;
  2256.             if (tn_wait_idx == TN_WAIT_BUF_SZ) {
  2257.                 /*
  2258.                  * We are attempting to start a kermit server on the peer
  2259.                  * the most likely reason is because we want to perform a
  2260.                  * file transfer.  But there is a huge amount of non telnet
  2261.                  * negotiation data coming in and so we have not been able
  2262.                  * to find the response.  So we will lie and assume that
  2263.                  * response is 'yes'.  The worse that will happen is that
  2264.                  * a RESP_STOP is received after we enter protocol mode.
  2265.                  * And the protocol operation will be canceled.
  2266.                  */
  2267.                 tn_push();
  2268.                 return(1);
  2269.             } else {
  2270.                 tn_push();
  2271.                 return(TELOPT_SB(TELOPT_KERMIT).kermit.u_start);
  2272.             }
  2273.           case KERMIT_REQ_STOP:
  2274.             debug(F111,
  2275.                   "iks_wait KERMIT_REQ_STOP",
  2276.                   "u_start",
  2277.                   TELOPT_SB(TELOPT_KERMIT).kermit.u_start
  2278.                   );
  2279.             tn_siks(KERMIT_REQ_STOP);
  2280.             tn_wait_flg = 1;            /* Kermit Option MUST wait */
  2281.             do {
  2282.                 if (flushok)
  2283.                   tn_wait_idx = 0;
  2284.                 x = tn_wait("iks_wait() me_iks_req_stop");
  2285.             } while (x == 0 && flushok && tn_wait_idx == TN_WAIT_BUF_SZ);
  2286.             tn_wait_flg = tn_wait_save;
  2287.             if (flushok)
  2288.               tn_wait_idx = 0;
  2289.  
  2290.             if (tn_wait_idx == TN_WAIT_BUF_SZ) {
  2291.                 /*
  2292.                  * We are attempting to stop a kermit server on the peer
  2293.                  * the most likely reason being that we want to enter
  2294.                  * CONNECT mode.  But there is a huge amount of non telnet
  2295.                  * negotiation data coming in and so we have not been able
  2296.                  * to find the response.  So we will lie and assume that
  2297.                  * the answer is 'yes' and allow the CONNECT command to
  2298.                  * succeed.  The worst that happens is that CONNECT mode
  2299.                  * swallows the incoming data displaying it to the user
  2300.                  * and then it resumes Kermit client mode.
  2301.                  */
  2302.                 tn_push();
  2303.                 return(1);
  2304.             } else {
  2305.                 tn_push();
  2306.                 return(!TELOPT_SB(TELOPT_KERMIT).kermit.u_start);
  2307.             }
  2308.         }
  2309.         tn_push();
  2310.     }
  2311.     return(1);
  2312. }
  2313.  
  2314. int
  2315. #ifdef CK_ANSIC
  2316. iks_tn_sb(CHAR * sb, int n)
  2317. #else
  2318. iks_tn_sb(sb, n) CHAR * sb; int n;
  2319. #endif /* CK_ANSIC */
  2320. {
  2321.     extern int server;
  2322. #ifdef NOICP
  2323.     extern int autodl;
  2324.     int inautodl = 0, cmdadl = 1;
  2325. #else
  2326. #ifdef CK_AUTODL
  2327.     extern int autodl, inautodl, cmdadl;
  2328. #endif /* CK_AUTODL */
  2329. #endif /* NOICP */
  2330.     switch (sb[0]) {
  2331.       case KERMIT_START:                /* START */
  2332.         TELOPT_SB(TELOPT_KERMIT).kermit.u_start = 1;
  2333.         return(4);
  2334.  
  2335.       case KERMIT_STOP:                 /* STOP */
  2336.         TELOPT_SB(TELOPT_KERMIT).kermit.u_start = 0;
  2337.         return(4);
  2338.  
  2339.       case KERMIT_REQ_START:            /* REQ-START */
  2340. #ifndef NOXFER
  2341.         if (inserver) {
  2342. #ifdef CK_AUTODL
  2343.             cmdadl = 1;                 /* Turn on packet detection */
  2344. #endif /* CK_AUTODL */
  2345.             TELOPT_SB(TELOPT_KERMIT).kermit.me_start = 1;
  2346.             tn_siks(KERMIT_RESP_START);
  2347.         } else if (TELOPT_SB(TELOPT_KERMIT).kermit.me_start) {
  2348.             tn_siks(KERMIT_RESP_START);
  2349.         } else {
  2350. #ifdef CK_AUTODL
  2351.             if ((local && what == W_CONNECT && autodl) ||
  2352.                 (local && what != W_CONNECT && inautodl)
  2353.                 )
  2354.               tn_siks(KERMIT_RESP_START); /* STOP */
  2355.             else
  2356. #endif /* CK_AUTODL */
  2357.               tn_siks(KERMIT_RESP_STOP);
  2358.         }
  2359. #else /* NOXFER */
  2360.           tn_siks(KERMIT_RESP_STOP);
  2361. #endif /* NOXFER */
  2362.         return(4);
  2363.  
  2364.       case KERMIT_REQ_STOP:             /* REQ-STOP */
  2365.         /* The protocol requires that the request be responded to */
  2366.         /* either by changing states or by reporting the current  */
  2367.         /* state.  */
  2368.  
  2369.         /* We need to provide the user some way of dictating what */
  2370.         /* the policies should be.  For instance, if we are in    */
  2371.         /* CONNECT mode with autodownload ON and we get a REQ-STOP*/
  2372.         /* what should the proper response be?                    */
  2373. #ifndef NOXFER
  2374.         if (inserver
  2375. #ifdef CK_AUTODL
  2376.             || !local && cmdadl
  2377. #endif /* CK_AUTODL */
  2378.             ) {
  2379. #ifdef CK_AUTODL
  2380.             cmdadl = 0;                 /* Turn off packet detection */
  2381. #endif /* CK_AUTODL */
  2382.             tn_siks(KERMIT_RESP_STOP);
  2383.         } else if (server) {
  2384.             extern int en_fin;
  2385.             if (en_fin) {               /* If the server is allowed to stop */
  2386.                 tn_siks(KERMIT_RESP_STOP);
  2387.             } else {                    /* We are not allowed to stop */
  2388.                 tn_siks(KERMIT_RESP_START);
  2389.             }
  2390. #ifdef CK_AUTODL
  2391.         } else if ((local && what == W_CONNECT && autodl) ||
  2392.                    (local && what != W_CONNECT && inautodl)
  2393.                    ) {
  2394.             /* If we are a pseudo-server and the other side requests */
  2395.             /* that we stop, tell then that we have even though we   */
  2396.             /* have not.  Otherwise, the other side might refuse to  */
  2397.             /* enter SERVER mode.                                    */
  2398.  
  2399.             tn_siks(KERMIT_RESP_STOP);  /* STOP */
  2400. #endif /* CK_AUTODL */
  2401.  
  2402.         } else
  2403. #endif /* NOXFER */
  2404.         {
  2405.             /* If we are not currently in any mode that accepts */
  2406.             /* Kermit packets then of course report that we are */
  2407.             /* not being a Kermit server.                       */
  2408.  
  2409.             tn_siks(KERMIT_RESP_STOP);  /* STOP */
  2410.         }
  2411.         return(4);
  2412.  
  2413.       case KERMIT_SOP: {                /* SOP */
  2414. #ifndef NOXFER
  2415.           extern CHAR stchr;            /* Incoming SOP character */
  2416.           stchr = sb[1];
  2417. #endif /* NOXFER */
  2418.           TELOPT_SB(TELOPT_KERMIT).kermit.sop = 1;
  2419.           return(4);
  2420.       }
  2421.  
  2422.       case KERMIT_RESP_START:           /* START */
  2423.         TELOPT_SB(TELOPT_KERMIT).kermit.u_start = 1;
  2424.         if (TELOPT_SB(TELOPT_KERMIT).kermit.me_req_start) {
  2425.             TELOPT_SB(TELOPT_KERMIT).kermit.me_req_start = 0;
  2426.         } else if (TELOPT_SB(TELOPT_KERMIT).kermit.me_req_stop) {
  2427.             /* If we have issued a request to stop a Kermit Server */
  2428.             /* and the response is Start, then we must report this */
  2429.             /* to the caller.                                      */
  2430.             TELOPT_SB(TELOPT_KERMIT).kermit.me_req_stop = 0;
  2431.         }
  2432.         return(4);
  2433.  
  2434.       case KERMIT_RESP_STOP:            /* STOP */
  2435.         TELOPT_SB(TELOPT_KERMIT).kermit.u_start = 0;
  2436.         if (TELOPT_SB(TELOPT_KERMIT).kermit.me_req_start) {
  2437.             TELOPT_SB(TELOPT_KERMIT).kermit.me_req_start = 0;
  2438.             /* If we have issued a request to start a Kermit Server */
  2439.             /* and the response is Stop, then we must report this   */
  2440.             /* to the caller.                                       */
  2441.         } else if (TELOPT_SB(TELOPT_KERMIT).kermit.me_req_stop) {
  2442.             TELOPT_SB(TELOPT_KERMIT).kermit.me_req_stop = 0;
  2443.         }
  2444.         return(4);
  2445.  
  2446.       default:
  2447.         return(0);
  2448.  
  2449.     } /* switch (sb[0]) */
  2450. }
  2451. #endif /* IKS_OPTION */
  2452.  
  2453. /* Initialize telnet settings - set default values for ME and U modes */
  2454. int
  2455. tn_set_modes() {
  2456.     int opt,cmd;
  2457. #ifdef CK_FORWARD_X
  2458.     int x;
  2459. #endif /* CK_FORWARD_X */
  2460. #ifdef CK_ENVIRONMENT
  2461.     {
  2462.         int i,j;
  2463.         for (i = 0; i < 8; i++) {
  2464.             tn_env_uservar[i][0] = NULL;
  2465.             tn_env_uservar[i][1] = NULL;
  2466.         }
  2467.     }
  2468. #endif /* CK_ENVIRONMENT */
  2469.  
  2470.     /* initialize all options to refuse in both directions */
  2471.     for (opt = 0; opt < NTELOPTS; opt++) {
  2472.         TELOPT_ME(opt) = 0;
  2473.         TELOPT_U(opt)  = 0;
  2474.         TELOPT_UNANSWERED_WILL(opt) = 0;
  2475.         TELOPT_UNANSWERED_DO(opt)   = 0;
  2476.         TELOPT_UNANSWERED_WONT(opt) = 0;
  2477.         TELOPT_UNANSWERED_DONT(opt)   = 0;
  2478.         TELOPT_UNANSWERED_SB(opt)   = 0;
  2479.         TELOPT_ME_MODE(opt) = TN_NG_RF;
  2480.         TELOPT_U_MODE(opt) = TN_NG_RF;
  2481.         TELOPT_DEF_S_ME_MODE(opt) = TN_NG_RF;
  2482.         TELOPT_DEF_S_U_MODE(opt) = TN_NG_RF;
  2483.         TELOPT_DEF_C_ME_MODE(opt) = TN_NG_RF;
  2484.         TELOPT_DEF_C_U_MODE(opt) = TN_NG_RF;
  2485.         for (cmd = 0; cmd < 4; cmd ++)
  2486.           tncnts[TELOPT_INDEX(opt)][cmd] = 0;
  2487.     }
  2488. #ifdef IKS_OPTION
  2489.     TELOPT_SB(TELOPT_KERMIT).kermit.me_start = 0;
  2490.     TELOPT_SB(TELOPT_KERMIT).kermit.u_start = 0;
  2491.     TELOPT_SB(TELOPT_KERMIT).kermit.me_req_start = 0;
  2492.     TELOPT_SB(TELOPT_KERMIT).kermit.me_req_stop = 0;
  2493.     TELOPT_SB(TELOPT_KERMIT).kermit.sop = 0;
  2494. #endif /* IKS_OPTION */
  2495.  
  2496. #ifdef CK_ENCRYPTION
  2497.     TELOPT_SB(TELOPT_ENCRYPTION).encrypt.stop = 0;
  2498. #endif /* CK_ENCRYPTION */
  2499.  
  2500. #ifdef  CK_NAWS
  2501.     TELOPT_SB(TELOPT_NAWS).naws.x = 0;
  2502.     TELOPT_SB(TELOPT_NAWS).naws.y = 0;
  2503. #endif /* CK_NAWS */
  2504.  
  2505. #ifdef CK_SSL
  2506.     TELOPT_SB(TELOPT_START_TLS).start_tls.u_follows = 0;
  2507.     TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows = 0;
  2508. #endif /* CK_SSL */
  2509.  
  2510.     /* Now set the ones we want to accept to the proper values */
  2511.     TELOPT_DEF_S_ME_MODE(TELOPT_SGA) = TN_NG_RQ;
  2512.     TELOPT_DEF_S_U_MODE(TELOPT_SGA) = TN_NG_RQ;
  2513.     TELOPT_DEF_C_ME_MODE(TELOPT_SGA) = TN_NG_AC;
  2514.     TELOPT_DEF_C_U_MODE(TELOPT_SGA) = TN_NG_AC;
  2515.  
  2516.     TELOPT_DEF_S_ME_MODE(TELOPT_BINARY) = TN_NG_AC;
  2517.     TELOPT_DEF_S_U_MODE(TELOPT_BINARY) = TN_NG_AC;
  2518.     TELOPT_DEF_C_ME_MODE(TELOPT_BINARY) = TN_NG_AC;
  2519.     TELOPT_DEF_C_U_MODE(TELOPT_BINARY) = TN_NG_AC;
  2520.  
  2521.     TELOPT_DEF_S_ME_MODE(TELOPT_LOGOUT) = TN_NG_AC;
  2522.     TELOPT_DEF_S_U_MODE(TELOPT_LOGOUT) = TN_NG_AC;
  2523.     TELOPT_DEF_C_ME_MODE(TELOPT_LOGOUT) = TN_NG_AC;
  2524.     TELOPT_DEF_C_U_MODE(TELOPT_LOGOUT) = TN_NG_AC;
  2525.  
  2526. #ifdef IKS_OPTION
  2527.     TELOPT_DEF_S_ME_MODE(TELOPT_KERMIT) = TN_NG_RQ;
  2528.     TELOPT_DEF_S_U_MODE(TELOPT_KERMIT) = TN_NG_RQ;
  2529.     TELOPT_DEF_C_ME_MODE(TELOPT_KERMIT) = TN_NG_RQ;
  2530.     TELOPT_DEF_C_U_MODE(TELOPT_KERMIT) = TN_NG_RQ;
  2531. #endif /* IKS_OPTION */
  2532.  
  2533. #ifdef CK_ENCRYPTION
  2534.     TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
  2535.     TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
  2536.     TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
  2537.     TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
  2538. #endif /* CK_ENCRYPTION */
  2539.  
  2540.     TELOPT_DEF_S_ME_MODE(TELOPT_ECHO) = TN_NG_RQ;
  2541. #ifdef IKSD
  2542.     if ( !inserver )
  2543. #endif /* IKSD */
  2544.       TELOPT_DEF_S_U_MODE(TELOPT_TTYPE) = TN_NG_RQ;
  2545.  
  2546. #ifdef CK_ENVIRONMENT
  2547.     TELOPT_DEF_S_U_MODE(TELOPT_NEWENVIRON) = TN_NG_RQ;
  2548. #endif /* CK_ENVIRONMENT */
  2549.  
  2550. #ifdef CK_AUTHENTICATION
  2551.     TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_RQ;
  2552. #endif /* CK_AUTHENTICATION */
  2553.  
  2554. #ifdef CK_SSL
  2555.     if (ck_ssleay_is_installed()) {
  2556.         TELOPT_DEF_S_U_MODE(TELOPT_START_TLS) = TN_NG_RQ;
  2557.         TELOPT_DEF_C_ME_MODE(TELOPT_START_TLS) = TN_NG_AC;
  2558.     }
  2559. #endif /* CK_SSL */
  2560.  
  2561. #ifdef CK_NAWS
  2562.     TELOPT_DEF_S_U_MODE(TELOPT_NAWS) = TN_NG_RQ;
  2563. #endif /* CK_NAWS */
  2564.  
  2565.     TELOPT_DEF_C_U_MODE(TELOPT_ECHO) = TN_NG_AC;
  2566.     TELOPT_DEF_C_ME_MODE(TELOPT_TTYPE) = TN_NG_RQ;
  2567.  
  2568. #ifdef CK_ENVIRONMENT
  2569.     TELOPT_DEF_C_ME_MODE(TELOPT_NEWENVIRON) = TN_NG_RQ;
  2570. #endif /* CK_ENVIRONMENT */
  2571.  
  2572. #ifdef CK_AUTHENTICATION
  2573.     TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_RQ;
  2574. #endif /* CK_AUTHENTICATION */
  2575.  
  2576. #ifdef CK_NAWS
  2577.     TELOPT_DEF_C_ME_MODE(TELOPT_NAWS) = TN_NG_RQ;
  2578. #endif /* CK_NAWS */
  2579.  
  2580. #ifdef CK_SNDLOC
  2581.     TELOPT_DEF_C_ME_MODE(TELOPT_SNDLOC) = TN_NG_RQ;
  2582. #endif /* CK_SNDLOC */
  2583.  
  2584. #ifdef CK_FORWARD_X
  2585.     TELOPT_DEF_C_U_MODE(TELOPT_FORWARD_X) = TN_NG_AC;
  2586.     TELOPT_SB(TELOPT_FORWARD_X).forward_x.listen_socket = -1;
  2587.     for (x = 0; x < MAXFWDX; x++) {
  2588.        TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[x].fd = -1;
  2589.        TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[x].id = -1;
  2590.        TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[x].need_to_send_xauth = 0;
  2591.        TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[x].suspend = 0;
  2592.     }
  2593. #endif /* CK_FORWARD_X */
  2594.  
  2595. #ifdef TN_COMPORT
  2596.     TELOPT_DEF_C_ME_MODE(TELOPT_COMPORT) = TN_NG_RQ;
  2597. #endif /* TN_COMPORT */
  2598.  
  2599.     /* Set the initial values for currently known mode */
  2600.     for (opt = TELOPT_FIRST; opt <= TELOPT_LAST; opt++) {
  2601.         if (TELOPT_OK(opt)) {
  2602.             TELOPT_ME_MODE(opt) = sstelnet ?
  2603.               TELOPT_DEF_S_ME_MODE(opt) :
  2604.                 TELOPT_DEF_C_ME_MODE(opt);
  2605.             TELOPT_U_MODE(opt) = sstelnet ?
  2606.               TELOPT_DEF_S_U_MODE(opt) :
  2607.                 TELOPT_DEF_C_U_MODE(opt);
  2608.         }
  2609.     }
  2610.     return(1);
  2611. }
  2612.  
  2613.  
  2614. /* Send Delayed Subnegotiations */
  2615.  
  2616. VOID
  2617. tn_sdsb() {
  2618.     if (TELOPT_SB(TELOPT_TTYPE).term.need_to_send) {
  2619.         tn_sttyp();
  2620.         TELOPT_SB(TELOPT_TTYPE).term.need_to_send = 0;
  2621.     }
  2622. #ifdef CK_ENVIRONMENT
  2623.     if (TELOPT_SB(TELOPT_NEWENVIRON).env.need_to_send &&
  2624.         TELOPT_SB(TELOPT_NEWENVIRON).env.str) {
  2625.         tn_snenv((CHAR *)TELOPT_SB(TELOPT_NEWENVIRON).env.str,
  2626.                  TELOPT_SB(TELOPT_NEWENVIRON).env.len);
  2627.         free(TELOPT_SB(TELOPT_NEWENVIRON).env.str);
  2628.         TELOPT_SB(TELOPT_NEWENVIRON).env.str=NULL;
  2629.         TELOPT_SB(TELOPT_NEWENVIRON).env.len=0;
  2630.         TELOPT_SB(TELOPT_NEWENVIRON).env.need_to_send = 0;
  2631.     }
  2632. #ifdef CK_XDISPLOC
  2633.     if (TELOPT_SB(TELOPT_XDISPLOC).xdisp.need_to_send) {
  2634.         tn_sxdisploc();
  2635.         TELOPT_SB(TELOPT_XDISPLOC).xdisp.need_to_send = 0;
  2636.     }
  2637. #endif /* CK_XDISPLOC */
  2638. #endif /* CK_ENVIRONMENT */
  2639. #ifdef CK_NAWS
  2640.     if (TELOPT_SB(TELOPT_NAWS).naws.need_to_send) {
  2641.         tn_snaws();
  2642.         TELOPT_SB(TELOPT_NAWS).naws.need_to_send = 0;
  2643.     }
  2644. #endif /* CK_NAWS */
  2645. #ifdef CK_SNDLOC
  2646.     if (TELOPT_SB(TELOPT_SNDLOC).sndloc.need_to_send) {
  2647.         tn_sndloc();
  2648.         TELOPT_SB(TELOPT_SNDLOC).sndloc.need_to_send = 0;
  2649.     }
  2650. #endif /* CK_SNDLOC */
  2651. #ifdef CK_FORWARD_X
  2652.     if (TELOPT_SB(TELOPT_FORWARD_X).forward_x.need_to_send) {
  2653.         if ( sstelnet )
  2654.             fwdx_send_options();
  2655.         TELOPT_SB(TELOPT_FORWARD_X).forward_x.need_to_send = 0;
  2656.     }
  2657. #endif /* CK_FORWARD_X */
  2658. #ifdef TN_COMPORT
  2659.     if (TELOPT_SB(TELOPT_COMPORT).comport.need_to_send) {
  2660.         tn_sndcomport();
  2661.         TELOPT_SB(TELOPT_COMPORT).comport.need_to_send = 0;
  2662.     }
  2663. #endif /* TN_COMPORT */
  2664.  
  2665. }
  2666.  
  2667. int
  2668. tn_reset() {
  2669.     int x,opt,cmd;
  2670.  
  2671.     tn_wait_idx = 0;                    /* Clear the tn_push() buffer */
  2672.     tn_wait_tmo = TN_TIMEOUT;           /* Reset wait timer stats */
  2673.  
  2674.     nflag = 0;
  2675.  
  2676.     /* Reset the TELNET OPTIONS counts */
  2677.     for (opt = TELOPT_FIRST; opt <= TELOPT_LAST; opt++) {
  2678.         if (TELOPT_OK(opt)) {
  2679.             TELOPT_ME(opt) = 0;
  2680.             TELOPT_U(opt)  = 0;
  2681.             TELOPT_UNANSWERED_WILL(opt) = 0;
  2682.             TELOPT_UNANSWERED_DO(opt)   = 0;
  2683.             TELOPT_UNANSWERED_WONT(opt) = 0;
  2684.             TELOPT_UNANSWERED_DONT(opt)   = 0;
  2685.             TELOPT_UNANSWERED_SB(opt)   = 0;
  2686.             TELOPT_ME_MODE(opt) = sstelnet ?
  2687.               TELOPT_DEF_S_ME_MODE(opt) :
  2688.                 TELOPT_DEF_C_ME_MODE(opt);
  2689.             TELOPT_U_MODE(opt) = sstelnet ?
  2690.               TELOPT_DEF_S_U_MODE(opt) :
  2691.                 TELOPT_DEF_C_U_MODE(opt);
  2692.  
  2693. #ifdef DEBUG
  2694.             if (deblog) {
  2695.                 switch (TELOPT_ME_MODE(opt)) {
  2696.                   case TN_NG_RF:
  2697.                     debug(F110,"tn_ini ME REFUSE ",TELOPT(opt),0);
  2698.                     break;
  2699.                   case TN_NG_AC:
  2700.                     debug(F110,"tn_ini ME ACCEPT ",TELOPT(opt),0);
  2701.                     break;
  2702.                   case TN_NG_RQ:
  2703.                     debug(F110,"tn_ini ME REQUEST",TELOPT(opt),0);
  2704.                     break;
  2705.                   case TN_NG_MU:
  2706.                     debug(F110,"tn_ini ME REQUIRE",TELOPT(opt),0);
  2707.                     break;
  2708.                 }
  2709.                 switch (TELOPT_U_MODE(opt)) {
  2710.                   case TN_NG_RF:
  2711.                     debug(F110,"tn_ini U  REFUSE ",TELOPT(opt),0);
  2712.                     break;
  2713.                   case TN_NG_AC:
  2714.                     debug(F110,"tn_ini U  ACCEPT ",TELOPT(opt),0);
  2715.                     break;
  2716.                   case TN_NG_RQ:
  2717.                     debug(F110,"tn_ini U  REQUEST",TELOPT(opt),0);
  2718.                     break;
  2719.                   case TN_NG_MU:
  2720.                     debug(F110,"tn_ini U  REQUIRE",TELOPT(opt),0);
  2721.                     break;
  2722.                 }
  2723.             }
  2724. #endif /* DEBUG */
  2725.             for (cmd = 0; cmd < 4; cmd ++)
  2726.               tncnts[TELOPT_INDEX(opt)][cmd] = 0;
  2727.         }
  2728.     }
  2729. #ifdef CK_ENVIRONMENT
  2730.     if (!tn_env_flg) {
  2731.         TELOPT_ME_MODE(TELOPT_NEWENVIRON) = TN_NG_RF;
  2732.         TELOPT_U_MODE(TELOPT_NEWENVIRON) = TN_NG_RF;
  2733.     }
  2734. #endif /* CK_ENVIRONMENT */
  2735. #ifdef CK_SNDLOC
  2736.     if (!tn_loc)
  2737.         TELOPT_DEF_C_ME_MODE(TELOPT_SNDLOC) = TN_NG_RF;
  2738. #endif /* CK_SNDLOC */
  2739. #ifdef IKS_OPTION
  2740.     TELOPT_SB(TELOPT_KERMIT).kermit.me_start = 0;
  2741.     TELOPT_SB(TELOPT_KERMIT).kermit.u_start = 0;
  2742.     TELOPT_SB(TELOPT_KERMIT).kermit.me_req_start = 0;
  2743.     TELOPT_SB(TELOPT_KERMIT).kermit.me_req_stop = 0;
  2744.     TELOPT_SB(TELOPT_KERMIT).kermit.sop = 0;
  2745. #endif /* IKS_OPTION */
  2746. #ifdef CK_ENCRYPTION
  2747.     TELOPT_SB(TELOPT_ENCRYPTION).encrypt.stop = 0;
  2748.     TELOPT_SB(TELOPT_ENCRYPTION).encrypt.need_to_send = 0;
  2749. #endif /* CK_ENCRYPTION */
  2750. #ifdef  CK_NAWS
  2751.     TELOPT_SB(TELOPT_NAWS).naws.need_to_send = 0;
  2752.     TELOPT_SB(TELOPT_NAWS).naws.x = 0;
  2753.     TELOPT_SB(TELOPT_NAWS).naws.y = 0;
  2754. #endif /* CK_NAWS */
  2755.     TELOPT_SB(TELOPT_TTYPE).term.need_to_send = 0;
  2756.     TELOPT_SB(TELOPT_TTYPE).term.type[0] = '\0';
  2757. #ifdef CK_ENVIRONMENT
  2758.     TELOPT_SB(TELOPT_NEWENVIRON).env.need_to_send = 0;
  2759.     if (tn_first)
  2760.         TELOPT_SB(TELOPT_NEWENVIRON).env.str=NULL;
  2761.     else if (TELOPT_SB(TELOPT_NEWENVIRON).env.str) {
  2762.         free(TELOPT_SB(TELOPT_NEWENVIRON).env.str);
  2763.         TELOPT_SB(TELOPT_NEWENVIRON).env.str=NULL;
  2764.     }
  2765.     TELOPT_SB(TELOPT_NEWENVIRON).env.len=0;
  2766. #ifdef CK_XDISPLOC
  2767.     TELOPT_SB(TELOPT_XDISPLOC).xdisp.need_to_send = 0;
  2768. #endif /* CK_XDISPLOC */
  2769. #endif /* CK_ENVIRONMENT */
  2770. #ifdef CK_SNDLOC
  2771.     TELOPT_SB(TELOPT_SNDLOC).sndloc.need_to_send = 0;
  2772. #endif /* CK_SNDLOC */
  2773. #ifdef CK_FORWARD_X
  2774.     TELOPT_SB(TELOPT_FORWARD_X).forward_x.need_to_send = 0;
  2775.     TELOPT_SB(TELOPT_FORWARD_X).forward_x.listen_socket = -1;
  2776.     for (x = 0; x < MAXFWDX; x++) {
  2777.        TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[x].fd = -1;
  2778.        TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[x].id = -1;
  2779.        TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[x].need_to_send_xauth = 0;
  2780.        TELOPT_SB(TELOPT_FORWARD_X).forward_x.channel[x].suspend = 0;
  2781.     }
  2782.     /* Reset Xauth data */
  2783.     if ( real_xauth ) {
  2784.         XauDisposeAuth(real_xauth);
  2785.         real_xauth = NULL;
  2786.     }
  2787.     if ( fake_xauth.name )
  2788.         free(fake_xauth.name);
  2789.     if ( fake_xauth.data )
  2790.         free(fake_xauth.data);
  2791.     if ( fake_xauth.address )
  2792.         free(fake_xauth.address);
  2793.     if ( fake_xauth.number )
  2794.         free(fake_xauth.number);
  2795.     memset(&fake_xauth,0,sizeof(fake_xauth));
  2796. #ifdef NT
  2797.     TELOPT_SB(TELOPT_FORWARD_X).forward_x.thread_started = 0;
  2798. #endif /* NT */
  2799. #endif /* CK_FORWARD_X */
  2800. #ifdef CK_SSL
  2801.     if (tls_only_flag || ssl_only_flag) {
  2802.         TELOPT_ME_MODE(TELOPT_START_TLS) = TN_NG_RF;
  2803.         TELOPT_U_MODE(TELOPT_START_TLS) = TN_NG_RF;
  2804.     }
  2805.     TELOPT_SB(TELOPT_START_TLS).start_tls.u_follows = 0;
  2806.     TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows = 0;
  2807. #endif /* CK_SSL */
  2808.  
  2809. #ifdef CK_ENCRYPTION
  2810.     if (!ck_crypt_is_installed()
  2811. #ifdef CK_SSL
  2812.         || tls_only_flag || ssl_only_flag
  2813. #endif /* CK_SSL */
  2814.         ) {
  2815.         TELOPT_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  2816.         TELOPT_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  2817.     }
  2818. #endif /* CK_ENCRYPTION */
  2819.  
  2820. #ifdef TN_COMPORT
  2821.     TELOPT_SB(TELOPT_COMPORT).comport.need_to_send = 0;
  2822.     TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  2823.     tnc_init();
  2824. #endif /* TN_COMPORT */
  2825.  
  2826.     tn_first = 0;                       /* No longer the first time init */
  2827.  
  2828. #ifdef OS2
  2829.     ttnum = -1;                         /* Reset TermType negotiation */
  2830.     ttnumend = 0;
  2831. #endif /* OS2 */
  2832.  
  2833.     return(0);
  2834. }
  2835.  
  2836. int
  2837. tn_start() {
  2838.     int wait, x, opt;
  2839.  
  2840.     if (tn_init && tn_begun)
  2841.         return(0);
  2842.     tn_begun = 1;
  2843.  
  2844.     debug(F111,"tn_start","sstelnet",sstelnet);
  2845.     wait = 0;
  2846.     if (tn_duplex)  {
  2847.         oldplex = duplex;               /* save old duplex value */
  2848.         duplex = 1;                     /* and set to half duplex for telnet */
  2849.     }
  2850. #ifdef CK_SSL
  2851.     if (!TELOPT_ME(TELOPT_START_TLS) &&
  2852.         TELOPT_ME_MODE(TELOPT_START_TLS) >= TN_NG_RQ) {
  2853.         if (tn_sopt(WILL, TELOPT_START_TLS) < 0)
  2854.           return(-1);
  2855.         TELOPT_UNANSWERED_WILL(TELOPT_START_TLS) = 1;
  2856.         wait = 1;
  2857.     }
  2858.     if (!TELOPT_U(TELOPT_START_TLS) &&
  2859.         TELOPT_U_MODE(TELOPT_START_TLS) >= TN_NG_RQ) {
  2860.         if (tn_sopt(DO, TELOPT_START_TLS) < 0)
  2861.           return(-1);
  2862.         TELOPT_UNANSWERED_DO(TELOPT_START_TLS) = 1;
  2863.         wait = 1;
  2864.     }
  2865. #ifdef COMMENT
  2866. /*
  2867.   We can put off waiting for this until after we have requested AUTH.  The
  2868.   next draft will specify how the WILL side is to decide between these
  2869.   conflicting options.
  2870. */
  2871.     if (wait) {
  2872.         if (tn_wait("start_tls") < 0) {
  2873.             tn_push();
  2874.             return(-1);
  2875.         }
  2876.         wait = 0;
  2877.     }
  2878. #endif /* COMMENT */
  2879. #endif /* CK_SSL */
  2880.  
  2881. #ifdef CK_AUTHENTICATION
  2882.     debug(F110,"tn_ini() CK_AUTHENTICATION","",0);
  2883.     if (tn_init)                /* tn_ini() might be called recursively */
  2884.       return(0);
  2885.     if (!TELOPT_ME(TELOPT_AUTHENTICATION) &&
  2886.         TELOPT_ME_MODE(TELOPT_AUTHENTICATION) >= TN_NG_RQ) {
  2887.         if (tn_sopt(WILL, TELOPT_AUTHENTICATION) < 0)
  2888.           return(-1);
  2889.         TELOPT_UNANSWERED_WILL(TELOPT_AUTHENTICATION) = 1;
  2890.         wait = 1;
  2891.     }
  2892.     if (!TELOPT_U(TELOPT_AUTHENTICATION) &&
  2893.         TELOPT_U_MODE(TELOPT_AUTHENTICATION) >= TN_NG_RQ) {
  2894.         if (tn_sopt(DO, TELOPT_AUTHENTICATION) < 0)
  2895.           return(-1);
  2896.         TELOPT_UNANSWERED_DO(TELOPT_AUTHENTICATION) = 1;
  2897.         wait = 1;
  2898.     }
  2899. #ifdef CK_ENCRYPTION
  2900.     if (TELOPT_U_MODE(TELOPT_AUTHENTICATION) == TN_NG_RF &&
  2901.          TELOPT_ME_MODE(TELOPT_AUTHENTICATION) == TN_NG_RF) {
  2902.         TELOPT_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  2903.         TELOPT_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  2904.     }
  2905. #endif /* CK_ENCRYPTION */
  2906. #endif /* CK_AUTHENTICATION */
  2907.  
  2908. #ifdef CK_NAWS
  2909. #ifndef NOLOCAL
  2910.     debug(F110,"tn_ini() CK_NAWS !NOLOCAL","",0);
  2911.     if (!sstelnet) {
  2912.         /* Console terminal screen rows and columns */
  2913. #ifdef OS2
  2914.         debug(F101,
  2915.               "tn_ini tt_rows 1",
  2916.               "",
  2917.               VscrnGetHeight(VTERM)-(tt_status[VTERM]?1:0)
  2918.               );
  2919.         debug(F101,"tn_ini tt_cols 1","",VscrnGetWidth(VTERM));
  2920.         /* Not known yet */
  2921.         if (VscrnGetWidth(VTERM) < 0 ||
  2922.             VscrnGetHeight(VTERM)-(tt_status[VTERM]?1:0) < 0) {
  2923.             ttgwsiz();                  /* Try to find out */
  2924.         }
  2925.         debug(F101,
  2926.               "tn_ini tt_rows 2",
  2927.               "",
  2928.               VscrnGetHeight(VTERM)-(tt_status[VTERM]?1:0)
  2929.               );
  2930.         debug(F101,"tn_ini tt_cols 2","",VscrnGetWidth(VTERM));
  2931.         /* Now do we know? */
  2932.         if (VscrnGetWidth(VTERM) > 0 &&
  2933.             VscrnGetHeight(VTERM)-(tt_status[VTERM]?1:0) > 0) {
  2934.             if (!TELOPT_ME(TELOPT_NAWS) &&
  2935.                 TELOPT_ME_MODE(TELOPT_NAWS) >= TN_NG_RQ) {
  2936.                 if (tn_sopt(WILL, TELOPT_NAWS) < 0)
  2937.                   return(-1);
  2938.                 TELOPT_UNANSWERED_WILL(TELOPT_NAWS) = 1;
  2939.                 wait = 1;
  2940.             }
  2941.         }
  2942. #else /* OS2 */
  2943.         debug(F101,"tn_ini tt_rows 1","",tt_rows);
  2944.         debug(F101,"tn_ini tt_cols 1","",tt_cols);
  2945.         if (tt_rows < 0 || tt_cols < 0) { /* Not known yet */
  2946.             ttgwsiz();                  /* Try to find out */
  2947.         }
  2948.         debug(F101,"tn_ini tt_rows 2","",tt_rows);
  2949.         debug(F101,"tn_ini tt_cols 2","",tt_cols);
  2950.         if (tt_rows > 0 && tt_cols > 0) { /* Now do we know? */
  2951.             if (!TELOPT_ME(TELOPT_NAWS) &&
  2952.                 TELOPT_ME_MODE(TELOPT_NAWS) >= TN_NG_RQ) {
  2953.                 if (tn_sopt(WILL, TELOPT_NAWS) < 0)
  2954.                   return(-1);
  2955.                 TELOPT_UNANSWERED_WILL(TELOPT_NAWS) = 1;
  2956.                 wait = 1;
  2957.             }
  2958.         }
  2959. #endif /* OS2 */
  2960.     } else
  2961. #endif /* NOLOCAL */
  2962.     {
  2963.         if (!TELOPT_U(TELOPT_NAWS) &&
  2964.             TELOPT_U_MODE(TELOPT_NAWS) >= TN_NG_RQ) {
  2965.             if (tn_sopt(DO, TELOPT_NAWS) < 0)
  2966.               return(-1);
  2967.             TELOPT_UNANSWERED_DO(TELOPT_NAWS) = 1;
  2968.             wait = 1;
  2969.         }
  2970.     }
  2971. #endif /* CK_NAWS */
  2972.  
  2973.     if (!TELOPT_ME(TELOPT_SGA) &&
  2974.         TELOPT_ME_MODE(TELOPT_SGA) >= TN_NG_RQ) {
  2975.         if (tn_sopt(WILL, TELOPT_SGA) < 0)
  2976.           return(-1);
  2977.         TELOPT_UNANSWERED_WILL(TELOPT_SGA) = 1;
  2978.         wait = 1;
  2979.     }
  2980.     if (!TELOPT_U(TELOPT_SGA) &&
  2981.         TELOPT_U_MODE(TELOPT_SGA) >= TN_NG_RQ) {
  2982.         if (tn_sopt(DO, TELOPT_SGA) < 0)
  2983.           return(-1);
  2984.         TELOPT_UNANSWERED_DO(TELOPT_SGA) = 1;
  2985.         wait = 1;
  2986.     }
  2987.     if (!tn_duplex) {
  2988.         if (!TELOPT_U(TELOPT_ECHO) &&
  2989.             TELOPT_U_MODE(TELOPT_ECHO) >= TN_NG_RQ) {
  2990.             if (tn_sopt(DO, TELOPT_ECHO) < 0)
  2991.               return(-1);
  2992.             TELOPT_UNANSWERED_DO(TELOPT_ECHO) = 1;
  2993.             wait = 1;
  2994.         }
  2995.     }
  2996.     if (!TELOPT_ME(TELOPT_ECHO) &&
  2997.         TELOPT_ME_MODE(TELOPT_ECHO) >= TN_NG_RQ) {
  2998.         if (tn_sopt(WILL, TELOPT_ECHO) < 0)
  2999.           return(-1);
  3000.         TELOPT_UNANSWERED_WILL(TELOPT_ECHO) = 1;
  3001.         wait = 1;
  3002.     }
  3003.  
  3004.     debug(F100,"tn_ini about to send WILL TTYPE if requested","",0);
  3005. /*
  3006.   Talking to TELNET port, so send WILL TERMINAL TYPE and DO SGA.
  3007.   Also send WILL NAWS if we know our screen dimensions.
  3008. */
  3009.     if (!TELOPT_ME(TELOPT_TTYPE) &&
  3010.         TELOPT_ME_MODE(TELOPT_TTYPE) >= TN_NG_RQ) {
  3011.         if ((x = tn_sopt(WILL,TELOPT_TTYPE)) < 0) {
  3012.             debug(F101,"tn_ini tn_sopt WILL TTYPE failed","",x);
  3013.             return(-1);
  3014.         }
  3015.         TELOPT_UNANSWERED_WILL(TELOPT_TTYPE) = 1;
  3016.         wait = 1;
  3017.         debug(F100,"tn_ini sent WILL TTYPE ok","",0);
  3018.     }
  3019.     if (!TELOPT_U(TELOPT_TTYPE) &&
  3020.         TELOPT_U_MODE(TELOPT_TTYPE) >= TN_NG_RQ) {
  3021.         if ((x = tn_sopt(DO,TELOPT_TTYPE)) < 0) {
  3022.             debug(F101,"tn_ini tn_sopt DO TTYPE failed","",x);
  3023.             return(-1);
  3024.         }
  3025.         TELOPT_UNANSWERED_DO(TELOPT_TTYPE) = 1;
  3026.         wait = 1;
  3027.         debug(F100,"tn_ini sent DO TTYPE ok","",0);
  3028.     }
  3029.     if (!TELOPT_ME(TELOPT_BINARY) &&
  3030.         TELOPT_ME_MODE(TELOPT_BINARY) >= TN_NG_RQ) {
  3031.         if (tn_sopt(WILL, TELOPT_BINARY) < 0)
  3032.           return(-1);
  3033.         TELOPT_UNANSWERED_WILL(TELOPT_BINARY) = 1;
  3034.         wait = 1;
  3035.     }
  3036.     if (!TELOPT_U(TELOPT_BINARY) &&
  3037.         TELOPT_U_MODE(TELOPT_BINARY) >= TN_NG_RQ) {
  3038.         if (tn_sopt(DO, TELOPT_BINARY) < 0)
  3039.           return(-1);
  3040.         TELOPT_UNANSWERED_DO(TELOPT_BINARY) = 1;
  3041.         wait = 1;
  3042.     }
  3043. #ifdef CK_SNDLOC
  3044.     if (tn_loc) {
  3045.         if (!TELOPT_ME(TELOPT_SNDLOC) &&
  3046.             TELOPT_ME_MODE(TELOPT_SNDLOC) >= TN_NG_RQ) {
  3047.             if (tn_sopt(WILL, TELOPT_SNDLOC) < 0)
  3048.               return(-1);
  3049.             TELOPT_UNANSWERED_WILL(TELOPT_SNDLOC) = 1;
  3050.             wait = 1;
  3051.         }
  3052.     }
  3053. #endif /* CK_SNDLOC */
  3054. #ifdef CK_ENVIRONMENT
  3055. #ifdef CK_FORWARD_X
  3056.     if (!TELOPT_U(TELOPT_FORWARD_X) &&
  3057.          TELOPT_U_MODE(TELOPT_FORWARD_X) >= TN_NG_RQ) {
  3058.         if (tn_sopt(WILL, TELOPT_FORWARD_X) < 0)
  3059.             return(-1);
  3060.         TELOPT_UNANSWERED_WILL(TELOPT_FORWARD_X) = 1;
  3061.         wait = 1;
  3062.     }
  3063. #endif /* FORWARD_X */
  3064. #ifdef CK_XDISPLOC
  3065.     if (!TELOPT_ME(TELOPT_XDISPLOC) &&
  3066.          TELOPT_ME_MODE(TELOPT_XDISPLOC) >= TN_NG_RQ) {
  3067.         if (tn_sopt(WILL, TELOPT_XDISPLOC) < 0)
  3068.             return(-1);
  3069.         TELOPT_UNANSWERED_WILL(TELOPT_XDISPLOC) = 1;
  3070.         wait = 1;
  3071.     }
  3072. #endif /* CK_XDISPLOC */
  3073.     /* Will send terminal environment. */
  3074.     if (!TELOPT_ME(TELOPT_NEWENVIRON) &&
  3075.         TELOPT_ME_MODE(TELOPT_NEWENVIRON) >= TN_NG_RQ) {
  3076.         if (tn_sopt(WILL, TELOPT_NEWENVIRON) < 0)
  3077.           return(-1);
  3078.         TELOPT_UNANSWERED_WILL(TELOPT_NEWENVIRON) = 1;
  3079.         wait = 1;
  3080.     }
  3081.     if (!TELOPT_U(TELOPT_NEWENVIRON) &&
  3082.         TELOPT_U_MODE(TELOPT_NEWENVIRON) >= TN_NG_RQ) {
  3083.         if (tn_sopt(DO, TELOPT_NEWENVIRON) < 0)
  3084.           return(-1);
  3085.         TELOPT_UNANSWERED_DO(TELOPT_NEWENVIRON) = 1;
  3086.         wait = 1;
  3087.     }
  3088. #endif /* CK_ENVIRONMENT */
  3089.  
  3090.     /* Take care of any other telnet options that require handling. */
  3091.  
  3092.     for (opt = TELOPT_FIRST; opt <= TELOPT_LAST; opt++) {
  3093.         switch (opt) {
  3094.           case TELOPT_AUTHENTICATION:
  3095.           case TELOPT_ENCRYPTION:
  3096.           case TELOPT_TTYPE:
  3097.           case TELOPT_NAWS:
  3098.           case TELOPT_BINARY:
  3099.           case TELOPT_NEWENVIRON:
  3100.           case TELOPT_SNDLOC:
  3101.           case TELOPT_XDISPLOC:
  3102.           case TELOPT_SGA:
  3103.           case TELOPT_ECHO:
  3104.           case TELOPT_KERMIT:
  3105.           case TELOPT_START_TLS:
  3106.           case TELOPT_FORWARD_X:
  3107.                 break;
  3108.             break;
  3109.           default:
  3110.             if (TELOPT_OK(opt)) {
  3111.                 if (!TELOPT_ME(opt) &&
  3112.                     TELOPT_ME_MODE(opt) >= TN_NG_RQ) {
  3113.                     if (tn_sopt(WILL, opt) < 0)
  3114.                       return(-1);
  3115.                     TELOPT_UNANSWERED_WILL(opt) = 1;
  3116.                     wait = 1;
  3117.                 }
  3118.                 if (!TELOPT_U(opt) &&
  3119.                     TELOPT_U_MODE(opt) >= TN_NG_RQ) {
  3120.                     if (tn_sopt(DO, opt) < 0)
  3121.                       return(-1);
  3122.                     TELOPT_UNANSWERED_DO(opt) = 1;
  3123.                     wait = 1;
  3124.                 }
  3125.             }
  3126.         }
  3127.     }
  3128.     if (wait) {
  3129.         if (tn_wait("pre-encrypt") < 0) {
  3130.             tn_push();
  3131.             return(-1);
  3132.         }
  3133.         wait = 0;
  3134.     }
  3135.  
  3136. #ifdef CK_ENCRYPTION
  3137.     if (tn_init)                /* tn_ini() may be called recursively */
  3138.       return(0);
  3139.  
  3140.     if (!TELOPT_ME(TELOPT_ENCRYPTION) &&
  3141.         TELOPT_ME_MODE(TELOPT_ENCRYPTION) >= TN_NG_RQ) {
  3142.         if (tn_sopt(WILL, TELOPT_ENCRYPTION) < 0)
  3143.           return(-1);
  3144.         TELOPT_UNANSWERED_WILL(TELOPT_ENCRYPTION) = 1;
  3145.         wait = 1;
  3146.     }
  3147.     if (!TELOPT_U(TELOPT_ENCRYPTION) &&
  3148.         TELOPT_U_MODE(TELOPT_ENCRYPTION) >= TN_NG_RQ) {
  3149.         if (tn_sopt(DO, TELOPT_ENCRYPTION) < 0)
  3150.           return(-1);
  3151.         TELOPT_UNANSWERED_DO(TELOPT_ENCRYPTION) = 1;
  3152.         wait = 1;
  3153.     }
  3154.  
  3155.     /* If we are going to encrypt, we want to do it before we send any more */
  3156.     /* data, especially the terminal type and environment variables.        */
  3157.     if (wait) {
  3158.         if (tn_wait("post-encrypt") < 0) {
  3159.             tn_push();
  3160.             return(-1);
  3161.         }
  3162.         wait = 0;
  3163.     }
  3164. #endif /* CK_ENCRYPTION */
  3165.  
  3166.     tn_sdsb();
  3167.  
  3168.     if (tn_init)                   /* tn_ini() may be called recursively */
  3169.         return(0);
  3170.  
  3171. #ifdef IKS_OPTION
  3172.     /* Kermit Server negotiation must go last */
  3173.     /* Send U before ME */
  3174.  
  3175.     if (!TELOPT_U(TELOPT_KERMIT) &&
  3176.         TELOPT_U_MODE(TELOPT_KERMIT) >= TN_NG_RQ) {
  3177.         if (tn_sopt(DO, TELOPT_KERMIT) < 0)
  3178.           return(-1);
  3179.         TELOPT_UNANSWERED_DO(TELOPT_KERMIT) = 1;
  3180.         wait = 1;
  3181.     }
  3182.     if (!TELOPT_ME(TELOPT_KERMIT) &&
  3183.         TELOPT_ME_MODE(TELOPT_KERMIT) >= TN_NG_RQ) {
  3184.         if (tn_sopt(WILL, TELOPT_KERMIT) < 0)
  3185.           return(-1);
  3186.         TELOPT_UNANSWERED_WILL(TELOPT_KERMIT) = 1;
  3187.         wait = 1;
  3188.     }
  3189. #endif /* IKS_OPTION */
  3190.  
  3191.     if (wait) {
  3192.         if (tn_wait("end of telnet negotiations") < 0) {
  3193.             tn_push();
  3194.             return(-1);
  3195.         }
  3196.         wait = 0;
  3197.     }
  3198.  
  3199.     tn_sdsb();                          /* Send delayed subnegotiations */
  3200.     tn_push();
  3201.     return(0);
  3202. }
  3203.  
  3204. /* Start a telnet connection. */
  3205. /* Returns -1 on error, 0 if nothing happens, 1 if init msgs sent ok */
  3206.  
  3207. int
  3208. tn_ini() {
  3209.     int x;
  3210.  
  3211.     debug(F101,"tn_ini ttnproto","",ttnproto);
  3212.     debug(F101,"tn_ini tn_init","",tn_init);
  3213.  
  3214.     if (ttnet != NET_TCPB)              /* Make sure connection is TCP/IP */
  3215.       return(0);
  3216.     if (tn_init)                        /* Have we done this already? */
  3217.       return(0);                        /* Don't do it again. */
  3218.  
  3219.     tn_reset();                         /* Reset telnet parameters */
  3220.     tn_begun = 0;                       /* Reset; will be set by tn_start() */
  3221.  
  3222.     switch ( ttnproto ) {
  3223.       case NP_RLOGIN:
  3224.       case NP_K4LOGIN:
  3225.       case NP_EK4LOGIN:
  3226.       case NP_K5LOGIN:
  3227.       case NP_EK5LOGIN:
  3228.       case NP_K5U2U:
  3229.         tn_init = 1;
  3230.         debug(F100,"tn_ini telnet negotiations ignored","tn_init",tn_init);
  3231.         return(0);
  3232.       case NP_NONE:
  3233.       case NP_SSL:
  3234.       case NP_TLS:                      /* If not talking to a telnet port, */
  3235.         ttnproto = NP_TELNET;           /* pretend it's telnet anyway, */
  3236.         oldplex = duplex;               /* save old duplex value */
  3237.         duplex = 1;                     /* and set to half duplex for telnet */
  3238.         tn_wait("tn_ini - waiting to see if telnet negotiations were sent");
  3239.         debug(F100,"tn_ini skipping telnet negotiations","",0);
  3240.         return(0);
  3241.       case NP_TCPRAW:                   /* Raw socket requested. */
  3242.         debug(F100,"tn_ini telnet negotiations ignored","tn_init",tn_init);
  3243.         return(0);
  3244.       case NP_KERMIT:                   /* switching to Telnet protocol */
  3245.       case NP_SSL_TELNET:
  3246.       case NP_TLS_TELNET:
  3247.         debug(F101,"tn_ini switching from XXX to Telnet","",ttnproto);
  3248.         ttnproto = NP_TELNET;
  3249.         /* fall through */
  3250.       default:
  3251.         /* We are already using a variation on Telnet protocol */
  3252.         ;
  3253.     }
  3254.  
  3255.     x = tn_start();
  3256.     tn_init = 1;                        /* Remember successful completion. */
  3257.  
  3258.     /* Don't send anything else! */
  3259.     debug(F101,"tn_ini duplex","",duplex);
  3260.     debug(F101,"tn_ini done, tn_init","",tn_init);
  3261.     return(x);
  3262. }
  3263.  
  3264. int
  3265. #ifdef CK_ANSIC
  3266. tn_hex(CHAR * buf, int buflen, CHAR * data, int datalen)
  3267. #else /* CK_ANSIC */
  3268. tn_hex(buf, buflen, data, datalen)
  3269.     CHAR * buf;
  3270.     int buflen;
  3271.     CHAR * data;
  3272.     int datalen;
  3273. #endif /* CK_ANSIC */
  3274. {
  3275.     int i = 0, j = 0, k = 0;
  3276.     CHAR tmp[8];
  3277. #ifdef COMMENT
  3278.     int was_hex = 1;
  3279.  
  3280.     for (k=0; k < datalen; k++) {
  3281.         if (data[k] < 32 || data[k] >= 127) {
  3282.             sprintf(tmp,"%s%02X ",was_hex?"":"\" ",data[k]);
  3283.             was_hex = 1;
  3284.         } else {
  3285.             sprintf(tmp,"%s%c",was_hex?"\"":"",data[k]);
  3286.             was_hex = 0;
  3287.         }
  3288.         ckstrncat((char *)buf,tmp,buflen);
  3289.     }
  3290.     if (!was_hex)
  3291.         ckstrncat((char *)buf,"\" ",buflen);
  3292. #else /* COMMENT */
  3293.     if (datalen <= 0 || data == NULL)
  3294.         return(0);
  3295.  
  3296.     for (i = 0; i < datalen; i++) {
  3297.         ckstrncat((char *)buf,"\r\n  ",buflen);
  3298.         for (j = 0 ; (j < 16); j++) {
  3299.             if ((i + j) < datalen)
  3300.               sprintf((char *)tmp,
  3301.                       "%s%02x ",
  3302.                       (j == 8 ? "| " : ""),
  3303.                       (char) data[i + j]
  3304.                       );
  3305.             else
  3306.               sprintf((char *)tmp,
  3307.                       "%s   ",
  3308.                       (j == 8 ? "| " : "")
  3309.                       );
  3310.             ckstrncat((char *)buf,(char *)tmp,buflen);
  3311.         }
  3312.         ckstrncat((char *)buf," ",buflen);
  3313.         for (k = 0; (k < 16) && ((i + k) < datalen); k++) {
  3314.             sprintf((char *)tmp,
  3315.                      "%s%c",
  3316.                      (k == 8 ? " " : ""),
  3317.                      isprint((char)(data[i+k])) ? data[i+k] : '.'
  3318.                      );
  3319.             ckstrncat((char *)buf,(char *)tmp,buflen);
  3320.         }
  3321.         i += j - 1;
  3322.     } /* end for */
  3323.     ckstrncat((char *)buf,"\r\n  ",buflen);
  3324. #endif /* COMMENT */
  3325.     return(strlen((char *)buf));
  3326. }
  3327.  
  3328. VOID
  3329. tn_debug(s) char *s; {
  3330. #ifdef NOLOCAL
  3331.     return;
  3332. #else /* NOLOCAL */
  3333. #ifdef OS2
  3334.     void cwrite(unsigned short);
  3335.     char *p = s;
  3336.     _PROTOTYP (void os2bold, (void));
  3337.     extern int tt_type_mode;
  3338. #endif /* OS2 */
  3339.  
  3340.     if (!(tn_deb || debses))
  3341.       return;
  3342.     debug(F111,"tn_debug",s,what);
  3343. #ifdef OS2
  3344.     if ( what == W_COMMAND || what == W_NOTHING ) {
  3345.         extern unsigned char colorcmd;
  3346.         colorcmd ^= 0x8 ;
  3347.         printf("%s\r\n",s);
  3348.         colorcmd ^= 0x8 ;
  3349.     }
  3350.     if (!scrninitialized[VTERM]) {
  3351.         USHORT x,y;
  3352.         checkscreenmode();
  3353.         GetCurPos(&y, &x);
  3354.         SaveCmdMode(x+1,y+1);
  3355.         scrninit();
  3356.         RestoreCmdMode();
  3357.     }
  3358.  
  3359.     if ( ISVTNT(tt_type_mode) && ttnum != -1 && !debses )
  3360.         return;
  3361.  
  3362.     RequestVscrnMutex( VTERM, SEM_INDEFINITE_WAIT ) ;
  3363.  
  3364.     os2bold();                          /* Toggle boldness */
  3365.     while (*p)
  3366.       cwrite((CHAR) *p++);              /* Go boldly ... */
  3367.     os2bold();                          /* Toggle boldness back */
  3368.     if (debses) {
  3369.         debses = 0;
  3370.         cwrite((CHAR) '\015');
  3371.         cwrite((CHAR) '\012');
  3372.         debses = 1;
  3373.     } else {
  3374.         cwrite((CHAR) '\015');
  3375.         cwrite((CHAR) '\012');
  3376.     }
  3377.     ReleaseVscrnMutex(VTERM) ;
  3378. #else
  3379.     if (what != W_CONNECT && what != W_COMMAND && what != W_NOTHING)
  3380.       return;                           /* CONNECT/command must be active */
  3381.     conoll(s);
  3382. #endif /* OS2 */
  3383. #endif /* NOLOCAL */
  3384. }
  3385.  
  3386. /*
  3387.   Process in-band Telnet negotiation characters from the remote host.
  3388.   Call with the telnet IAC character and the current duplex setting
  3389.   (0 = remote echo, 1 = local echo), and a pointer to a function to call
  3390.   to read more characters.  Returns:
  3391.     6 if DO LOGOUT was received and accepted
  3392.     5 if the Kermit start of packet character has changed
  3393.     4 if state of remote Internet Kermit Service has changed
  3394.     3 if a quoted IAC was received
  3395.     2 if local echo must be changed to remote
  3396.     1 if remote echo must be changed to local
  3397.     0 if nothing happens or no action necessary
  3398.    -1 on failure (= internal or i/o error)
  3399. */
  3400. #ifdef IKS_OPTION
  3401. int
  3402. tn_siks(cmd) int cmd; {         /* TELNET SEND IKS SUB */
  3403.     CHAR buf[8];
  3404. #ifndef NOXFER
  3405.     extern CHAR mystch;                 /* Outgoing Start of Packet Char */
  3406. #else
  3407.     CHAR mystch = '\1';
  3408. #endif /* NOXFER */
  3409.     int n,m,rc;
  3410.  
  3411.     if (ttnet != NET_TCPB) return(0);   /* Must be TCP/IP */
  3412.     if (ttnproto != NP_TELNET) return(0); /* Must be telnet protocol */
  3413.     if (cmd < KERMIT_START || cmd > KERMIT_RESP_STOP) /* Illegal subcommand */
  3414.       return(-1);
  3415.  
  3416. #ifdef CK_SSL
  3417.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  3418.         return(0);
  3419.     }
  3420. #endif /* CK_SSL */
  3421.     if (cmd == KERMIT_START || cmd == KERMIT_RESP_START) {
  3422.         TELOPT_SB(TELOPT_KERMIT).kermit.me_start = 1;
  3423.     } else if (cmd == KERMIT_STOP || cmd == KERMIT_RESP_STOP) {
  3424.         TELOPT_SB(TELOPT_KERMIT).kermit.me_start = 0;
  3425.     } else if (cmd == KERMIT_REQ_STOP)
  3426.       TELOPT_SB(TELOPT_KERMIT).kermit.me_req_stop = 1;
  3427.     else if (cmd == KERMIT_REQ_START)
  3428.       TELOPT_SB(TELOPT_KERMIT).kermit.me_req_start = 1;
  3429.  
  3430.     if (cmd == KERMIT_SOP) {
  3431.         buf[0] = (CHAR) IAC;
  3432.         buf[1] = (CHAR) SB;
  3433.         buf[2] = (CHAR) TELOPT_KERMIT;
  3434.         buf[3] = (CHAR) (cmd & 0xff);
  3435.         buf[4] = (CHAR) mystch;
  3436.         buf[5] = (CHAR) IAC;
  3437.         buf[6] = (CHAR) SE;
  3438.         buf[7] = (CHAR) 0;
  3439. #ifdef DEBUG
  3440.         if (tn_deb || debses || deblog)
  3441.             ckmakmsg( tn_msg_out,TN_MSG_LEN,"TELNET SENT SB KERMIT SOP ",
  3442.                       ckctox(mystch,1)," IAC SE",NULL);
  3443. #endif /* DEBUG */
  3444. #ifdef OS2
  3445.         RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  3446. #endif
  3447. #ifdef DEBUG
  3448.         debug(F101,tn_msg_out,"",cmd);
  3449.         if (tn_deb || debses) tn_debug(tn_msg_out);
  3450. #endif /* DEBUG */
  3451.         rc = ( ttol(buf,7) < 7 );                /* Send it. */
  3452. #ifdef OS2
  3453.         ReleaseTelnetMutex();
  3454. #endif
  3455.     if (rc)
  3456.         return(-1);
  3457.     } else {
  3458.         buf[0] = (CHAR) IAC;
  3459.         buf[1] = (CHAR) SB;
  3460.         buf[2] = (CHAR) TELOPT_KERMIT;
  3461.         buf[3] = (CHAR) (cmd & 0xff);
  3462.         buf[4] = (CHAR) IAC;
  3463.         buf[5] = (CHAR) SE;
  3464.         buf[6] = (CHAR) 0;
  3465.  
  3466. #ifdef DEBUG
  3467.         if (tn_deb || debses || deblog) {
  3468.             char * s = 0;
  3469.             switch (cmd) {
  3470.               case KERMIT_START: s = "START"; break;
  3471.               case KERMIT_STOP: s = "STOP"; break;
  3472.               case KERMIT_REQ_START: s = "REQ-START"; break;
  3473.               case KERMIT_REQ_STOP: s = "REQ-STOP"; break;
  3474.               case KERMIT_RESP_START: s = "RESP-START"; break;
  3475.               case KERMIT_RESP_STOP:  s = "RESP-STOP"; break;
  3476.             }
  3477.             ckmakmsg( tn_msg_out,TN_MSG_LEN,
  3478.                       "TELNET SENT SB kermit ",s," IAC SE",NULL);
  3479.         }
  3480. #endif /* DEBUG */
  3481. #ifdef OS2
  3482.         RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  3483. #endif
  3484. #ifdef DEBUG
  3485.         debug(F101,tn_msg_out,"",cmd);
  3486.         if (tn_deb || debses) tn_debug(tn_msg_out);
  3487. #endif /* DEBUG */
  3488.         rc = ( ttol(buf,6) < 6 );                /* Send it. */
  3489. #ifdef OS2
  3490.         ReleaseTelnetMutex();
  3491. #endif
  3492.         if (rc)
  3493.             return(-1);
  3494.     }
  3495.     return(1);
  3496. }
  3497. #endif /* IKS_OPTION */
  3498.  
  3499. /* tn_sb() performs Telnet Subnegotiation Parsing and Debugging */
  3500. /* returns <= 0 on error, 1 on success */
  3501. /* the length returned includes the IAC SE bytes */
  3502.  
  3503. int
  3504. #ifdef CK_ANSIC                         /* TELNET SB */
  3505. tn_sb( int opt, int * len, int (*fn)(int) )
  3506. #else
  3507. tn_sb( opt, len, fn ) int opt; int * len; int (*fn)();
  3508. #endif /* CK_ANSIC */
  3509. /* tn_sb */ {
  3510.     int c, x, y, n, m, flag;
  3511.     debug(F100,"Entering tn_sb()","",0);
  3512.     *len = 0;                   /* Initialize Len to 0 */
  3513.     n = flag = 0;               /* Flag for when done reading SB */
  3514.     while (n < TSBUFSIZ) {      /* Loop looking for IAC SE */
  3515.         if ((y = (*fn)(0)) < 0) /* Read a byte */
  3516.           return(y);
  3517.         y &= 0xff;              /* Make sure it's just 8 bits. */
  3518.         sb[n++] = (char) y;     /* Deposit in buffer. */
  3519.         if (seslog && sessft == XYFT_D) { /* Take care of session log */
  3520.             logchar((char) y);
  3521.         }
  3522.         if (y == IAC) {         /* If this is an IAC                */
  3523.             if (flag) {         /* If previous char was IAC         */
  3524.                 n--;            /* it's quoted, keep one IAC        */
  3525.                 flag = 0;       /* and turn off the flag.           */
  3526.             } else flag = 1;    /* Otherwise set the flag.          */
  3527.         } else if (flag) {      /* Something else following IAC     */
  3528.             if (y == SE)        /* If not SE, it's a protocol error */
  3529.               break;
  3530.             else if (y == DONT) { /* Used DONT instead of SE */
  3531.                 debug(F100,
  3532.                       "TELNET Subnegotiation error - used DONT instead of SE!",
  3533.                       ""
  3534.                       ,0
  3535.                       );
  3536.                 if (tn_deb || debses)
  3537.                   tn_debug(
  3538.                      "TELNET Subnegotiation error - used DONT instead of SE!");
  3539.                 flag = 3;
  3540.                 break;
  3541.             } else {            /* Other protocol error */
  3542.                 flag = 0;
  3543.                 break;
  3544.             }
  3545.         }
  3546.  
  3547. #ifdef CK_FORWARD_X
  3548.         if ( opt == TELOPT_FORWARD_X && sb[0] == FWDX_DATA &&
  3549.              n >= (TSBUFSIZ-4) && !flag ) {
  3550.             /* do not let the buffer over flow */
  3551.             /* write the data to the channel and continue processing */
  3552.             /* the incoming data until IAC SE is reached. */
  3553.             sb[n++] = IAC;
  3554.             sb[n++] = SE;
  3555.  
  3556. #ifdef DEBUG
  3557.             if ( deblog || tn_deb || debses ) {
  3558.                 int i;
  3559.                 ckmakmsg( tn_msg,TN_MSG_LEN,
  3560.                           "TELNET RCVD SB ",TELOPT(opt),
  3561.                                                   " DATA(buffer-full) ",NULL);
  3562.                 tn_hex(tn_msg,TN_MSG_LEN,&sb[1],n-3);
  3563.                 if (flag == 2)
  3564.                     ckstrncat(tn_msg," SE",TN_MSG_LEN);
  3565.                 else if (flag == 3)
  3566.                     ckstrncat(tn_msg," IAC DONT",TN_MSG_LEN);
  3567.                 else
  3568.                     ckstrncat(tn_msg," IAC SE",TN_MSG_LEN);
  3569.                 debug(F100,tn_msg,"",0);
  3570.                 if (tn_deb || debses)
  3571.                     tn_debug(tn_msg);
  3572.             }
  3573. #endif /* DEBUG */
  3574.  
  3575.             if ( fwdx_tn_sb(sb,n) < 0 ) {
  3576.                                 debug(F100,"fxdx_tn_sb() failed","",0);
  3577.                 /* We can't return though because that would leave  */
  3578.                 /* data to be forwarded in the queue to the be sent */
  3579.                 /* to the terminal emulator.                        */
  3580.             }
  3581.             /* reset leave the msg type and channel number in place */
  3582.             n = 3;
  3583.         }
  3584. #endif /* CK_FORWARD_X */
  3585.     }
  3586.     debug(F111,"tn_sb end of while loop","flag",flag);
  3587.     if (!flag) {                        /* Make sure we got a valid SB */
  3588.         debug(F111, "TELNET Subnegotiation prematurely broken","opt",opt);
  3589.         if (tn_deb || debses) {
  3590.             ckmakmsg( tn_msg, TN_MSG_LEN,
  3591.                       "TELNET ", TELOPT(opt),
  3592.                       " Subnegotiation prematurely broken",NULL
  3593.                       );
  3594.  
  3595.           tn_debug(tn_msg);
  3596.         }
  3597.         /* Was -1 but that would be an I/O error, so absorb it and go on. */
  3598.         return(0);
  3599.     }
  3600. #ifdef DEBUG
  3601.     if (deblog || tn_deb || debses) {
  3602.         int i;
  3603.         char * s[16];
  3604.         for (i = 0; i < 16; i++)
  3605.           s[i] = "";
  3606.         if (opt == TELOPT_NAWS) {
  3607.             i = 0;
  3608.         } else {
  3609.             i = 1;
  3610.             s[0] = "UNKNOWN";
  3611.  
  3612.             switch (sb[0]) {
  3613.               case 0:
  3614.                 if (opt == TELOPT_FORWARD_X)
  3615.                   s[0] = "SCREEN";
  3616.                 else if (opt == TELOPT_KERMIT)
  3617.                   s[0] = "START";
  3618.                 else if (opt == TELOPT_LFLOW)
  3619.                   s[0] = "OFF";
  3620.                 else if (opt == TELOPT_COMPORT)
  3621.                   s[0] = "SIGNATURE";
  3622.                 else
  3623.                   s[0] = "IS";
  3624.                 if (opt == TELOPT_ENCRYPTION) {
  3625.                     i++;
  3626.                     if (sb[1] < ENCTYPE_CNT) {
  3627.                         s[1] = enctype_names[sb[1]];
  3628.                         i++;
  3629.                         switch(sb[2]) {
  3630.                           case 1:
  3631.                             s[2] = "FB64_IV";
  3632.                             break;
  3633.                           case 2:
  3634.                             s[2] = "FB64_IV_OK";
  3635.                             break;
  3636.                           case 3:
  3637.                             s[2] = "FB64_IV_BAD";
  3638.                             break;
  3639.                           case 4:
  3640.                             s[2] = "FB64_CHALLENGE";
  3641.                             break;
  3642.                           case 5:
  3643.                             s[2] = "FB64_RESPONSE";
  3644.                             break;
  3645.                         }
  3646.                     } else {
  3647.                         s[1] = "UNKNOWN";
  3648.                     }
  3649.                 }
  3650.                 if (opt == TELOPT_AUTHENTICATION) {
  3651.                     i += 2;
  3652.                     s[1] = AUTHTYPE_NAME(sb[1]);
  3653.                     s[2] = AUTHMODE_NAME(sb[2]);
  3654.                     if (sb[1]) {
  3655.                         i++;
  3656.                         switch (sb[3]) {
  3657.                           case 0:
  3658.                             switch (sb[1]) {
  3659.                               case AUTHTYPE_NTLM:
  3660.                                 s[3] = "NTLM_AUTH";
  3661.                                 break;
  3662.                               default:
  3663.                                 s[3] = "AUTH";
  3664.                             }
  3665.                             break;
  3666.                           case 1:
  3667.                             switch (sb[1]) {
  3668.                               case AUTHTYPE_SSL:
  3669.                                 s[3] = "START";
  3670.                                 break;
  3671.                               case AUTHTYPE_NTLM:
  3672.                                 s[3] = "NTLM_CHALLENGE";
  3673.                                 break;
  3674.                               default:
  3675.                                 s[3] = "REJECT";
  3676.                             }
  3677.                             break;
  3678.                           case 2:
  3679.                             switch (sb[1]) {
  3680.                               case AUTHTYPE_NTLM:
  3681.                                 s[3] = "NTLM_RESPONSE";
  3682.                                 break;
  3683.                               default:
  3684.                                 s[3] = "ACCEPT";
  3685.                             }
  3686.                             break;
  3687.                           case 3:
  3688.                             switch (sb[1]) {
  3689.                               case AUTHTYPE_NTLM:
  3690.                                 s[3] = "NTLM_ACCEPT";
  3691.                                 break;
  3692.                               case 1:   /* KERBEROS_v4 */
  3693.                               case 5:   /* SRP */
  3694.                                 s[3] = "CHALLENGE";
  3695.                                 break;
  3696.                               case 2:   /* KERBEROS_v5 */
  3697.                                 s[3] = "RESPONSE";
  3698.                                 break;
  3699.                               case AUTHTYPE_SSL:
  3700.                                 s[3] = "REJECT";
  3701.                                 break;
  3702.                             }
  3703.                             break;
  3704.                           case 4:
  3705.                             switch (sb[1]) {
  3706.                               case AUTHTYPE_NTLM:
  3707.                                 s[3] = "NTLM_REJECT";
  3708.                                 break;
  3709.                               case 1:   /* KERBEROS_V4 */
  3710.                               case 5:   /* SRP */
  3711.                                 s[3] = "RESPONSE";
  3712.                                 break;
  3713.                               case 2:   /* KERBEROS_V5 */
  3714.                                 s[3] = "FORWARD";
  3715.                                 break;
  3716.                             }
  3717.                             break;
  3718.                           case 5:
  3719.                             switch (sb[1]) {
  3720.                               case 5:   /* SRP */
  3721.                                 s[3] = "FORWARD";
  3722.                                 break;
  3723.                               case 2:   /* KERBEROS_V5 */
  3724.                                 s[3] = "FORWARD_ACCEPT";
  3725.                                 break;
  3726.                             }
  3727.                             break;
  3728.                           case 6:
  3729.                             switch (sb[1]) {
  3730.                               case 5:   /* SRP */
  3731.                                 s[3] = "FORWARD_ACCEPT";
  3732.                                 break;
  3733.                               case 2: /* KERBEROS_V5 */
  3734.                                 s[3] = "FORWARD_REJECT";
  3735.                                 break;
  3736.                             }
  3737.                             break;
  3738.                           case 7:
  3739.                             switch (sb[1]) {
  3740.                               case 5:   /* SRP */
  3741.                                 s[3] = "FORWARD_REJECT";
  3742.                                 break;
  3743.                               case 2: /* KERBEROS_V5 */
  3744.                                 s[3] = "TLS_VERIFY";
  3745.                                 break;
  3746.                               }
  3747.                             break;
  3748.                           case 8:
  3749.                             switch (sb[1]) {
  3750.                               case 5: /* SRP */
  3751.                                 s[3] = "EXP";
  3752.                                 break;
  3753.                             }
  3754.                             break;
  3755.                           case 9:
  3756.                             switch (sb[1]) {
  3757.                               case 5: /* SRP */
  3758.                                 s[3] = "PARAMS";
  3759.                                 break;
  3760.                             }
  3761.                             break;
  3762.                         }
  3763.                     }
  3764.                 }
  3765.                 break;
  3766.               case 1:
  3767.                 switch (opt) {
  3768.                   case TELOPT_FORWARD_X:
  3769.                     s[0] = "OPEN";
  3770.                     break;
  3771.                   case TELOPT_LFLOW:
  3772.                     s[0] = "ON";
  3773.                     break;
  3774.                   case TELOPT_KERMIT:
  3775.                     s[0] = "STOP";
  3776.                     break;
  3777.                   case TELOPT_COMPORT:
  3778.                     s[0] = "SET-BAUDRATE";
  3779.                       break;
  3780.                   case TELOPT_AUTHENTICATION:
  3781.                     s[0] = "SEND";
  3782.                     hexbuf[0] = '\0';
  3783.                     for (; i < n-2; i += 2) {
  3784.                         if ( AUTHTYPE_NAME_OK(sb[i]) &&
  3785.                              AUTHMODE_NAME_OK(sb[i]))
  3786.                             ckmakmsg( tn_msg, TN_MSG_LEN,
  3787.                                       AUTHTYPE_NAME(sb[i])," ",
  3788.                                       AUTHMODE_NAME(sb[i+1])," "
  3789.                                       );
  3790.                         else
  3791.                           ckmakxmsg(tn_msg, TN_MSG_LEN,
  3792.                                     AUTHTYPE_NAME(sb[i]),
  3793.                                     "=",
  3794.                                     ckitoa(sb[i]),
  3795.                                     " ",
  3796.                                     AUTHMODE_NAME(sb[i+1]),
  3797.                                     "=",
  3798.                                     ckitoa(sb[i+1]),
  3799.                                     " ",
  3800.                                     NULL,NULL,NULL,NULL
  3801.                                     );
  3802.                         ckstrncat(hexbuf,tn_msg,sizeof(hexbuf));
  3803.                     }
  3804.                     s[1] = hexbuf;
  3805.                     break;
  3806.  
  3807.                   case TELOPT_ENCRYPTION:
  3808.                     s[0] = "SUPPORT";
  3809.                     while (i < n-2) {
  3810.                         s[i] = enctype_names[sb[i]];
  3811.                         i++;
  3812.                     }
  3813.                     break;
  3814.  
  3815.                   case TELOPT_START_TLS:
  3816.                     s[0] = "FOLLOWS";
  3817.                     break;
  3818.                   default:
  3819.                     s[0] = "SEND";
  3820.                 }
  3821.                 break;
  3822.  
  3823.               case 2:
  3824.                 switch (opt) {
  3825.                 case TELOPT_FORWARD_X:
  3826.                     s[0] = "CLOSE";
  3827.                     break;
  3828.                   case TELOPT_LFLOW:
  3829.                     s[0] = "RESTART-ANY";
  3830.                     break;
  3831.                   case TELOPT_KERMIT:
  3832.                     s[0] = "REQ-START";
  3833.                     break;
  3834.                   case TELOPT_COMPORT:
  3835.                     s[0] = "SET-DATASIZE";
  3836.                     break;
  3837.                   case TELOPT_NEWENVIRON:
  3838.                     s[0] = "INFO";
  3839.                     break;
  3840.                   case TELOPT_AUTHENTICATION:
  3841.                     s[0] = "REPLY";
  3842.                     i=4;
  3843.                     s[1] = AUTHTYPE_NAME(sb[1]);
  3844.                     s[2] = AUTHMODE_NAME(sb[2]);
  3845.                     switch (sb[3]) {
  3846.                       case 0:
  3847.                         switch (sb[1]) {
  3848.                           case AUTHTYPE_NTLM:
  3849.                             s[3] = "NTLM_AUTH";
  3850.                             break;
  3851.                           default:
  3852.                             s[3] = "AUTH";
  3853.                         }
  3854.                         break;
  3855.                       case 1:
  3856.                         switch (sb[1]) {
  3857.                           case AUTHTYPE_NTLM:
  3858.                             s[3] = "NTLM_CHALLENGE";
  3859.                             break;
  3860.                           default:
  3861.                             s[3] = "REJECT";
  3862.                         }
  3863.                         break;
  3864.                       case 2:
  3865.                         switch (sb[1]) {
  3866.                           case AUTHTYPE_NTLM:
  3867.                             s[3] = "NTLM_RESPONSE";
  3868.                             break;
  3869.                           default:
  3870.                             s[3] = "ACCEPT";
  3871.                         }
  3872.                         break;
  3873.                       case 3:
  3874.                         switch (sb[1]) {
  3875.                           case AUTHTYPE_NTLM:
  3876.                             s[3] = "NTLM_ACCEPT";
  3877.                             break;
  3878.                           case AUTHTYPE_KERBEROS_V4:
  3879.                           case AUTHTYPE_SRP:
  3880.                             s[3] = "CHALLENGE";
  3881.                             break;
  3882.                           case AUTHTYPE_KERBEROS_V5:
  3883.                             s[3] = "RESPONSE";
  3884.                             break;
  3885.                         }
  3886.                         break;
  3887.                       case 4:
  3888.                         switch (sb[1]) {
  3889.                           case AUTHTYPE_NTLM:
  3890.                             s[3] = "NTLM_REJECT";
  3891.                             break;
  3892.                           case AUTHTYPE_KERBEROS_V4:
  3893.                           case AUTHTYPE_SRP:
  3894.                             s[3] = "RESPONSE";
  3895.                             break;
  3896.                           case AUTHTYPE_KERBEROS_V5:
  3897.                             s[3] = "FORWARD";
  3898.                             break;
  3899.                         }
  3900.                         break;
  3901.                       case 5:
  3902.                         switch (sb[1]) {
  3903.                           case AUTHTYPE_SRP:
  3904.                             s[3] = "FORWARD";
  3905.                             break;
  3906.                           case AUTHTYPE_KERBEROS_V5:
  3907.                             s[3] = "FORWARD_ACCEPT";
  3908.                             break;
  3909.                         }
  3910.                         break;
  3911.                       case 6:
  3912.                         switch (sb[1]) {
  3913.                           case AUTHTYPE_SRP:
  3914.                             s[3] = "FORWARD_ACCEPT";
  3915.                             break;
  3916.                           case AUTHTYPE_KERBEROS_V5:
  3917.                             s[3] = "FORWARD_REJECT";
  3918.                             break;
  3919.                         }
  3920.                         break;
  3921.                       case 7:
  3922.                         switch (sb[1]) {
  3923.                           case AUTHTYPE_SRP:
  3924.                             s[3] = "FORWARD_REJECT";
  3925.                             break;
  3926.                           case AUTHTYPE_KERBEROS_V5:
  3927.                             s[3] = "TLS_VERIFY";
  3928.                             break;
  3929.                         }
  3930.                         break;
  3931.                       case 8:
  3932.                         switch (sb[1]) {
  3933.                           case AUTHTYPE_SRP:
  3934.                             s[3] = "EXP";
  3935.                             break;
  3936.                         }
  3937.                         break;
  3938.                       case 9:
  3939.                         switch (sb[1]) {
  3940.                           case AUTHTYPE_SRP:
  3941.                             s[3] = "PARAMS";
  3942.                             break;
  3943.                         }
  3944.                         break;
  3945.                     }
  3946.                     break;
  3947.                   case TELOPT_ENCRYPTION:
  3948.                     s[0] = "REPLY";
  3949.                     s[1] = enctype_names[sb[1]];
  3950.                     i++;
  3951.                     switch (sb[2]) {
  3952.                       case 1:
  3953.                         i++;
  3954.                         s[2] = "FB64_IV";
  3955.                         break;
  3956.                       case 2:
  3957.                         i++;
  3958.                         s[2] = "FB64_IV_OK";
  3959.                         break;
  3960.                       case 3:
  3961.                         i++;
  3962.                         s[2] = "FB64_IV_BAD";
  3963.                         break;
  3964.                       case 4:
  3965.                         i++;
  3966.                         s[2] = "FB64_CHALLENGE";
  3967.                         break;
  3968.                       case 5:
  3969.                         i++;
  3970.                         s[2] = "FB64_RESPONSE";
  3971.                         break;
  3972.                     }
  3973.                     break;
  3974.                 }
  3975.                 break;
  3976.               case 3:
  3977.                 switch (opt) {
  3978.                   case TELOPT_FORWARD_X:
  3979.                     s[0] = "DATA";
  3980.                     break;
  3981.                   case TELOPT_LFLOW:
  3982.                     s[0] = "RESTART-XON";
  3983.                     break;
  3984.                   case TELOPT_KERMIT:
  3985.                     s[0] = "REQ-STOP";
  3986.                     break;
  3987.                   case TELOPT_COMPORT:
  3988.                       s[0] = "SET-PARITY";
  3989.                       break;
  3990.                   case TELOPT_AUTHENTICATION:
  3991.                     s[0] = "NAME";
  3992.                     break;
  3993.                   case TELOPT_ENCRYPTION:
  3994.                     s[0] = "START";
  3995.                     break;
  3996.                 }
  3997.                 break;
  3998.               case 4:
  3999.                 switch (opt) {
  4000.                   case TELOPT_FORWARD_X:
  4001.                     s[0] = "OPTIONS";
  4002.                     break;
  4003.                   case TELOPT_KERMIT:
  4004.                     s[0] = "SOP";
  4005.                     break;
  4006.                   case TELOPT_COMPORT:
  4007.                       s[0] = "SET-STOPSIZE";
  4008.                       break;
  4009.                   case TELOPT_ENCRYPTION:
  4010.                     s[0] = "END";
  4011.                     break;
  4012.                 }
  4013.                 break;
  4014.               case 5:
  4015.                 switch (opt) {
  4016.                 case TELOPT_FORWARD_X:
  4017.                     s[0] = "OPTION_DATA";
  4018.                     break;
  4019.                 case TELOPT_ENCRYPTION:
  4020.                     s[0] = "REQUEST-START";
  4021.                     break;
  4022.                 case TELOPT_COMPORT:
  4023.                     s[0] = "SET-CONTROL";
  4024.                     break;
  4025.                 }
  4026.                 break;
  4027.               case 6:
  4028.                 switch (opt) {
  4029.                   case TELOPT_FORWARD_X:
  4030.                     s[0] = "XOFF";
  4031.                     break;
  4032.                   case TELOPT_ENCRYPTION:
  4033.                     s[0] = "REQUEST-END";
  4034.                     break;
  4035.                   case TELOPT_COMPORT:
  4036.                       s[0] = "NOTIFY-LINESTATE";
  4037.                       break;
  4038.                   }
  4039.                 break;
  4040.               case 7:
  4041.                 switch (opt) {
  4042.                   case TELOPT_FORWARD_X:
  4043.                     s[0] = "XON";
  4044.                     break;
  4045.                   case TELOPT_ENCRYPTION:
  4046.                     s[0] = "ENC-KEYID";
  4047.                     break;
  4048.                   case TELOPT_COMPORT:
  4049.                       s[0] = "NOTIFY-MODEMSTATE";
  4050.                       break;
  4051.                   }
  4052.                 break;
  4053.               case 8:
  4054.                 switch (opt) {
  4055.                   case TELOPT_KERMIT:
  4056.                     s[0] = "RESP-START";
  4057.                     break;
  4058.                   case TELOPT_ENCRYPTION:
  4059.                     s[0] = "DEC-KEYID";
  4060.                     break;
  4061.                   case TELOPT_COMPORT:
  4062.                       s[0] = "FLOWCONTROL-SUSPEND";
  4063.                       break;
  4064.                   }
  4065.                 break;
  4066.               case 9:
  4067.                 switch (opt) {
  4068.                   case TELOPT_KERMIT:
  4069.                     s[0] = "RESP-STOP";
  4070.                     break;
  4071.                   case TELOPT_COMPORT:
  4072.                       s[0] = "FLOWCONTROL-RESUME";
  4073.                       break;
  4074.                   }
  4075.                 break;
  4076.               case 10:
  4077.                   switch (opt) {
  4078.                   case TELOPT_COMPORT:
  4079.                     s[0] = "SET-LINESTATE-MASK";
  4080.                     break;
  4081.                   }
  4082.                   break;
  4083.             case 11:
  4084.                   switch (opt) {
  4085.                   case TELOPT_COMPORT:
  4086.                       s[0] = "SET-MODEMSTATE-MASK";
  4087.                       break;
  4088.                   }
  4089.                   break;
  4090.             case 12:
  4091.                   switch (opt) {
  4092.                   case TELOPT_COMPORT:
  4093.                       s[0] = "PURGE-DATA";
  4094.                       break;
  4095.                   }
  4096.                   break;
  4097.  
  4098.  
  4099.             case 100:
  4100.                   switch (opt) {
  4101.                   case TELOPT_COMPORT:
  4102.                       s[0] = "S_SIGNATURE";
  4103.                       break;
  4104.                   }
  4105.                   break;
  4106.             case 101:
  4107.                   switch (opt) {
  4108.                   case TELOPT_COMPORT:
  4109.                       s[0] = "S_SET-BAUDRATE";
  4110.                       break;
  4111.                   }
  4112.                   break;
  4113.             case 102:
  4114.                   switch (opt) {
  4115.                   case TELOPT_COMPORT:
  4116.                       s[0] = "S_SET-DATASIZE";
  4117.                       break;
  4118.                   }
  4119.                   break;
  4120.             case 103:
  4121.                   switch (opt) {
  4122.                   case TELOPT_COMPORT:
  4123.                       s[0] = "S_SET-PARITY";
  4124.                       break;
  4125.                   }
  4126.                   break;
  4127.             case 104:
  4128.                   switch (opt) {
  4129.                   case TELOPT_COMPORT:
  4130.                       s[0] = "S_SET-STOPSIZE";
  4131.                       break;
  4132.                   }
  4133.                   break;
  4134.             case 105:
  4135.                   switch (opt) {
  4136.                   case TELOPT_COMPORT:
  4137.                       s[0] = "S_SET-CONTROL";
  4138.                       break;
  4139.                   }
  4140.                   break;
  4141.             case 106:
  4142.                   switch (opt) {
  4143.                   case TELOPT_COMPORT:
  4144.                       s[0] = "S_NOTIFY-LINESTATE";
  4145.                       break;
  4146.                   }
  4147.                   break;
  4148.             case 107:
  4149.                   switch (opt) {
  4150.                   case TELOPT_COMPORT:
  4151.                       s[0] = "S_NOTIFY-MODEMSTATE";
  4152.                       break;
  4153.                   }
  4154.                   break;
  4155.             case 108:
  4156.                   switch (opt) {
  4157.                   case TELOPT_COMPORT:
  4158.                       s[0] = "S_FLOWCONTROL-SUSPEND";
  4159.                       break;
  4160.                   }
  4161.                   break;
  4162.             case 109:
  4163.                   switch (opt) {
  4164.                   case TELOPT_COMPORT:
  4165.                       s[0] = "S_FLOWCONTROL-RESUME";
  4166.                       break;
  4167.                   }
  4168.                   break;
  4169.             case 110:
  4170.                   switch (opt) {
  4171.                   case TELOPT_COMPORT:
  4172.                       s[0] = "S_SET-LINESTATE-MASK";
  4173.                       break;
  4174.                   }
  4175.                   break;
  4176.             case 111:
  4177.                   switch (opt) {
  4178.                   case TELOPT_COMPORT:
  4179.                       s[0] = "S_SET-MODEMSTATE-MASK";
  4180.                       break;
  4181.                   }
  4182.                   break;
  4183.             case 112:
  4184.                   switch (opt) {
  4185.                   case TELOPT_COMPORT:
  4186.                       s[0] = "S_PURGE-DATA";
  4187.                       break;
  4188.                   }
  4189.                   break;
  4190.               }
  4191.         }
  4192. #ifdef M_XENIX
  4193.         {
  4194.           int len, param, param_len;
  4195.           ckmakmsg( tn_msg, TN_MSG_LEN,
  4196.                     "TELNET RCVD SB ",
  4197.                     TELOPT(opt)," ",NULL);
  4198.           len = strlen(tn_msg);
  4199.           for (param = 0; param <= 15; param++) {
  4200.             param_len = strlen(s[param]);
  4201.             if (param_len > 0) {
  4202.               strcpy(&tn_msg[len], s[param]);
  4203.               len += param_len;
  4204.               tn_msg[len++] = ' ';
  4205.             }
  4206.           }
  4207.           tn_msg[len] = '\0';
  4208.         }
  4209. #else /* M_XENIX */
  4210.         ckmakxmsg(tn_msg,TN_MSG_LEN,"TELNET RCVD SB ",TELOPT(opt)," ",
  4211.                   NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  4212.         {
  4213.             int i;
  4214.             for (i = 0; i <= 15; i++) {
  4215.                 if (s[i][0]) {
  4216.                     ckstrncat(tn_msg,s[i],TN_MSG_LEN);
  4217.                     ckstrncat(tn_msg," ",TN_MSG_LEN);
  4218.                 }
  4219.             }
  4220.         }
  4221. #endif /* M_XENIX */
  4222.         tn_hex((CHAR *)tn_msg,TN_MSG_LEN,&sb[i],n-2-i);
  4223.         if (flag == 2)
  4224.           ckstrncat(tn_msg," SE",TN_MSG_LEN);
  4225.         else if (flag == 3)
  4226.           ckstrncat(tn_msg," IAC DONT",TN_MSG_LEN);
  4227.         else
  4228.           ckstrncat(tn_msg," IAC SE",TN_MSG_LEN);
  4229.         debug(F100,tn_msg,"",0);
  4230.         if (tn_deb || debses)
  4231.           tn_debug(tn_msg);
  4232.     }
  4233.     debug(F111,"tn_sb","len",n);
  4234. #endif /* DEBUG */
  4235.     *len = n;           /* return length */
  4236.     return(1);          /* success */
  4237. }
  4238.  
  4239. static char rows_buf[16] = { 0, 0 }; /* LINES Environment variable */
  4240. static char cols_buf[16] = { 0, 0 }; /* COLUMNS Enviornment variable */
  4241. static char term_buf[64] = { 0, 0 }; /* TERM Environment variable */
  4242.  
  4243. #ifdef CK_CURSES
  4244. #ifndef VMS
  4245. #ifndef COHERENT
  4246. _PROTOTYP(int tgetent,(char *, char *));
  4247. #endif /* COHERENT */
  4248. #else
  4249. #ifdef __DECC
  4250. _PROTOTYP(int tgetent,(char *, char *));
  4251. #endif /* __DECC */
  4252. #endif /* VMS */
  4253. extern char * trmbuf;                   /* Real curses */
  4254. #endif /* CK_CURSES */
  4255.  
  4256. #ifdef CK_ENCRYPTION
  4257. static int
  4258. tn_no_encrypt()
  4259. {
  4260.     /* Prevent Encryption from being negotiated */
  4261.     TELOPT_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  4262.     TELOPT_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  4263.  
  4264.     /* Cancel any negotiation that might have started */
  4265.     ck_tn_enc_stop();
  4266.  
  4267.     if (TELOPT_ME(TELOPT_ENCRYPTION) ||
  4268.          TELOPT_UNANSWERED_WILL(TELOPT_ENCRYPTION)) {
  4269.         TELOPT_ME(TELOPT_ENCRYPTION) = 0;
  4270.         if (tn_sopt(WONT,TELOPT_ENCRYPTION) < 0)
  4271.             return(-1);
  4272.         TELOPT_UNANSWERED_WONT(TELOPT_ENCRYPTION) = 1;
  4273.     }
  4274.     if (TELOPT_U(TELOPT_ENCRYPTION) ||
  4275.          TELOPT_UNANSWERED_DO(TELOPT_ENCRYPTION)) {
  4276.         TELOPT_U(TELOPT_ENCRYPTION) = 0;
  4277.         if (tn_sopt(DONT,TELOPT_ENCRYPTION) < 0)
  4278.             return(-1);
  4279.         TELOPT_UNANSWERED_DONT(TELOPT_ENCRYPTION) = 1;
  4280.     }
  4281.     return(0);
  4282. }
  4283. #endif /* CK_ENCRYPTION */
  4284.  
  4285. /* The following note came from the old SGA negotiation code.  This should */
  4286. /* no longer be necessary with the New Telnet negotiation state machine.   */
  4287. /*
  4288.   Note: The following is proper behavior, and required for talking to the
  4289.   Apertus interface to the NOTIS library system, e.g. at Iowa State U:
  4290.   scholar.iastate.edu.  Without this reply, the server hangs forever.  This
  4291.   code should not be loop-inducing, since C-Kermit never sends WILL SGA as
  4292.   an initial bid, so if DO SGA comes, it is never an ACK.
  4293. */
  4294. /*
  4295.   Return values:
  4296.   -1 = Telnet Option negotiation error
  4297.   -2 = Connection closed by peer
  4298.   -3 = Connection closed by us
  4299.   0  = Success
  4300.   1  = Echoing on
  4301.   2  = Echoing off
  4302.   3  = Quoted IAC
  4303.   4  = IKS Event
  4304.   5  = (unassigned)
  4305.   6  = Logout
  4306. */
  4307.  
  4308. static int
  4309. #ifdef CK_ANSIC                         /* TELNET DO OPTION */
  4310. tn_xdoop(CHAR z, int echo, int (*fn)(int))
  4311. #else
  4312. tn_xdoop(z, echo, fn) CHAR z; int echo; int (*fn)();
  4313. #endif /* CK_ANSIC */
  4314. /* tn_xdoop */ {
  4315.     int c, x, y, n, m;
  4316. #ifdef IKS_OPTION
  4317.     extern int server;
  4318. #ifdef NOICP
  4319.     extern int autodl;
  4320.     int inautodl = 0, cmdadl = 1;
  4321. #else
  4322. #ifdef CK_AUTODL
  4323.     extern int autodl, inautodl, cmdadl;
  4324. #endif /* CK_AUTODL */
  4325. #endif /* NOICP */
  4326. #endif /* IKS_OPTION */
  4327.  
  4328.  
  4329. /* Have IAC, read command character. */
  4330.  
  4331.     while ((c = (*fn)(0)) == -1);       /* Read command character */
  4332.     if (c < 0)
  4333.       return(c);
  4334.     c &= 0xFF;                          /* Strip high bits */
  4335.  
  4336.     if (!TELCMD_OK(c)) {
  4337. #ifdef DEBUG
  4338.         if (tn_deb || debses || deblog) {
  4339.             ckmakmsg(tn_msg,TN_MSG_LEN,"TELNET RCVD UNKNOWN (",
  4340.                      ckitoa(c),")",NULL);
  4341.             debug(F101,tn_msg,"",c);
  4342.             if (tn_deb || debses)
  4343.               tn_debug(tn_msg);
  4344.         }
  4345. #endif /* DEBUG */
  4346.         return(0);
  4347.     }
  4348.     if (ttnproto == NP_NONE) {
  4349.         debug(F100,"tn_doop discovered a Telnet command",
  4350.               "ttnproto = NP_TELNET",0);
  4351.         ttnproto = NP_TELNET;
  4352.     }
  4353.     if (seslog && sessft == XYFT_D) {   /* Copy to session log, if any. */
  4354.         logchar((char)z);
  4355.         logchar((char)c);
  4356.     }
  4357.  
  4358.     if (c == (CHAR) IAC)                /* Quoted IAC */
  4359.       return(3);
  4360.  
  4361.     if (c < SB) {                       /* Other command with no arguments. */
  4362. #ifdef DEBUG
  4363.         if (deblog || tn_deb || debses) {
  4364.             ckmakmsg(tn_msg,TN_MSG_LEN,"TELNET RCVD ",TELCMD(c),NULL,NULL);
  4365.             debug(F101,tn_msg,"",c);
  4366.             if (tn_deb || debses) tn_debug(tn_msg);
  4367.         }
  4368. #endif /* DEBUG */
  4369.         switch (c) {                    /* What we would like to do here    */
  4370.           case TN_GA:                   /* Is substitute ASCII characters   */
  4371.             break;                      /* for the Telnet Command so that   */
  4372.           case TN_EL:                   /* the command may be processed by  */
  4373.             break;                      /* either the internal emulator or  */
  4374.           case TN_EC:                   /* by the superior process or shell */
  4375.             break;
  4376.           case TN_AYT:
  4377. #ifdef OS2
  4378.             RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  4379. #endif
  4380.             ttol((CHAR *)"[Yes]\015\012",7);
  4381. #ifdef OS2
  4382.             ReleaseTelnetMutex();
  4383. #endif
  4384.             break;
  4385.           case TN_AO:
  4386. #ifdef BETADEBUG
  4387.             bleep(BP_NOTE);
  4388. #endif /* BETADEBUG */
  4389.             break;
  4390.           case TN_IP:
  4391.             break;
  4392.           case BREAK:
  4393.             break;
  4394.           case TN_DM:
  4395.             break;
  4396.           case TN_NOP:
  4397.             break;
  4398.           case SE:
  4399.             break;
  4400.           case TN_EOR:
  4401.             break;
  4402.           case TN_ABORT:
  4403.             break;
  4404.           case TN_SUSP:
  4405.             break;
  4406.           case TN_EOF:
  4407.             break;
  4408.           case TN_SAK:
  4409.             break;
  4410.         }
  4411.         return(0);
  4412.     }
  4413.  
  4414. /* SB, WILL, WONT, DO, or DONT need more bytes... */
  4415.  
  4416.     if ((x = (*fn)(0)) < 0)             /* Get the option. */
  4417.       return(x);
  4418.     x &= 0xff;                          /* Trim to 8 bits. */
  4419.  
  4420.     if (seslog && sessft == XYFT_D) {   /* Session log */
  4421.         logchar((char) x);
  4422.     }
  4423. #ifdef DEBUG
  4424.     if ((deblog || tn_deb || debses) && c != SB) {
  4425.         ckmakmsg(tn_msg,TN_MSG_LEN,"TELNET RCVD ",TELCMD(c)," ",TELOPT(x));
  4426.         debug(F101,tn_msg,"",x);
  4427.         if (tn_deb || debses) tn_debug(tn_msg);
  4428.     }
  4429. #endif /* DEBUG */
  4430.     /* Now handle the command */
  4431.     switch (c) {
  4432.       case WILL:
  4433. #ifdef CK_SSL
  4434.         if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  4435.             return(0);
  4436. #endif /* CK_SSL */
  4437. #ifdef CK_FORWARD_X
  4438.           if (x == TELOPT_FORWARD_X) {
  4439.               if (!fwdx_server_avail() || !(fwdx_no_encrypt ||
  4440. #ifdef CK_SSL
  4441.                  (ssl_active_flag || tls_active_flag)
  4442. #else /* CK_SSL */
  4443.                  0
  4444. #endif /* CK_SSL */
  4445.                  ||
  4446. #ifdef CK_ENCRYPTION
  4447.                  (ck_tn_encrypting() && ck_tn_decrypting())
  4448. #else /* CK_ENCRYPTION */
  4449.                  0
  4450. #endif /* CK_ENCRYPTION */
  4451.                  )) {
  4452.                   TELOPT_U_MODE(TELOPT_FORWARD_X) = TN_NG_RF;
  4453.                   TELOPT_ME_MODE(TELOPT_FORWARD_X) = TN_NG_RF;
  4454.               }
  4455.           }
  4456. #endif /* CK_FORWARD_X */
  4457.         if (!TELOPT_OK(x) || TELOPT_U_MODE(x) == TN_NG_RF) {
  4458.             if (tn_sopt(DONT,x) < 0)
  4459.               return(-1);
  4460.             if (TELOPT_UNANSWERED_DO(x))
  4461.                 TELOPT_UNANSWERED_DO(x) = 0;
  4462.         } else if (!TELOPT_U(x)) {
  4463.             if (!TELOPT_UNANSWERED_DO(x)) {
  4464.                 if (tn_sopt(DO,x) < 0)
  4465.                   return -1;
  4466.             }
  4467.             if (TELOPT_UNANSWERED_DO(x))
  4468.                 TELOPT_UNANSWERED_DO(x) = 0;
  4469.             TELOPT_U(x) = 1;
  4470.  
  4471.             switch (x) {
  4472. #ifdef CK_SSL
  4473.               case TELOPT_START_TLS:
  4474.                 /*
  4475.                    If my proposal is accepted, at this point the Telnet
  4476.                    protocol is turned off and a TLS negotiation takes
  4477.                    place.
  4478.  
  4479.                    Start by sending SB START_TLS FOLLOWS  to signal
  4480.                    we are ready.  Wait for the peer to send the same
  4481.                    and then start the TLS negotiation.
  4482.  
  4483.                    If the TLS negotiation succeeds we call tn_ini()
  4484.                    again to reset the telnet state machine and restart
  4485.                    the negotiation process over the now secure link.
  4486.  
  4487.                    If the TLS negotiation fails, we call ttclos()
  4488.                    to terminate the connection.
  4489.  
  4490.                    Only the server should receive a WILL START_TLS
  4491.                  */
  4492.                 tn_ssbopt(TELOPT_START_TLS,1,NULL,0);
  4493.                 TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows = 1;
  4494.                 break;
  4495. #endif /* CK_SSL */
  4496.  
  4497. #ifdef CK_AUTHENTICATION
  4498.               case TELOPT_AUTHENTICATION: {
  4499.                   /* We now have to perform a SB SEND to identify the  */
  4500.                   /* supported authentication types to the other side. */
  4501.                   extern int authentication_version;
  4502.                   authentication_version = AUTHTYPE_AUTO;
  4503.                   ck_tn_auth_request();
  4504.                   break;
  4505.               }
  4506. #endif /* CK_AUTHENTICATION */
  4507. #ifdef CK_ENCRYPTION
  4508.               case TELOPT_ENCRYPTION:
  4509.                 if (!(TELOPT_ME(TELOPT_AUTHENTICATION) ||
  4510.                       TELOPT_U(TELOPT_AUTHENTICATION))
  4511.                     ) {
  4512.                     if (tn_sopt(DONT,x) < 0)
  4513.                       return(-1);
  4514.                     TELOPT_U(x) = 0;
  4515.                 } else {
  4516.                     if (ck_tn_auth_in_progress()) {
  4517.                         TELOPT_SB(TELOPT_ENCRYPTION).encrypt.need_to_send = 1;
  4518.                     } else {
  4519.                         /* Perform subnegotiation */
  4520.                         ck_encrypt_send_support();
  4521.                     }
  4522.                     if (!(TELOPT_ME(x) || TELOPT_UNANSWERED_WILL(x))
  4523.                         && TELOPT_ME_MODE(x) != TN_NG_RF) {
  4524.                         if (tn_sopt(WILL, x) < 0)
  4525.                           return(-1);
  4526.                         TELOPT_UNANSWERED_WILL(x) = 1;
  4527.                     }
  4528.                 }
  4529.                 break;
  4530. #endif /* CK_ENCRYPTION */
  4531. #ifdef IKS_OPTION
  4532.               case TELOPT_KERMIT:
  4533.                 if (!TELOPT_ME(x)) {
  4534.                     /* Tell the other side what Start of Packet Character */
  4535.                     tn_siks(KERMIT_SOP); /* SOP */
  4536.  
  4537.                     if (!TELOPT_UNANSWERED_WILL(x) &&
  4538.                         TELOPT_ME_MODE(x) != TN_NG_RF) {
  4539.                         if (tn_sopt(WILL, x) < 0)
  4540.                           return(-1);
  4541.                         TELOPT_UNANSWERED_WILL(x) = 1;
  4542.                     }
  4543.                 }
  4544.                 break;
  4545. #endif /* IKS_OPTION */
  4546.               case TELOPT_BINARY:
  4547.                 if (!TELOPT_ME(x)) {
  4548.                     if (!TELOPT_UNANSWERED_WILL(x) &&
  4549.                         TELOPT_ME_MODE(x) >= TN_NG_RQ) {
  4550.                         if (tn_sopt(WILL, x) < 0)
  4551.                           return(-1);
  4552.                         TELOPT_UNANSWERED_WILL(x) = 1;
  4553.                     }
  4554.                 }
  4555.                 break;
  4556.               case TELOPT_ECHO:
  4557.                 if (echo) {
  4558.                     if (TELOPT_UNANSWERED_DO(x))
  4559.                       TELOPT_UNANSWERED_DO(x) = 0;
  4560.                     return(2);
  4561.                 }
  4562.                 break;
  4563.               case TELOPT_TTYPE:
  4564.                 /* SB TTYPE SEND */
  4565.                 tn_ssbopt(TELOPT_TTYPE,TELQUAL_SEND,NULL,0);
  4566.                 TELOPT_UNANSWERED_SB(TELOPT_TTYPE)=1;
  4567.                 break;
  4568. #ifdef CK_ENVIRONMENT
  4569.               case TELOPT_NEWENVIRON:   /* SB NEW-ENVIRON SEND */
  4570.                 {
  4571.                   char request[6];      /* request it */
  4572.                   sprintf(request,"%cUSER",TEL_ENV_VAR);        /* safe */
  4573.                   tn_ssbopt(TELOPT_NEWENVIRON,TELQUAL_SEND,request,
  4574.                             strlen(request));
  4575.                   TELOPT_UNANSWERED_SB(TELOPT_NEWENVIRON)=1;
  4576.                 }
  4577.                 break;
  4578. #endif /* CK_ENVIRONMENT */
  4579.             } /* switch */
  4580.         } else {
  4581.             if (TELOPT_UNANSWERED_DO(x))
  4582.                 TELOPT_UNANSWERED_DO(x) = 0;
  4583.         }
  4584.         break;
  4585.       case WONT:
  4586. #ifdef CK_SSL
  4587.         if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  4588.             return(0);
  4589. #endif /* CK_SSL */
  4590.         if (TELOPT_U(x) || TELOPT_UNANSWERED_DO(x)) {
  4591.             /* David Borman says we should not respond DONT when
  4592.              * the WONT is a response to a DO that we sent.
  4593.              * Nor should we send one if the state is already WONT
  4594.              * such as when we do not recognize the option since
  4595.              * options are initialized in the WONT/DONT state.
  4596.              */
  4597.             if (!(TELOPT_UNANSWERED_DO(x) || TELOPT_UNANSWERED_DONT(x)))
  4598.               if (tn_sopt(DONT,x) < 0)
  4599.                 return(-1);
  4600.             if (TELOPT_UNANSWERED_DONT(x))
  4601.                 TELOPT_UNANSWERED_DONT(x) = 0;
  4602.             if (TELOPT_UNANSWERED_DO(x))
  4603.                 TELOPT_UNANSWERED_DO(x) = 0;
  4604.             if (TELOPT_U(x)) {
  4605.                 TELOPT_U(x) = 0;
  4606.             }
  4607.             switch(x) {
  4608. #ifdef CK_SSL
  4609.             case TELOPT_START_TLS:
  4610.                 if (sstelnet && TELOPT_U_MODE(x) == TN_NG_MU) {
  4611.                     printf("Telnet Start-TLS refused.\n");
  4612.                     ttclos(0);
  4613.                     whyclosed = WC_TELOPT;
  4614.                     return(-3);
  4615.                 }
  4616.                 break;
  4617. #endif /* CK_SSL */
  4618. #ifdef CK_AUTHENTICATION
  4619.               case TELOPT_AUTHENTICATION:
  4620.                 if (sstelnet && TELOPT_U_MODE(x) == TN_NG_MU) {
  4621.                     printf("Telnet authentication refused.\n");
  4622.                     ttclos(0);
  4623.                     whyclosed = WC_TELOPT;
  4624.                     return(-3);
  4625.                 } else if (TELOPT_U_MODE(x) == TN_NG_RQ) {
  4626.                     TELOPT_U_MODE(x) = TN_NG_AC;
  4627.                 }
  4628.                 if (ck_tn_auth_in_progress())
  4629.                   printf("Telnet authentication refused.\n");
  4630. #ifdef CK_ENCRYPTION
  4631.                 if (sstelnet) {
  4632.                     if (tn_no_encrypt()<0)
  4633.                         return(-1);
  4634.                 }
  4635. #endif /* CK_ENCRYPTION */
  4636.                 break;
  4637. #endif /* CK_AUTHENTICATION */
  4638. #ifdef CK_ENCRYPTION
  4639.               case TELOPT_ENCRYPTION:
  4640.                 ck_tn_enc_stop();
  4641.                 break;
  4642. #endif /* CK_ENCRYPTION */
  4643. #ifdef IKS_OPTION
  4644.               case TELOPT_KERMIT:
  4645.                 TELOPT_SB(x).kermit.u_start = 0;
  4646.                 TELOPT_SB(x).kermit.me_req_start = 0;
  4647.                 TELOPT_SB(x).kermit.me_req_stop = 0;
  4648.                 break;
  4649. #endif /* IKS_OPTION */
  4650.               case TELOPT_NAWS: {
  4651.                   /* The client does not support NAWS. */
  4652.                   /* Assume a height of 24 and a width of 80 */
  4653.                   if (sstelnet
  4654. #ifdef IKSD
  4655.                    || inserver
  4656. #endif /* IKSD */
  4657.                    ) {
  4658.                       int w = 80, h = 24;
  4659. #ifndef NOLOCAL
  4660.                       if (tcp_incoming) {
  4661. #ifdef OS2
  4662.                           tt_cols[VTERM] = w;
  4663.                           tt_rows[VTERM] = h;
  4664.                           VscrnSetWidth(VTERM, w);
  4665.                           VscrnSetHeight(VTERM, h+(tt_status[VTERM]?1:0));
  4666. #else /* OS2 */
  4667.                           tt_cols = w;
  4668.                           tt_rows = h;
  4669. #endif /* OS2 */
  4670.                       } else {
  4671. #ifdef OS2
  4672.                           tt_cols[VCMD] = w;
  4673.                           tt_rows[VCMD] = h;
  4674.                           VscrnSetWidth(VCMD, w);
  4675.                           VscrnSetHeight(VCMD, h);
  4676. #endif /* OS2 */
  4677.                           cmd_cols = w;
  4678.                           cmd_rows = h;
  4679.                       }
  4680. #else /* NOLOCAL */
  4681.                       cmd_cols = w;
  4682.                       cmd_rows = h;
  4683. #endif /* NOLOCAL */
  4684.                       /* Add LINES and COLUMNS to the environment */
  4685.                       ckmakmsg((char *)rows_buf,16,"LINES=",ckitoa(h),
  4686.                                 NULL,NULL);
  4687.                       ckmakmsg((char *)cols_buf,16,"COLUMNS=",ckitoa(w),
  4688.                                 NULL,NULL);
  4689. #ifdef OS2ORUNIX
  4690. #ifndef NOPUTENV
  4691.                       putenv(rows_buf);
  4692.                       putenv(cols_buf);
  4693. #endif /* NOPUTENV */
  4694. #endif /* OS2ORUNIX */
  4695.                   }
  4696.                   break;
  4697.               }
  4698.               case TELOPT_ECHO:
  4699.                 if (!echo) {
  4700.                     if (TELOPT_UNANSWERED_DO(x))
  4701.                       TELOPT_UNANSWERED_DO(x) = 0;
  4702.                     return(1);
  4703.                 }
  4704.                 break;
  4705.             }
  4706.         } else {
  4707.             if (TELOPT_UNANSWERED_DONT(x))
  4708.                 TELOPT_UNANSWERED_DONT(x) = 0;
  4709.             if (TELOPT_UNANSWERED_DO(x))
  4710.                 TELOPT_UNANSWERED_DO(x) = 0;
  4711.         }
  4712.         if (TELOPT_U_MODE(x) == TN_NG_MU) {
  4713.             ckmakmsg( tn_msg,TN_MSG_LEN,
  4714.                       "Peer refuses TELNET DO ",TELOPT(x),
  4715.                       " negotiations - terminating connection",NULL
  4716.                     );
  4717.             debug(F100,tn_msg,"",0);
  4718.             if (tn_deb || debses) tn_debug(tn_msg);
  4719.             printf("%s\n",tn_msg);
  4720.             ttclos(0);
  4721.             whyclosed = WC_TELOPT;
  4722.             return(-3);
  4723.         }
  4724. #ifdef COMMENT
  4725.         if (x == TELOPT_ECHO && !echo) /* Special handling for echo */
  4726.           return(1);                   /* because we allow 'duplex' */
  4727. #endif /* COMMENT */
  4728.         break;
  4729.  
  4730.       case DO:
  4731. #ifdef CK_SSL
  4732.         if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  4733.             return(0);
  4734. #endif /* CK_SSL */
  4735.         if (!TELOPT_OK(x) || TELOPT_ME_MODE(x) == TN_NG_RF) {
  4736.             if (tn_sopt(WONT,x) < 0)
  4737.               return(-1);
  4738.             if (TELOPT_UNANSWERED_WILL(x))
  4739.                 TELOPT_UNANSWERED_WILL(x) = 0;
  4740.         } else if (!TELOPT_ME(x)) {
  4741.             if (!TELOPT_UNANSWERED_WILL(x)) {
  4742.                 if (tn_sopt(WILL,x) < 0)
  4743.                   return(-1);
  4744.             }
  4745.             if (TELOPT_UNANSWERED_WILL(x))
  4746.                 TELOPT_UNANSWERED_WILL(x) = 0;
  4747.             TELOPT_ME(x) = 1;
  4748.  
  4749.             switch (x) {
  4750. #ifdef CK_SSL
  4751.               case TELOPT_START_TLS:
  4752.                 /*
  4753.                    If my proposal is accepted at this point the Telnet
  4754.                    protocol is turned off and a TLS negotiation takes
  4755.                    place.
  4756.  
  4757.                    Start by sending SB START_TLS FOLLOWS  to signal
  4758.                    we are ready.  Wait for the peer to send the same
  4759.                    and then start the TLS negotiation.
  4760.  
  4761.                    If the TLS negotiation succeeds we call tn_ini()
  4762.                    again to reset the telnet state machine and restart
  4763.                    the negotiation process over the now secure link.
  4764.  
  4765.                    If the TLS negotiation fails, we call ttclos()
  4766.                    to terminate the connection.  Then we set the
  4767.                    U_MODE and ME_MODE for TELOPT_START_TLS to REFUSE
  4768.                    and then call ttopen() to create a new connection
  4769.                    to the same host but this time do not attempt
  4770.                    TLS security.
  4771.  
  4772.                    Only the client should receive DO START_TLS.
  4773.                 */
  4774.                 tn_ssbopt(TELOPT_START_TLS,1,NULL,0);
  4775.                 TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows = 1;
  4776.                 break;
  4777. #endif /* CK_SSL */
  4778.  
  4779. #ifdef CK_AUTHENTICATION
  4780.               case TELOPT_AUTHENTICATION: {
  4781.                   /* We don't know what authentication we are using yet */
  4782.                   /* but it is not NULL until a failure is detected so */
  4783.                   /* use AUTO in the meantime. */
  4784.                   extern int authentication_version;
  4785.                   authentication_version = AUTHTYPE_AUTO;
  4786.                   break;
  4787.               }
  4788. #endif /* CK_AUTHENTICATION */
  4789. #ifdef CK_ENCRYPTION
  4790.               case TELOPT_ENCRYPTION:
  4791.                 if (!(TELOPT_ME(TELOPT_AUTHENTICATION) ||
  4792.                       TELOPT_U(TELOPT_AUTHENTICATION))
  4793.                     ) {
  4794.                     if (tn_sopt(WONT,x) < 0)
  4795.                       return(-1);
  4796.                     TELOPT_ME(x) = 0;
  4797.                 } else {
  4798.                     if (!(TELOPT_U(x) || TELOPT_UNANSWERED_DO(x))
  4799.                         && TELOPT_U_MODE(x) != TN_NG_RF) {
  4800.                         if (tn_sopt(DO, x) < 0)
  4801.                           return(-1);
  4802.                         TELOPT_UNANSWERED_DO(x) = 1;
  4803.                     }
  4804.                 }
  4805.                 break;
  4806. #endif /* CK_ENCRYPTION */
  4807. #ifdef IKS_OPTION
  4808.               case TELOPT_KERMIT:
  4809. /* If currently processing Kermit server packets, must tell the other side */
  4810.  
  4811.                 debug(F111,"tn_doop","what",what);
  4812.                 debug(F111,"tn_doop","server",server);
  4813. #ifdef CK_AUTODL
  4814.                 debug(F111,"tn_doop","autodl",autodl);
  4815.                 debug(F111,"tn_doop","inautodl",inautodl);
  4816.                 debug(F111,"tn_doop","cmdadl",cmdadl);
  4817. #endif /* CK_AUTODL */
  4818.  
  4819.                 if (server
  4820. #ifdef CK_AUTODL
  4821.                     || (local && ((what == W_CONNECT && autodl) ||
  4822.                                   (what != W_CONNECT && inautodl)))
  4823.                     || (!local && cmdadl)
  4824. #endif /* CK_AUTODL */
  4825.                     ) {
  4826.                     tn_siks(KERMIT_START);      /* START */
  4827.                 }
  4828.                 if (!TELOPT_U(x)) {
  4829.                     /* Tell the other side what Start of Packet Character */
  4830.                     tn_siks(KERMIT_SOP);             /* SOP */
  4831.                     if (!TELOPT_UNANSWERED_DO(x) &&
  4832.                         TELOPT_U_MODE(x) != TN_NG_RF) {
  4833.                         if (tn_sopt(DO, x) < 0)
  4834.                           return(-1);
  4835.                         TELOPT_UNANSWERED_DO(x) = 1;
  4836.                     }
  4837.                 }
  4838.                 break;
  4839. #endif /* IKS_OPTION */
  4840.  
  4841.               case TELOPT_BINARY:
  4842.                 if (!TELOPT_U(x)) {
  4843.                     if (!TELOPT_UNANSWERED_DO(x) &&
  4844.                         TELOPT_U_MODE(x) >= TN_NG_RQ) {
  4845.                         if (tn_sopt(DO, x) < 0)
  4846.                           return(-1);
  4847.                         TELOPT_UNANSWERED_DO(x) = 1;
  4848.                     }
  4849.                 }
  4850.                 break;
  4851.               case TELOPT_NAWS:
  4852. #ifdef CK_NAWS
  4853. #ifndef NOSIGWINCH
  4854. #ifdef SIGWINCH
  4855. #ifdef UNIX
  4856.                 if (sw_armed++ < 1) {   /* Catch window-size changes. */
  4857.                     debug(F100,"tn_doop arming SIGWINCH","",0);
  4858.                     signal(SIGWINCH,winchh);
  4859.                 }
  4860. #else
  4861.                 debug(F100,"SIGWINCH defined but not used","",0);
  4862. #endif /* UNIX */
  4863. #else  /* SIGWINCH */
  4864.                 debug(F100,"SIGWINCH not defined","",0);
  4865. #endif /* SIGWINCH */
  4866. #else  /* NOSIGWINCH */
  4867.                 debug(F100,"NOSIGWINCH defined","",0);
  4868. #endif /* NOSIGWINCH */
  4869.                 if ( !tn_delay_sb || !tn_outst(0) || tn_init ) {
  4870.                     if (tn_snaws() < 0)
  4871.                         return(-1);
  4872.                 } else {
  4873.                     TELOPT_SB(TELOPT_NAWS).naws.need_to_send = 1;
  4874.                 }
  4875. #endif /* CK_NAWS */
  4876.                 break;
  4877.               case TELOPT_LOGOUT:
  4878.                 ttclos(0);              /* And then hangup */
  4879.                 whyclosed = WC_TELOPT;
  4880. #ifdef IKSD
  4881.                 if (inserver
  4882. #ifndef NOLOCAL
  4883.                     && !local
  4884. #endif /* NOLOCAL */
  4885.                     )
  4886.                   doexit(GOOD_EXIT,0);
  4887. #endif /* IKSD */
  4888.                 if (TELOPT_UNANSWERED_WILL(x))
  4889.                   TELOPT_UNANSWERED_WILL(x) = 0;
  4890.                 return(6);
  4891. #ifdef CK_SNDLOC
  4892.                case TELOPT_SNDLOC:
  4893.                   if ( !tn_delay_sb || !tn_outst(0) || tn_init ) {
  4894.                       if (tn_sndloc() < 0)
  4895.                           return(-1);
  4896.                   } else {
  4897.                       TELOPT_SB(TELOPT_SNDLOC).sndloc.need_to_send = 1;
  4898.                   }
  4899.                   break;
  4900. #endif /* CK_SNDLOC */
  4901. #ifdef CK_FORWARD_X
  4902.                case TELOPT_FORWARD_X:
  4903.                   if ( !tn_delay_sb || !tn_outst(0) || tn_init ) {
  4904.                       if (fwdx_send_options() < 0) {
  4905.                           if (tn_sopt(DONT,x) < 0)
  4906.                               return(-1);
  4907.                           TELOPT_UNANSWERED_DONT(x) = 1;
  4908.                       }
  4909.                   } else {
  4910.                       TELOPT_SB(TELOPT_FORWARD_X).forward_x.need_to_send = 1;
  4911.                   }
  4912.                   break;
  4913. #endif /* CK_FORWARD_X */
  4914. #ifdef TN_COMPORT
  4915.               case TELOPT_COMPORT: {
  4916.                 extern int reliable;
  4917.                 if (!tn_delay_sb || !tn_outst(0) || tn_init) {
  4918.                     if (tn_sndcomport() < 0)
  4919.                       return(-1);
  4920.                 } else {
  4921.                     TELOPT_SB(TELOPT_COMPORT).comport.need_to_send = 1;
  4922.                 }
  4923.                 /* Telnet -> Serial -> ??? is not a reliable connection. */
  4924.                 reliable = SET_OFF;
  4925.                 break;
  4926.               }
  4927. #endif /* TN_COMPORT */
  4928.             } /* switch */
  4929.         } else {
  4930.           if (TELOPT_UNANSWERED_WILL(x))
  4931.             TELOPT_UNANSWERED_WILL(x) = 0;
  4932.         }
  4933.         break;
  4934.  
  4935.       case DONT:
  4936. #ifdef CK_SSL
  4937.         if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows)
  4938.             return(0);
  4939. #endif /* CK_SSL */
  4940.         if (TELOPT_ME(x) || TELOPT_UNANSWERED_WILL(x)) {
  4941.             /* David Borman says we should not respond WONT when
  4942.              * the DONT is a response to a WILL that we sent.
  4943.              * Nor should we send one if the state is already WONT
  4944.              * such as when we do not recognize the option since
  4945.              * options are initialized in the WONT/DONT state.
  4946.              */
  4947.             if (!(TELOPT_UNANSWERED_WILL(x) || TELOPT_UNANSWERED_WONT(x)))
  4948.               if (tn_sopt(WONT,x) < 0)
  4949.                 return(-1);
  4950.  
  4951.             if (TELOPT_UNANSWERED_WILL(x))
  4952.                 TELOPT_UNANSWERED_WILL(x) = 0;
  4953.             if (TELOPT_UNANSWERED_WONT(x))
  4954.                 TELOPT_UNANSWERED_WONT(x) = 0;
  4955.             if (TELOPT_ME(x))
  4956.               TELOPT_ME(x) = 0;
  4957.  
  4958.             switch (x) {
  4959. #ifdef CK_SSL
  4960.             case TELOPT_START_TLS:
  4961.                 if (!sstelnet && TELOPT_ME_MODE(x) == TN_NG_MU) {
  4962.                     printf("Telnet Start-TLS refused.\n");
  4963.                     ttclos(0);
  4964.                     whyclosed = WC_TELOPT;
  4965.                     return(-3);
  4966.                 }
  4967.                 break;
  4968. #endif /* CK_SSL */
  4969. #ifdef CK_AUTHENTICATION
  4970.               case TELOPT_AUTHENTICATION:
  4971.                 if (!sstelnet && TELOPT_ME_MODE(x) == TN_NG_MU) {
  4972. #ifdef CK_SSL
  4973.                     if (tls_active_flag) {
  4974.                         TELOPT_ME_MODE(x) = TN_NG_AC;
  4975.                         break;
  4976.                     } else
  4977. #endif /* CK_SSL */
  4978.                     {
  4979.                         printf("Telnet authentication refused.\n");
  4980.                         ttclos(0);
  4981.                         whyclosed = WC_TELOPT;
  4982.                         return(-3);
  4983.                     }
  4984.                 } else if (TELOPT_ME_MODE(x) == TN_NG_RQ) {
  4985.                     TELOPT_ME_MODE(x) = TN_NG_AC;
  4986.                 }
  4987.                 if (ck_tn_auth_in_progress())
  4988.                   printf("Telnet authentication refused.\n");
  4989. #ifdef CK_ENCRYPTION
  4990.                 if (!sstelnet) {
  4991.                     if (tn_no_encrypt()<0)
  4992.                         return(-1);
  4993.                 }
  4994. #endif /* CK_ENCRYPTION */
  4995.                 break;
  4996. #endif /* CK_AUTHENTICATION */
  4997.               case TELOPT_ENCRYPTION:
  4998. #ifdef CK_ENCRYPTION
  4999.                 ck_tn_enc_stop();
  5000. #endif /* CK_ENCRYPTION */
  5001.                 break;
  5002.               case TELOPT_KERMIT:
  5003. #ifdef IKS_OPTION
  5004.                 TELOPT_SB(x).kermit.me_start = 0;
  5005. #endif /* IKS_OPTION */
  5006.                 break;
  5007.               default:
  5008.                 break;
  5009.             } /* switch */
  5010.         } else {
  5011.           if (TELOPT_UNANSWERED_WILL(x))
  5012.               TELOPT_UNANSWERED_WILL(x) = 0;
  5013.           if (TELOPT_UNANSWERED_WONT(x))
  5014.               TELOPT_UNANSWERED_WONT(x) = 0;
  5015.         }
  5016.         if (TELOPT_ME_MODE(x) == TN_NG_MU) {
  5017.             ckmakmsg( tn_msg,TN_MSG_LEN,
  5018.                       "Peer refuses TELNET WILL ",TELOPT(x),
  5019.                       " negotiations - terminating connection",
  5020.                       NULL
  5021.                       );
  5022.             debug(F100,tn_msg,"",0);
  5023.             if (tn_deb || debses) tn_debug(tn_msg);
  5024.             printf("%s\n",tn_msg);
  5025.             ttclos(0);
  5026.             whyclosed = WC_TELOPT;
  5027.             return(-3);
  5028.         }
  5029.         break;
  5030.       case SB:
  5031.         if ((y = tn_sb(x,&n,fn)) <= 0)
  5032.           return(y);
  5033.  
  5034. #ifdef CK_SSL
  5035.         /* Do not process subnegotiations other than START_TLS after we */
  5036.         /* have agreed to begin the TLS negotiation sequence.           */
  5037.         if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows &&
  5038.              x != TELOPT_START_TLS)
  5039.             break;
  5040. #endif /* CK_SSL */
  5041.  
  5042.         if (!TELOPT_OK(x)) {
  5043.             hexdump("unknown telnet subnegotiation",sb,n);
  5044.             break;
  5045.         } else if ( !(TELOPT_ME(x) || TELOPT_U(x)) ) {
  5046.             hexdump("telnet option not negotiated",sb,n);
  5047.             if (!tn_sb_bug)
  5048.                 break;
  5049.             if (TELOPT_UNANSWERED_WILL(x)) {
  5050.                 TELOPT_UNANSWERED_WILL(x) = 0;
  5051.                 TELOPT_U(x) = 1;
  5052.                 ckmakmsg(tn_msg,TN_MSG_LEN,
  5053.                          "TELNET DO ",TELOPT(x),
  5054.                          "(implied by receipt of SB - protocol error ignored)",
  5055.                          NULL
  5056.                          );
  5057.                 debug(F100,tn_msg,"",0);
  5058.                 if (tn_deb || debses) tn_debug(tn_msg);
  5059.             }
  5060.             if (TELOPT_UNANSWERED_DO(x)) {
  5061.                 TELOPT_UNANSWERED_DO(x) = 0;
  5062.                 TELOPT_ME(x) = 1;
  5063.                 ckmakmsg(tn_msg,TN_MSG_LEN,"TELNET WILL ",TELOPT(x),
  5064.                         " (implied by receipt of SB - protocol error ignored)",
  5065.                         NULL);
  5066.                 debug(F100,tn_msg,"",0);
  5067.                 if (tn_deb || debses) tn_debug(tn_msg);
  5068.              }
  5069.         }
  5070.  
  5071.         TELOPT_UNANSWERED_SB(x)=0;
  5072.         switch (x) {
  5073. #ifdef CK_FORWARD_X
  5074.           case TELOPT_FORWARD_X:
  5075.             return(fwdx_tn_sb(sb, n));
  5076. #endif /* CK_FORWARD_X */
  5077. #ifdef CK_SSL
  5078.           case TELOPT_START_TLS: {
  5079.               /*
  5080.                  the other side is saying SB START_TLS FOLLOWS
  5081.                  the incoming channel is now ready for starting the
  5082.                  TLS negotiation.
  5083.                  */
  5084.               int def_tls_u_mode, def_tls_me_mode;
  5085.               int def_enc_u_mode, def_enc_me_mode;
  5086.               int rc = 0;
  5087.  
  5088.                           if (sb[0] != 1) {
  5089.                                   break;
  5090.                           }
  5091.  
  5092.               TELOPT_SB(TELOPT_START_TLS).start_tls.u_follows = 1;
  5093.               /* Preserve the default modes and make sure we will */
  5094.               /* refuse START_TLS when we retry. */
  5095.               if (sstelnet) {
  5096.                   def_tls_u_mode = TELOPT_DEF_S_U_MODE(TELOPT_START_TLS);
  5097.                   def_tls_me_mode = TELOPT_DEF_S_ME_MODE(TELOPT_START_TLS);
  5098.                   TELOPT_DEF_S_U_MODE(TELOPT_START_TLS) = TN_NG_RF;
  5099.                   TELOPT_DEF_S_ME_MODE(TELOPT_START_TLS)= TN_NG_RF;
  5100. #ifdef CK_ENCRYPTION
  5101.                   def_enc_u_mode = TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION);
  5102.                   def_enc_me_mode = TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION);
  5103.                   TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  5104.                   TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION)= TN_NG_RF;
  5105. #endif /* CK_ENCRYPTION */
  5106.               } else {
  5107.                   def_tls_u_mode = TELOPT_DEF_C_U_MODE(TELOPT_START_TLS);
  5108.                   def_tls_me_mode = TELOPT_DEF_C_ME_MODE(TELOPT_START_TLS);
  5109.                   TELOPT_DEF_C_U_MODE(TELOPT_START_TLS) = TN_NG_RF;
  5110.                   TELOPT_DEF_C_ME_MODE(TELOPT_START_TLS)= TN_NG_RF;
  5111. #ifdef CK_ENCRYPTION
  5112.                   def_enc_u_mode = TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION);
  5113.                   def_enc_me_mode = TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION);
  5114.                   TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  5115.                   TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION)= TN_NG_RF;
  5116. #endif /* CK_ENCRYPTION */
  5117.               }
  5118.               /* Negotiate TLS */
  5119.               ttnproto = NP_TLS;
  5120.               tn_init = 0;
  5121.               tn_begun = 0;
  5122.               if (ck_tn_tls_negotiate()<0) {
  5123.                   /* we failed.  disconnect and if we are the client */
  5124.                   /* then reconnect and try without START_TLS.       */
  5125.                   extern char * line;
  5126.                   int x = -1;
  5127.                   extern int mdmtyp;
  5128.  
  5129.                   if (sstelnet) {
  5130.                       printf("TLS failed:  Disconnecting.\n");
  5131.                       TELOPT_DEF_S_U_MODE(TELOPT_START_TLS)  = def_tls_u_mode;
  5132.                       TELOPT_DEF_S_ME_MODE(TELOPT_START_TLS) = def_tls_me_mode;
  5133. #ifdef CK_ENCRYPTION
  5134.                      TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION)  = def_enc_u_mode;
  5135.                      TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) = def_enc_me_mode;
  5136. #endif /* CK_ENCRYPTION */
  5137.                       ttclos(0);
  5138.                       whyclosed = WC_TELOPT;
  5139.                       ttnproto = NP_TELNET;
  5140.                       rc = -3;
  5141.                   } else {
  5142. #ifndef NOLOCAL
  5143.                       extern tls_norestore;
  5144. #endif /* NOLOCAL */
  5145.                       printf("TLS failed:  Disconnecting...\n");
  5146. #ifdef CK_ENCRYPTION
  5147.                      TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION)  = def_enc_u_mode;
  5148.                      TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) = def_enc_me_mode;
  5149. #endif /* CK_ENCRYPTION */
  5150.                       /* if START_TLS is not REQUIRED, then retry without it */
  5151.                       if ( def_tls_me_mode != TN_NG_MU ) {
  5152. #ifndef NOLOCAL
  5153.                           tls_norestore = 1;
  5154. #endif /* NOLOCAL */
  5155.                           ttclos(0);
  5156.                           whyclosed = WC_TELOPT;
  5157. #ifndef NOLOCAL
  5158.                           tls_norestore = 0;
  5159. #endif /* NOLOCAL */
  5160.                           ttnproto = NP_TELNET;
  5161.                           printf("Reconnecting without TLS.\n");
  5162.                           sleep(2);
  5163.                           if (ttopen(line,&x,mdmtyp,0)<0)
  5164.                               rc = -3;
  5165.                       } else {
  5166.                           TELOPT_DEF_C_U_MODE(TELOPT_START_TLS) =
  5167.                             def_tls_u_mode;
  5168.                           TELOPT_DEF_C_ME_MODE(TELOPT_START_TLS) =
  5169.                             def_tls_me_mode;
  5170.                           ttclos(0);
  5171.                           whyclosed = WC_TELOPT;
  5172.                           ttnproto = NP_TELNET;
  5173.                           rc = -3;
  5174.                       }
  5175.                   }
  5176.               } else {
  5177. #ifdef CK_AUTHENTICATION
  5178.                   /* we succeeded.  restart telnet negotiations from */
  5179.                   /* the beginning.  However, if we have received a  */
  5180.                   /* client certificate and we are a server, then do */
  5181.                   /* not offer TELOPT_AUTH.                          */
  5182.                   if ( ck_tn_auth_valid() == AUTH_VALID ) {
  5183.                       TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_AC;
  5184.                       TELOPT_DEF_S_ME_MODE(TELOPT_AUTHENTICATION)= TN_NG_AC;
  5185.                   }
  5186. #endif /* CK_AUTHENTICATION */
  5187.                   ttnproto = NP_TELNET;
  5188.                   if (tn_ini() < 0)
  5189.                     if (ttchk() < 0)
  5190.                       rc = -1;
  5191.               }
  5192.               /* Restore the default modes */
  5193.               if (sstelnet) {
  5194.                   TELOPT_DEF_S_U_MODE(TELOPT_START_TLS)  = def_tls_u_mode;
  5195.                   TELOPT_DEF_S_ME_MODE(TELOPT_START_TLS) = def_tls_me_mode;
  5196. #ifdef CK_ENCRYPTION
  5197.                   TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION)  = def_enc_u_mode;
  5198.                   TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) = def_enc_me_mode;
  5199. #endif /* CK_ENCRYPTION */
  5200.               } else {
  5201.                   TELOPT_DEF_C_U_MODE(TELOPT_START_TLS)  = def_tls_u_mode;
  5202.                   TELOPT_DEF_C_ME_MODE(TELOPT_START_TLS) = def_tls_me_mode;
  5203. #ifdef CK_ENCRYPTION
  5204.                   TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION)  = def_enc_u_mode;
  5205.                   TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) = def_enc_me_mode;
  5206. #endif /* CK_ENCRYPTION */
  5207.               }
  5208.               return(rc);
  5209.           }
  5210. #endif /* CK_SSL */
  5211. #ifdef CK_AUTHENTICATION
  5212.           case TELOPT_AUTHENTICATION:
  5213.             if (ck_tn_sb_auth(sb,n) < 0) {
  5214.                 if (sstelnet && TELOPT_U_MODE(x) == TN_NG_MU) {
  5215.                     ttclos(0);
  5216.                     whyclosed = WC_TELOPT;
  5217.                     return(-3);
  5218.                 } else if (!sstelnet && TELOPT_ME_MODE(x) == TN_NG_MU) {
  5219.                     ttclos(0);
  5220.                     whyclosed = WC_TELOPT;
  5221.                     return(-3);
  5222.                 } else {
  5223.                     if (TELOPT_ME_MODE(x) == TN_NG_RQ)
  5224.                       TELOPT_ME_MODE(x) = TN_NG_AC;
  5225.                     if (TELOPT_U_MODE(x) == TN_NG_RQ)
  5226.                       TELOPT_U_MODE(x) = TN_NG_AC;
  5227.                 }
  5228.                 if (TELOPT_ME(x)) {
  5229.                     TELOPT_ME(x) = 0;
  5230.                     if (tn_sopt(WONT,x) < 0)
  5231.                       return(-1);
  5232.                 }
  5233.                 if (TELOPT_U(x)) {
  5234.                     TELOPT_U(x) = 0;
  5235.                     if (tn_sopt(DONT,x) < 0)
  5236.                       return(-1);
  5237.                 }
  5238. #ifdef CK_ENCRYPTION
  5239.                 if (tn_no_encrypt()<0)
  5240.                     return(-1);
  5241. #endif /* CK_ENCRYPTION */
  5242.             } else {
  5243. #ifdef CK_ENCRYPTION
  5244.                 if (!ck_tn_auth_in_progress()) { /* we are finished */
  5245.                     if (ck_tn_authenticated() == AUTHTYPE_SSL) {
  5246.                         /* TLS was successful.  Disable ENCRYPTION */
  5247.                         TELOPT_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  5248.                         TELOPT_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  5249.                     }
  5250.                     if (TELOPT_SB(TELOPT_ENCRYPTION).encrypt.need_to_send) {
  5251.                         ck_encrypt_send_support();
  5252.                         TELOPT_SB(TELOPT_ENCRYPTION).encrypt.need_to_send = 0;
  5253.                     }
  5254.                 }
  5255. #endif /* CK_ENCRYPTION */
  5256.             }
  5257.             break;
  5258. #endif /* CK_AUTHENTICATION */
  5259. #ifdef CK_ENCRYPTION
  5260.           case TELOPT_ENCRYPTION:
  5261.             if (ck_tn_sb_encrypt(sb, n) < 0) {
  5262.                 if (TELOPT_U_MODE(x) == TN_NG_MU ||
  5263.                     TELOPT_ME_MODE(x) == TN_NG_MU)
  5264.                   {
  5265.                       ttclos(0);
  5266.                       whyclosed = WC_TELOPT;
  5267.                       return(-3);
  5268.                 } else {
  5269.                     if (TELOPT_ME_MODE(x) == TN_NG_RQ)
  5270.                       TELOPT_ME_MODE(x) = TN_NG_AC;
  5271.                     if (TELOPT_U_MODE(x) == TN_NG_RQ)
  5272.                       TELOPT_U_MODE(x) = TN_NG_AC;
  5273.                 }
  5274.                 if (TELOPT_ME(x)) {
  5275.                     TELOPT_ME(x) = 0;
  5276.                     if (tn_sopt(WONT,x) < 0)
  5277.                       return(-1);
  5278.                 }
  5279.                 if (TELOPT_U(x)) {
  5280.                     TELOPT_U(x) = 0;
  5281.                     if (tn_sopt(DONT,x) < 0)
  5282.                       return(-1);
  5283.                 }
  5284.             }
  5285.             break;
  5286. #endif /* CK_ENCRYPTION */
  5287. #ifdef IKS_OPTION
  5288.           case TELOPT_KERMIT:
  5289.             return(iks_tn_sb(sb, n-2));
  5290. #endif /* IKS_OPTION */
  5291. #ifdef TN_COMPORT
  5292.           case TELOPT_COMPORT:
  5293.             return(tnc_tn_sb(sb, n-2));
  5294. #endif /* TN_COMPORT */
  5295.           case TELOPT_TTYPE:
  5296.             switch (sb[0]) {
  5297.               case TELQUAL_SEND:        /* SEND terminal type? */
  5298.                 if ( !tn_delay_sb || !tn_outst(0) || tn_init ) {
  5299.                     if (tn_sttyp() < 0) /* Yes, so send it. */
  5300.                         return(-1);
  5301.                 } else {
  5302.                     TELOPT_SB(TELOPT_TTYPE).term.need_to_send = 1;
  5303.                 }
  5304.                 break;
  5305.               case TELQUAL_IS: {        /* IS terminal type? */
  5306.                   /* IS terminal type -- remote gave us its current type */
  5307.                   int i = 0;
  5308. #ifndef OS2
  5309.                   CHAR oldterm[64], *p;
  5310. #endif /* OS2 */
  5311.                   /* Isolate the specified terminal type string */
  5312.                   while (sb[i++] != IAC) {
  5313.                       if (i == 40 ||    /* max len of term string - RFC */
  5314.                           sb[i] == IAC) {
  5315.                           sb[i] = '\0';
  5316.                           break;
  5317.                       }
  5318.                   }
  5319. #ifdef OS2
  5320. #ifndef NOTERM
  5321.                   strupr(&(sb[1]));     /* Upper case it */
  5322.                   for (i = 0; i <= max_tt; i++) { /* find it in our list */
  5323.                       if (!strcmp(&(sb[1]),tt_info[i].x_name)
  5324.                           && i != TT_VTNT) /* can't support VTNT as server */
  5325.                         {
  5326.                           /* Set terminal type to the one chosen */
  5327.                           if (i != tt_type)
  5328.                             settermtype(i,0);
  5329.                           break;
  5330.                       }
  5331.                   }
  5332.                   if (i > max_tt &&
  5333.                       strcmp(&(sb[1]),TELOPT_SB(TELOPT_TTYPE).term.type)) {
  5334.                       /* Couldn't find the specified term type */
  5335.                       sb[40] = '\0';
  5336.                       strcpy(TELOPT_SB(TELOPT_TTYPE).term.type,&(sb[1]));
  5337.                       /* SB TTYPE SEND */
  5338.                       tn_ssbopt(TELOPT_TTYPE,TELQUAL_SEND,NULL,0);
  5339.                       TELOPT_UNANSWERED_SB(TELOPT_TTYPE)=1;
  5340.                   }
  5341. #endif /* NOTERM */
  5342. #else /* OS2 */
  5343.                   p = (CHAR *) getenv("TERM");
  5344.                   if (p)
  5345.                     ckstrncpy((char *)oldterm,(char *)p,63);
  5346.                   else
  5347.                     oldterm[0] = '\0';
  5348.                   cklower((char *)&(sb[1])); /* Lower case new term */
  5349.                   ckmakmsg(term_buf,64,"TERM=",(char *)&(sb[1]),NULL,NULL);
  5350. #ifdef OS2ORUNIX
  5351. #ifndef NOPUTENV
  5352.                   putenv(term_buf);
  5353. #endif /* NOPUTENV */
  5354. #endif /* OS2ORUNIX */
  5355. #ifdef CK_CURSES
  5356. #ifndef MYCURSES
  5357. #ifndef COHERENT
  5358.                   if (trmbuf) {
  5359.                       if (tgetent(trmbuf,(char *)&sb[1]) < 1) {
  5360.                           /* Unsupported terminal.  If new and old terminal */
  5361.                           /* types do not match, ask for another type. */
  5362.                           if (strcmp((char *)oldterm,(char *)&sb[1])) {
  5363.                               /* SB TTYPE SEND */
  5364.                               tn_ssbopt(TELOPT_TTYPE,TELQUAL_SEND,NULL,0);
  5365.                               TELOPT_UNANSWERED_SB(TELOPT_TTYPE)=1;
  5366.                           }
  5367.                       }
  5368.                   }
  5369. #endif /* COHERENT */
  5370. #endif /* MYCURSES */
  5371. #endif /* CK_CURSES */
  5372. #endif /* OS2 */
  5373.               }
  5374.             }
  5375.             break;
  5376. #ifdef CK_ENVIRONMENT
  5377. #ifdef CK_XDISPLOC
  5378.           case TELOPT_XDISPLOC:         /* Send X-Display Location */
  5379.             if (sb[0] == TELQUAL_SEND) {/* SEND X-Display Loc? */
  5380.                 if ( !tn_delay_sb || !tn_outst(0) || tn_init ) {
  5381.                     if (tn_sxdisploc() < 0)     /* Yes, so send it. */
  5382.                         return(-1);
  5383.                 } else {
  5384.                     TELOPT_SB(TELOPT_XDISPLOC).xdisp.need_to_send = 1;
  5385.                 }
  5386.             }
  5387.             /* IS -- X Display Location (not supported) */
  5388.             else if (sb[0] == TELQUAL_IS) {
  5389.                 int i = 0;
  5390.                 /* Isolate the specified X-display string */
  5391.                 while (sb[i++] != IAC) {
  5392.                     if (i >= TSBUFSIZ)
  5393.                       return (-1);
  5394.                     if (sb[i] == IAC) {
  5395.                         sb[i] = '\0';
  5396.                         break;
  5397.                     }
  5398.                 }
  5399.                 debug(F110,"TELNET SB XDISPLOC IS",&sb[1],0);
  5400.             }
  5401.             break;
  5402. #endif /* CK_XDISPLOC */
  5403. #endif /* CK_ENVIRONMENT */
  5404.           case TELOPT_NAWS:
  5405.               if (sstelnet
  5406. #ifdef IKSD
  5407.                    || inserver
  5408. #endif /* IKSD */
  5409.                    ) {
  5410.                   int w = 0, h = 0;
  5411.                   int i = 0;
  5412.                   /* At this point sb[] should contain width and height */
  5413.                   if (sb[i] == IAC) i++;
  5414.                   w = (sb[i++] << 8);   /* save upper height */
  5415.                   if (sb[i] == IAC) i++;
  5416.                   w += sb[i++];         /* save the width */
  5417.                   if (sb[i] == IAC) i++;
  5418.                   h = (sb[i++] << 8);   /* save upper height */
  5419.                   if (sb[i] == IAC) i++;
  5420.                   h += sb[i++];
  5421.                   debug(F111,"tn_doop NAWS SB","width",w);
  5422.                   debug(F111,"tn_doop NAWS SB","height",h);
  5423.  
  5424.                   if (w == 0)
  5425.                     w = 80;
  5426.                   if (h == 0)
  5427.                     h = 24;
  5428. #ifndef NOLOCAL
  5429.                   if (tcp_incoming || inserver) {
  5430. #ifdef OS2
  5431.                       tt_cols[VTERM] = w;
  5432.                       tt_rows[VTERM] = h;
  5433.                       VscrnSetWidth(VTERM, w);
  5434.                       VscrnSetHeight(VTERM, h+(tt_status[VTERM]?1:0));
  5435. #ifdef IKSD
  5436.                       if (inserver) {
  5437.                           cmd_cols = tt_cols[VCMD] = w;
  5438.                           cmd_rows = tt_rows[VCMD] = h;
  5439.                           VscrnSetWidth(VCMD, w);
  5440.                           VscrnSetHeight(VCMD, h);
  5441.                       }
  5442. #endif /* IKSD */
  5443. #else /* OS2 */
  5444.                       tt_cols = w;
  5445.                       tt_rows = h;
  5446. #endif /* OS2 */
  5447.                   } else {
  5448. #ifdef OS2
  5449.                       tt_cols[VCMD] = w;
  5450.                       tt_rows[VCMD] = h;
  5451.                       VscrnSetWidth(VCMD, w);
  5452.                       VscrnSetHeight(VCMD, h);
  5453. #endif /* OS2 */
  5454.                       cmd_cols = w;
  5455.                       cmd_rows = h;
  5456.                   }
  5457. #else /* NOLOCAL */
  5458.                   cmd_cols = w;
  5459.                   cmd_rows = h;
  5460. #endif /* NOLOCAL */
  5461.  
  5462.                   /* Add LINES and COLUMNS to the environment */
  5463.                   ckmakmsg((char *)rows_buf,16,"LINES=",ckitoa(h),NULL,NULL);
  5464.                   ckmakmsg((char *)cols_buf,16,"COLUMNS=",ckitoa(w),NULL,NULL);
  5465. #ifdef OS2ORUNIX
  5466. #ifndef NOPUTENV
  5467.                   putenv(rows_buf);
  5468.                   putenv(cols_buf);
  5469. #endif /* NOPUTENV */
  5470. #endif /* OS2ORUNIX */
  5471.               }
  5472.               break;
  5473. #ifdef CK_ENVIRONMENT
  5474.           case TELOPT_NEWENVIRON:
  5475.             switch (sb[0]) {
  5476.               case TELQUAL_IS:                  /* IS */
  5477.               case TELQUAL_INFO:                /* INFO */
  5478.                 if (sb[0] == TELQUAL_IS)
  5479.                   debug(F101,"tn_doop NEW-ENV SB IS","",n-3);
  5480.                 else
  5481.                   debug(F101,"tn_doop NEW-ENV SB INFO","",n-3);
  5482.                 if (sstelnet || inserver) { /* Yes, receive it. */
  5483.                     if (tn_rnenv((CHAR *)&sb[1],n-3) < 0)
  5484.                       return(-1);
  5485.                 }
  5486.                 break;
  5487.               case TELQUAL_SEND:        /* SEND */
  5488.                 if ( sstelnet || inserver )         /* ignore if server */
  5489.                     break;
  5490.                 /* We need to take the sb[] and build a structure */
  5491.                 /* containing all of the variables and types that */
  5492.                 /* we are supposed to keep track of and send to   */
  5493.                 /* the host, then call tn_snenv().                  */
  5494.                 /* Or we can punt ...                               */
  5495.                 if ( !tn_delay_sb || !tn_outst(0) || tn_init ) {
  5496.                   if (tn_snenv((CHAR *)&sb[1],n-3) < 0) /* Yes, send it. */
  5497.                      return(-1);
  5498.                 } else {
  5499. #ifndef VMS
  5500.                   CHAR * xxx;
  5501.                   xxx = (CHAR *) malloc(n-1);
  5502. #else
  5503.                   unsigned char * xxx;
  5504.                   xxx = (unsigned char *) malloc(n-1);
  5505. #endif /* VMS */
  5506.                   /* Postpone sending until end of tn_ini() */
  5507.                   TELOPT_SB(TELOPT_NEWENVIRON).env.str = xxx;
  5508.                   if (TELOPT_SB(TELOPT_NEWENVIRON).env.str) {
  5509.                   memcpy((char *)TELOPT_SB(TELOPT_NEWENVIRON).env.str,
  5510.                             (char *)&sb[1],n-3);
  5511.                   TELOPT_SB(TELOPT_NEWENVIRON).env.str[n-3] = IAC;
  5512.                   TELOPT_SB(TELOPT_NEWENVIRON).env.str[n-2] = '\0';
  5513.                   TELOPT_SB(TELOPT_NEWENVIRON).env.len = n-3;
  5514.                   TELOPT_SB(TELOPT_NEWENVIRON).env.need_to_send = 1;
  5515.                   }
  5516.                 }
  5517.                 break;
  5518.               }
  5519.               break;
  5520. #endif /* CK_ENVIRONMENT */
  5521. #ifdef CK_SNDLOC
  5522.           case TELOPT_SNDLOC: {
  5523.               if ( deblog ) {
  5524.                   sb[n-2] = '\0';
  5525.                   debug(F110,"TELNET Send-Location",sb,0);
  5526.               }
  5527.               break;
  5528.           }
  5529. #endif /* CK_SNDLOC */
  5530.           } /* switch */
  5531.         break;
  5532.     }
  5533.     return(0);
  5534. }
  5535.  
  5536. int
  5537. #ifdef CK_ANSIC                         /* TELNET DO OPTION */
  5538. tn_doop(CHAR z, int echo, int (*fn)(int))
  5539. #else
  5540. tn_doop(z, echo, fn) CHAR z; int echo; int (*fn)();
  5541. #endif /* CK_ANSIC */
  5542. /* tn_doop */ {
  5543.     int x=0, y=0;
  5544.  
  5545.     if (z != (CHAR) IAC) {
  5546.         debug(F101,"tn_doop bad call","",z);
  5547.         return(-1);
  5548.     }
  5549.     if (ttnet != NET_TCPB)              /* Check network type */
  5550.       return(0);
  5551.     if (ttnproto != NP_TELNET &&
  5552.          ttnproto != NP_NONE)           /* Check protocol */
  5553.         return(0);
  5554.  
  5555.     x = tn_xdoop(z,echo,fn);
  5556.     if (x >= 0 && !tn_begun) {
  5557.         y = tn_start();
  5558.     }
  5559.     return(y < 0 ? y : x);
  5560. }
  5561.  
  5562. #ifdef CK_ENVIRONMENT
  5563.  
  5564. /* Telnet receive new environment */
  5565. /* Returns -1 on error, 0 if nothing happens, 1 on success */
  5566. /* In order for this code to work, sb[len] == IAC          */
  5567. /* We currently only support the USER environment variable */
  5568.  
  5569. int
  5570. #ifdef CK_ANSIC
  5571. tn_rnenv(CHAR * sb, int len)
  5572. #else
  5573. tn_rnenv(sb, len) CHAR * sb; int len;
  5574. #endif /* CK_ANSIC */
  5575. /* tn_rnenv */ {                        /* Receive new environment */
  5576.     char varname[17];
  5577.     char value[65];
  5578.     char * reply = 0, * s = 0;
  5579.     int i,j,k,n;                                /* Worker. */
  5580.     int type = 0; /* 0 for NONE, 1 for VAR, 2 for USERVAR, */
  5581.                   /* 3 for VALUE in progress */
  5582.  
  5583.     if (ttnet != NET_TCPB) return(0);
  5584.     if (ttnproto != NP_TELNET) return(0);
  5585.     if (sb == NULL) return(-1);
  5586.  
  5587.     if (len == 0) return(1);
  5588.  
  5589.     /*
  5590.     Pairs of <type> [VAR=0, VALUE=1, ESC=2, USERVAR=3] <value> "unterminated"
  5591.     follow here until done...
  5592.     */
  5593.     for (i = 0, j = 0, k = 0, type = 0, varname[0]= '\0'; i <= len; i++) {
  5594.         switch (sb[i]) {
  5595.         case TEL_ENV_VAR:               /* VAR */
  5596.         case TEL_ENV_USERVAR:           /* USERVAR */
  5597.         case IAC:                       /* End of the list */
  5598.             switch (type) {
  5599.               case 0:                   /* Nothing in progress */
  5600.                 /* If we get IAC only, then that means there were */
  5601.                 /* no environment variables to send.  we are done */
  5602.                 if (j == 0 && sb[i] == IAC)
  5603.                     return(1);
  5604.               case 1:                   /* VAR in progress */
  5605.               case 2:                   /* USERVAR in progress */
  5606.               case 3:                   /* VALUE in progress */
  5607.                 value[k] = '\0';
  5608.                 varname[j] = '\0';
  5609.                 debug(F111,"tn_rnenv varname",varname,type);
  5610.                 debug(F111,"tn_rnenv value",value,type);
  5611.                 if (!strcmp(varname,"USER")) {
  5612. #ifdef CK_AUTHENTICATION
  5613.                     if (ck_tn_auth_valid() != AUTH_VALID) {
  5614.                         extern char szUserNameRequested[];
  5615.                         debug(F100,"tn_rnenv != AUTH_VALID","",0);
  5616.                         ckstrncpy(szUserNameRequested,value,UIDBUFLEN);
  5617.                         ckstrncpy(uidbuf,value,UIDBUFLEN);
  5618. #ifdef CK_SSL
  5619.                         if (ssl_active_flag) {
  5620.                             if ( tls_is_user_valid(ssl_con, uidbuf) ) {
  5621.                                 extern char szUserNameAuthenticated[];
  5622.                                 ckstrncpy(szUserNameAuthenticated,uidbuf,
  5623.                                            UIDBUFLEN);
  5624.                                 auth_finished(AUTH_VALID);
  5625.                             }
  5626.                         } else if (tls_active_flag) {
  5627.                             if ( tls_is_user_valid(tls_con, uidbuf) ) {
  5628.                                 extern char szUserNameAuthenticated[];
  5629.                                 ckstrncpy(szUserNameAuthenticated,uidbuf,
  5630.                                            UIDBUFLEN);
  5631.                                 auth_finished(AUTH_VALID);
  5632.                             }
  5633.                         }
  5634. #endif /* CK_SSL */
  5635.                     } else {    /* AUTH_VALID */
  5636.                         int x = 0;
  5637.                         debug(F110,"tn_rnenv AUTH_VALID uidbuf",uidbuf,0);
  5638.  
  5639. #ifdef OS2
  5640.                         x = ckstrcmp(value,uidbuf,-1,0); /* case insensitive */
  5641. #ifdef NT
  5642.                         /* NTLM authentication returns names of the form */
  5643.                         /* DOMAIN\user.  We need to check to see of the  */
  5644.                         /* USER VAR contains a domain name or not.  If   */
  5645.                         /* not, then we do not want to change state if   */
  5646.                         /* the uidbuf matches the USER VAR when the      */
  5647.                         /* DOMAIN is ignored.                            */
  5648.                         if ( x && ck_tn_authenticated() == AUTHTYPE_NTLM ) {
  5649.                             char * s1=NULL, * s2=NULL;
  5650.                             int    len1, len2, i;
  5651.  
  5652.                             len1 = strlen(value);
  5653.                             for ( i=len1-1 ; i>=0 ; i--) {
  5654.                                 if ( value[i] == '\\' ) {
  5655.                                     s1 = &value[i+1];   /* DOMAIN found */
  5656.                                     break;
  5657.                                 }
  5658.                             }
  5659.  
  5660.                             if ( s1 == NULL ) {
  5661.                                 len2 = strlen(uidbuf);
  5662.                                 for ( i=len2-1 ; i>=0 ; i--) {
  5663.                                     if ( uidbuf[i] == '\\' ) {
  5664.                                         s2 = &uidbuf[i+1];   /* DOMAIN found */
  5665.                                         break;
  5666.                                     }
  5667.                                 }
  5668.  
  5669.                                 if ( s2 )
  5670.                                     x = ckstrcmp(value,s2,-1,0);
  5671.                             }
  5672.                         }
  5673. #endif /* NT */
  5674. #else /* OS2 */
  5675.                         x = ckstrcmp(value,uidbuf,-1,1); /* case sensitive */
  5676. #endif /* OS2 */
  5677.                         if ( x ) {
  5678.                             extern char szUserNameRequested[];
  5679.                             ckstrncpy(uidbuf,value,UIDBUFLEN);
  5680.                             ckstrncpy(szUserNameRequested,value,UIDBUFLEN);
  5681.                             auth_finished(AUTH_USER);
  5682. #ifdef CK_SSL
  5683.                             if (ssl_active_flag || tls_active_flag) {
  5684.                                 if ( tls_is_user_valid(ssl_con, uidbuf) )
  5685.                                     auth_finished(AUTH_VALID);
  5686.                             }
  5687. #endif /* CK_SSL */
  5688.                         }
  5689.                     }
  5690. #else /* CK_AUTHENTICATION */
  5691.                     ckstrncpy(uidbuf,value,UIDBUFLEN);
  5692. #endif /* CK_AUTHENTICATION */
  5693.                 }
  5694.                 break;
  5695.             }
  5696.             varname[0] = '\0';
  5697.             value[0] = '\0';
  5698.             j = 0;
  5699.             k = 0;
  5700.             type = (sb[i] == TEL_ENV_USERVAR ? 2 :      /* USERVAR */
  5701.                     sb[i] == TEL_ENV_VAR ? 1 :  /* VAR */
  5702.                      0
  5703.                      );
  5704.             break;
  5705.         case TEL_ENV_VALUE: /* VALUE */
  5706.             if ( type == 1 || type == 2 )
  5707.                 type = 3;
  5708.             break;
  5709.         case TEL_ENV_ESC:       /* ESC */
  5710.             /* Take next character literally */
  5711.             if ( ++i >= len )
  5712.                 break;
  5713.             /* otherwise, fallthrough so byte will be added to string. */
  5714.         default:
  5715.             switch (type) {
  5716.             case 1:     /* VAR in progress */
  5717.             case 2:     /* USERVAR in progress */
  5718.                 if ( j < 16 )
  5719.                     varname[j++] = sb[i];
  5720.                 break;
  5721.             case 3:
  5722.                 if ( k < 64 )
  5723.                     value[k++] = sb[i];
  5724.                 break;
  5725.             }
  5726.         }
  5727.     }
  5728.     return(0);
  5729. }
  5730.  
  5731. /* These are for Microsoft SFU version 2 Telnet Server */
  5732. #define SFUTLNTVER "SFUTLNTVER"
  5733. #define SFUTLNTMODE "SFUTLNTMODE"
  5734. #define SFUTLNTVER_VALUE  "2"
  5735. #define SFUTLNTMODE_VALUE "console"  /* The other value is "stream" */
  5736.  
  5737. /* Telnet send new environment */
  5738. /* Returns -1 on error, 0 if nothing happens, 1 on success */
  5739. /* In order for this code to work, sb[len] == IAC          */
  5740.  
  5741. int
  5742. #ifdef CK_ANSIC
  5743. tn_snenv(CHAR * sb, int len)
  5744. #else
  5745. tn_snenv(sb, len) CHAR * sb; int len;
  5746. #endif /* CK_ANSIC */
  5747. /* tn_snenv */ {                        /* Send new environment */
  5748.     char varname[16];
  5749.     char * reply = 0, * s = 0;
  5750.     int i,j,n;                          /* Worker. */
  5751.     int type = 0;       /* 0 for NONE, 1 for VAR, 2 for USERVAR in progress */
  5752.     extern int ck_lcname;
  5753.     char localuidbuf[UIDBUFLEN];
  5754.     char * uu = uidbuf;
  5755.     char * disp = NULL;
  5756.  
  5757.     if (ttnet != NET_TCPB) return(0);
  5758.     if (ttnproto != NP_TELNET) return(0);
  5759.     if (!sb) return(-1);
  5760.  
  5761. #ifdef CK_SSL
  5762.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  5763.         return(0);
  5764.     }
  5765. #endif /* CK_SSL */
  5766.  
  5767. #ifdef CK_FORWARD_X
  5768.     if (TELOPT_U(TELOPT_FORWARD_X)) {
  5769.         disp = NULL;
  5770.     } else
  5771. #endif /* CK_FORWARD_X */
  5772.         disp = (char *)tn_get_display();
  5773.  
  5774.     if (ck_lcname) {
  5775.         ckstrncpy(localuidbuf,uidbuf,UIDBUFLEN);
  5776.         cklower(localuidbuf);
  5777.         uu = localuidbuf;
  5778.     }
  5779.  
  5780.     hexdump((CHAR *)"tn_snenv sb[]",sb,len);
  5781.     debug(F110,"tn_snenv uidbuf",uidbuf,0);
  5782.     debug(F110,"tn_snenv localuidbuf",localuidbuf,0);
  5783.     debug(F110,"tn_snenv tn_env_sys",tn_env_sys,0);
  5784.     debug(F110,"tn_snenv tn_env_disp",tn_env_disp,0);
  5785.     debug(F110,"tn_snenv disp",disp,0);
  5786.  
  5787.     /* First determine the size of the buffer we will need */
  5788.     for (i = 0, j = 0, n = 0, type = 0, varname[0]= '\0'; i <= len; i++) {
  5789.         switch (sb[i]) {
  5790.           case TEL_ENV_VAR:             /* VAR */
  5791.           case TEL_ENV_USERVAR:         /* USERVAR */
  5792.         case IAC:                     /* End of the list */
  5793.             switch (type) {
  5794.             case 0:                   /* Nothing in progress */
  5795.                 /* If we get IAC only, then that means send all */
  5796.                 /* VAR and USERVAR.                             */
  5797.                 if (!(j == 0 && sb[i] == IAC))
  5798.                   break;
  5799.             case 1:                   /* VAR in progress */
  5800.                 varname[j] = '\0' ;
  5801.                 if (!varname[0]) {      /* Send All */
  5802.                     if (uu[0])
  5803.                       n += strlen(uu) + 4 + 2;
  5804.                     if (tn_env_job[0])
  5805.                       n += strlen(tn_env_job) + 3 + 2;
  5806.                     if (tn_env_acct[0])
  5807.                       n += strlen(tn_env_acct) + 4 + 2;
  5808.                     if (tn_env_prnt[0])
  5809.                       n += strlen(tn_env_prnt) + 7 + 2;
  5810.                     if (tn_env_sys[0])
  5811.                       n += strlen(tn_env_sys) + 10 + 2;
  5812.                     if (disp)
  5813.                       n += strlen(disp) + 7 + 2;
  5814.                 } else if (!strcmp(varname,"USER") && uu[0])
  5815.                   n += strlen(uu) + 4 + 2;
  5816.                 else if (!strcmp(varname,"JOB") && tn_env_job[0])
  5817.                   n += strlen(tn_env_job) + 3 + 2;
  5818.                 else if (!strcmp(varname,"ACCT") && tn_env_acct[0])
  5819.                   n += strlen(tn_env_acct) + 4 + 2;
  5820.                 else if (!strcmp(varname,"PRINTER") && tn_env_prnt[0])
  5821.                   n += strlen(tn_env_prnt) + 7 + 2;
  5822.                 else if (!strcmp(varname,"SYSTEMTYPE") && tn_env_sys[0])
  5823.                   n += strlen(tn_env_sys) + 10 + 2;
  5824.                 else if (!strcmp(varname,"DISPLAY") && disp)
  5825.                   n += strlen(disp) + 7 + 2;
  5826.                 /* If we get IAC only, then that means send all */
  5827.                 /* VAR and USERVAR.                             */
  5828.                   if (!(j == 0 && sb[i] == IAC))
  5829.                       break;
  5830.             case 2:                   /* USERVAR in progress */
  5831.                 varname[j] = '\0' ;
  5832.                 if (!varname[0]) {      /* Send All */
  5833.                     int x;
  5834.                     for ( x=0 ; x<8 ; x++ ) {
  5835.                         if ( tn_env_uservar[x][0] &&
  5836.                              tn_env_uservar[x][1] )
  5837.                             n += strlen(tn_env_uservar[x][0])
  5838.                                 + strlen(tn_env_uservar[x][1]) + 2;
  5839.                     }
  5840.                     if ( tn_sfu ) {
  5841.                         /* For compatibility with Microsoft Telnet Server */
  5842.                         n += strlen(SFUTLNTVER) + strlen(SFUTLNTVER_VALUE) + 2;
  5843.                         n += strlen(SFUTLNTMODE) +
  5844.                           strlen(SFUTLNTMODE_VALUE) + 2;
  5845.                     }
  5846. #ifdef CK_SNDLOC
  5847.                     if ( tn_loc && tn_loc[0] )
  5848.                         n += strlen("LOCATION") + strlen(tn_loc) + 2;
  5849. #endif /* CK_SNDLOC */
  5850.                 }
  5851.                 else if (tn_sfu && !strcmp(varname,SFUTLNTVER))
  5852.                     n += strlen(SFUTLNTVER) + strlen(SFUTLNTVER_VALUE) + 2;
  5853.                 else if (tn_sfu && !strcmp(varname,SFUTLNTMODE))
  5854.                     n += strlen(SFUTLNTMODE) + strlen(SFUTLNTMODE_VALUE) + 2;
  5855. #ifdef CK_SNDLOC
  5856.                 else if ( tn_loc && tn_loc[0] && !strcmp(varname,"LOCATION"))
  5857.                     n += strlen("LOCATION") + strlen(tn_loc) + 2;
  5858. #endif /* CK_SNDLOC */
  5859.                 else {
  5860.                     int x;
  5861.                     for ( x=0 ; x<8 ; x++ ) {
  5862.                         if ( tn_env_uservar[x][0] &&
  5863.                              tn_env_uservar[x][1] &&
  5864.                              !strcmp(varname,tn_env_uservar[x][0]))
  5865.                             n += strlen(tn_env_uservar[x][0])
  5866.                                 + strlen(tn_env_uservar[x][1]) + 2;
  5867.                     }
  5868.                 }
  5869.                 break;
  5870.             }
  5871.             varname[0] = '\0';
  5872.             j = 0;
  5873.             type = (sb[i] == TEL_ENV_USERVAR ? 2 :      /* USERVAR */
  5874.                     sb[i] == TEL_ENV_VAR ? 1 :          /* VAR */
  5875.                     0
  5876.                    );
  5877.             break;
  5878.           case TEL_ENV_VALUE:           /* VALUE */
  5879.             /* Protocol Error */
  5880.             debug(F100, "TELNET Subnegotiation error - VALUE in SEND", "",0);
  5881.             if (tn_deb || debses)
  5882.               tn_debug("TELNET Subnegotiation error - VALUE in SEND");
  5883.             return(0);
  5884.           case TEL_ENV_ESC:     /* ESC */
  5885.             if (++i >= len)
  5886.               break;
  5887.           default:
  5888.             if (j < 16 )
  5889.               varname[j++] = sb[i];
  5890.         }
  5891.     }
  5892.     reply = malloc(n + 16);              /* Leave room for IAC stuff */
  5893.     if (!reply) {
  5894.         debug(F100, "TELNET Subnegotiation error - malloc failed", "",0);
  5895.         if (tn_deb || debses)
  5896.           tn_debug("TELNET Subnegotiation error - malloc failed");
  5897.  
  5898.         /* Send a return packet with no variables so that the host */
  5899.         /* may continue with additional negotiations               */
  5900.         if (tn_ssbopt(TELOPT_NEWENVIRON,TELQUAL_IS,"",0) < 0)
  5901.           return(-1);
  5902.         return(0);
  5903.     }
  5904.  
  5905.     /* Now construct the real reply */
  5906.  
  5907.     n = 0;                              /* Start at beginning of buffer */
  5908. /*
  5909.   Pairs of <type> [VAR=0, VALUE=1, ESC=2, USERVAR=3] <value> "unterminated"
  5910.   follow here until done...
  5911. */
  5912.     for (i = 0, j = 0, type = 0, varname[0]= '\0'; i <= len; i++) {
  5913.         switch (sb[i]) {
  5914.           case TEL_ENV_VAR:             /* VAR */
  5915.           case TEL_ENV_USERVAR:         /* USERVAR */
  5916.           case IAC:                     /* End of the list */
  5917.             switch (type) {
  5918.               case 0:                   /* Nothing in progress */
  5919.                 /* If we get IAC only, then that means send all */
  5920.                 /* VAR and USERVAR.                             */
  5921.                 if (!(j == 0 && sb[i] == IAC))
  5922.                   break;
  5923.               case 1:                   /* VAR in progress */
  5924.                 varname[j] = '\0';
  5925.                 if (!varname[0]) {
  5926.                     /* Send All */
  5927.                     if (uu[0]) {
  5928.                         reply[n] = TEL_ENV_VAR; /* VAR */
  5929.                         strcpy(&reply[n+1],"USER");
  5930.                         reply[n+5] = TEL_ENV_VALUE;             /* VALUE */
  5931.                         strcpy(&reply[n+6],uu);
  5932.                         n += strlen(uu) + 4 + 2;
  5933.                     }
  5934.                     if (tn_env_job[0]) {
  5935.                         reply[n] = TEL_ENV_VAR; /* VAR */
  5936.                         strcpy(&reply[n+1],"JOB");
  5937.                         reply[n+4] = TEL_ENV_VALUE;     /* VALUE */
  5938.                         strcpy(&reply[n+5],tn_env_job);
  5939.                         n += strlen(tn_env_job) + 3 + 2;
  5940.                     }
  5941.                     if (tn_env_acct[0]) {
  5942.                         reply[n] = TEL_ENV_VAR; /* VAR */
  5943.                         strcpy(&reply[n+1],"ACCT");
  5944.                         reply[n+5] = TEL_ENV_VALUE;     /* VALUE */
  5945.                         strcpy(&reply[n+6],tn_env_acct);
  5946.                         n += strlen(tn_env_acct) + 4 + 2;
  5947.                     }
  5948.                     if (tn_env_prnt[0]) {
  5949.                         reply[n] = TEL_ENV_VAR; /* VAR */
  5950.                         strcpy(&reply[n+1],"PRINTER");
  5951.                         reply[n+8] = TEL_ENV_VALUE;     /* VALUE */
  5952.                         strcpy(&reply[n+9],tn_env_prnt);
  5953.                         n += strlen(tn_env_prnt) + 7 + 2;
  5954.                     }
  5955.                     if (tn_env_sys[0]) {
  5956.                         reply[n] = TEL_ENV_VAR; /* VAR */
  5957.                         strcpy(&reply[n+1],"SYSTEMTYPE");
  5958.                         reply[n+11] = TEL_ENV_VALUE; /* VALUE */
  5959.                         strcpy(&reply[n+12],tn_env_sys);
  5960.                         n += strlen(tn_env_sys) + 10 + 2;
  5961.                     }
  5962.                     if (disp) {
  5963.                         reply[n] = TEL_ENV_VAR; /* VAR */
  5964.                         strcpy(&reply[n+1],"DISPLAY");
  5965.                         reply[n+8] = TEL_ENV_VALUE;     /* VALUE */
  5966.                         strcpy(&reply[n+9],disp);
  5967.                         n += strlen(disp) + 7 + 2;
  5968.                     }
  5969.                 } else if (!strcmp(varname,"USER") && uu[0]) {
  5970.                     reply[n] = TEL_ENV_VAR;     /* VAR */
  5971.                     strcpy(&reply[n+1],"USER");
  5972.                     reply[n+5] = TEL_ENV_VALUE; /* VALUE */
  5973.                     strcpy(&reply[n+6],uu);
  5974.                     n += strlen(uu) + 4 + 2;
  5975.                 } else if (!strcmp(varname,"JOB") && tn_env_job[0]) {
  5976.                     reply[n] = TEL_ENV_VAR;     /* VAR */
  5977.                     strcpy(&reply[n+1],"JOB");
  5978.                     reply[n+4] = TEL_ENV_VALUE; /* VALUE */
  5979.                     strcpy(&reply[n+5],tn_env_job);
  5980.                     n += strlen(tn_env_job) + 3 + 2;
  5981.                 } else if (!strcmp(varname,"ACCT") && tn_env_acct[0]) {
  5982.                     reply[n] = TEL_ENV_VAR;     /* VAR */
  5983.                     strcpy(&reply[n+1],"ACCT");
  5984.                     reply[n+5] = TEL_ENV_VALUE; /* VALUE */
  5985.                     strcpy(&reply[n+6],tn_env_acct);
  5986.                     n += strlen(tn_env_acct) + 4 + 2;
  5987.                 } else if (!strcmp(varname,"PRINTER") && tn_env_prnt[0]) {
  5988.                     reply[n] = TEL_ENV_VAR;     /* VAR */
  5989.                     strcpy(&reply[n+1],"PRINTER");
  5990.                     reply[n+8] = TEL_ENV_VALUE; /* VALUE */
  5991.                     strcpy(&reply[n+9],tn_env_prnt);
  5992.                     n += strlen(tn_env_prnt) + 7 + 2;
  5993.                 } else if (!strcmp(varname,"SYSTEMTYPE") && tn_env_sys[0]) {
  5994.                     reply[n] = TEL_ENV_VAR;     /* VAR */
  5995.                     strcpy(&reply[n+1],"SYSTEMTYPE");
  5996.                     reply[n+11] = TEL_ENV_VALUE;        /* VALUE */
  5997.                     strcpy(&reply[n+12],tn_env_sys);
  5998.                     n += strlen(tn_env_sys) + 10 + 2;
  5999.                 } else if (!strcmp(varname,"DISPLAY") && disp) {
  6000.                     reply[n] = TEL_ENV_VAR;     /* VAR */
  6001.                     strcpy(&reply[n+1],"DISPLAY");
  6002.                     reply[n+8] = TEL_ENV_VALUE; /* VALUE */
  6003.                     strcpy(&reply[n+9],disp);
  6004.                     n += strlen(disp) + 7 + 2;
  6005.                 }
  6006.                   /* If we get IAC only, then that means send all */
  6007.                   /* VAR and USERVAR.                             */
  6008.                   if (!(j == 0 && sb[i] == IAC))
  6009.                       break;
  6010.             case 2:     /* USERVAR in progress */
  6011.                   varname[j] = '\0';
  6012.                   if (!varname[0]) {
  6013.                       /* Send All */
  6014.                       int x,y;
  6015.                       for ( x=0 ; x<8 ; x++ ) {
  6016.                           if ( tn_env_uservar[x][0] &&
  6017.                                tn_env_uservar[x][1] ) {
  6018.                               reply[n] = TEL_ENV_USERVAR;     /* VAR */
  6019.                               y = strlen(tn_env_uservar[x][0]);
  6020.                               strcpy(&reply[n+1],tn_env_uservar[x][0]);
  6021.                               reply[n+y+1] = TEL_ENV_VALUE; /* VALUE */
  6022.                               strcpy(&reply[n+y+2],tn_env_uservar[x][1]);
  6023.                               n += y+strlen(tn_env_uservar[x][1])+2;
  6024.                           }
  6025.                       }
  6026.                       if ( tn_sfu ) {
  6027.                           /* Compatibility with Microsoft Telnet Server */
  6028.                           reply[n] = TEL_ENV_USERVAR;     /* VAR */
  6029.                           strcpy(&reply[n+1],SFUTLNTVER);
  6030.                           reply[n+11] = TEL_ENV_VALUE; /* VALUE */
  6031.                           strcpy(&reply[n+12],SFUTLNTVER_VALUE);
  6032.                           n += strlen(SFUTLNTVER)+strlen(SFUTLNTVER_VALUE)+2;
  6033.  
  6034.                           reply[n] = TEL_ENV_USERVAR;     /* VAR */
  6035.                           strcpy(&reply[n+1],SFUTLNTMODE);
  6036.                           reply[n+12] = TEL_ENV_VALUE; /* VALUE */
  6037.                           strcpy(&reply[n+13],SFUTLNTMODE_VALUE);
  6038.                           n += strlen(SFUTLNTMODE)+strlen(SFUTLNTMODE_VALUE)+2;
  6039.                       }
  6040.                       if (tn_loc && tn_loc[0]) {
  6041.                           reply[n] = TEL_ENV_USERVAR;     /* VAR */
  6042.                           strcpy(&reply[n+1],"LOCATION");
  6043.                           reply[n+9] = TEL_ENV_VALUE; /* VALUE */
  6044.                           strcpy(&reply[n+10],tn_loc);
  6045.                           n += strlen("LOCATION") + strlen(tn_loc) + 2;
  6046.                       }
  6047.                   }  else if (tn_sfu && !strcmp(varname,SFUTLNTVER)) {
  6048.                       reply[n] = TEL_ENV_USERVAR;     /* VAR */
  6049.                       strcpy(&reply[n+1],SFUTLNTVER);
  6050.                       reply[n+11] = TEL_ENV_VALUE; /* VALUE */
  6051.                       strcpy(&reply[n+12],SFUTLNTVER_VALUE);
  6052.                       n += strlen(SFUTLNTVER) + strlen(SFUTLNTVER_VALUE) + 2;
  6053.                   }  else if (tn_sfu && !strcmp(varname,SFUTLNTMODE)) {
  6054.                       reply[n] = TEL_ENV_USERVAR;     /* VAR */
  6055.                       strcpy(&reply[n+1],SFUTLNTMODE);
  6056.                       reply[n+12] = TEL_ENV_VALUE; /* VALUE */
  6057.                       strcpy(&reply[n+13],SFUTLNTMODE_VALUE);
  6058.                       n += strlen(SFUTLNTMODE) + strlen(SFUTLNTMODE_VALUE) + 2;
  6059.                   }
  6060. #ifdef CK_SNDLOC
  6061.                   else if (tn_loc && tn_loc[0] && !strcmp(varname,"LOCATION")){
  6062.                       reply[n] = TEL_ENV_USERVAR;     /* VAR */
  6063.                       strcpy(&reply[n+1],"LOCATION");
  6064.                       reply[n+9] = TEL_ENV_VALUE; /* VALUE */
  6065.                       strcpy(&reply[n+10],tn_loc);
  6066.                       n += strlen("LOCATION") + strlen(tn_loc) + 2;
  6067.                   }
  6068. #endif /* CK_SNDLOC */
  6069.                   else {
  6070.                       int x,y;
  6071.                       for ( x=0 ; x<8 ; x++ ) {
  6072.                           if ( tn_env_uservar[x][0] &&
  6073.                                tn_env_uservar[x][1] &&
  6074.                                !strcmp(varname,tn_env_uservar[x][0])) {
  6075.                               reply[n] = TEL_ENV_USERVAR;     /* VAR */
  6076.                               y = strlen(tn_env_uservar[x][0]);
  6077.                               strcpy(&reply[n+1],tn_env_uservar[x][0]);
  6078.                               reply[n+y+1] = TEL_ENV_VALUE; /* VALUE */
  6079.                               strcpy(&reply[n+y+2],tn_env_uservar[x][1]);
  6080.                               n += y+strlen(tn_env_uservar[x][1])+2;
  6081.                           }
  6082.                       }
  6083.                   }
  6084.                 break;
  6085.             }
  6086.             varname[0] = '\0';
  6087.             j = 0;
  6088.             type = (sb[i] == TEL_ENV_USERVAR ? 2 :      /* USERVAR */
  6089.                     sb[i] == TEL_ENV_VAR ? 1 :  /* VAR */
  6090.                     0
  6091.                    );
  6092.             break;
  6093.           case TEL_ENV_VALUE: /* VALUE */
  6094.             /* Protocol Error */
  6095.             debug(F100, "TELNET Subnegotiation error - VALUE in SEND", "",0);
  6096.             if (tn_deb || debses)
  6097.               tn_debug("TELNET Subnegotiation error - VALUE in SEND");
  6098.             return(0);  /* Was -1 but that would be taken as */
  6099.                         /* an I/O error, so absorb it and go on. */
  6100.           case TEL_ENV_ESC:     /* ESC */
  6101.             /* Not sure what this for.  Quote next character? */
  6102.             break;
  6103.           default:
  6104.             varname[j++] = sb[i];
  6105.         }
  6106.     }
  6107.     if (tn_ssbopt(TELOPT_NEWENVIRON,TELQUAL_IS,reply,n) < 0) {
  6108.         free(reply);
  6109.         return(-1);
  6110.     }
  6111.     free(reply);
  6112.     return(1);
  6113. }
  6114. #endif /* CK_ENVIRONMENT */
  6115.  
  6116. /* Telnet send terminal type */
  6117. /* Returns -1 on error, 0 if nothing happens, 1 if type sent successfully */
  6118.  
  6119. int
  6120. tn_sttyp() {                            /* Send telnet terminal type. */
  6121.     char *ttn;                          /* Name of terminal type. */
  6122. #ifdef OS2
  6123.     static int alias = -1;              /* which alias are we using ? */
  6124.     int settype = 0;
  6125. #endif /* OS2 */
  6126.     int i, rc;                          /* Worker. */
  6127.     int tntermflg = 0;
  6128.  
  6129.     if (ttnet != NET_TCPB) return(0);
  6130.     if (ttnproto != NP_TELNET) return(0);
  6131.  
  6132.     if (!TELOPT_ME(TELOPT_TTYPE)) return(0);
  6133.  
  6134. #ifdef CK_SSL
  6135.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  6136.         return(0);
  6137.     }
  6138. #endif /* CK_SSL */
  6139.     ttn = NULL;
  6140.  
  6141. #ifndef NOTERM
  6142. #ifdef OS2
  6143.     if (!tn_term) {
  6144.         if (ttnum == -1) {
  6145.             ttnum = tt_type;
  6146.             settype = 0;
  6147.             alias = -1;
  6148.         } else if (ttnumend) {
  6149.             ttnumend = 0;
  6150.             settype = 0;
  6151.         } else {
  6152.             if (tt_info[tt_type].x_aliases[++alias] == NULL)  {
  6153.                 if (--tt_type < 0)
  6154.                   tt_type = max_tt;
  6155.                 if (ttnum == tt_type)
  6156.                   ttnumend = 1;
  6157.                 settype = 1;
  6158.                 alias = -1;
  6159.             }
  6160.         }
  6161.         if (tt_type >= 0 && tt_type <= max_tt) {
  6162.             if (alias == -1)
  6163.               ttn = tt_info[tt_type].x_name;
  6164.             else
  6165.               ttn = tt_info[tt_type].x_aliases[alias];
  6166.         } else
  6167.           ttn = NULL;
  6168.     }
  6169.     else settype = 0;
  6170. #endif /* OS2 */
  6171. #endif /* NOTERM */
  6172.  
  6173.     if (tn_term) {                      /* Terminal type override? */
  6174.         debug(F110,"tn_sttyp",tn_term,0);
  6175.         if (*tn_term) {
  6176.             ttn = tn_term;
  6177.             tntermflg = 1;
  6178.         }
  6179.     } else debug(F100,"tn_sttyp no term override","",0);
  6180.  
  6181. #ifndef datageneral
  6182.     if (!ttn) {                         /* If no override, */
  6183.         ttn = getenv("TERM");           /* get it from the environment. */
  6184.     }
  6185. #endif /* datageneral */
  6186.     if ((ttn == ((char *)0)) || ((int)strlen(ttn) >= TSBUFSIZ))
  6187.       ttn = "UNKNOWN";
  6188.     sb_out[0] = (CHAR) IAC;                 /* I Am a Command */
  6189.     sb_out[1] = (CHAR) SB;                  /* Subnegotiation */
  6190.     sb_out[2] = TELOPT_TTYPE;               /* Terminal Type */
  6191.     sb_out[3] = (CHAR) 0;                   /* Is... */
  6192.     for (i = 4; *ttn; ttn++,i++) {      /* Copy and uppercase it */
  6193. #ifdef VMS
  6194.         if (!tntermflg && *ttn == '-' &&
  6195.             (!strcmp(ttn,"-80") || !strcmp(ttn,"-132")))
  6196.           break;
  6197.         else
  6198. #endif /* VMS */
  6199.           sb_out[i] = (char) ((!tntermflg && islower(*ttn)) ?
  6200.                               toupper(*ttn) :
  6201.                               *ttn);
  6202.     }
  6203.     ttn = (char *)sb_out;                   /* Point back to beginning */
  6204. #ifdef DEBUG
  6205.     if (deblog || tn_deb || debses) {
  6206.         sb_out[i] = '\0';                   /* For debugging */
  6207.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,"TELNET SENT SB ",
  6208.                  TELOPT(TELOPT_TTYPE)," IS ",(char *)sb_out+4," IAC SE",
  6209.                  NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  6210.     }
  6211. #endif /* DEBUG */
  6212.     sb_out[i++] = (CHAR) IAC;               /* End of Subnegotiation */
  6213.     sb_out[i++] = (CHAR) SE;                /* marked by IAC SE */
  6214. #ifdef OS2
  6215.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  6216. #endif
  6217. #ifdef DEBUG
  6218.     debug(F100,tn_msg_out,"",0);
  6219.     if (tn_deb || debses) tn_debug(tn_msg_out);
  6220. #endif /* DEBUG */
  6221.     rc = (ttol((CHAR *)sb_out,i) < 0);       /* Send it. */
  6222. #ifdef OS2
  6223.     ReleaseTelnetMutex();
  6224. #endif
  6225.     if (rc)
  6226.         return(-1);
  6227. #ifndef NOTERM
  6228. #ifdef OS2
  6229.     if (settype)
  6230.         settermtype(tt_type,0);
  6231.     else {
  6232.         ipadl25();
  6233.         VscrnIsDirty(VTERM);
  6234.     }
  6235. #endif /* OS2 */
  6236. #endif /* NOTERM */
  6237.     return(1);
  6238. }
  6239.  
  6240. #ifdef CK_ENVIRONMENT
  6241. #ifdef CK_XDISPLOC
  6242.  
  6243. /* Telnet send xdisplay location */
  6244. /* Returns -1 on error, 0 if nothing happens, 1 if type sent successfully */
  6245.  
  6246. int
  6247. tn_sxdisploc() {                        /* Send telnet X display location. */
  6248.     char * disp=NULL;
  6249.     int i,rc;
  6250.  
  6251.     if (ttnet != NET_TCPB) return(0);
  6252.     if (ttnproto != NP_TELNET) return(0);
  6253.  
  6254.     if (!TELOPT_ME(TELOPT_XDISPLOC)) return(0);
  6255.  
  6256. #ifdef CK_SSL
  6257.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  6258.         return(0);
  6259.     }
  6260. #endif /* CK_SSL */
  6261.  
  6262. #ifdef CK_FORWARD_X
  6263.     if (TELOPT_U(TELOPT_FORWARD_X)) {
  6264.         disp = NULL;
  6265.     } else
  6266. #endif /* CK_FORWARD_X */
  6267.         disp = (char *)tn_get_display();
  6268.     debug(F110,"tn_sxdisploc",disp,0);
  6269.  
  6270.     if (!disp) {
  6271.         /* Can't do both, send WONT */
  6272.         if (tn_sopt(WONT,TELOPT_XDISPLOC) < 0)
  6273.             return(-1);
  6274.         TELOPT_UNANSWERED_WONT(TELOPT_XDISPLOC) = 1;
  6275.         return(0);
  6276.     }
  6277.  
  6278.     sb_out[0] = (CHAR) IAC;                 /* I Am a Command */
  6279.     sb_out[1] = (CHAR) SB;                  /* Subnegotiation */
  6280.     sb_out[2] = TELOPT_XDISPLOC;            /* X-Display Location */
  6281.     sb_out[3] = (CHAR) 0;                   /* Is... */
  6282.     for (i = 4; *disp; disp++,i++) {      /* Copy and uppercase it */
  6283.         sb_out[i] = (char) *disp;
  6284.     }
  6285. #ifdef DEBUG
  6286.     if (deblog || tn_deb || debses) {
  6287.         sb_out[i] = '\0';                   /* For debugging */
  6288.         ckmakxmsg( tn_msg_out,TN_MSG_LEN,
  6289.                   "TELNET SENT SB ",TELOPT(TELOPT_XDISPLOC),
  6290.                   " IS ",(char *)sb_out+4," IAC SE",
  6291.                   NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  6292.     }
  6293. #endif /* DEBUG */
  6294.     sb_out[i++] = (CHAR) IAC;               /* End of Subnegotiation */
  6295.     sb_out[i++] = (CHAR) SE;                /* marked by IAC SE */
  6296. #ifdef OS2
  6297.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  6298. #endif
  6299. #ifdef DEBUG
  6300.     debug(F100,tn_msg_out,"",0);
  6301.     if (tn_deb || debses) tn_debug(tn_msg_out);
  6302. #endif /* DEBUG */
  6303.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  6304. #ifdef OS2
  6305.     ReleaseTelnetMutex();
  6306. #endif
  6307.     if (rc)
  6308.         return(-1);
  6309.     return(1);
  6310. }
  6311. #endif /* CK_XDISPLOC */
  6312. #endif /* CK_ENVIRONMENT */
  6313.  
  6314. #ifdef CK_FORWARD_X
  6315. int
  6316. tn_sndfwdx() {                          /* Send Fwd X Screen number to host */
  6317.     unsigned char screen = 0;
  6318.     char * disp;
  6319.     int i,rc;
  6320.  
  6321.     if (!TELOPT_U(TELOPT_FORWARD_X)) return(0);
  6322. #ifdef CK_SSL
  6323.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  6324.         return(0);
  6325.     }
  6326. #endif /* CK_SSL */
  6327.  
  6328.     /*
  6329.      * The format of the DISPLAY variable is [<host>:]<display>[.<screen>]
  6330.      * where <host> is an optional DNS name or ip address with a default of
  6331.      * the localhost; the screen defaults to 0
  6332.      */
  6333.  
  6334.     disp = tn_get_display();
  6335.     if (disp) {
  6336.         int colon,dot;
  6337.         colon = ckindex(":",disp,0,0,1);
  6338.         dot   = ckindex(".",&disp[colon],0,0,1);
  6339.  
  6340.         if ( dot ) {
  6341.             screen = atoi(&disp[colon+dot]);
  6342.         }
  6343.     } else {
  6344.         screen = 0;
  6345.     }
  6346.  
  6347.     i = 0;
  6348.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  6349.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  6350.     sb_out[i++] = TELOPT_FORWARD_X;           /* Forward X */
  6351.     sb_out[i++] = FWDX_SCREEN;                /* Screen */
  6352.     sb_out[i++] = screen;
  6353.     if ( screen == IAC )
  6354.         sb_out[i++] = IAC;
  6355.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  6356.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  6357. #ifdef DEBUG
  6358.     if (deblog || tn_deb || debses) {
  6359.         ckmakxmsg( tn_msg_out,TN_MSG_LEN,
  6360.                    "TELNET SENT SB ",TELOPT(TELOPT_FORWARD_X),
  6361.                    " SCREEN ",ckctox(screen,1)," IAC SE",
  6362.                    NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  6363.     }
  6364. #endif /* DEBUG */
  6365. #ifdef OS2
  6366.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  6367. #endif
  6368. #ifdef DEBUG
  6369.     debug(F100,tn_msg_out,"",0);
  6370.     if (tn_deb || debses) tn_debug(tn_msg_out);
  6371. #endif /* DEBUG */
  6372.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  6373. #ifdef OS2
  6374.     ReleaseTelnetMutex();
  6375. #endif
  6376.     if (rc)
  6377.         return(-1);
  6378.     return(0);
  6379. }
  6380. #endif /* CK_FORWARD_X */
  6381.  
  6382. #ifdef CK_SNDLOC
  6383. int
  6384. tn_sndloc() {                           /* Send location. */
  6385.     int i,rc;                              /* Worker. */
  6386.     char *ttloc;
  6387.  
  6388.     if (!TELOPT_ME(TELOPT_SNDLOC)) return(0);
  6389.  
  6390. #ifdef CK_SSL
  6391.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  6392.         return(0);
  6393.     }
  6394. #endif /* CK_SSL */
  6395.     ttloc = (tn_loc ? tn_loc : "");     /* In case we are being called even */
  6396.                                         /* though there is no location. */
  6397.     sb_out[0] = (CHAR) IAC;                 /* I Am a Command */
  6398.     sb_out[1] = (CHAR) SB;                  /* Subnegotiation */
  6399.     sb_out[2] = TELOPT_SNDLOC;              /* Location */
  6400.     for (i = 3; *ttloc && i < TSBUFSIZ; ttloc++,i++) /* Copy it */
  6401.       sb_out[i] = (char) *ttloc;
  6402.     sb_out[i++] = (CHAR) IAC;               /* End of Subnegotiation */
  6403.     sb_out[i++] = (CHAR) SE;                /* marked by IAC SE */
  6404.  
  6405. #ifdef DEBUG
  6406.     if (deblog || tn_deb || debses) {
  6407.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  6408.                   "TELNET SENT SB ",TELOPT(TELOPT_SNDLOC)," ",(char *)sb_out+3,
  6409.                   " IAC SE", NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  6410.     }
  6411. #endif /* DEBUG */
  6412. #ifdef OS2
  6413.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  6414. #endif
  6415. #ifdef DEBUG
  6416.     debug(F100,tn_msg_out,"",0);
  6417.     if (tn_deb || debses) tn_debug(tn_msg_out);
  6418. #endif /* DEBUG */
  6419.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  6420. #ifdef OS2
  6421.     ReleaseTelnetMutex();
  6422. #endif
  6423.     if (rc)
  6424.         return(-1);
  6425.     sb_out[i-2] = '\0';                     /* For debugging */
  6426.     return(0);
  6427. }
  6428. #endif /* CK_SNDLOC */
  6429.  
  6430. #ifdef CK_NAWS                  /*  NAWS = Negotiate About Window Size  */
  6431. int
  6432. tn_snaws() {                    /*  Send terminal width and height, RFC 1073 */
  6433. #ifndef NOLOCAL
  6434.     CHAR sb_out[24];            /*  multiple threads */
  6435.     int i = 0,rc;
  6436. #ifdef OS2
  6437.     int x = VscrnGetWidth(VTERM),
  6438.     y = VscrnGetHeight(VTERM) - (tt_status[VTERM] ? 1 : 0);
  6439. #else /* OS2 */
  6440.     int x = tt_cols, y = tt_rows;
  6441. #endif /* OS2 */
  6442.  
  6443.     if (ttnet != NET_TCPB) return(0);
  6444.     if (ttnproto != NP_TELNET) return(0);
  6445.     if (!TELOPT_ME(TELOPT_NAWS)) return(0);
  6446.  
  6447. #ifdef CK_SSL
  6448.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  6449.         return(0);
  6450.     }
  6451. #endif /* CK_SSL */
  6452.     if (x < 0) x = 0;
  6453.     if (y < 0) y = 0;
  6454.  
  6455.     if (x == TELOPT_SB(TELOPT_NAWS).naws.x && /* Only send if changed */
  6456.         y == TELOPT_SB(TELOPT_NAWS).naws.y
  6457.         )
  6458.       return(0);
  6459.     TELOPT_SB(TELOPT_NAWS).naws.x = x;  /* Remember the size     */
  6460.     TELOPT_SB(TELOPT_NAWS).naws.y = y;
  6461.  
  6462.     sb_out[i++] = (CHAR) IAC;               /* Send the subnegotiation */
  6463.     sb_out[i++] = (CHAR) SB;
  6464.     sb_out[i++] = TELOPT_NAWS;
  6465.     sb_out[i++] = (CHAR) (x >> 8) & 0xff;
  6466.     if ((CHAR) sb_out[i-1] == (CHAR) IAC)   /* IAC in data must be doubled */
  6467.       sb_out[i++] = (CHAR) IAC;
  6468.     sb_out[i++] = (CHAR) (x & 0xff);
  6469.     if ((CHAR) sb_out[i-1] == (CHAR) IAC)
  6470.       sb_out[i++] = (CHAR) IAC;
  6471.     sb_out[i++] = (CHAR) (y >> 8) & 0xff;
  6472.     if ((CHAR) sb_out[i-1] == (CHAR) IAC)
  6473.       sb_out[i++] = (CHAR) IAC;
  6474.     sb_out[i++] = (CHAR) (y & 0xff);
  6475.     if ((CHAR) sb_out[i-1] == (CHAR) IAC)
  6476.       sb_out[i++] = (CHAR) IAC;
  6477.     sb_out[i++] = (CHAR) IAC;
  6478.     sb_out[i++] = (CHAR) SE;
  6479. #ifdef DEBUG
  6480.     if (deblog || tn_deb || debses) {
  6481.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,"TELNET SENT SB NAWS ",
  6482.                   ckitoa(x)," ",ckitoa(y)," IAC SE",
  6483.                    NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  6484.     }
  6485. #endif /* DEBUG */
  6486. #ifdef OS2
  6487.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  6488. #endif
  6489. #ifdef DEBUG
  6490.     debug(F100,tn_msg_out,"",0);
  6491.     if (tn_deb || debses) tn_debug(tn_msg_out);
  6492. #endif /* DEBUG */
  6493.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  6494. #ifdef OS2
  6495.     ReleaseTelnetMutex();
  6496. #endif
  6497.     if (rc)
  6498.         return(-1);
  6499. #endif /* NOLOCAL */
  6500.     return (0);
  6501. }
  6502. #endif /* CK_NAWS */
  6503.  
  6504. #ifdef TN_COMPORT
  6505. static char * tnc_signature = NULL;
  6506. static int tnc_ls_mask = 0;
  6507. static int tnc_ls = 0;
  6508. static int tnc_ms_mask = 255;
  6509. static int tnc_ms = 0;
  6510. static int tnc_oflow = 0;
  6511. static int tnc_iflow = 0;
  6512. static int tnc_bps = 0;
  6513. static int tnc_datasize = 0;
  6514. static int tnc_parity = 0;
  6515. static int tnc_stopbit = 0;
  6516. static int tnc_break = 0;
  6517. static int tnc_dtr = 0;
  6518. static int tnc_rts = 0;
  6519. static int tnc_suspend_xmit = 0;
  6520. static int tnc_bps_index = -1;
  6521.  
  6522. int
  6523. #ifdef CK_ANSIC
  6524. tnc_init(void)
  6525. #else /* CK_ANSIC */
  6526. tnc_init()
  6527. #endif /* CK_ANSIC */
  6528. /* tnc_init */ {
  6529.     debug(F100,"tnc_init","",0);
  6530.  
  6531.     if (tnc_signature) {
  6532.         free(tnc_signature);
  6533.         tnc_signature = NULL;
  6534.     }
  6535.     tnc_ls_mask = 0;
  6536.     tnc_ls = 0;
  6537.     tnc_ms_mask = 255;
  6538.     tnc_ms = 0;
  6539.     tnc_oflow = 0;
  6540.     tnc_iflow = 0;
  6541.     tnc_bps = 0;
  6542.     tnc_datasize = 0;
  6543.     tnc_parity = 0;
  6544.     tnc_stopbit = 0;
  6545.     tnc_break = 0;
  6546.     tnc_dtr = 0;
  6547.     tnc_rts = 0;
  6548.     tnc_suspend_xmit = 0;
  6549.     tnc_bps_index = -1;
  6550.     return(0);
  6551. }
  6552.  
  6553. int
  6554. #ifdef CK_ANSIC
  6555. tn_sndcomport(void)
  6556. #else /* CK_ANSIC */
  6557. tn_sndcomport()
  6558. #endif /* CK_ANSIC */
  6559. /* tn_sndcomport */ {
  6560.     int baud, datasize, parity, stopsize, oflow, iflow;
  6561.     CONST char * signature;
  6562.  
  6563.     debug(F100,"tnc_sndcomport","",0);
  6564.     signature = tnc_get_signature();
  6565.     baud = tnc_get_baud();
  6566.     datasize = tnc_get_datasize();
  6567.     parity = tnc_get_parity();
  6568.     stopsize = tnc_get_stopsize();
  6569.     oflow = tnc_get_oflow();
  6570.     iflow = tnc_get_iflow();
  6571.     tnc_set_ls_mask(255);
  6572.     tnc_set_ms_mask(255);
  6573.     return(0);
  6574. }
  6575.  
  6576. int
  6577. #ifdef CK_ANSIC
  6578. tnc_wait(char * msg)
  6579. #else /* CK_ANSIC */
  6580. tnc_wait(msg) char * msg;
  6581. #endif /* CK_ANSIC */
  6582. /* tnc_wait */ {
  6583.     int rc, tn_wait_save = tn_wait_flg;
  6584.     debug(F110,"tnc_wait","begin",0);
  6585.     TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 1;
  6586.     tn_wait_flg = 1;
  6587.     rc = tn_wait(msg);
  6588.     debug(F110,"tnc_wait","end",0);
  6589.     tn_wait_flg = tn_wait_save;
  6590.     return(rc);
  6591. }
  6592.  
  6593. /* Returns -1 on error, 0 on success */
  6594. /* In order for this code to work, sb[len] == IAC          */
  6595.  
  6596. int
  6597. #ifdef CK_ANSIC
  6598. tnc_tn_sb(CHAR * sb, int len)
  6599. #else
  6600. tnc_tn_sb(sb, len) CHAR * sb; int len;
  6601. #endif /* CK_ANSIC */
  6602. /* tnc_tn_sb */ {
  6603.     if (ttnet != NET_TCPB) return(0);
  6604.     if (ttnproto != NP_TELNET) return(0);
  6605.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  6606.  
  6607.     if (!sb) return(-1);
  6608.  
  6609. #ifdef CK_SSL
  6610.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  6611.         return(0);
  6612.     }
  6613. #endif /* CK_SSL */
  6614.  
  6615.     switch (sb[0]) {
  6616.       case TNC_C2S_SIGNATURE:
  6617.       case TNC_S2C_SIGNATURE:
  6618.         debug(F111,"tnc_tn_sb","signature",len);
  6619.         if (len == 1) {
  6620.             tnc_send_signature("Kermit Telnet Com Port Option");
  6621.         } else {
  6622.             TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6623.             if (tnc_signature)
  6624.               free(tnc_signature);
  6625.             tnc_signature = malloc(len);
  6626.             if (tnc_signature) {
  6627.                 memcpy(tnc_signature,&sb[1],len-1);
  6628.                 tnc_signature[len-1] = '\0';
  6629.             }
  6630.         }
  6631.         break;
  6632.  
  6633.       case TNC_C2S_SET_BAUDRATE:
  6634.       case TNC_S2C_SET_BAUDRATE: {
  6635.           long baudrate;
  6636.           char * br = (char *)&baudrate;
  6637.           TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6638.           if (len == 2) {
  6639.             /* Actual behavior of the Access Server... */
  6640.             debug(F111,"tnc_tn_sb","baudrate index",sb[1]);
  6641.             tnc_bps_index = 1;
  6642.             switch (sb[1]) {
  6643.             case TNC_BPS_300:
  6644.               tnc_bps = 300;
  6645.               break;
  6646.             case TNC_BPS_600:
  6647.               tnc_bps = 600;
  6648.               break;
  6649.             case TNC_BPS_1200:
  6650.               tnc_bps = 1200;
  6651.               break;
  6652.             case TNC_BPS_2400:
  6653.               tnc_bps = 2400;
  6654.               break;
  6655.             case TNC_BPS_4800:
  6656.               tnc_bps = 4800;
  6657.               break;
  6658.             case TNC_BPS_9600:
  6659.               tnc_bps = 9600;
  6660.               break;
  6661.             case TNC_BPS_14400:
  6662.               tnc_bps = 14400;
  6663.               break;
  6664.             case TNC_BPS_19200:
  6665.               tnc_bps = 19200;
  6666.               break;
  6667.             case TNC_BPS_28800:
  6668.               tnc_bps = 28800;
  6669.               break;
  6670.             case TNC_BPS_38400:
  6671.               tnc_bps = 38400;
  6672.               break;
  6673.             case TNC_BPS_57600:
  6674.               tnc_bps = 57600;
  6675.               break;
  6676.             case TNC_BPS_115200:
  6677.               tnc_bps = 115200;
  6678.               break;
  6679.             case TNC_BPS_230400:
  6680.               tnc_bps = 230400;
  6681.               break;
  6682.             case TNC_BPS_460800:
  6683.               tnc_bps = 460800;
  6684.               break;
  6685.             default:
  6686.               tnc_bps = -1;
  6687.             }
  6688.           } else if (len == 5) {
  6689.             /* This section attempts to follow RFC 2217 */
  6690.               tnc_bps_index = 0;
  6691.               br[0] = sb[1];
  6692.               br[1] = sb[2];
  6693.               br[2] = sb[3];
  6694.               br[3] = sb[4];
  6695. #ifdef datageneral
  6696.               /* AOS/VS doesn't have ntohl() but MV's are big-endian */
  6697.               tnc_bps = baudrate;
  6698. #else
  6699.               tnc_bps = ntohl(baudrate);
  6700. #endif /* datageneral */
  6701.               debug(F111,"tnc_tn_sb","baudrate rfc",tnc_bps);
  6702.           } else {
  6703.               debug(F111,"tnc_tn_sb","baudrate invalid len",len);
  6704.               return(-1);
  6705.           }
  6706.           break;
  6707.       }
  6708.       case TNC_C2S_SET_DATASIZE:
  6709.       case TNC_S2C_SET_DATASIZE:
  6710.         TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6711.         if (len < 2)
  6712.           return(-1);
  6713.         tnc_datasize = sb[1];
  6714.         debug(F111,"tnc_tn_sb","datasize",sb[1]);
  6715.         break;
  6716.  
  6717.       case TNC_C2S_SET_PARITY:
  6718.       case TNC_S2C_SET_PARITY:
  6719.         TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6720.         if (len < 2)
  6721.           return(-1);
  6722.         tnc_parity = sb[1];
  6723.         debug(F111,"tnc_tn_sb","parity",sb[1]);
  6724.         break;
  6725.  
  6726.       case TNC_C2S_SET_STOPSIZE:
  6727.       case TNC_S2C_SET_STOPSIZE:
  6728.         TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6729.         if (len < 2)
  6730.           return(-1);
  6731.         tnc_stopbit = sb[1];
  6732.         debug(F111,"tnc_tn_sb","stopsize",sb[1]);
  6733.         break;
  6734.  
  6735.       case TNC_C2S_SET_CONTROL:
  6736.       case TNC_S2C_SET_CONTROL:
  6737.         if (len < 2) {
  6738.             TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6739.             return(-1);
  6740.         }
  6741.  
  6742.         /* This line should be removed when testing is complete. */
  6743.         TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6744.  
  6745.         switch ( sb[1] ) {
  6746.           case TNC_CTL_OFLOW_REQUEST:
  6747.             /* determine local outbound flow control and send to peer */
  6748.             debug(F110,"tnc_tn_sb","oflow request",0);
  6749.             break;
  6750.           case TNC_CTL_OFLOW_NONE:
  6751.           case TNC_CTL_OFLOW_XON_XOFF:
  6752.           case TNC_CTL_OFLOW_RTS_CTS:
  6753.           case TNC_CTL_OFLOW_DCD:
  6754.           case TNC_CTL_OFLOW_DSR:
  6755.             TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6756.             tnc_oflow = sb[1];
  6757.             debug(F111,"tnc_tn_sb","oflow",sb[1]);
  6758.             break;
  6759.           case TNC_CTL_BREAK_REQUEST:
  6760.             /* determine local break state and send to peer */
  6761.             debug(F110,"tnc_tn_sb","break request",0);
  6762.             break;
  6763.           case TNC_CTL_BREAK_ON:
  6764.             TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6765.             tnc_break = 1;
  6766.             debug(F110,"tnc_tn_sb","break on",0);
  6767.             break;
  6768.  
  6769.           case TNC_CTL_BREAK_OFF:
  6770.             TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6771.             tnc_break = 0;
  6772.             debug(F110,"tnc_tn_sb","break off",0);
  6773.             break;
  6774.  
  6775.           case TNC_CTL_DTR_REQUEST:
  6776.             /* determine local dtr state and send to peer */
  6777.             debug(F110,"tnc_tn_sb","dtr request",0);
  6778.             break;
  6779.  
  6780.           case TNC_CTL_DTR_ON:
  6781.             TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6782.             tnc_dtr = 1;
  6783.             debug(F110,"tnc_tn_sb","dtr on",0);
  6784.             break;
  6785.  
  6786.           case TNC_CTL_DTR_OFF:
  6787.             TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6788.             tnc_dtr = 0;
  6789.             debug(F110,"tnc_tn_sb","dtr off",0);
  6790.             break;
  6791.  
  6792.           case TNC_CTL_RTS_REQUEST:
  6793.             /* determine local rts state and send to peer */
  6794.             debug(F110,"tnc_tn_sb","rts request",0);
  6795.             break;
  6796.  
  6797.           case TNC_CTL_RTS_ON:
  6798.             TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6799.             tnc_rts = 1;
  6800.             debug(F110,"tnc_tn_sb","rts on",0);
  6801.             break;
  6802.  
  6803.           case TNC_CTL_RTS_OFF:
  6804.             TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6805.             tnc_rts = 0;
  6806.             debug(F110,"tnc_tn_sb","rts off",0);
  6807.             break;
  6808.  
  6809.           case TNC_CTL_IFLOW_REQUEST:
  6810.             /* determine local inbound flow control and send to peer */
  6811.             debug(F110,"tnc_tn_sb","iflow request",0);
  6812.             break;
  6813.  
  6814.           case TNC_CTL_IFLOW_NONE:
  6815.           case TNC_CTL_IFLOW_XON_XOFF:
  6816.           case TNC_CTL_IFLOW_RTS_CTS:
  6817.           case TNC_CTL_IFLOW_DTR:
  6818.             TELOPT_SB(TELOPT_COMPORT).comport.wait_for_sb = 0;
  6819.             tnc_iflow = sb[1];
  6820.             debug(F111,"tnc_tn_sb","iflow",sb[1]);
  6821.             break;
  6822.           default:
  6823.             return(-1);
  6824.         }
  6825.         break;
  6826.  
  6827.       case TNC_C2S_NOTIFY_LINESTATE:
  6828.       case TNC_S2C_SEND_LS:
  6829.         if (len < 2)
  6830.           return(-1);
  6831.         tnc_ls = sb[1];
  6832.         debug(F111,"tnc_tn_sb","linestate",sb[1]);
  6833.         if (tn_deb || debses) {
  6834.             if (tnc_ls & TNC_MS_DATA_READY )
  6835.               tn_debug("  ComPort Linestate Data Ready");
  6836.             if (tnc_ls & TNC_MS_OVERRUN_ERROR )
  6837.               tn_debug("  ComPort Linestate Overrun Error");
  6838.             if (tnc_ls & TNC_MS_PARITY_ERROR )
  6839.               tn_debug("  ComPort Linestate Parity Error");
  6840.             if (tnc_ls & TNC_MS_FRAME_ERROR )
  6841.               tn_debug("  ComPort Linestate Framing Error");
  6842.             if (tnc_ls & TNC_MS_BREAK_ERROR )
  6843.               tn_debug("  ComPort Linestate Break Detect Error");
  6844.             if (tnc_ls & TNC_MS_HR_EMPTY )
  6845.               tn_debug("  ComPort Linestate Holding Register Empty");
  6846.             if (tnc_ls & TNC_MS_SR_EMPTY )
  6847.               tn_debug("  ComPort Linestate Shift Register Empty");
  6848.             if (tnc_ls & TNC_MS_TIMEOUT_ERROR )
  6849.               tn_debug("  ComPort Linestate Timeout Error");
  6850.         }
  6851.         break;
  6852.  
  6853.       case TNC_C2S_NOTIFY_MODEMSTATE:
  6854.       case TNC_S2C_SEND_MS:
  6855.         if (len < 2)
  6856.           return(-1);
  6857.         tnc_ms = sb[1];
  6858.         debug(F111,"tnc_tn_sb","modemstate",sb[1]);
  6859.         if (tn_deb || debses) {
  6860.             if (tnc_ms & TNC_MS_CTS_DELTA )
  6861.               tn_debug("  ComPort Modemstate CTS State Change");
  6862.             if (tnc_ms & TNC_MS_DSR_DELTA )
  6863.               tn_debug("  ComPort Modemstate DSR State Change");
  6864.             if (tnc_ms &
  6865.                 TNC_MS_EDGE_RING )
  6866.               tn_debug("  ComPort Modemstate Trailing Edge Ring Detector On");
  6867.             else
  6868.               tn_debug("  ComPort Modemstate Trailing Edge Ring Detector Off");
  6869.             if (tnc_ms & TNC_MS_RLSD_DELTA )
  6870.               tn_debug("  ComPort Modemstate RLSD State Change");
  6871.             if (tnc_ms & TNC_MS_CTS_SIG )
  6872.               tn_debug("  ComPort Modemstate CTS Signal On");
  6873.             else
  6874.               tn_debug("  ComPort Modemstate CTS Signal Off");
  6875.             if (tnc_ms & TNC_MS_DSR_SIG )
  6876.               tn_debug("  ComPort Modemstate DSR Signal On");
  6877.             else
  6878.               tn_debug("  ComPort Modemstate DSR Signal Off");
  6879.             if (tnc_ms & TNC_MS_RI_SIG )
  6880.               tn_debug("  ComPort Modemstate Ring Indicator On");
  6881.             else
  6882.               tn_debug("  ComPort Modemstate Ring Indicator Off");
  6883.             if (tnc_ms & TNC_MS_RLSD_SIG )
  6884.               tn_debug("  ComPort Modemstate RLSD Signal On");
  6885.             else
  6886.               tn_debug("  ComPort Modemstate RLSD Signal Off");
  6887.         }
  6888.         break;
  6889.  
  6890.       case TNC_C2S_FLOW_SUSPEND:
  6891.       case TNC_S2C_FLOW_SUSPEND:
  6892.         debug(F110,"tnc_tn_sb","flow suspend",0);
  6893.         tnc_suspend_xmit = 1;
  6894.         break;
  6895.  
  6896.       case TNC_C2S_FLOW_RESUME:
  6897.       case TNC_S2C_FLOW_RESUME:
  6898.         debug(F110,"tnc_tn_sb","flow resume",0);
  6899.         tnc_suspend_xmit = 0;
  6900.         break;
  6901.  
  6902.       case TNC_C2S_SET_LS_MASK:
  6903.       case TNC_S2C_SET_LS_MASK:
  6904.         if (len < 2)
  6905.           return(-1);
  6906.         debug(F111,"tnc_tn_sb","linestate mask",sb[1]);
  6907.         tnc_ls_mask = sb[1];
  6908.         break;
  6909.  
  6910.       case TNC_C2S_SET_MS_MASK:
  6911.       case TNC_S2C_SET_MS_MASK:
  6912.         if (len < 2)
  6913.           return(-1);
  6914.         debug(F111,"tnc_tn_sb","modemstate mask",sb[1]);
  6915.         tnc_ls_mask = sb[1];
  6916.         break;
  6917.  
  6918.       case TNC_C2S_PURGE:
  6919.       case TNC_S2C_PURGE:
  6920.         if (len < 2)
  6921.           return(-1);
  6922.         debug(F111,"tnc_tn_sb","purge",sb[1]);
  6923.         switch ( sb[1] ) {
  6924.           case TNC_PURGE_RECEIVE:
  6925.           case TNC_PURGE_TRANSMIT:
  6926.           case TNC_PURGE_BOTH:
  6927.             /* purge local buffers */
  6928.             break;
  6929.           default:
  6930.             return(-1);
  6931.         }
  6932.         break;
  6933.       default:
  6934.         return(-1);
  6935.     }
  6936.     return(0);
  6937. }
  6938.  
  6939. CONST char *
  6940. #ifdef CK_ANSIC
  6941. tnc_get_signature(void)
  6942. #else /* CK_ANSIC */
  6943. tnc_get_signature()
  6944. #endif /* CK_ANSIC */
  6945. /* tnc_get_signature */ {
  6946.     /* send IAC SB COM-PORT SIGNATURE IAC SE */
  6947.     /* wait for response */
  6948.     int i = 0, rc;
  6949.  
  6950.     if (ttnet != NET_TCPB) return(NULL);
  6951.     if (ttnproto != NP_TELNET) return(NULL);
  6952.  
  6953.     if (!TELOPT_ME(TELOPT_COMPORT)) return(NULL);
  6954.  
  6955. #ifdef CK_SSL
  6956.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  6957.         return(NULL);
  6958.     }
  6959. #endif /* CK_SSL */
  6960.  
  6961.     sb_out[i++] = (CHAR) IAC;           /* I Am a Command */
  6962.     sb_out[i++] = (CHAR) SB;            /* Subnegotiation */
  6963.     sb_out[i++] = TELOPT_COMPORT;               /* ComPort */
  6964.     sb_out[i++] = TNC_C2S_SIGNATURE;    /* Signature */
  6965.     sb_out[i++] = (CHAR) IAC;               /* End of Subnegotiation */
  6966.     sb_out[i++] = (CHAR) SE;                /* marked by IAC SE */
  6967.  
  6968. #ifdef DEBUG
  6969.     if (deblog || tn_deb || debses) {
  6970.         ckmakmsg(tn_msg_out,TN_MSG_LEN,
  6971.                  "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  6972.                  " SIGNATURE IAC SE", NULL);
  6973.     }
  6974. #endif /* DEBUG */
  6975. #ifdef OS2
  6976.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  6977. #endif
  6978. #ifdef DEBUG
  6979.     debug(F100,tn_msg_out,"",0);
  6980.     if (tn_deb || debses) tn_debug(tn_msg_out);
  6981. #endif /* DEBUG */
  6982.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  6983. #ifdef OS2
  6984.     ReleaseTelnetMutex();
  6985. #endif
  6986.     if (rc)
  6987.         return(NULL);
  6988.  
  6989.     if (tnc_wait("comport signature request") < 0) {
  6990.         tn_push();
  6991.         return(NULL);
  6992.     }
  6993.     debug(F110,"tnc_get_signature",tnc_signature,0);
  6994.     return(tnc_signature);
  6995. }
  6996.  
  6997. int
  6998. #ifdef CK_ANSIC
  6999. tnc_send_signature(char * signature)
  7000. #else /* CK_ANSIC */
  7001. tnc_send_signature(signature) char * signature;
  7002. #endif /* CK_ANSIC */
  7003. /* tnc_send_signature */ {
  7004.     /* send IAC SB COM-PORT SIGNATURE <text> IAC SE */
  7005.     int i = 0, j = 0, rc;
  7006.  
  7007.     debug(F110,"tnc_send_signature",signature,0);
  7008.  
  7009.     if (!signature || !signature[0])
  7010.       return(0);
  7011.  
  7012.     if (ttnet != NET_TCPB) return(0);
  7013.     if (ttnproto != NP_TELNET) return(0);
  7014.  
  7015.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7016.  
  7017. #ifdef CK_SSL
  7018.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7019.         return(0);
  7020.     }
  7021. #endif /* CK_SSL */
  7022.  
  7023.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7024.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7025.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7026.     sb_out[i++] = TNC_C2S_SIGNATURE;      /* Signature */
  7027.     for (; signature[j]; i++,j++)
  7028.       sb_out[i] = signature[j];
  7029.     sb_out[i++] = (CHAR) IAC;               /* End of Subnegotiation */
  7030.     sb_out[i++] = (CHAR) SE;                /* marked by IAC SE */
  7031.  
  7032. #ifdef DEBUG
  7033.     if (deblog || tn_deb || debses) {
  7034.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7035.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7036.                   " SIGNATURE ", signature, " IAC SE", NULL,
  7037.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7038.     }
  7039. #endif /* DEBUG */
  7040. #ifdef OS2
  7041.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7042. #endif
  7043. #ifdef DEBUG
  7044.     debug(F100,tn_msg_out,"",0);
  7045.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7046. #endif /* DEBUG */
  7047.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7048. #ifdef OS2
  7049.     ReleaseTelnetMutex();
  7050. #endif
  7051.     if (rc)
  7052.         return(-1);
  7053.     return(0);
  7054. }
  7055.  
  7056. int
  7057. #ifdef CK_ANSIC
  7058. tnc_set_baud( long baud )
  7059. #else /* CK_ANSIC */
  7060. tnc_set_baud(baud) long baud;
  7061. #endif /* CK_ANSIC */
  7062. /* tnc_set_baud */ {
  7063.     /* send IAC SB COM-PORT SET-BAUD <value(4)> IAC SE  */
  7064.     /* wait for response */
  7065.     /* 0 is used to request the current baud rate and */
  7066.     /* may not be sent by this func */
  7067.     /* return new host value */
  7068.  
  7069.     /*
  7070.      *   the above comes from the RFC.  But that is not what I am seeing
  7071.      *   instead I appear to be seeing to following:
  7072.      *
  7073.      *      Value               Baud
  7074.      *          1               ?
  7075.      *          2               ?
  7076.      *          3               300
  7077.      *          4               600
  7078.      *          5               1200
  7079.      *          6               2400
  7080.      *          7               4800      ?
  7081.      *          8               9600
  7082.      *          9                         ?
  7083.      *          10              19200     ?
  7084.      *          11                        ?
  7085.      *          12              38400
  7086.      *          13              57600     ?
  7087.      *          14              115200
  7088.      *          15              230400    ?
  7089.      *          16              460800    ?
  7090.      */
  7091.  
  7092.     int i = 0, rc;
  7093. #ifdef datageneral
  7094.     /* AOS/VS doesn't have htonl() but MV's are big-endian */
  7095.     long net_baud = baud;
  7096. #else
  7097.     long net_baud = htonl(baud);
  7098. #endif /* datageneral */
  7099.     CHAR b;
  7100.  
  7101.     debug(F111,"tnc_set_baud","begin",baud);
  7102.  
  7103.     if (ttnet != NET_TCPB) return(0);
  7104.     if (ttnproto != NP_TELNET) return(0);
  7105.  
  7106.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7107.  
  7108. #ifdef CK_SSL
  7109.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7110.         return(0);
  7111.     }
  7112. #endif /* CK_SSL */
  7113.  
  7114.     if (baud <= 0)
  7115.         return(0);
  7116.  
  7117.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7118.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7119.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7120.     sb_out[i++] = TNC_C2S_SET_BAUDRATE;   /* Set Baud Rate */
  7121.  
  7122.     if (tnc_bps_index) {
  7123.         /* IOS Access Server */
  7124.         if (baud <= 300)
  7125.             b = TNC_BPS_300;
  7126.         else if (baud <= 600)
  7127.             b = TNC_BPS_600;
  7128.         else if (baud <= 1200)
  7129.             b = TNC_BPS_1200;
  7130.         else if (baud <= 2400)
  7131.             b = TNC_BPS_2400;
  7132.         else if (baud <= 4800)
  7133.             b = TNC_BPS_4800;
  7134.         else if (baud <= 9600)
  7135.             b = TNC_BPS_9600;
  7136.         else if (baud <= 14400)
  7137.             b = TNC_BPS_14400;
  7138.         else if (baud <= 19200)
  7139.             b = TNC_BPS_19200;
  7140.         else if (baud <= 28800)
  7141.             b = TNC_BPS_28800;
  7142.         else if (baud <= 38400)
  7143.             b = TNC_BPS_38400;
  7144.         else if (baud <= 57600)
  7145.             b = TNC_BPS_57600;
  7146.         else if (baud <= 115200)
  7147.             b = TNC_BPS_115200;
  7148.         else if (baud <= 230400)
  7149.             b = TNC_BPS_230400;
  7150.         else
  7151.             b = TNC_BPS_460800;
  7152.         sb_out[i++] = b;
  7153.     } else {
  7154.         /* RFC 2217 */
  7155.         sb_out[i++] = ((char *)&net_baud)[0];
  7156.         sb_out[i++] = ((char *)&net_baud)[1];
  7157.         sb_out[i++] = ((char *)&net_baud)[2];
  7158.         sb_out[i++] = ((char *)&net_baud)[3];
  7159.     }
  7160.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7161.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7162.  
  7163. #ifdef DEBUG
  7164.     if (deblog || tn_deb || debses) {
  7165.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7166.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7167.                   " SET-BAUD-RATE ", ckltoa(baud)," IAC SE", NULL,
  7168.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7169.     }
  7170. #endif /* DEBUG */
  7171.  
  7172. #ifdef OS2
  7173.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7174. #endif
  7175. #ifdef DEBUG
  7176.     debug(F100,tn_msg_out,"",0);
  7177.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7178. #endif /* DEBUG */
  7179.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7180. #ifdef OS2
  7181.     ReleaseTelnetMutex();
  7182. #endif
  7183.     if (rc)
  7184.         return(-1);
  7185.  
  7186.     if (tnc_wait("comport set baud rate") < 0) {
  7187.         tn_push();
  7188.         return(-1);
  7189.     }
  7190.     debug(F111,"tnc_set_baud","end",tnc_bps);
  7191.     return(tnc_bps);
  7192. }
  7193.  
  7194. int
  7195. #ifdef CK_ANSIC
  7196. tnc_get_baud(void)
  7197. #else /* CK_ANSIC */
  7198. tnc_get_baud()
  7199. #endif /* CK_ANSIC */
  7200. /* tnc_get_baud */ {
  7201.     /* send IAC SB COM-PORT SET-BAUD <value(4)=0> IAC SE  */
  7202.     /* wait for response */
  7203.     int i = 0, rc;
  7204.  
  7205.     debug(F110,"tnc_get_baud","begin",0);
  7206.  
  7207.     if (ttnet != NET_TCPB) return(0);
  7208.     if (ttnproto != NP_TELNET) return(0);
  7209.  
  7210.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7211.  
  7212. #ifdef CK_SSL
  7213.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7214.         return(0);
  7215.     }
  7216. #endif /* CK_SSL */
  7217.  
  7218.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7219.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7220.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7221.     sb_out[i++] = TNC_C2S_SET_BAUDRATE;   /* Set Baud Rate */
  7222.  
  7223.     if (tnc_bps_index > 0) {
  7224.         /* Access Server */
  7225.         sb_out[i++] = 0;
  7226.     } else {
  7227.         /* RFC 2217 */
  7228.         sb_out[i++] = 0;
  7229.         sb_out[i++] = 0;
  7230.         sb_out[i++] = 0;
  7231.         sb_out[i++] = 0;
  7232.     }
  7233.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7234.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7235.  
  7236. #ifdef DEBUG
  7237.     if (deblog || tn_deb || debses) {
  7238.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7239.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7240.                   " SET-BAUD-RATE ", ckltoa(0)," IAC SE", NULL,
  7241.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7242.     }
  7243. #endif /* DEBUG */
  7244. #ifdef OS2
  7245.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7246. #endif
  7247. #ifdef DEBUG
  7248.     debug(F100,tn_msg_out,"",0);
  7249.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7250. #endif /* DEBUG */
  7251.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7252. #ifdef OS2
  7253.     ReleaseTelnetMutex();
  7254. #endif
  7255.     if (rc)
  7256.         return(-1);
  7257.  
  7258.     if (tnc_wait("comport get baud rate") < 0) {
  7259.         tn_push();
  7260.         return(-1);
  7261.     }
  7262.     debug(F111,"tnc_get_baud","end",tnc_bps);
  7263.     return(tnc_bps);
  7264. }
  7265.  
  7266. int
  7267. #ifdef CK_ANSIC
  7268. tnc_set_datasize(int datasize)
  7269. #else /* CK_ANSIC */
  7270. tnc_set_datasize(datasize) int datasize;
  7271. #endif /* CK_ANSIC */
  7272. /* tnc_set_datasize */ {
  7273.     /* IAC SB COM-PORT SET_DATASIZE <value(1)> IAC SE */
  7274.     /* Valid <value>s are 5 through 8 */
  7275.     /* Wait for response */
  7276.     /* return new host value */
  7277.  
  7278.     int i = 0, rc;
  7279.  
  7280.     debug(F111,"tnc_set_datasize","begin",datasize);
  7281.  
  7282.     if (ttnet != NET_TCPB) return(0);
  7283.     if (ttnproto != NP_TELNET) return(0);
  7284.  
  7285.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7286.  
  7287. #ifdef CK_SSL
  7288.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7289.         return(0);
  7290.     }
  7291. #endif /* CK_SSL */
  7292.  
  7293.     if ( !(datasize >= 5 && datasize <= 8) )
  7294.         return(0);
  7295.  
  7296.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7297.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7298.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7299.     sb_out[i++] = TNC_C2S_SET_DATASIZE;   /* Set DataSize */
  7300.     sb_out[i++] = (unsigned char)(datasize & 0xFF);
  7301.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7302.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7303.  
  7304. #ifdef DEBUG
  7305.     if (deblog || tn_deb || debses) {
  7306.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7307.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7308.                   " SET-DATASIZE ", ckitoa(datasize)," IAC SE", NULL,
  7309.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7310.     }
  7311. #endif /* DEBUG */
  7312. #ifdef OS2
  7313.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7314. #endif
  7315. #ifdef DEBUG
  7316.     debug(F100,tn_msg_out,"",0);
  7317.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7318. #endif /* DEBUG */
  7319.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7320. #ifdef OS2
  7321.     ReleaseTelnetMutex();
  7322. #endif
  7323.     if (rc)
  7324.         return(-1);
  7325.  
  7326.     if (tnc_wait("comport set datasize") < 0) {
  7327.         tn_push();
  7328.         return(-1);
  7329.     }
  7330.     debug(F111,"tnc_set_datasize","end",tnc_datasize);
  7331.     return(tnc_datasize);
  7332. }
  7333.  
  7334. int
  7335. #ifdef CK_ANSIC
  7336. tnc_get_datasize(void)
  7337. #else /* CK_ANSIC */
  7338. tnc_get_datasize()
  7339. #endif /* CK_ANSIC */
  7340. /* tnc_get_datasize */ {
  7341.     /* IAC SB COM-PORT SET_DATASIZE <value(1)=0> IAC SE */
  7342.     /* Wait for response */
  7343.     int i = 0, rc;
  7344.  
  7345.     debug(F110,"tnc_get_datasize","begin",0);
  7346.  
  7347.     if (ttnet != NET_TCPB) return(0);
  7348.     if (ttnproto != NP_TELNET) return(0);
  7349.  
  7350.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7351.  
  7352. #ifdef CK_SSL
  7353.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7354.         return(0);
  7355.     }
  7356. #endif /* CK_SSL */
  7357.  
  7358.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7359.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7360.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7361.     sb_out[i++] = TNC_C2S_SET_DATASIZE;   /* Set DataSize */
  7362.     sb_out[i++] = 0;
  7363.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7364.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7365.  
  7366. #ifdef DEBUG
  7367.     if (deblog || tn_deb || debses) {
  7368.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7369.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7370.                   " SET-DATASIZE ", ckltoa(0)," IAC SE", NULL,
  7371.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7372.     }
  7373. #endif /* DEBUG */
  7374. #ifdef OS2
  7375.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7376. #endif
  7377. #ifdef DEBUG
  7378.     debug(F100,tn_msg_out,"",0);
  7379.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7380. #endif /* DEBUG */
  7381.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7382. #ifdef OS2
  7383.     ReleaseTelnetMutex();
  7384. #endif
  7385.     if (rc)
  7386.         return(-1);
  7387.  
  7388.     if (tnc_wait("comport get datasize") < 0) {
  7389.         tn_push();
  7390.         return(-1);
  7391.     }
  7392.     debug(F111,"tnc_get_datasize","end",tnc_datasize);
  7393.     return(tnc_datasize);
  7394. }
  7395.  
  7396. int
  7397. #ifdef CK_ANSIC
  7398. tnc_set_parity(int parity)
  7399. #else /* CK_ANSIC */
  7400. tnc_set_parity(parity) int parity;
  7401. #endif /* CK_ANSIC */
  7402. /* tnc_set_parity */ {
  7403.     /* IAC SB COM-PORT SET_PARITY <value(1)> IAC SE */
  7404.     /*        Value     Parity
  7405.      *          1       None
  7406.      *          2       Odd
  7407.      *          3       Even
  7408.      *          4       Mark
  7409.      *          5       Space
  7410.      */
  7411.     /* Wait for response.  Return new host value. */
  7412.     int i = 0, rc;
  7413.  
  7414.     debug(F110,"tnc_set_parity","begin",parity);
  7415.  
  7416.     if (ttnet != NET_TCPB) return(0);
  7417.     if (ttnproto != NP_TELNET) return(0);
  7418.  
  7419.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7420.  
  7421. #ifdef CK_SSL
  7422.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7423.         return(0);
  7424.     }
  7425. #endif /* CK_SSL */
  7426.  
  7427.     if ( !(parity >= 1 && parity <= 5) )
  7428.         return(0);
  7429.  
  7430.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7431.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7432.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7433.     sb_out[i++] = TNC_C2S_SET_PARITY;     /* Set Parity */
  7434.     sb_out[i++] = (unsigned char)(parity & 0xFF);
  7435.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7436.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7437.  
  7438. #ifdef DEBUG
  7439.     if (deblog || tn_deb || debses) {
  7440.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7441.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7442.                   " SET-PARITY ", ckitoa(parity)," IAC SE", NULL,
  7443.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7444.     }
  7445. #endif /* DEBUG */
  7446. #ifdef OS2
  7447.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7448. #endif
  7449. #ifdef DEBUG
  7450.     debug(F100,tn_msg_out,"",0);
  7451.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7452. #endif /* DEBUG */
  7453.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7454. #ifdef OS2
  7455.     ReleaseTelnetMutex();
  7456. #endif
  7457.     if (rc)
  7458.         return(-1);
  7459.  
  7460.     if (tnc_wait("comport set parity") < 0) {
  7461.         tn_push();
  7462.         return(-1);
  7463.     }
  7464.     debug(F111,"tnc_set_parity","end",tnc_parity);
  7465.     return(tnc_parity);
  7466. }
  7467.  
  7468. int
  7469. #ifdef CK_ANSIC
  7470. tnc_get_parity(void)
  7471. #else /* CK_ANSIC */
  7472. tnc_get_parity()
  7473. #endif /* CK_ANSIC */
  7474. /* tnc_get_parity */ {
  7475.     /* IAC SB COM-PORT SET_PARITY <value(1)=0> IAC SE */
  7476.     /* wait for response */
  7477.     int i = 0, rc;
  7478.  
  7479.     debug(F110,"tnc_get_parity","begin",0);
  7480.     if (ttnet != NET_TCPB) return(0);
  7481.     if (ttnproto != NP_TELNET) return(0);
  7482.  
  7483.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7484.  
  7485. #ifdef CK_SSL
  7486.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7487.         return(0);
  7488.     }
  7489. #endif /* CK_SSL */
  7490.  
  7491.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7492.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7493.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7494.     sb_out[i++] = TNC_C2S_SET_PARITY;     /* Set Parity */
  7495.     sb_out[i++] = 0;
  7496.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7497.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7498.  
  7499. #ifdef DEBUG
  7500.     if (deblog || tn_deb || debses) {
  7501.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7502.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7503.                   " SET-PARITY ", ckitoa(0)," IAC SE", NULL,
  7504.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7505.     }
  7506. #endif /* DEBUG */
  7507. #ifdef OS2
  7508.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7509. #endif
  7510. #ifdef DEBUG
  7511.     debug(F100,tn_msg_out,"",0);
  7512.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7513. #endif /* DEBUG */
  7514.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7515. #ifdef OS2
  7516.     ReleaseTelnetMutex();
  7517. #endif
  7518.     if (rc)
  7519.         return(-1);
  7520.  
  7521.     if (tnc_wait("comport get parity") < 0) {
  7522.         tn_push();
  7523.         return(-1);
  7524.     }
  7525.     debug(F111,"tnc_get_parity","end",tnc_parity);
  7526.     return(tnc_parity);
  7527. }
  7528.  
  7529. int
  7530. #ifdef CK_ANSIC
  7531. tnc_set_stopsize(int stopsize)
  7532. #else /* CK_ANSIC */
  7533. tnc_set_stopsize(stopsize) int stopsize;
  7534. #endif /* CK_ANSIC */
  7535. /* tnc_set_stopsize */ {
  7536.     /* IAC SB COM-PORT SET_STOPSIZE <value(1)> IAC SE */
  7537.     /*        Value     Stop Bit Size
  7538.      *          1       1
  7539.      *          2       2
  7540.      *          3       1.5
  7541.      */
  7542.     /* Wait for response.  Return new host value. */
  7543.     int i = 0, rc;
  7544.  
  7545.     debug(F111,"tnc_set_stopsize","begin",stopsize);
  7546.     if (ttnet != NET_TCPB) return(0);
  7547.     if (ttnproto != NP_TELNET) return(0);
  7548.  
  7549.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7550.  
  7551. #ifdef CK_SSL
  7552.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7553.         return(0);
  7554.     }
  7555. #endif /* CK_SSL */
  7556.  
  7557.     if (!(stopsize >= 1 && stopsize <= 3) )
  7558.       return(0);
  7559.  
  7560.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7561.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7562.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7563.     sb_out[i++] = TNC_C2S_SET_STOPSIZE;   /* Set Stop Bits */
  7564.     sb_out[i++] = (unsigned char)(stopsize & 0xFF);
  7565.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7566.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7567.  
  7568. #ifdef DEBUG
  7569.     if (deblog || tn_deb || debses) {
  7570.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7571.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7572.                   " SET-STOPSIZE ", ckitoa(stopsize)," IAC SE", NULL,
  7573.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7574.     }
  7575. #endif /* DEBUG */
  7576. #ifdef OS2
  7577.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7578. #endif
  7579. #ifdef DEBUG
  7580.     debug(F100,tn_msg_out,"",0);
  7581.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7582. #endif /* DEBUG */
  7583.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7584. #ifdef OS2
  7585.     ReleaseTelnetMutex();
  7586. #endif
  7587.     if (rc)
  7588.         return(-1);
  7589.  
  7590.     if (tnc_wait("comport set stopsize") < 0) {
  7591.         tn_push();
  7592.         return(-1);
  7593.     }
  7594.     debug(F111,"tnc_set_stopsize","end",tnc_stopbit);
  7595.     return(tnc_stopbit);
  7596. }
  7597.  
  7598. int
  7599. #ifdef CK_ANSIC
  7600. tnc_get_stopsize(void)
  7601. #else /* CK_ANSIC */
  7602. tnc_get_stopsize()
  7603. #endif /* CK_ANSIC */
  7604. /* tnc_get_stopsize */ {
  7605.     /* IAC SB COM-PORT SET_STOPSIZE <value(1)=0> IAC SE */
  7606.     /* Wait for response */
  7607.     int i = 0, rc;
  7608.  
  7609.     debug(F110,"tnc_get_stopsize","begin",0);
  7610.     if (ttnet != NET_TCPB) return(0);
  7611.     if (ttnproto != NP_TELNET) return(0);
  7612.  
  7613.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7614.  
  7615. #ifdef CK_SSL
  7616.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7617.         return(0);
  7618.     }
  7619. #endif /* CK_SSL */
  7620.  
  7621.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7622.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7623.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7624.     sb_out[i++] = TNC_C2S_SET_STOPSIZE;   /* Set Stop Bits */
  7625.     sb_out[i++] = 0;
  7626.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7627.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7628.  
  7629. #ifdef DEBUG
  7630.     if (deblog || tn_deb || debses) {
  7631.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7632.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7633.                   " SET-STOPSIZE ", ckitoa(0)," IAC SE", NULL,
  7634.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7635.     }
  7636. #endif /* DEBUG */
  7637. #ifdef OS2
  7638.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7639. #endif
  7640. #ifdef DEBUG
  7641.     debug(F100,tn_msg_out,"",0);
  7642.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7643. #endif /* DEBUG */
  7644.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7645. #ifdef OS2
  7646.     ReleaseTelnetMutex();
  7647. #endif
  7648.     if (rc)
  7649.         return(-1);
  7650.  
  7651.     if (tnc_wait("comport set stopsize") < 0) {
  7652.         tn_push();
  7653.         return(-1);
  7654.     }
  7655.     debug(F111,"tnc_get_stopsize","end",tnc_stopbit);
  7656.     return(tnc_stopbit);
  7657. }
  7658.  
  7659. int
  7660. #ifdef CK_ANSIC
  7661. tnc_set_oflow(int control)
  7662. #else /* CK_ANSIC */
  7663. tnc_set_oflow(control) int control;
  7664. #endif /* CK_ANSIC */
  7665. /* tnc_set_oflow */ {
  7666.     /* IAC SB COM_PORT SET_CONTROL <value(1)> IAC SE */
  7667.     /*        Value     Flow Control
  7668.      *          1       No Flow Control
  7669.      *          2       Xon/Xoff
  7670.      *          3       Rts/Cts
  7671.      *         17       DCD
  7672.      *         19       DSR
  7673.      */
  7674.     /* wait for response, return new host value. */
  7675.     int i = 0, rc;
  7676.  
  7677.     debug(F111,"tnc_set_oflow","begin",control);
  7678.     if (ttnet != NET_TCPB) return(0);
  7679.     if (ttnproto != NP_TELNET) return(0);
  7680.  
  7681.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7682.  
  7683. #ifdef CK_SSL
  7684.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7685.         return(0);
  7686.     }
  7687. #endif /* CK_SSL */
  7688.  
  7689.     if (control != 1 && control != 2 && control != 3 &&
  7690.         control != 17 && control != 19)
  7691.       return(0);
  7692.  
  7693.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7694.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7695.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7696.     sb_out[i++] = TNC_C2S_SET_CONTROL;    /* Set Control */
  7697.     sb_out[i++] = (unsigned char)(control & 0xFF);
  7698.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7699.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7700.  
  7701. #ifdef DEBUG
  7702.     if (deblog || tn_deb || debses) {
  7703.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7704.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7705.                   " SET-CONTROL ", ckitoa(control)," IAC SE", NULL,
  7706.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7707.     }
  7708. #endif /* DEBUG */
  7709. #ifdef OS2
  7710.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7711. #endif
  7712. #ifdef DEBUG
  7713.     debug(F100,tn_msg_out,"",0);
  7714.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7715. #endif /* DEBUG */
  7716.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7717. #ifdef OS2
  7718.     ReleaseTelnetMutex();
  7719. #endif
  7720.     if (rc)
  7721.         return(-1);
  7722.  
  7723.     if (tnc_wait("comport set outbound flow control") < 0) {
  7724.         tn_push();
  7725.         return(-1);
  7726.     }
  7727.     debug(F111,"tnc_set_oflow","end",tnc_oflow);
  7728.     return(tnc_oflow);
  7729. }
  7730.  
  7731. int
  7732. #ifdef CK_ANSIC
  7733. tnc_get_oflow(void)
  7734. #else /* CK_ANSIC */
  7735. tnc_get_oflow()
  7736. #endif /* CK_ANSIC */
  7737. /* tnc_get_oflow */ {
  7738.     /* IAC SB COM_PORT SET_CONTROL <value(1)=0> IAC SE */
  7739.     /* wait for response */
  7740.     int i = 0, rc;
  7741.  
  7742.     debug(F110,"tnc_get_oflow","begin",0);
  7743.     if (ttnet != NET_TCPB) return(0);
  7744.     if (ttnproto != NP_TELNET) return(0);
  7745.  
  7746.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7747.  
  7748. #ifdef CK_SSL
  7749.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7750.         return(0);
  7751.     }
  7752. #endif /* CK_SSL */
  7753.  
  7754.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7755.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7756.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7757.     sb_out[i++] = TNC_C2S_SET_CONTROL;    /* Set Control */
  7758.     sb_out[i++] = TNC_CTL_OFLOW_REQUEST;
  7759.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7760.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7761.  
  7762. #ifdef DEBUG
  7763.     if (deblog || tn_deb || debses) {
  7764.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7765.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7766.                   " SET-CONTROL ",
  7767.                    ckitoa(TNC_CTL_OFLOW_REQUEST),
  7768.                    " IAC SE", NULL,
  7769.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7770.     }
  7771. #endif /* DEBUG */
  7772. #ifdef OS2
  7773.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7774. #endif
  7775. #ifdef DEBUG
  7776.     debug(F100,tn_msg_out,"",0);
  7777.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7778. #endif /* DEBUG */
  7779.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7780. #ifdef OS2
  7781.     ReleaseTelnetMutex();
  7782. #endif
  7783.     if (rc)
  7784.         return(-1);
  7785.  
  7786.     if (tnc_wait("comport get outbound flow control") < 0) {
  7787.         tn_push();
  7788.         return(-1);
  7789.     }
  7790.     debug(F111,"tnc_get_oflow","end",tnc_oflow);
  7791.     return(tnc_oflow);
  7792. }
  7793.  
  7794. int
  7795. #ifdef CK_ANSIC
  7796. tnc_set_iflow(int control)
  7797. #else /* CK_ANSIC */
  7798. tnc_set_iflow(control) int control;
  7799. #endif /* CK_ANSIC */
  7800. /* tnc_set_iflow */ {
  7801.     /* IAC SB COM_PORT SET_CONTROL <value(1)> IAC SE */
  7802.     /*        Value     Flow Control
  7803.      *         14       No Flow Control
  7804.      *         15       Xon/Xoff
  7805.      *         16       Rts/Cts
  7806.      *         18       DTR
  7807.      */
  7808.     /* wait for response, return new host value. */
  7809.     int i = 0, rc;
  7810.  
  7811.     debug(F111,"tnc_set_iflow","begin",control);
  7812.     if (ttnet != NET_TCPB) return(0);
  7813.     if (ttnproto != NP_TELNET) return(0);
  7814.  
  7815.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7816.  
  7817. #ifdef CK_SSL
  7818.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7819.         return(0);
  7820.     }
  7821. #endif /* CK_SSL */
  7822.  
  7823.     if (control != 14 && control != 15 && control != 16 && control != 18)
  7824.       return(0);
  7825.  
  7826.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7827.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7828.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7829.     sb_out[i++] = TNC_C2S_SET_CONTROL;    /* Set Control */
  7830.     sb_out[i++] = (unsigned char)(control & 0xFF);
  7831.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7832.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7833.  
  7834. #ifdef DEBUG
  7835.     if (deblog || tn_deb || debses) {
  7836.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7837.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7838.                   " SET-CONTROL ", ckitoa(control)," IAC SE", NULL,
  7839.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7840.     }
  7841. #endif /* DEBUG */
  7842. #ifdef OS2
  7843.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7844. #endif
  7845. #ifdef DEBUG
  7846.     debug(F100,tn_msg_out,"",0);
  7847.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7848. #endif /* DEBUG */
  7849.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7850. #ifdef OS2
  7851.     ReleaseTelnetMutex();
  7852. #endif
  7853.     if (rc)
  7854.       return(-1);
  7855.  
  7856.     if (tnc_wait("comport set inbound flow control") < 0) {
  7857.         tn_push();
  7858.         return(-1);
  7859.     }
  7860.     debug(F111,"tnc_set_iflow","end",tnc_iflow);
  7861.     return(tnc_iflow);
  7862. }
  7863.  
  7864. int
  7865. #ifdef CK_ANSIC
  7866. tnc_get_iflow(void)
  7867. #else /* CK_ANSIC */
  7868. tnc_get_iflow()
  7869. #endif /* CK_ANSIC */
  7870. /* tnc_get_iflow */ {
  7871.     /* IAC SB COM_PORT SET_CONTROL <value(1)=13> IAC SE */
  7872.     /* wait for response */
  7873.     int i = 0, rc;
  7874.  
  7875.     debug(F110,"tnc_get_iflow","begin",0);
  7876.     if (ttnet != NET_TCPB) return(0);
  7877.     if (ttnproto != NP_TELNET) return(0);
  7878.  
  7879.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7880.  
  7881. #ifdef CK_SSL
  7882.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7883.         return(0);
  7884.     }
  7885. #endif /* CK_SSL */
  7886.  
  7887.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7888.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7889.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7890.     sb_out[i++] = TNC_C2S_SET_CONTROL;    /* Set Control */
  7891.     sb_out[i++] = TNC_CTL_IFLOW_REQUEST;
  7892.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7893.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7894.  
  7895. #ifdef DEBUG
  7896.     if (deblog || tn_deb || debses) {
  7897.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7898.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7899.                   " SET-CONTROL ",
  7900.                   ckitoa(TNC_CTL_IFLOW_REQUEST),
  7901.                   " IAC SE", NULL,
  7902.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7903.     }
  7904. #endif /* DEBUG */
  7905. #ifdef OS2
  7906.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7907. #endif
  7908. #ifdef DEBUG
  7909.     debug(F100,tn_msg_out,"",0);
  7910.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7911. #endif /* DEBUG */
  7912.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7913. #ifdef OS2
  7914.     ReleaseTelnetMutex();
  7915. #endif
  7916.     if (rc)
  7917.         return(-1);
  7918.  
  7919.     if (tnc_wait("comport get inbound flow control") < 0) {
  7920.         tn_push();
  7921.         return(-1);
  7922.     }
  7923.     debug(F111,"tnc_get_iflow","end",tnc_iflow);
  7924.     return(tnc_iflow);
  7925. }
  7926.  
  7927. int
  7928. #ifdef CK_ANSIC
  7929. tnc_set_break_state(int onoff)
  7930. #else /* CK_ANSIC */
  7931. tnc_set_break_state(onoff) int onoff;
  7932. #endif /* CK_ANSIC */
  7933. /* tnc_set_break_state */ {
  7934.     /* IAC SB COM_PORT SET_CONTROL <value(1)> IAC SE */
  7935.     /*        Value     Break State
  7936.      *          5       On
  7937.      *          6       Off
  7938.      */
  7939.     /* wait for response, return new host value. */
  7940.     int i = 0, rc;
  7941.  
  7942.     debug(F111,"tnc_set_break_state","begin",onoff);
  7943.     if (ttnet != NET_TCPB) return(0);
  7944.     if (ttnproto != NP_TELNET) return(0);
  7945.  
  7946.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  7947.  
  7948. #ifdef CK_SSL
  7949.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  7950.         return(0);
  7951.     }
  7952. #endif /* CK_SSL */
  7953.  
  7954.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  7955.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  7956.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  7957.     sb_out[i++] = TNC_C2S_SET_CONTROL;    /* Set Control */
  7958.     sb_out[i++] = onoff ?
  7959.       TNC_CTL_BREAK_ON : TNC_CTL_BREAK_OFF;
  7960.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  7961.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  7962.  
  7963. #ifdef DEBUG
  7964.     if (deblog || tn_deb || debses) {
  7965.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  7966.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  7967.                   " SET-CONTROL ",
  7968.                   onoff ? "BREAK-ON" : "BREAK-OFF",
  7969.                   " IAC SE", NULL,
  7970.                   NULL,NULL,NULL,NULL,NULL,NULL);
  7971.     }
  7972. #endif /* DEBUG */
  7973. #ifdef OS2
  7974.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  7975. #endif
  7976. #ifdef DEBUG
  7977.     debug(F100,tn_msg_out,"",0);
  7978.     if (tn_deb || debses) tn_debug(tn_msg_out);
  7979. #endif /* DEBUG */
  7980.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  7981. #ifdef OS2
  7982.     ReleaseTelnetMutex();
  7983. #endif
  7984.     if (rc)
  7985.         return(-1);
  7986.  
  7987.     if (tnc_wait("comport set break state") < 0) {
  7988.         tn_push();
  7989.         return(-1);
  7990.     }
  7991.     debug(F111,"tnc_set_break_state","end",tnc_break);
  7992.     return(tnc_break);
  7993. }
  7994.  
  7995. int
  7996. #ifdef CK_ANSIC
  7997. tnc_get_break_state(void)
  7998. #else /* CK_ANSIC */
  7999. tnc_get_break_state()
  8000. #endif /* CK_ANSIC */
  8001. /* tnc_get_break_state */ {
  8002.     /* IAC SB COM_PORT SET_CONTROL <value(1)=4> IAC SE */
  8003.     /* wait for response */
  8004.     int i = 0, rc;
  8005.  
  8006.     debug(F110,"tnc_get_break_state","begin",0);
  8007.     if (ttnet != NET_TCPB) return(0);
  8008.     if (ttnproto != NP_TELNET) return(0);
  8009.  
  8010.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  8011.  
  8012. #ifdef CK_SSL
  8013.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  8014.         return(0);
  8015.     }
  8016. #endif /* CK_SSL */
  8017.  
  8018.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  8019.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  8020.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  8021.     sb_out[i++] = TNC_C2S_SET_CONTROL;    /* Set Control */
  8022.     sb_out[i++] = TNC_CTL_BREAK_REQUEST;
  8023.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  8024.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  8025.  
  8026. #ifdef DEBUG
  8027.     if (deblog || tn_deb || debses) {
  8028.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  8029.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  8030.                   " SET-CONTROL ",
  8031.                   "BREAK-REQUEST",
  8032.                   " IAC SE", NULL,
  8033.                   NULL,NULL,NULL,NULL,NULL,NULL);
  8034.     }
  8035. #endif /* DEBUG */
  8036. #ifdef OS2
  8037.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  8038. #endif
  8039. #ifdef DEBUG
  8040.     debug(F100,tn_msg_out,"",0);
  8041.     if (tn_deb || debses) tn_debug(tn_msg_out);
  8042. #endif /* DEBUG */
  8043.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  8044. #ifdef OS2
  8045.     ReleaseTelnetMutex();
  8046. #endif
  8047.     if (rc)
  8048.         return(-1);
  8049.  
  8050.     if (tnc_wait("comport get break state") < 0) {
  8051.         tn_push();
  8052.         return(-1);
  8053.     }
  8054.     debug(F111,"tnc_get_break_state","end",tnc_break);
  8055.     return(tnc_break);
  8056. }
  8057.  
  8058. int
  8059. #ifdef CK_ANSIC
  8060. tnc_set_dtr_state(int onoff)
  8061. #else /* CK_ANSIC */
  8062. tnc_set_dtr_state(onoff) int onoff;
  8063. #endif /* CK_ANSIC */
  8064. /* tnc_set_dtr_state */ {
  8065.     /* IAC SB COM_PORT SET_CONTROL <value(1)> IAC SE */
  8066.     /*        Value     Dtr State
  8067.      *          8       On
  8068.      *          9       Off
  8069.      */
  8070.     /* wait for response, return new host value. */
  8071.     int i = 0, rc;
  8072.  
  8073.     debug(F111,"tnc_set_dtr_state","begin",onoff);
  8074.     if (ttnet != NET_TCPB) return(0);
  8075.     if (ttnproto != NP_TELNET) return(0);
  8076.  
  8077.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  8078.  
  8079. #ifdef CK_SSL
  8080.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  8081.         return(0);
  8082.     }
  8083. #endif /* CK_SSL */
  8084.  
  8085.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  8086.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  8087.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  8088.     sb_out[i++] = TNC_C2S_SET_CONTROL;    /* Set Control */
  8089.     sb_out[i++] = onoff ?
  8090.         TNC_CTL_DTR_ON : TNC_CTL_DTR_OFF;
  8091.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  8092.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  8093.  
  8094. #ifdef DEBUG
  8095.     if (deblog || tn_deb || debses) {
  8096.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  8097.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  8098.                   " SET-CONTROL ",
  8099.                   onoff ? "DTR-ON" : "DTR-OFF",
  8100.                   " IAC SE", NULL,
  8101.                   NULL,NULL,NULL,NULL,NULL,NULL);
  8102.     }
  8103. #endif /* DEBUG */
  8104. #ifdef OS2
  8105.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  8106. #endif
  8107. #ifdef DEBUG
  8108.     debug(F100,tn_msg_out,"",0);
  8109.     if (tn_deb || debses) tn_debug(tn_msg_out);
  8110. #endif /* DEBUG */
  8111.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  8112. #ifdef OS2
  8113.     ReleaseTelnetMutex();
  8114. #endif
  8115.     if (rc)
  8116.       return(-1);
  8117.  
  8118.     if (tnc_wait("comport set dtr state") < 0) {
  8119.         tn_push();
  8120.         return(-1);
  8121.     }
  8122.     debug(F111,"tnc_set_dtr_state","end",tnc_dtr);
  8123.     return(tnc_dtr);
  8124. }
  8125.  
  8126. int
  8127. #ifdef CK_ANSIC
  8128. tnc_get_dtr_state(void)
  8129. #else /* CK_ANSIC */
  8130. tnc_get_dtr_state()
  8131. #endif /* CK_ANSIC */
  8132. /* tnc_get_dtr_state */ {
  8133.     /* IAC SB COM_PORT SET_CONTROL <value(1)=7> IAC SE */
  8134.     /* wait for response */
  8135.     int i = 0, rc;
  8136.  
  8137.     debug(F110,"tnc_get_dtr_state","begin",0);
  8138.     if (ttnet != NET_TCPB) return(0);
  8139.     if (ttnproto != NP_TELNET) return(0);
  8140.  
  8141.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  8142.  
  8143. #ifdef CK_SSL
  8144.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  8145.         return(0);
  8146.     }
  8147. #endif /* CK_SSL */
  8148.  
  8149.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  8150.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  8151.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  8152.     sb_out[i++] = TNC_C2S_SET_CONTROL;    /* Set Control */
  8153.     sb_out[i++] = TNC_CTL_DTR_REQUEST;
  8154.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  8155.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  8156.  
  8157. #ifdef DEBUG
  8158.     if (deblog || tn_deb || debses) {
  8159.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  8160.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  8161.                   " SET-CONTROL ",
  8162.                   "DTR-REQUEST",
  8163.                   " IAC SE", NULL,
  8164.                   NULL,NULL,NULL,NULL,NULL,NULL);
  8165.     }
  8166. #endif /* DEBUG */
  8167. #ifdef OS2
  8168.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  8169. #endif
  8170. #ifdef DEBUG
  8171.     debug(F100,tn_msg_out,"",0);
  8172.     if (tn_deb || debses) tn_debug(tn_msg_out);
  8173. #endif /* DEBUG */
  8174.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  8175. #ifdef OS2
  8176.     ReleaseTelnetMutex();
  8177. #endif
  8178.     if (rc)
  8179.       return(-1);
  8180.  
  8181.     if (tnc_wait("comport get dtr state") < 0) {
  8182.         tn_push();
  8183.         return(-1);
  8184.     }
  8185.     debug(F111,"tnc_get_dtr_state","end",tnc_dtr);
  8186.     return(tnc_dtr);
  8187. }
  8188.  
  8189. int
  8190. #ifdef CK_ANSIC
  8191. tnc_set_rts_state(int onoff)
  8192. #else /* CK_ANSIC */
  8193. tnc_set_rts_state(onoff) int onoff;
  8194. #endif /* CK_ANSIC */
  8195. /* tnc_set_rts_state */ {
  8196.     /* IAC SB COM_PORT SET_CONTROL <value(1)> IAC SE */
  8197.     /*        Value     Rts State
  8198.      *          5       On
  8199.      *          6       Off
  8200.      */
  8201.     /* wait for response, return new host value. */
  8202.     int i = 0, rc;
  8203.  
  8204.     debug(F111,"tnc_set_rts_state","begin",onoff);
  8205.     if (ttnet != NET_TCPB) return(0);
  8206.     if (ttnproto != NP_TELNET) return(0);
  8207.  
  8208.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  8209.  
  8210. #ifdef CK_SSL
  8211.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  8212.         return(0);
  8213.     }
  8214. #endif /* CK_SSL */
  8215.  
  8216.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  8217.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  8218.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  8219.     sb_out[i++] = TNC_C2S_SET_CONTROL;    /* Set Control */
  8220.     sb_out[i++] = onoff ?
  8221.       TNC_CTL_RTS_ON : TNC_CTL_RTS_OFF;
  8222.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  8223.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  8224.  
  8225. #ifdef DEBUG
  8226.     if (deblog || tn_deb || debses) {
  8227.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  8228.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  8229.                   " SET-CONTROL ",
  8230.                   onoff ? "RTS-ON" : "RTS-OFF",
  8231.                   " IAC SE", NULL,
  8232.                   NULL,NULL,NULL,NULL,NULL,NULL);
  8233.     }
  8234. #endif /* DEBUG */
  8235. #ifdef OS2
  8236.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  8237. #endif
  8238. #ifdef DEBUG
  8239.     debug(F100,tn_msg_out,"",0);
  8240.     if (tn_deb || debses) tn_debug(tn_msg_out);
  8241. #endif /* DEBUG */
  8242.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  8243. #ifdef OS2
  8244.     ReleaseTelnetMutex();
  8245. #endif
  8246.     if (rc)
  8247.       return(-1);
  8248.  
  8249.     if (tnc_wait("comport set rts state") < 0) {
  8250.         tn_push();
  8251.         return(-1);
  8252.     }
  8253.     debug(F111,"tnc_set_rts_state","end",tnc_rts);
  8254.     return(tnc_rts);
  8255. }
  8256.  
  8257. int
  8258. #ifdef CK_ANSIC
  8259. tnc_get_rts_state(void)
  8260. #else /* CK_ANSIC */
  8261. tnc_get_rts_state()
  8262. #endif /* CK_ANSIC */
  8263. /* tnc_get_rts_state */ {
  8264.     /* IAC SB COM_PORT SET_CONTROL <value(1)=10> IAC SE */
  8265.     /* wait for response */
  8266.     int i = 0, rc;
  8267.  
  8268.     debug(F110,"tnc_get_rts_state","begin",0);
  8269.     if (ttnet != NET_TCPB) return(0);
  8270.     if (ttnproto != NP_TELNET) return(0);
  8271.  
  8272.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  8273.  
  8274. #ifdef CK_SSL
  8275.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  8276.         return(0);
  8277.     }
  8278. #endif /* CK_SSL */
  8279.  
  8280.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  8281.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  8282.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  8283.     sb_out[i++] = TNC_C2S_SET_CONTROL;    /* Set Control */
  8284.     sb_out[i++] = TNC_CTL_RTS_REQUEST;
  8285.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  8286.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  8287.  
  8288. #ifdef DEBUG
  8289.     if (deblog || tn_deb || debses) {
  8290.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  8291.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  8292.                   " SET-CONTROL ",
  8293.                   "RTS-REQUEST",
  8294.                   " IAC SE", NULL,
  8295.                   NULL,NULL,NULL,NULL,NULL,NULL);
  8296.     }
  8297. #endif /* DEBUG */
  8298. #ifdef OS2
  8299.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  8300. #endif
  8301. #ifdef DEBUG
  8302.     debug(F100,tn_msg_out,"",0);
  8303.     if (tn_deb || debses) tn_debug(tn_msg_out);
  8304. #endif /* DEBUG */
  8305.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  8306. #ifdef OS2
  8307.     ReleaseTelnetMutex();
  8308. #endif
  8309.     if (rc)
  8310.         return(-1);
  8311.  
  8312.     if (tnc_wait("comport get rts state") < 0) {
  8313.         tn_push();
  8314.         return(-1);
  8315.     }
  8316.     debug(F111,"tnc_get_rts_state","end",tnc_rts);
  8317.     return(tnc_rts);
  8318. }
  8319.  
  8320. int
  8321. #ifdef CK_ANSIC
  8322. tnc_set_ls_mask(int mask)
  8323. #else /* CK_ANSIC */
  8324. tnc_set_ls_mask(mask) int mask;
  8325. #endif /* CK_ANSIC */
  8326. /* tnc_set_ls_mask */ {
  8327.     /* IAC SB COM_PORT SET_LINESTATE_MASK <value(1)> IAC SE */
  8328.     /*        Bit       Meaning
  8329.      *          0       Data Ready
  8330.      *          1       Overrun Error
  8331.      *          2       Parity Error
  8332.      *          3       Framing Error
  8333.      *          4       Break Detect Error
  8334.      *          5       Transfer Holding Register Empty
  8335.      *          6       Transfer Shift Register Empty
  8336.      *          7       Timeout Error
  8337.      */
  8338.     int i = 0, rc;
  8339.  
  8340.     debug(F111,"tnc_set_ls_mask","begin",mask);
  8341.     if (ttnet != NET_TCPB) return(0);
  8342.     if (ttnproto != NP_TELNET) return(0);
  8343.  
  8344.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  8345.  
  8346. #ifdef CK_SSL
  8347.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  8348.         return(0);
  8349.     }
  8350. #endif /* CK_SSL */
  8351.  
  8352.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  8353.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  8354.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  8355.     sb_out[i++] = TNC_C2S_SET_LS_MASK;
  8356.     sb_out[i++] = (unsigned char)(mask & 0xFF);
  8357.     if (sb_out[i-1] == IAC )
  8358.       sb_out[i++] = IAC;
  8359.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  8360.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  8361.  
  8362. #ifdef DEBUG
  8363.     if (deblog || tn_deb || debses) {
  8364.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  8365.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  8366.                   " SET-LINESTATE-MASK ",
  8367.                   ckitoa(mask & 0xFF),
  8368.                   " IAC SE", NULL,
  8369.                   NULL,NULL,NULL,NULL,NULL,NULL);
  8370.     }
  8371. #endif /* DEBUG */
  8372. #ifdef OS2
  8373.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  8374. #endif
  8375. #ifdef DEBUG
  8376.     debug(F100,tn_msg_out,"",0);
  8377.     if (tn_deb || debses) tn_debug(tn_msg_out);
  8378. #endif /* DEBUG */
  8379.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  8380. #ifdef OS2
  8381.     ReleaseTelnetMutex();
  8382. #endif
  8383.     if (rc)
  8384.       return(-1);
  8385.  
  8386.     tnc_ls_mask = mask;
  8387.     debug(F111,"tnc_set_ls_mask","end",tnc_ls_mask);
  8388.     return(0);
  8389. }
  8390.  
  8391. int
  8392. #ifdef CK_ANSIC
  8393. tnc_get_ls_mask(void)
  8394. #else /* CK_ANSIC */
  8395. tnc_get_ls_mask()
  8396. #endif /* CK_ANSIC */
  8397. /* tnc_get_ls_mask */ {
  8398.     debug(F101,"tnc_get_ls_mask","",tnc_ls_mask);
  8399.     return(tnc_ls_mask);
  8400. }
  8401.  
  8402. int
  8403. #ifdef CK_ANSIC
  8404. tnc_get_ls(void)
  8405. #else /* CK_ANSIC */
  8406. tnc_get_ls()
  8407. #endif /* CK_ANSIC */
  8408. /* tnc_get_ls */ {
  8409.     int ls = tnc_ls;
  8410.     debug(F111,"tnc_get_ls","begin",tnc_ls);
  8411.     tnc_ls = 0;
  8412.     debug(F111,"tnc_get_ls","end",tnc_ls);
  8413.     return(ls);
  8414. }
  8415.  
  8416. int
  8417. #ifdef CK_ANSIC
  8418. tnc_set_ms_mask(int mask)
  8419. #else /* CK_ANSIC */
  8420. tnc_set_ms_mask(mask) int mask;
  8421. #endif /* CK_ANSIC */
  8422. /* tnc_set_ms_mask */ {
  8423.     /* IAC SB COM_PORT SET_MODEMSTATE_MASK <value(1)> IAC SE */
  8424.     /*        Bit       Meaning
  8425.      *          0       Delta Clear To Send
  8426.      *          1       Delta Data Set Ready
  8427.      *          2       Trailing Edge Ring Detector
  8428.      *          3       Delta Receive Line Signal (Carrier) Detect
  8429.      *          4       Clear To Send Signal State
  8430.      *          5       Data-Set-Ready Signal State
  8431.      *          6       Ring Indicator
  8432.      *          7       Receive Line Signal (Carrier) Detect
  8433.      */
  8434.  
  8435.     int i = 0, rc;
  8436.  
  8437.     debug(F111,"tnc_set_ms_mask","begin",mask);
  8438.     if (ttnet != NET_TCPB) return(0);
  8439.     if (ttnproto != NP_TELNET) return(0);
  8440.  
  8441.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  8442.  
  8443. #ifdef CK_SSL
  8444.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  8445.         return(0);
  8446.     }
  8447. #endif /* CK_SSL */
  8448.  
  8449.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  8450.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  8451.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  8452.     sb_out[i++] = TNC_C2S_SET_MS_MASK;
  8453.     sb_out[i++] = (unsigned char)(mask & 0xFF);
  8454.     if (sb_out[i-1] == IAC )
  8455.       sb_out[i++] = IAC;
  8456.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  8457.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  8458.  
  8459. #ifdef DEBUG
  8460.     if (deblog || tn_deb || debses) {
  8461.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  8462.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  8463.                   " SET-MODEMSTATE-MASK ",
  8464.                   ckitoa(mask & 0xFF),
  8465.                   " IAC SE", NULL,
  8466.                   NULL,NULL,NULL,NULL,NULL,NULL);
  8467.     }
  8468. #endif /* DEBUG */
  8469. #ifdef OS2
  8470.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  8471. #endif
  8472. #ifdef DEBUG
  8473.     debug(F100,tn_msg_out,"",0);
  8474.     if (tn_deb || debses) tn_debug(tn_msg_out);
  8475. #endif /* DEBUG */
  8476.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  8477. #ifdef OS2
  8478.     ReleaseTelnetMutex();
  8479. #endif
  8480.     if (rc)
  8481.       return(-1);
  8482.  
  8483.     tnc_ms_mask = mask;
  8484.     debug(F111,"tnc_set_ms_mask","end",tnc_ms_mask);
  8485.     return(0);
  8486. }
  8487.  
  8488. int
  8489. #ifdef CK_ANSIC
  8490. tnc_get_ms_mask(void)
  8491. #else /* CK_ANSIC */
  8492. tnc_get_ms_mask()
  8493. #endif /* CK_ANSIC */
  8494. /* tnc_get_ms_mask */ {
  8495.     debug(F101,"tnc_get_gs_mask","",tnc_ms_mask);
  8496.     return(tnc_ms_mask);
  8497. }
  8498.  
  8499. int
  8500. #ifdef CK_ANSIC
  8501. tnc_get_ms(void)
  8502. #else /* CK_ANSIC */
  8503. tnc_get_ms()
  8504. #endif /* CK_ANSIC */
  8505. /* tnc_get_ms */ {
  8506.     int ms = tnc_ms;
  8507.     debug(F111,"tnc_get_ms","begin",tnc_ms);
  8508.     tnc_ms = 0;
  8509.     debug(F111,"tnc_get_ms_mask","end",tnc_ms);
  8510.     return(ms);
  8511. }
  8512.  
  8513. int
  8514. #ifdef CK_ANSIC
  8515. tnc_send_purge_data(int mode)
  8516. #else /* CK_ANSIC */
  8517. tnc_send_purge_data(mode) int mode;
  8518. #endif /* CK_ANSIC */
  8519. /* tnc_send_purge_data */ {
  8520.     /* IAC SB COM_PORT PURGE_DATA <value(1)> IAC SE */
  8521.     /*        Value     Meaning
  8522.      *          1       Purge access server receive data buffer
  8523.      *          2       Purge access server transmit data buffer
  8524.      *          3       Purge access server receive and transmit data buffers
  8525.      */
  8526.     /* No response */
  8527.     int i = 0, rc;
  8528.  
  8529.     debug(F111,"tnc_send_purge_data","begin",mode);
  8530.     if (ttnet != NET_TCPB) return(0);
  8531.     if (ttnproto != NP_TELNET) return(0);
  8532.  
  8533.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  8534.  
  8535. #ifdef CK_SSL
  8536.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  8537.         return(0);
  8538.     }
  8539. #endif /* CK_SSL */
  8540.  
  8541.     if ( !(mode >= 1 && mode <= 3) )
  8542.         return(0);
  8543.  
  8544.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  8545.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  8546.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  8547.     sb_out[i++] = TNC_C2S_PURGE;
  8548.     sb_out[i++] = (unsigned char)(mode & 0xFF);
  8549.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  8550.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  8551.  
  8552. #ifdef DEBUG
  8553.     if (deblog || tn_deb || debses) {
  8554.         ckmakxmsg(tn_msg_out,TN_MSG_LEN,
  8555.                   "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  8556.                   " PURGE-DATA ",
  8557.                   ckitoa(mode & 0xFF),
  8558.                   " IAC SE", NULL,
  8559.                   NULL,NULL,NULL,NULL,NULL,NULL);
  8560.     }
  8561. #endif /* DEBUG */
  8562. #ifdef OS2
  8563.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  8564. #endif
  8565. #ifdef DEBUG
  8566.     debug(F100,tn_msg_out,"",0);
  8567.     if (tn_deb || debses) tn_debug(tn_msg_out);
  8568. #endif /* DEBUG */
  8569.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  8570. #ifdef OS2
  8571.     ReleaseTelnetMutex();
  8572. #endif
  8573.     if (rc)
  8574.       return(-1);
  8575.     debug(F110,"tnc_send_purge_data","end",0);
  8576.     return(0);
  8577. }
  8578.  
  8579. int
  8580. #ifdef CK_ANSIC
  8581. tnc_flow_suspended(void)
  8582. #else /* CK_ANSIC */
  8583. tnc_flow_suspended()
  8584. #endif /* CK_ANSIC */
  8585. /* tnc_flow_suspended */ {
  8586.     debug(F111,"tnc_flow_suspended","",tnc_suspend_xmit);
  8587.     return(tnc_suspend_xmit);
  8588. }
  8589.  
  8590. int
  8591. #ifdef CK_ANSIC
  8592. tnc_suspend_flow(void)
  8593. #else /* CK_ANSIC */
  8594. tnc_suspend_flow()
  8595. #endif /* CK_ANSIC */
  8596. /* tnc_suspend_flow */ {
  8597.     /* IAC SB COM_PORT FLOWCONTROL_SUSPEND IAC SE */
  8598.     int i = 0, rc;
  8599.  
  8600.     debug(F110,"tnc_suspend_flow","begin",0);
  8601.     if (ttnet != NET_TCPB) return(0);
  8602.     if (ttnproto != NP_TELNET) return(0);
  8603.  
  8604.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  8605.  
  8606. #ifdef CK_SSL
  8607.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  8608.         return(0);
  8609.     }
  8610. #endif /* CK_SSL */
  8611.  
  8612.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  8613.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  8614.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  8615.     sb_out[i++] = TNC_C2S_FLOW_SUSPEND;
  8616.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  8617.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  8618.  
  8619. #ifdef DEBUG
  8620.     if (deblog || tn_deb || debses) {
  8621.         ckmakmsg(tn_msg_out,TN_MSG_LEN,
  8622.                  "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  8623.                  " FLOWCONTROL-SUSPEND IAC SE", NULL);
  8624.     }
  8625. #endif /* DEBUG */
  8626. #ifdef OS2
  8627.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  8628. #endif
  8629. #ifdef DEBUG
  8630.     debug(F100,tn_msg_out,"",0);
  8631.     if (tn_deb || debses) tn_debug(tn_msg_out);
  8632. #endif /* DEBUG */
  8633.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  8634. #ifdef OS2
  8635.     ReleaseTelnetMutex();
  8636. #endif
  8637.     if (rc)
  8638.         return(-1);
  8639.     debug(F110,"tnc_suspend_flow","end",0);
  8640.     return(0);
  8641. }
  8642.  
  8643. int
  8644. #ifdef CK_ANSIC
  8645. tnc_resume_flow(void)
  8646. #else /* CK_ANSIC */
  8647. tnc_resume_flow()
  8648. #endif /* CK_ANSIC */
  8649. /* tnc_resume_flow */ {
  8650.     /* IAC SB COM_PORT FLOWCONTROL_RESUME IAC SE */
  8651.     int i = 0, rc;
  8652.  
  8653.     debug(F110,"tnc_resume_flow","begin",0);
  8654.     if (ttnet != NET_TCPB) return(0);
  8655.     if (ttnproto != NP_TELNET) return(0);
  8656.  
  8657.     if (!TELOPT_ME(TELOPT_COMPORT)) return(0);
  8658.  
  8659. #ifdef CK_SSL
  8660.     if (TELOPT_SB(TELOPT_START_TLS).start_tls.me_follows) {
  8661.         return(0);
  8662.     }
  8663. #endif /* CK_SSL */
  8664.  
  8665.     sb_out[i++] = (CHAR) IAC;                 /* I Am a Command */
  8666.     sb_out[i++] = (CHAR) SB;                  /* Subnegotiation */
  8667.     sb_out[i++] = TELOPT_COMPORT;             /* ComPort */
  8668.     sb_out[i++] = TNC_C2S_FLOW_RESUME;
  8669.     sb_out[i++] = (CHAR) IAC;                 /* End of Subnegotiation */
  8670.     sb_out[i++] = (CHAR) SE;                  /* marked by IAC SE */
  8671.  
  8672. #ifdef DEBUG
  8673.     if (deblog || tn_deb || debses) {
  8674.         ckmakmsg(tn_msg_out,TN_MSG_LEN,
  8675.                  "TELNET SENT SB ",TELOPT(TELOPT_COMPORT),
  8676.                  " FLOWCONTROL-RESUME IAC SE", NULL);
  8677.     }
  8678. #endif /* DEBUG */
  8679. #ifdef OS2
  8680.     RequestTelnetMutex( SEM_INDEFINITE_WAIT );
  8681. #endif
  8682. #ifdef DEBUG
  8683.     debug(F100,tn_msg_out,"",0);
  8684.     if (tn_deb || debses) tn_debug(tn_msg_out);
  8685. #endif /* DEBUG */
  8686.     rc = (ttol((CHAR *)sb_out,i) < 0);      /* Send it. */
  8687. #ifdef OS2
  8688.     ReleaseTelnetMutex();
  8689. #endif
  8690.     if (rc)
  8691.         return(-1);
  8692.     debug(F110,"tnc_resume_flow","end",0);
  8693.     return(0);
  8694. }
  8695.  
  8696. int
  8697. #ifdef CK_ANSIC
  8698. tnsetflow(int nflow)
  8699. #else
  8700. tnsetflow(nflow) int nflow;
  8701. #endif /* CK_ANSIC */
  8702. /* tnsetflow */ {
  8703.  
  8704.     int rc = -1;
  8705.  
  8706.     debug(F111,"tnsetflow","begin",nflow);
  8707.     if (ttnet != NET_TCPB || ttnproto != NP_TELNET)
  8708.         return(-1);
  8709.  
  8710.     if (TELOPT_ME(TELOPT_COMPORT)) {
  8711.         switch(nflow) {
  8712.           case FLO_XONX:
  8713.             rc = tnc_set_oflow(
  8714.                  TNC_CTL_OFLOW_XON_XOFF
  8715.                  );
  8716.             if (rc >= 0)
  8717.               rc = tnc_set_iflow(
  8718.                    TNC_CTL_IFLOW_XON_XOFF
  8719.                    );
  8720.             break;
  8721.           case FLO_RTSC:
  8722.             rc = tnc_set_oflow(
  8723.                  TNC_CTL_OFLOW_RTS_CTS
  8724.                  );
  8725.             if (rc >= 0)
  8726.               rc = tnc_set_iflow(
  8727.                    TNC_CTL_IFLOW_RTS_CTS
  8728.                    );
  8729.             break;
  8730.           case FLO_KEEP:
  8731.             /* leave things exactly as they are */
  8732.             rc = 0;
  8733.             break;
  8734.           case FLO_NONE:
  8735.           case FLO_DIAL:  /* dialing hack */
  8736.           case FLO_DIAX:  /* cancel dialing hack */
  8737.             rc = tnc_set_oflow(
  8738.                  TNC_CTL_OFLOW_NONE
  8739.                  );
  8740.             if (rc >= 0)
  8741.               rc = tnc_set_iflow(
  8742.                    TNC_CTL_IFLOW_NONE
  8743.                    );
  8744.             break;
  8745.           case FLO_DTRC:
  8746.           case FLO_ETXA:
  8747.           case FLO_STRG:
  8748.           case FLO_DTRT:
  8749.           default:
  8750.             /* not supported */
  8751.             rc = -1;
  8752.             break;
  8753.         }
  8754.     }
  8755.     debug(F111,"tnsetflow","end",rc);
  8756.     return(rc >= 0 ? 0 : -1);
  8757. }
  8758.  
  8759. int
  8760. #ifdef CK_ANSIC
  8761. tnsettings(int par, int stop)
  8762. #else
  8763. tnsettings(par, stop) int par, stop;
  8764. #endif /* CK_ANSIC */
  8765. /* tnsettings */ {
  8766.     int rc = -1;
  8767.     int datasize = 0;
  8768.     extern int hwparity;
  8769.  
  8770.     debug(F111,"tnsettings begin","par",par);
  8771.     debug(F111,"tnsettings begin","stop",stop);
  8772.     if (ttnet != NET_TCPB || ttnproto != NP_TELNET)
  8773.       return(-1);
  8774.  
  8775.     datasize = par ? TNC_DS_7 : TNC_DS_8;
  8776.     if (!par) par = hwparity;
  8777.  
  8778.     if (TELOPT_ME(TELOPT_COMPORT)) {
  8779.         switch (par) {
  8780.           case 'e':
  8781.             rc = tnc_set_parity(TNC_PAR_EVEN);
  8782.             if (rc >= 0)
  8783.               rc = tnc_set_datasize(datasize);
  8784.             break;
  8785.           case 'o':
  8786.             rc = tnc_set_parity(TNC_PAR_ODD);
  8787.             if (rc >= 0)
  8788.               rc = tnc_set_datasize(datasize);
  8789.             break;
  8790.           case 'm':
  8791.             rc = tnc_set_parity(TNC_PAR_MARK);
  8792.             if (rc >= 0)
  8793.               rc = tnc_set_datasize(datasize);
  8794.             break;
  8795.           case 's':
  8796.             rc = tnc_set_parity(TNC_PAR_SPACE);
  8797.             if (rc >= 0)
  8798.               rc = tnc_set_datasize(datasize);
  8799.             break;
  8800.           case 0:
  8801.           case 'n':
  8802.             rc = tnc_set_parity(TNC_PAR_NONE);
  8803.             if (rc >= 0)
  8804.               rc = tnc_set_datasize(datasize);
  8805.             break;
  8806.           default:
  8807.             /* no change */
  8808.             rc = 0;
  8809.         }
  8810.         switch(stop) {
  8811.           case 2:
  8812.             if (rc >= 0)
  8813.               rc = tnc_set_stopsize(TNC_SB_2);
  8814.             break;
  8815.           case 1:
  8816.             if (rc >= 0)
  8817.               rc = tnc_set_stopsize(TNC_SB_1);
  8818.             break;
  8819.           default:
  8820.             /* no change */
  8821.             if (rc >= 0)
  8822.               rc = 0;
  8823.         }
  8824.     }
  8825.     debug(F111,"tnsettings","end",rc);
  8826.     return((rc >= 0) ? 0 : -1);
  8827. }
  8828.  
  8829. /*  T N G M D M  --  Telnet Get modem signals  */
  8830. /*
  8831.  Looks for the modem signals CTS, DSR, and CTS, and returns those that are
  8832.  on in as its return value, in a bit mask as described for ttwmdm.
  8833.  Returns:
  8834.   -3 Not implemented
  8835.   -2 if the line does not have modem control
  8836.   -1 on error.
  8837.   >= 0 on success, with a bit mask containing the modem signals that are on.
  8838. */
  8839. int
  8840. #ifdef CK_ANSIC
  8841. tngmdm(void)
  8842. #else
  8843. tngmdm()
  8844. #endif /* CK_ANSIC */
  8845. /* tngmdm */ {
  8846.  
  8847.     int rc = -1;
  8848.  
  8849.     debug(F110,"tngmdm","begin",0);
  8850.     if (ttnet != NET_TCPB || ttnproto != NP_TELNET)
  8851.       return(-1);
  8852.  
  8853.     if (TELOPT_ME(TELOPT_COMPORT)) {
  8854.         int modemstate = tnc_get_ms();
  8855.         int modem = 0;
  8856.         if (modemstate & TNC_MS_CTS_SIG)
  8857.           modem |= BM_CTS;
  8858.         if (modemstate & TNC_MS_DSR_SIG)
  8859.           modem |= BM_DSR;
  8860.         if (modemstate & TNC_MS_RI_SIG)
  8861.           modem |= BM_RNG;
  8862.         if (modemstate & TNC_MS_RLSD_SIG)
  8863.           modem |= BM_DCD;
  8864.         debug(F111,"tngmdm","end",modem);
  8865.         return(modem);
  8866.     } else {
  8867.         debug(F111,"tngmdm","end",-2);
  8868.         return(-2);
  8869.     }
  8870. }
  8871.  
  8872. int
  8873. #ifdef CK_ANSIC
  8874. tnsndb(long wait)
  8875. #else
  8876. tnsndb(wait) long wait;
  8877. #endif /* CK_ANSIC */
  8878. /* tnsndb */ {
  8879.     int rc = -1;
  8880.  
  8881.     debug(F111,"tnsndb","begin",wait);
  8882.     if (ttnet != NET_TCPB || ttnproto != NP_TELNET)
  8883.       return(-1);
  8884.  
  8885.     if (TELOPT_ME(TELOPT_COMPORT)) {
  8886.         rc  = tnc_set_break_state(1);
  8887.         if (rc >= 0) {
  8888.             msleep(wait);                         /* ZZZzzz */
  8889.             rc = tnc_set_break_state(0);
  8890.         }
  8891.     }
  8892.     debug(F111,"tnsndb","end",rc);
  8893.     return((rc >= 0) ? 0 : -1);
  8894. }
  8895. #endif /* TN_COMPORT */
  8896. #endif /* TNCODE */
  8897.