home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / c-kermit / ckucns.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  78KB  |  2,721 lines
  1. #include "ckcsym.h"
  2. char *connv = "CONNECT Command for UNIX:select(), 9.0.139, 1 Mar 2010";
  3.  
  4. /*  C K U C N S  --  Terminal connection to remote system, for UNIX  */
  5. /*
  6.   Author: Frank da Cruz <fdc@columbia.edu>,
  7.   Columbia University Academic Information Systems, New York City.
  8.  
  9.   Copyright (C) 1985, 2010,
  10.     Trustees of Columbia University in the City of New York.
  11.     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  12.     copyright text in the ckcmai.c module for disclaimer and permissions.
  13. */
  14.  
  15. /*
  16.   This version of the UNIX CONNECT module uses select(), which is required for
  17.   Kerberos encryption.  Thus it can be used only on UNIX systems that support
  18.   select() on both TCP/IP and serial connections.  A separate module that uses
  19.   a completely portable fork() structure can be used on systems where select()
  20.   is not available or does not work as required.
  21. */
  22.  
  23. #include "ckcdeb.h"            /* Common things first */
  24.  
  25. #ifndef NOLOCAL
  26.  
  27. #ifdef OSF13
  28. #ifdef CK_ANSIC
  29. #ifdef _NO_PROTO
  30. #undef _NO_PROTO
  31. #endif /* _NO_PROTO */
  32. #endif /* CK_ANSIC */
  33. #endif /* OSF13 */
  34.  
  35. #include <errno.h>            /* Error numbers */
  36.  
  37. #ifndef NOTIMEH
  38. #include <time.h>            /* For FD_blah */
  39. #ifdef SYSTIMEH                /* (IRIX 5.3) */
  40. #include <sys/time.h>
  41. #endif /* SYSTIMEH */
  42. #endif /* NOTIMEH */
  43.  
  44. #ifdef BSD42HACK            /* Why is this necessary? */
  45. #ifndef DCLTIMEVAL
  46. #define DCLTIMEVAL
  47. #endif /* DCLTIMEVAL */
  48. #endif /* BSD42HACK */
  49.  
  50. /* Kermit-specific includes */
  51.  
  52. #include "ckcasc.h"            /* ASCII characters */
  53. #include "ckcker.h"            /* Kermit things */
  54. #include "ckucmd.h"            /* For xxesc() prototype */
  55. #include "ckcnet.h"            /* Network symbols */
  56. #ifndef NOCSETS
  57. #include "ckcxla.h"            /* Character set translation */
  58. #endif /* NOCSETS */
  59.  
  60. #ifdef BEBOX
  61. #include <kernel/OS.h>
  62. #include <socket.h>
  63. #include <stdio.h>
  64. #endif /* BEBOX */
  65.  
  66. #include <signal.h>            /* Signals */
  67.  
  68. /* All the following is for select()... */
  69.  
  70. #ifdef CKTIDLE                /* Timeouts only for SET TERM IDLE */
  71.  
  72. #ifndef DCLTIMEVAL
  73. #ifdef UNIXWARE
  74. #ifndef UW7
  75. #define DCLTIMEVAL
  76. #endif /* UW7 */
  77. #endif /* UNIXWARE */
  78. #endif /* DCLTIMEVAL */
  79.  
  80. #ifdef DCLTIMEVAL            /* Declare timeval ourselves */
  81. struct timeval {
  82.     long tv_sec;
  83.     long tv_usec;
  84. };
  85. #else  /* !DCLTIMEVAL */
  86. #ifndef NOSYSTIMEBH
  87. #ifdef SYSTIMEBH
  88. #include <sys/timeb.h>
  89. #endif /* SYSTIMEBH */
  90. #endif /* NOSYSTIMEBH */
  91. #endif /* DCLTIMEVAL */
  92. #endif /* CKTIDLE */
  93.  
  94. #ifndef SCO_OSR504
  95. #ifdef SELECT_H
  96. #include <sys/select.h>
  97. #endif /* SELECT_H */
  98. #endif /* SCO_OSR504 */
  99.  
  100. #ifndef FD_SETSIZE
  101. #ifdef CK_FORWARD_X
  102. #define FD_SETSIZE 256
  103. #else
  104. #define FD_SETSIZE 32
  105. #endif /* CK_FORWARD_X */
  106. #endif /* FD_SETSIZE */
  107.  
  108. #ifdef HPUX
  109. #ifndef HPUX10
  110. #ifndef HPUX1100
  111. /* The three interior args to select() are (int *) rather than (fd_set *) */
  112. #ifndef INTSELECT
  113. #define INTSELECT
  114. #endif /* INTSELECT */
  115. #endif /* HPUX1100 */
  116. #endif /* HPUX10 */
  117. #endif /* HPUX */
  118.  
  119. /* Internal function prototypes */
  120.  
  121. #ifdef NEWFTP
  122. #endif /* NEWFTP */
  123. _PROTOTYP( VOID ttflux, (void) );
  124. _PROTOTYP( VOID doesc, (char) );
  125. _PROTOTYP( int hconne, (void) );
  126. #ifndef NOSHOW
  127. _PROTOTYP( VOID shomdm, (void) );
  128. #endif /* NOSHOW */
  129. _PROTOTYP( static int kbget, (void) );
  130. _PROTOTYP( static int ckcputf, (void) );
  131.  
  132. /* External variables */
  133.  
  134. extern struct ck_p ptab[];
  135.  
  136. extern int local, escape, duplex, parity, flow, seslog, sessft, debses,
  137.  mdmtyp, ttnproto, cmask, cmdmsk, network, nettype, sosi, tnlm,
  138.  xitsta, what, ttyfd, ttpipe, quiet, backgrd, pflag, tt_crd, tt_lfd,
  139.  tn_nlm, ttfdflg,
  140.  tt_escape, justone, carrier, ttpty, hwparity;
  141.  
  142. #ifndef NODIAL
  143. extern int dialmhu, dialsta;
  144. #endif /* NODIAL */
  145.  
  146. #ifdef CKLEARN
  147. extern FILE * learnfp;
  148. extern int learning;
  149. static ULONG learnt1;
  150. static char learnbuf[LEARNBUFSIZ] = { NUL, NUL };
  151. static int  learnbc = 0;
  152. static int  learnbp = 0;
  153. static int  learnst = 0;
  154. #endif /* CKLEARN */
  155.  
  156. extern long speed;
  157. extern char ttname[], sesfil[], myhost[], *ccntab[];
  158. #ifdef TNCODE
  159. extern int tn_b_nlm, tn_rem_echo;
  160. #endif /* TNCODE */
  161.  
  162. #ifdef CK_TRIGGER
  163. extern char * tt_trigger[], * triggerval;
  164. #endif /* CK_TRIGGER */
  165.  
  166. #ifdef CKTIDLE
  167. extern int tt_idlelimit, tt_idleact;
  168. extern char * tt_idlestr;
  169. static int idlelimit = 0;
  170. #endif /* CKTIDLE */
  171. extern int cx_status;            /* CONNECT status code */
  172.  
  173. extern int nopush;
  174.  
  175. #ifdef CK_APC
  176. extern int apcactive;            /* Application Program Command (APC) */
  177. extern int apcstatus;            /* items ... */
  178. static int apclength = 0;
  179. #ifdef DCMDBUF
  180. extern char *apcbuf;
  181. #else
  182. extern char apcbuf[];
  183. #endif /* DCMDBUF */
  184. static int apcbuflen = APCBUFLEN - 2;
  185. extern int protocol;
  186. #endif /* CK_APC */
  187. #ifndef NOXFER
  188. extern int autodl;            /* Auto download */
  189. #endif /* NOXFER */
  190.  
  191. #ifdef CK_AUTODL
  192. extern CHAR ksbuf[];
  193. extern CHAR stchr;
  194. extern int kstartactive;
  195. #endif /* CK_AUTODL */
  196.  
  197. #ifdef CK_ENCRYPTION
  198. extern int me_auth;
  199. #endif /* CK_ENCRYPTION */
  200.  
  201. #ifdef CK_XYZ
  202. #ifdef XYZ_INTERNAL
  203. static int zmdlok = 1;            /* Zmodem autodownloads available */
  204. #else
  205. static int zmdlok = 0;            /* Depends on external protocol def */
  206. #endif /* XYZ_INTERNAL */
  207. #else
  208. static int zmdlok = 0;            /* Not available at all */
  209. #endif /* CK_XYZ */
  210.  
  211. #ifndef NOSETKEY            /* Keyboard mapping */
  212. extern KEY *keymap;            /* Single-character key map */
  213. extern MACRO *macrotab;            /* Key macro pointer table */
  214. static MACRO kmptr = NULL;        /* Pointer to current key macro */
  215. #endif /* NOSETKEY */
  216.  
  217. /* Global variables local to this module */
  218.  
  219. static int
  220.   active = 0,
  221.   quitnow = 0,                /* <esc-char>Q was typed */
  222.   dohangup = 0,                /* <esc-char>H was typed */
  223.   inshift = 0,                /* SO/SI shift states */
  224.   outshift = 0;
  225.  
  226. static char ecbuf[10], *ecbp;        /* Escape char buffer & pointer */
  227.  
  228. #ifdef CK_SMALL
  229. #define IBUFL 1536            /* Input buffer length */
  230. #else
  231. #define IBUFL 4096
  232. #endif /* CK_SMALL */
  233.  
  234. static int obc = 0;            /* Output buffer count */
  235.  
  236. #ifndef OXOS
  237. #define OBUFL 1024            /* Output buffer length */
  238. #else
  239. #define OBUFL IBUFL
  240. #endif /* OXOS */
  241.  
  242. #ifdef BIGBUFOK
  243. #define TMPLEN 4096            /* Temporary message buffer length */
  244. #else
  245. #define TMPLEN 200
  246. #endif /* BIGBUFOK */
  247.  
  248. #ifdef DYNAMIC
  249. static char *ibuf = NULL, *obuf = NULL, *temp = NULL; /* Buffers */
  250. #else
  251. static char ibuf[IBUFL], obuf[OBUFL], temp[TMPLEN];
  252. #endif /* DYNAMIC */
  253.  
  254. #ifdef TNCODE
  255. static char tnopt[4];
  256. #endif /* TNCODE */
  257.  
  258. #ifdef DYNAMIC
  259. static char *ibp;            /* Input buffer pointer */
  260. #else
  261. static char *ibp = ibuf;        /* Input buffer pointer */
  262. #endif /*DYNAMIC */
  263. static int ibc = 0;            /* Input buffer count */
  264.  
  265. #ifdef DYNAMIC
  266. static char *obp;            /* Output buffer pointer */
  267. #else
  268. static char *obp = obuf;        /* Output buffer pointer */
  269. #endif /* DYNAMIC */
  270.  
  271. /* Character-set items */
  272.  
  273. static int unicode = 0;
  274.  
  275. #ifndef NOCSETS
  276. #ifdef CK_ANSIC /* ANSI C prototypes... */
  277. extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* Character set */
  278. extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* translation functions */
  279. static CHAR (*sxo)(CHAR);    /* Local translation functions */
  280. static CHAR (*rxo)(CHAR);    /* for output (sending) terminal chars */
  281. static CHAR (*sxi)(CHAR);    /* and for input (receiving) terminal chars. */
  282. static CHAR (*rxi)(CHAR);
  283. #else /* Not ANSI C... */
  284. extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])();    /* Character set */
  285. extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])();    /* translation functions. */
  286. static CHAR (*sxo)();        /* Local translation functions */
  287. static CHAR (*rxo)();        /* for output (sending) terminal chars */
  288. static CHAR (*sxi)();        /* and for input (receiving) terminal chars. */
  289. static CHAR (*rxi)();
  290. #endif /* CK_ANSIC */
  291. extern int language;        /* Current language. */
  292. static int langsv;        /* For remembering language setting. */
  293. extern struct csinfo fcsinfo[]; /* File character set info. */
  294. extern int tcsr, tcsl;        /* Terminal character sets, remote & local. */
  295. static int tcs;            /* Intermediate ("transfer") character set. */
  296. static int tcssize = 0;        /* Size of tcs */
  297. #ifdef UNICODE                /* UTF-8 support */
  298. #ifdef CK_ANSIC
  299. extern int (*xl_ufc[MAXFCSETS+1])(USHORT);  /* Unicode to FCS */
  300. extern USHORT (*xl_fcu[MAXFCSETS+1])(CHAR); /* FCS to Unicode */
  301. extern int (*xuf)(USHORT);        /* Translation function UCS to FCS */
  302. extern USHORT (*xfu)(CHAR);        /* Translation function FCS to UCS */
  303. #else
  304. extern int (*xl_ufc[MAXFCSETS+1])();
  305. extern USHORT (*xl_fcu[MAXFCSETS+1])();
  306. extern int (*xuf)();
  307. extern USHORT (*xfu)();
  308. #endif /* CK_ANSIC */
  309. #endif /* UNICODE */
  310. #endif /* NOCSETS */
  311.  
  312. static int printing = 0;
  313.  
  314. /*
  315.   We do not need to parse and recognize escape sequences if we are being built
  316.   without character-set support AND without APC support.
  317. */
  318. #ifdef NOESCSEQ
  319. #ifdef XPRINT
  320. #undef XPRINT
  321. #endif /* XPRINT */
  322.  
  323. #else  /* NOESCSEQ not defined from outside */
  324.  
  325. #ifdef NOCSETS                /* No character sets */
  326. #ifndef CK_APC                /* No APC */
  327. #ifndef XPRINT                /* No transparent printing */
  328. #define NOESCSEQ            /* So no escape sequence recognizer */
  329. #endif /* XPRINT */
  330. #endif /* CK_APC */
  331. #endif /* NOCSETS */
  332. #endif /* NOESCSEQ */
  333.  
  334. /* inesc[] and oldesc[] made global 2010/03/01 for INPUT command */
  335.  
  336. static int escseq = 0;            /* 1 = Recognizer is active */
  337. /* static */ int inesc[2] = { 0, 0 };    /* State of sequence recognizer */
  338. /* static */ int oldesc[2] = { -1, -1 }; /* Previous state of recognizer */
  339.  
  340. #ifdef NOESCSEQ
  341. #define ES_NORMAL 0            /* Normal, not in an escape sequence */
  342. #define chkaes(x,y) 0
  343. #else
  344. /*
  345.   As of C-Kermit 5A(178), the CONNECT command skips past ANSI escape sequences
  346.   to avoid translating the characters within them.  This allows the CONNECT
  347.   command to work correctly with a host that uses a 7-bit ISO 646 national
  348.   character set, in which characters like '[' would normally be converted to
  349.   accented letters, ruining the terminal's interpretation (and generation)
  350.   of escape sequences.
  351.  
  352.   As of 5A(190), the CONNECT command responds to APC escape sequences
  353.   (ESC _ text ESC \) if the user SETs TERMINAL APC ON or UNCHECKED, and the
  354.   program was built with CK_APC defined.
  355.  
  356.   Non-ANSI/ISO-compliant escape sequences are not handled. */
  357.  
  358. /* States for the escape-sequence recognizer. */
  359.  
  360. #define ES_NORMAL 0            /* Normal, not in an escape sequence */
  361. #define ES_GOTESC 1            /* Current character is ESC */
  362. #define ES_ESCSEQ 2            /* Inside an escape sequence */
  363. #define ES_GOTCSI 3            /* Inside a control sequence */
  364. #define ES_STRING 4            /* Inside DCS,OSC,PM, or APC string */
  365. #define ES_TERMIN 5            /* 1st char of string terminator */
  366.  
  367. /*
  368.   ANSI escape sequence handling.  Only the 7-bit form is treated, because
  369.   translation is not a problem in the 8-bit environment, in which all GL
  370.   characters are ASCII and no translation takes place.  So we don't check
  371.   for the 8-bit single-character versions of CSI, DCS, OSC, APC, or ST.
  372.   Here is the ANSI sequence recognizer state table, followed by the code
  373.   that implements it.
  374.  
  375.   Definitions:
  376.     CAN = Cancel                       01/08         Ctrl-X
  377.     SUB = Substitute                   01/10         Ctrl-Z
  378.     DCS = Device Control Sequence      01/11 05/00   ESC P
  379.     CSI = Control Sequence Introducer  01/11 05/11   ESC [
  380.     ST  = String Terminator            01/11 05/12   ESC \
  381.     OSC = Operating System Command     01/11 05/13   ESC ]
  382.     PM  = Privacy Message              01/11 05/14   ESC ^
  383.     APC = Application Program Command  01/11 05/15   ESC _
  384.  
  385.   ANSI escape sequence recognizer:
  386.  
  387.     State    Input  New State  ; Commentary
  388.  
  389.     NORMAL   (start)           ; Start in NORMAL state
  390.  
  391.     (any)    CAN    NORMAL     ; ^X cancels
  392.     (any)    SUB    NORMAL     ; ^Z cancels
  393.  
  394.     NORMAL   ESC    GOTESC     ; Begin escape sequence
  395.     NORMAL   other             ; NORMAL control or graphic character
  396.  
  397.     GOTESC   ESC               ; Start again
  398.     GOTESC   [      GOTCSI     ; CSI
  399.     GOTESC   P      STRING     ; DCS introducer, consume through ST
  400.     GOTESC   ]      STRING     ; OSC introducer, consume through ST
  401.     GOTESC   ^      STRING     ; PM  introducer, consume through ST
  402.     GOTESC   _      STRING     ; APC introducer, consume through ST
  403.     GOTESC   0..~   NORMAL     ; 03/00 through 17/14 = Final character
  404.     GOTESC   other  ESCSEQ     ; Intermediate or ignored control character
  405.  
  406.     ESCSEQ   ESC    GOTESC     ; Start again
  407.     ESCSEQ   0..~   NORMAL     ; 03/00 through 17/14 = Final character
  408.     ESCSEQ   other             ; Intermediate or ignored control character
  409.  
  410.     GOTCSI   ESC    GOTESC     ; Start again
  411.     GOTCSI   @..~   NORMAL     ; 04/00 through 17/14 = Final character
  412.     GOTCSI   other             ; Intermediate char or ignored control char
  413.  
  414.     STRING   ESC    TERMIN     ; Maybe have ST
  415.     STRING   other             ; Consume all else
  416.  
  417.     TERMIN   \      NORMAL     ; End of string
  418.     TERMIN   other  STRING     ; Still in string
  419. */
  420.  
  421. #ifdef XPRINT                /* Transparent print support */
  422. /*
  423.   We can't just print each byte as it comes in because then the printer-off
  424.   sequence would be sent to the printer.  Thus we have to buffer up escape
  425.   sequences and print them only when they are complete AND we know they are
  426.   not the printer-off sequence.  All printing is done via zsoutx(ZMFILE,s,n).
  427.   This allows for strings that contain NULs.  Don't mix calls to zsoutx() with
  428.   calls to zchout(), or the output will be scrambled.  Also note that when
  429.   printing a saved-up escape sequence, we never print its final character
  430.   because that will be printed in the mainline code, upon return from
  431.   chkaes().  Note that the printer-on sequence is passed to the screen; this
  432.   is unavoidable, since we don't know what it is until after we get to the
  433.   end, and for screen display purposes we can't buffer up escape sequences
  434.   for numerous reasons.  Therefore we also must output the printer-off
  435.   sequence, otherwise a real terminal or emulator will be stuck in print mode.
  436. */
  437. extern int tt_print;
  438. #define ESCBUFLEN 63
  439. static char escbuf[ESCBUFLEN+1] = { NUL, NUL };
  440. static int escbufc = 0;
  441. static int dontprint = 0;
  442.  
  443. VOID
  444. printon() {                /* Turn printing on */
  445.     int x, pp;
  446.     char * p;
  447.     extern int printpipe, noprinter;
  448.     extern char * printername;
  449.  
  450.     if (noprinter) {
  451.     debug(F110,"PRINTER ON NOPRINTER","",0);
  452.     return;
  453.     }
  454.     p = printername;
  455.     pp = printpipe;
  456.     if (!p) p = "";
  457.     if (!*p) {
  458. #ifdef ANYBSD
  459.     p = "lpr";
  460. #else
  461.     p = "lp";
  462. #endif /* ANYBSD */
  463.     pp = 1;
  464.     debug(F110,"PRINTER DEFAULT",p,0);
  465.     }
  466.     debug(F111,"PRINTER ON",p,pp);
  467.     if (pp) {                /* Printing to pipe */
  468.     x = zxcmd(ZMFILE,p);
  469.     } else {                /* Append to file */
  470.     struct filinfo xx;
  471.     xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0;
  472.     xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = NUL;
  473.     xx.lblopts = 0;
  474.     x = zopeno(ZMFILE,p,NULL,&xx);
  475.     }
  476.     debug(F101,"PRINTER OPEN","",x);
  477.     printing = 1;
  478. }
  479.  
  480. VOID
  481. printoff() {                /* Turn printing off */
  482.     int x;
  483.     extern int noprinter;
  484.     if (noprinter) {
  485.     printing = 0;
  486.     debug(F100,"PRINTER OFF NOPRINTER","",0);
  487.     return;
  488.     }
  489.     debug(F100,"PRINTER OFF","",0);
  490.     if (printing) {
  491.     x = zclose(ZMFILE);
  492.     debug(F101,"PRINTER CLOSE","",x);
  493.     printing = 0;
  494.     }
  495. }
  496. #endif /* XPRINT */
  497.  
  498. /*
  499.   C H K A E S  --  Check ANSI Escape Sequence.
  500.  
  501.   Call with EACH character in input stream.
  502.   src = 0 means c is incoming from remote; 1 = char from keyboard.
  503.   Sets global inesc[src] variable according to escape sequence state.
  504.   Returns 0 normally, 1 if an APC sequence is to be executed.
  505.   Handles transparent printing internally.
  506. */
  507. int
  508. #ifdef CK_ANSIC
  509. chkaes(char c, int src)
  510. #else
  511. chkaes(c,src) char c; int src;
  512. #endif /* CK_ANSIC */
  513. /* chkaes */ {
  514.  
  515.     debug(F111,"chkaes entry inesc",ckitoa(src),inesc[src]);
  516.     debug(F101,"chkaes c","",c);
  517.  
  518.     if (src < 0 || src > 1)        /* Don't allow bad args. */
  519.       return(0);
  520.  
  521.     oldesc[src] = inesc[src];        /* Remember previous state */
  522.  
  523. #ifdef XPRINT
  524.     if (inesc[src] && !src) {        /* Save up escape seq for printing  */
  525.     if (!c) return(0);        /* Ignore NULs */
  526.     if (escbufc < ESCBUFLEN) {
  527.         escbuf[escbufc++] = c;
  528.         escbuf[escbufc] = NUL;
  529.         debug(F111,"ESCBUF 1",escbuf,escbufc);
  530.     } else {            /* Buffer overrun */
  531.         if (printing && escbufc)    /* Print what's there so far */
  532.           zsoutx(ZMFILE,escbuf,escbufc);
  533.         escbufc = 1;        /* clear it out */
  534.         escbuf[0] = c;        /* and start off fresh buffer */
  535.         escbuf[1] = NUL;        /* with this character. */
  536.     }
  537.     }
  538. #endif /* XPRINT */
  539.  
  540.     if (c == CAN || c == SUB) {        /* CAN and SUB cancel any sequence */
  541. #ifdef XPRINT
  542.     if (!src) {
  543.         if (printing && escbufc > 1)
  544.           zsoutx(ZMFILE,escbuf,escbufc-1);
  545.         escbufc = 0;        /* Clear buffer */
  546.         escbuf[0] = NUL;
  547.     }
  548. #endif /* XPRINT */
  549.     inesc[src] = ES_NORMAL;
  550.     } else                /* Otherwise */
  551.  
  552.       switch (inesc[src]) {        /* enter state switcher */
  553.     case ES_NORMAL:            /* NORMAL state */
  554.       if (c == ESC) {        /* Got an ESC */
  555.           inesc[src] = ES_GOTESC;    /* Change state to GOTESC */
  556. #ifdef XPRINT
  557.           if (!src) {
  558.           escbufc = 1;        /* Clear escape sequence buffer */
  559.           escbuf[0] = c;    /* and deposit the ESC */
  560.           escbuf[1] = NUL;
  561.           debug(F111,"ESCBUF 2",escbuf,escbufc);
  562.           }
  563. #endif /* XPRINT */
  564.       }
  565.       break;            /* Otherwise stay in NORMAL state */
  566.  
  567.     case ES_GOTESC:            /* GOTESC state - prev char was ESC*/
  568.       if (c == '[') {        /* Left bracket after ESC is CSI */
  569.           inesc[src] = ES_GOTCSI;    /* Change to GOTCSI state */
  570.       } else if (c == 'P' || (c > 0134 && c < 0140)) { /* P, ], ^, or _ */
  571.           inesc[src] = ES_STRING;    /* Switch to STRING-absorption state */
  572. #ifdef XPRINT
  573.           debug(F111,"ESCBUF STRING",escbuf,escbufc);
  574. #endif /* XPRINT */
  575. #ifdef CK_APC
  576.           /* If APC not disabled */
  577.           if (!src && c == '_' && (apcstatus & APC_ON)) {
  578.           debug(F100,"CONNECT APC begin","",0);
  579.           apcactive = APC_REMOTE; /* Set APC-Active flag */
  580.           apclength = 0;    /* and reset APC buffer pointer */
  581.           }
  582. #endif /* CK_APC */
  583.       } else if (c > 057 && c < 0177) { /* Final character '0' thru '~' */
  584.           inesc[src] = ES_NORMAL;    /* Back to normal */
  585. #ifdef XPRINT
  586.           if (!src) {
  587.           if (printing && escbufc > 1) {
  588.               /* Dump esc seq buf to printer */
  589.               zsoutx(ZMFILE,escbuf,escbufc-1);
  590.               debug(F111,"ESCBUF PRINT 1",escbuf,escbufc);
  591.           }
  592.  
  593.           escbufc = 0;        /* Clear parameter buffer */
  594.           escbuf[0] = NUL;
  595.           }
  596. #endif /* XPRINT */
  597.       } else if (c != ESC) {    /* ESC in an escape sequence... */
  598.           inesc[src] = ES_ESCSEQ;    /* starts a new escape sequence */
  599.       }
  600.       break;            /* Intermediate or ignored ctrl char */
  601.  
  602.     case ES_ESCSEQ:            /* ESCSEQ -- in an escape sequence */
  603.       if (c > 057 && c < 0177) {    /* Final character '0' thru '~' */
  604.           inesc[src] = ES_NORMAL;    /* Return to NORMAL state. */
  605. #ifdef XPRINT
  606.           if (!src) {
  607.           if (printing && escbufc > 1) {
  608.               zsoutx(ZMFILE,escbuf,escbufc-1);
  609.               debug(F111,"ESCBUF PRINT 2",escbuf,escbufc);
  610.           }
  611.           escbufc = 0;        /* Clear escseq buffer */
  612.           escbuf[0] = NUL;
  613.           }
  614. #endif /* XPRINT */
  615.       } else if (c == ESC) {    /* ESC ... */
  616.           inesc[src] = ES_GOTESC;    /* starts a new escape sequence */
  617.       }
  618.       break;            /* Intermediate or ignored ctrl char */
  619.  
  620.     case ES_GOTCSI:            /* GOTCSI -- In a control sequence */
  621.       if (c > 077 && c < 0177) {    /* Final character '@' thru '~' */
  622. #ifdef XPRINT
  623.           if (!src && tt_print) {    /* Printer enabled? */
  624.           if (c == 'i') {    /* Final char is "i"? */
  625.               char * p = (char *) (escbuf + escbufc - 4);
  626.               if (!strncmp(p, "\033[5i", 4)) { /* Turn printer on */
  627.               printon();
  628.               } else if (!strncmp(p, "\033[4i", 4)) { /* Or off... */
  629.               int i;
  630.               printoff();            /* Turn off printer. */
  631.               dontprint = 1;
  632.               for (i = 0; i < escbufc; i++)    /* And output the */
  633.                 ckcputc(escbuf[i]);         /* sequence. */
  634.               } else if (printing && escbufc > 1) {
  635.               zsoutx(ZMFILE,escbuf,escbufc-1);
  636.               debug(F011,"ESCBUF PRINT 3",escbuf,escbufc);
  637.               }
  638.           } else if (printing && escbufc > 1) {
  639.               zsoutx(ZMFILE,escbuf,escbufc-1);
  640.               debug(F111,"ESCBUF PRINT 4",escbuf,escbufc);
  641.           }
  642.           }
  643.           if (!src) {
  644.           escbufc = 0;        /* Clear esc sequence buffer */
  645.           escbuf[0] = NUL;
  646.           }
  647. #endif /* XPRINT */
  648.           inesc[src] = ES_NORMAL;    /* Return to NORMAL. */
  649.       } else if (c == ESC) {    /* ESC ... */
  650.           inesc[src] = ES_GOTESC;    /* starts over. */
  651.       }
  652.       break;
  653.  
  654.     case ES_STRING:            /* Inside a string */
  655.       if (c == ESC)            /* ESC may be 1st char of terminator */
  656.         inesc[src] = ES_TERMIN;    /* Go see. */
  657. #ifdef CK_APC
  658.       else if (apcactive) {        /* If in APC */
  659.           if (apclength < apcbuflen) { /* and there is room... */
  660.           apcbuf[apclength++] = c; /* deposit this character. */
  661.           } else {            /* Buffer overrun */
  662.           apcactive = 0;    /* Discard what we got */
  663.           apclength = 0;    /* and go back to normal */
  664.           apcbuf[0] = 0;    /* Not pretty, but what else */
  665.           inesc[src] = ES_NORMAL; /* can we do?  (ST might not come) */
  666.           }
  667.       }
  668. #endif /* CK_APC */
  669.       break;            /* Absorb all other characters. */
  670.  
  671.     case ES_TERMIN:            /* Maybe a string terminator */
  672.       if (c == '\\') {        /* which must be backslash */
  673.           inesc[src] = ES_NORMAL;    /* If so, back to NORMAL */
  674. #ifdef XPRINT
  675.           if (!src) {
  676.           if (printing && escbufc > 1) { /* If printing... */
  677.               /* Print esc seq buffer */
  678.               zsoutx(ZMFILE,escbuf,escbufc-1);
  679.               debug(F111,"ESCBUF PRINT 5",escbuf,escbufc);
  680.           }
  681.           escbufc = 0;        /* Clear escseq buffer */
  682.           escbuf[0] = NUL;
  683.           }
  684. #endif /* XPRINT */
  685. #ifdef CK_APC
  686.           if (!src && apcactive) {    /* If it was an APC string, */
  687.           debug(F101,"CONNECT APC terminated","",c);
  688.           apcbuf[apclength] = NUL; /* terminate it and then ... */
  689.           return(1);
  690.           }
  691. #endif /* CK_APC */
  692.       } else {            /* It's not a backslash so... */
  693.           inesc[src] = ES_STRING;    /* back to string absorption. */
  694. #ifdef CK_APC
  695.           if (apcactive) {        /* In APC string */
  696.           if (apclength+1 < apcbuflen) { /* If enough room */
  697.               apcbuf[apclength++] = ESC; /* deposit the Esc */
  698.               apcbuf[apclength++] = c;   /* and this character too. */
  699.           } else {        /* Buffer overrun */
  700.               apcactive = 0;
  701.               apclength = 0;
  702.               apcbuf[0] = 0;
  703.               inesc[src] = ES_NORMAL;
  704.           }
  705.           }
  706. #endif /* CK_APC */
  707.       }
  708.       }    /* switch() */
  709.     debug(F111,"chkaes exit inesc",ckitoa(src),inesc[src]);
  710.     return(0);
  711. }
  712. #endif /* NOESCSEQ */
  713.  
  714. VOID
  715. #ifdef CK_ANSIC
  716. LOGCHAR(char c)
  717. #else
  718. LOGCHAR(c) char c;
  719. #endif /* CK_ANSIC */
  720. /* LOGCHAR */ {                         /* Log character c to session log */
  721.     /* but skip over escape sequences if session log is text */
  722.     if (escseq) {
  723.     if ((sessft == XYFT_T) && (debses == 0) &&
  724.         (inesc[0] != ES_NORMAL || oldesc[0] != ES_NORMAL))
  725.       return;
  726.     }
  727.     logchar(c);
  728. }
  729.  
  730. /*  C K C P U T C  --  C-Kermit CONNECT Put Character to Screen  */
  731. /*
  732.   Output is buffered to avoid slow screen writes on fast connections.
  733. */
  734. static int
  735. ckcputf() {                /* Dump the console output buffer */
  736.     int x = 0;
  737.     if (obc > 0)            /* If we have any characters, */
  738.       x = conxo(obc,obuf);        /* dump them, */
  739.     obp = obuf;                /* reset the pointer */
  740.     obc = 0;                /* and the counter. */
  741.     return(x);                /* Return conxo's return code */
  742. }
  743.  
  744. /*
  745.   NOTE: This is probably the right place for character-set translation,
  746.   rather than down below in the mainline code.  ckcputc() would act like
  747.   xpnbyte() in ckcfns.c, and ckcgetc() would act like xgnbyte().  This
  748.   would shield the rest of the code from all the complexities of many-to-one
  749.   and one-to-many conversions, and would allow handling of Kanji and other
  750.   CJK sets along with UTF-8 and the rest.
  751. */
  752. int
  753. ckcputc(c) int c; {
  754.     int x;
  755.  
  756.     *obp++ = c & 0xff;            /* Deposit the character */
  757.     obc++;                /* Count it */
  758.     if (ibc == 0 ||            /* If input buffer about empty */
  759.     obc == OBUFL) {            /* or output buffer full */
  760.     debug(F101,"CONNECT CKCPUTC obc","",obc);
  761.     x = conxo(obc,obuf);        /* dump the buffer, */
  762.     obp = obuf;            /* reset the pointer */
  763.     obc = 0;            /* and the counter. */
  764.     return(x);            /* Return conxo's return code */
  765.     } else return(0);
  766. }
  767.  
  768. /*  C K C G E T C  --  C-Kermit CONNECT Get Character  */
  769. /*
  770.   Buffered read from communication device.
  771.   Returns the next character, refilling the buffer if necessary.
  772.   On error, returns ttinc's return code (see ttinc() description).
  773.   Dummy argument for compatible calling conventions with ttinc()
  774.   so a pointer to this function can be passed to tn_doop().
  775. */
  776. int
  777. ckcgetc(dummy) int dummy; {
  778.     int c, n;
  779. #ifdef CK_SSL
  780.     extern int ssl_active_flag, tls_active_flag;
  781. #endif /* CK_SSL */
  782.  
  783. #ifdef CK_ENCRYPTION
  784.     /* No buffering for possibly encrypted connections */
  785.     if (network && IS_TELNET() && TELOPT_ME(TELOPT_AUTHENTICATION))
  786.       return(ttinc(0));
  787. #endif /* CK_ENCRYPTION */
  788. #ifdef CK_SSL
  789.     if (ssl_active_flag || tls_active_flag)
  790.         return(ttinc(0));
  791. #endif /* CK_SSL */
  792.  
  793.     if (ibc < 1) {            /* Need to refill buffer? */
  794.     ibc = 0;            /* Yes, reset count */
  795.     ibp = ibuf;            /* and buffer pointer */
  796.     c = ttinc(0);            /* Read one character, blocking */
  797.     if (c < 0) {            /* If error, return error code */
  798.         return(c);
  799.     } else {            /* Otherwise, got one character */
  800.         *ibp++ = c;            /* Advance buffer pointer */
  801.         ibc++;            /* and count. */
  802.     }
  803.     if ((n = ttchk()) > 0) {    /* Any more waiting? */
  804.         if (n > (IBUFL - ibc))    /* Get them all at once. */
  805.           n = IBUFL - ibc;        /* Don't overflow buffer */
  806.           if ((n = ttxin(n,(CHAR *)ibp)) > 0) {
  807.           ibc += n;        /* Advance counter */
  808.               }
  809.     } else if (n < 0) {        /* Error? */
  810.         return(n);            /* Return the error code */
  811.     }
  812.     ibp = ibuf;            /* Point to beginning of buffer */
  813.     }
  814.     c = *ibp++ & 0xff;            /* Get next character from buffer */
  815.     ibc--;                /* Reduce buffer count */
  816.     /* debug(F000,"CKCGETC","",c); */
  817.     return(c);                /* Return the character */
  818. }
  819.  
  820. /*
  821.    Keyboard handling, buffered for speed, which is needed when C-Kermit is
  822.    in CONNECT mode between two other computers that are transferring data.
  823. */
  824. static char *kbp;            /* Keyboard input buffer pointer */
  825. static int kbc;                /* Keyboard input buffer count */
  826.  
  827. #ifdef CK_SMALL                /* Keyboard input buffer length */
  828. #define KBUFL 32            /* Small for PDP-11 UNIX */
  829. #else
  830. #define KBUFL 257            /* Regular kernel size for others */
  831. #endif /* CK_SMALL */
  832.  
  833. #ifdef DYNAMIC
  834. static char *kbuf = NULL;
  835. #else
  836. static char kbuf[KBUFL];
  837. #endif /* DYNAMIC */
  838.  
  839. /* Macro for reading keystrokes. */
  840.  
  841. #define CONGKS() (((--kbc)>=0) ? ((int)(*kbp++) & 0377) : kbget())
  842.  
  843. /*
  844.   Note that we call read() directly here, normally a no-no, but in this case
  845.   we know it's UNIX and we're only doing what coninc(0) would have done,
  846.   except we're reading a block of characters rather than just one.  There is,
  847.   at present, no conxin() analog to ttxin() for chunk reads, and instituting
  848.   one would only add function-call overhead as it would only be a wrapper for
  849.   a read() call anyway.
  850.  
  851.   Another note: We stick in this read() till the user types something.
  852.   But we know they already did, since select() said so.  Therefore something
  853.   would need to be mighty wrong before we get stuck here.
  854. */
  855. static int                /* Keyboard buffer filler */
  856. kbget() {
  857. #ifdef EINTR
  858.     int tries = 10;            /* If read() is interrupted, */
  859.     int ok = 0;
  860.     while (tries-- > 0) {        /* try a few times... */
  861. #endif /* EINTR */
  862.     kbc = conchk();            /* How many chars waiting? */
  863.     debug(F101,"kbget kbc","",kbc);
  864.     if (kbc < 1)
  865.       kbc = 1;            /* If none or dunno, wait for one. */
  866.     else if (kbc > KBUFL)        /* If too many, */
  867.       kbc = KBUFL;            /* only read this many. */
  868.     if ((kbc = read(0, kbuf, kbc)) < 1) { /* Now read it/them. */
  869.         debug(F101,"CONNECT kbget errno","",errno);    /* Got an error. */
  870. #ifdef EINTR
  871.         if (errno == EINTR)        /* Interrupted system call. */
  872.           continue;            /* Try again, up to limit. */
  873.         else            /* Something else. */
  874. #endif /* EINTR */
  875.           return(-1);        /* Pass along read() error. */
  876.     }
  877. #ifdef EINTR
  878.     else { ok = 1; break; }
  879.     }
  880.     if (!ok) return(-1);
  881. #endif /* EINTR */
  882.     kbp = kbuf;                /* Adjust buffer pointer, */
  883.     kbc--;                /* count, */
  884.     return((int)(*kbp++) & 0377);    /* and return first character. */
  885. }
  886.  
  887. #ifdef BEBOX
  888. /*
  889.  * CreateSocketPair --
  890.  *
  891.  *    This procedure creates a connected socket pair
  892.  *
  893.  * Results:
  894.  *    0 if OK, the error if not OK.
  895.  *
  896.  * Side effects:
  897.  *    None
  898.  */
  899. int
  900. socketpair(int *pair) {
  901.     int servsock;
  902.     int val;
  903.     struct sockaddr_in serv_addr, cli_addr;
  904.     extern char myipaddr[];
  905.  
  906.     debug(F110,"socketpair",myipaddr,0);
  907.  
  908.     if (myipaddr[0] == 0)
  909.       getlocalipaddr();
  910.  
  911.     servsock = socket(AF_INET, SOCK_STREAM, 0);
  912.     if (servsock == 0) {
  913.     return h_errno;
  914.     }
  915.     debug(F111,"socketpair","socket",servsock);
  916.  
  917.     memset(&serv_addr, 0, sizeof(serv_addr));
  918.     serv_addr.sin_family = AF_INET;
  919.     serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  920.     serv_addr.sin_port = htons(0);
  921.  
  922.     val = sizeof(serv_addr);
  923.     if (bind(servsock, (struct sockaddr *) &serv_addr, val) < 0) {
  924.     closesocket(servsock);
  925.     return h_errno;
  926.     }
  927.     debug(F111,"socketpair","bind",0);
  928.  
  929.     listen(servsock, 1);
  930.     debug(F111,"socketpair","listen",0);
  931.  
  932.     if (getsockname(servsock, (struct sockaddr *) &serv_addr, &val) < 0) {
  933.     closesocket(servsock);
  934.     return h_errno;
  935.     }
  936.     debug(F111,"socketpair","getsockname",0);
  937.  
  938.     pair[0] = socket(AF_INET, SOCK_STREAM, 0);
  939.     if (pair[0] == 0) {
  940.     closesocket(servsock);
  941.     return h_errno;
  942.     }
  943.     debug(F111,"socketpair","socket",pair[0]);
  944.  
  945.     memset(&cli_addr, 0, sizeof(cli_addr));
  946.     cli_addr.sin_family = AF_INET;
  947.     cli_addr.sin_addr.s_addr = inet_addr(myipaddr[0]?myipaddr:"127.0.0.1");
  948.     cli_addr.sin_port = serv_addr.sin_port;
  949.  
  950.     if (connect(pair[0],(struct sockaddr *) &cli_addr, sizeof(cli_addr)) < 0) {
  951.     closesocket(pair[0]);
  952.     closesocket(servsock);
  953.     return h_errno;
  954.     }
  955.     debug(F111,"socketpair","connect",0);
  956.  
  957.     pair[1] = accept(servsock, (struct sockaddr *) &serv_addr, &val);
  958.     if (pair[1] == 0) {
  959.     closesocket(pair[0]);
  960.     closesocket(servsock);
  961.     return h_errno;
  962.     }
  963.     debug(F111,"socketpair","accept",pair[1]);
  964.  
  965.     closesocket(servsock);
  966.     debug(F111,"socketpair","closesocket",0);
  967.     return 0;
  968. }
  969.  
  970. long
  971. kbdread(void * param) {
  972.     int sock = (int) param;
  973.     char ch;
  974.     int rc = 0;
  975.  
  976.     debug(F111,"kbdread","sock",sock);
  977.  
  978.     while (rc >= 0) {
  979.     rc = read(fileno(stdin), &ch, 1); /* Read a character. */
  980.     if (rc > 0) {
  981.         rc = send(sock,&ch,1,0);
  982.         /* debug(F000,"kbdread","send()",ch); */
  983.         printf("\r\ngot: %c rc = %d\r\n",ch,rc);
  984.     } else
  985.       msleep(100);
  986.     }
  987.     debug(F110,"kbdread","terminating",0);
  988.     return(rc);
  989. }
  990. #endif /* BEBOX */
  991.  
  992. #ifdef CKLEARN
  993. static VOID
  994. learnchar(c) int c; {            /* Learned script keyboard character */
  995.     int cc;
  996.     char xbuf[8];
  997.  
  998.     if (!learning || !learnfp)
  999.       return;
  1000.  
  1001.     switch (learnst) {            /* Learn state... */
  1002.       case 0:                /* Neutral */
  1003.       case 1:                /* Net */
  1004.     if (learnbc > 0) {        /* Have net characters? */
  1005.         char buf[LEARNBUFSIZ];
  1006.         int i, j, n;
  1007.         ULONG t;
  1008.  
  1009.         t = (ULONG) time(0);    /* Calculate INPUT timeout */
  1010.         j = t - learnt1;
  1011.         j += (j / 4) > 0 ? (j / 4) : 1; /* Add some slop */
  1012.         if (j < 2) j = 2;            /* 2 seconds minimum */
  1013.  
  1014.         fputs("\nINPUT ",learnfp);    /* Give INPUT command for them */
  1015.         fputs(ckitoa(j),learnfp);
  1016.         fputs(" {",learnfp);
  1017.         learnt1 = t;
  1018.  
  1019.         n = LEARNBUFSIZ;
  1020.         if (learnbc < LEARNBUFSIZ) {  /* Circular buffer */
  1021.         n = learnbc;          /*  hasn't wrapped yet. */
  1022.         learnbp = 0;
  1023.         }
  1024.         j = 0;            /* Copy to linear buffer */
  1025.         for (i = 0; i < n; i++) {    /* Number of chars in circular buf */
  1026.  
  1027.         cc = learnbuf[(learnbp + i) % LEARNBUFSIZ];
  1028.  
  1029.         /* Later account for prompts that end with a newline? */
  1030.  
  1031.         if (cc == CR && j > 0) {
  1032.             if (buf[j-1] != LF)
  1033.               j = 0;
  1034.         }
  1035.         buf[j++] = cc;
  1036.         }
  1037.         for (i = 0; i < j; i++) {    /* Now copy out the buffer */
  1038.         cc = buf[i];        /* interpreting control chars */
  1039.         if (cc == 0) {        /* We don't INPUT NULs */
  1040.             continue;
  1041.         } else if (cc < SP ||    /* Controls need quoting */
  1042.                (cc > 126 && cc < 160)) {
  1043.             ckmakmsg(xbuf,8,"\\{",ckitoa((int)cc),"}",NULL);
  1044.             fputs(xbuf,learnfp);
  1045.         } else {        /* Plain character */
  1046.             putc(cc,learnfp);
  1047.         }
  1048.         }
  1049.         fputs("}\nIF FAIL STOP 1 INPUT timeout",learnfp);
  1050.         learnbc = 0;
  1051.     }
  1052.     learnbp = 0;
  1053.     fputs("\nPAUSE 1\nOUTPUT ",learnfp); /* Emit OUTPUT and fall thru */
  1054.  
  1055.       case 2:                /* Already in Keyboard state */
  1056.     if (c == 0) {
  1057.         fputs("\\N",learnfp);
  1058.     } else if (c == -7) {
  1059.         fputs("\\B",learnfp);
  1060.     } else if (c == -8) {
  1061.         fputs("\\L",learnfp);
  1062.     } else if (c < SP || (c > 126 && c < 160)) {
  1063.         ckmakmsg(xbuf,8,"\\{",ckitoa((int)c),"}",NULL);
  1064.         fputs(xbuf,learnfp);
  1065.     } else {
  1066.         putc(c,learnfp);
  1067.     }
  1068.     }
  1069. }
  1070. #endif /* CKLEARN */
  1071.  
  1072. static int printbar = 0;
  1073.  
  1074. #define OUTXBUFSIZ 15
  1075. static CHAR inxbuf[OUTXBUFSIZ+1];    /* Host-to-screen expansion buffer */
  1076. static int inxcount = 0;        /* and count */
  1077. static CHAR outxbuf[OUTXBUFSIZ+1];    /* Keyboard-to-host expansion buf */
  1078. static int outxcount = 0;        /* and count */
  1079.  
  1080. int
  1081. conect() {
  1082.     int rc = 0;                /* Return code: 0 = fail, 1 = OK */
  1083.     int i, x = 0, prev = -1;        /* Reason code in cx_status */
  1084. #ifdef CKLEARN
  1085.     int crflag = 0;
  1086. #endif /* CKLEARN */
  1087.     register int c = -1, c2, csave;    /* Characters */
  1088. #ifdef TNCODE
  1089.     int tx;                /* For Telnet negotiations */
  1090. #endif /* TNCODE */
  1091.     int apcrc = 0;            /* For APC and transparent print */
  1092.     int n, kbin, scrnout;        /* select() items... */
  1093.     fd_set in, out, err;        /* File descriptor sets */
  1094.     int gotnet = 0;            /* Flag for net ready to read */
  1095.     int gotkbd = 0;            /* Flag for keyboard ready to read */
  1096.     int oldprt = 0;            /* Used with printing */
  1097.     int msgflg = 0;
  1098.     char cbuf[2];            /* Ditto */
  1099.  
  1100. #ifdef BEBOX
  1101.     int tid = 0;            /* Thread ID */
  1102.     int pair[2];            /* Socket Pair */
  1103.     CHAR ch;
  1104.     CHAR buf[64];
  1105. #endif /* BEBOX */
  1106.  
  1107.     cx_status = CSX_INTERNAL;
  1108.     debok = 1;
  1109.  
  1110. #ifdef BEBOX
  1111.     {
  1112.     /* Create a socket pair to be used for the keyboard input */
  1113.     if (socketpair(pair)) {
  1114.         debug(F110,"conect","unable to create socket pair",0);
  1115.         return(-1);
  1116.     }
  1117.     debug(F111,"connect","socket pair[0]",pair[0]);
  1118.     debug(F111,"connect","socket pair[1]",pair[1]);
  1119.  
  1120.     /* Assign one end of the socket to kbin */
  1121.     kbin = pair[0];
  1122.         tid = spawn_thread(kbdread,
  1123.                "Kbd to Socket Pair",
  1124.                 B_NORMAL_PRIORITY,
  1125.                (void *)pair[1]
  1126.                );
  1127.         resume_thread(tid);
  1128.     debug(F110,"connect","tid",tid);
  1129.     }
  1130. #else /* BEBOX */
  1131.     kbin = fileno(stdin);        /* stdin file descriptor */
  1132. #endif /* BEBOX */
  1133.  
  1134.     scrnout = fileno(stdout);        /* stdout file descriptor */
  1135.  
  1136. #ifdef CK_TRIGGER
  1137.     makestr(&triggerval,NULL);        /* Reset trigger */
  1138. #endif /* CK_TRIGGER */
  1139.  
  1140. #ifdef XPRINT
  1141.     escbufc = 0;            /* Reset esc-sequence buffer */
  1142.     escbuf[0] = NUL;
  1143. #endif /* XPRINT */
  1144.     cbuf[1] = NUL;
  1145.  
  1146.     ttimoff();                /* Turn off any timer interrupts */
  1147.     if (!local) {            /* Be sure we're not in remote mode */
  1148. #ifdef NETCONN
  1149. #ifdef NEWFTP
  1150.     if (ftpisconnected())
  1151.       printf("Sorry, you can't CONNECT to an FTP server\n");
  1152.     else
  1153. #endif /* NEWFTP */
  1154.       printf("Sorry, you must SET LINE or SET HOST first\n");
  1155. #else
  1156.     printf("Sorry, you must SET LINE first\n");
  1157. #endif /* NETCONN */
  1158.     return(0);
  1159.     }
  1160.     if (speed < 0L && network == 0 && ttfdflg == 0) {
  1161.     printf("Sorry, you must SET SPEED first\n");
  1162.     return(0);
  1163.     }
  1164. #ifdef TCPSOCKET
  1165.     if (network && !ttpipe && (nettype != NET_TCPB && nettype != NET_PTY)) {
  1166.     printf("Sorry, network type not supported\n");
  1167.     return(0);
  1168.     }
  1169. #endif /* TCPSOCKET */
  1170.  
  1171. #ifdef DYNAMIC
  1172.     if (!ibuf) {
  1173.     if (!(ibuf = malloc(IBUFL+1))) { /* Allocate input line buffer */
  1174.         printf("Sorry, CONNECT input buffer can't be allocated\n");
  1175.         return(0);
  1176.     } else {
  1177.         ibp = ibuf;
  1178.         ibc = 0;
  1179.     }
  1180.     }
  1181.     if (!obuf) {
  1182.     if (!(obuf = malloc(OBUFL+1))) { /* Allocate output line buffer */
  1183.         printf("Sorry, CONNECT output buffer can't be allocated\n");
  1184.         return(0);
  1185.     } else {
  1186.         obp = obuf;
  1187.         obc = 0;
  1188.     }
  1189.     }
  1190.     if (!kbuf) {
  1191.     if (!(kbuf = malloc(KBUFL+1))) { /* Allocate keyboard input buffer */
  1192.         printf("Sorry, CONNECT keyboard buffer can't be allocated\n");
  1193.         return(0);
  1194.     }
  1195.     }
  1196.     if (!temp) {
  1197.     if (!(temp = malloc(TMPLEN+1))) { /* Allocate temporary buffer */
  1198.         printf("Sorry, CONNECT temporary buffer can't be allocated\n");
  1199.         return(0);
  1200.     }
  1201.     }
  1202. #else
  1203.     obp = obuf;
  1204.     obc = 0;
  1205. #endif /* DYNAMIC */
  1206.  
  1207.     kbp = kbuf;                /* Always clear these. */
  1208.     *kbp = NUL;                /* No need to preserve them between */
  1209.     kbc = 0;                /* CONNECT sessions. */
  1210.  
  1211. #ifdef DEBUG
  1212.     if (deblog) {
  1213.     debug(F101,"CONNECT conect entry ttyfd","",ttyfd);
  1214.     debug(F101,"CONNECT conect entry ibc","",ibc);
  1215.     debug(F101,"CONNECT conect entry obc","",obc);
  1216.     debug(F101,"CONNECT conect entry kbc","",kbc);
  1217. #ifdef CK_TRIGGER
  1218.     debug(F110,"CONNECT conect trigger",tt_trigger[0],0);
  1219. #endif /* CK_TRIGGER */
  1220.     if (ttyfd > -1) {
  1221.         n = ttchk();
  1222.         debug(F101,"CONNECT conect entry ttchk","",n);
  1223.     }
  1224.     }
  1225. #endif /* DEBUG */
  1226.  
  1227.     if (ttyfd < 0) {            /* If communication device not open */
  1228. #ifdef TTLEBUF
  1229.         int n = le_inbuf();
  1230.         debug(F111,"CONNECT le_inbuf()","ttyfd < 0",n);
  1231.         if (n > 0) {
  1232.             while (n--) {
  1233.                 CHAR ch;
  1234.                 le_getchar(&ch);
  1235.                 conoc(ch);
  1236.             }
  1237.             return(0);
  1238.         }
  1239. #endif /* TTLEBUF */
  1240.  
  1241.     debug(F101,"CONNECT ttnproto","",ttnproto);
  1242.     debug(F111,"CONNECT opening",ttname,0); /* Open it now */
  1243.     if (ttopen(ttname,
  1244.            &local,
  1245.            network ? -nettype : mdmtyp,
  1246.            0
  1247.            ) < 0) {
  1248.         ckmakmsg(temp,TMPLEN,"Sorry, can't open ",ttname,NULL,NULL);
  1249.         perror(temp);
  1250.         debug(F110,"CONNECT open failure",ttname,0);
  1251.         return(0);
  1252.     }
  1253.  
  1254. #ifdef IKS_OPTION
  1255.     /* If peer is in Kermit server mode, return now. */
  1256.     if (TELOPT_SB(TELOPT_KERMIT).kermit.u_start) {
  1257.         cx_status = CSX_IKSD;
  1258.         return(0);
  1259.     }
  1260. #endif /* IKS_OPTION */
  1261.     }
  1262.     dohangup = 0;            /* Hangup not requested yet */
  1263.  
  1264.     msgflg = !quiet
  1265. #ifdef CK_APC
  1266.       && !apcactive
  1267. #endif /* CK_APC */
  1268.     ;
  1269.  
  1270.     if (msgflg) {
  1271. #ifdef NETCONN
  1272.     if (network) {
  1273. #ifdef CK_ENCRYPTION
  1274.         extern int me_encrypt, u_encrypt;
  1275.         if (ck_tn_encrypting() && ck_tn_decrypting())
  1276.           printf("SECURE connection to host %s",ttname);
  1277.         else
  1278. #endif /* CK_ENCRYPTION */
  1279.           if (ttpipe || ttpty)
  1280.         printf("Connecting via command \"%s\"",ttname);
  1281.           else
  1282.         printf("Connecting to host %s",ttname);
  1283.     } else {
  1284. #endif /* NETCONN */
  1285.         printf("Connecting to %s",ttname);
  1286.         if (speed > -1L) printf(", speed %ld",speed);
  1287. #ifdef NETCONN
  1288.     }
  1289. #endif /* NETCONN */
  1290.     if (tt_escape) {
  1291.         printf("\r\n");
  1292.         shoesc(escape);
  1293.         printf("Type the escape character followed by C to get back,\r\n");
  1294.         printf("or followed by ? to see other options.\r\n");
  1295.     } else {
  1296.         printf(".\r\n\nESCAPE CHARACTER IS DISABLED\r\n\n");
  1297.     }
  1298.     if (seslog) {
  1299.         extern int slogts;
  1300.         char * s = "";
  1301.         switch (sessft) {
  1302.           case XYFT_D:
  1303.         s = "debug"; break;
  1304.           case XYFT_T:
  1305.         s = slogts ? "timestamped-text" : "text"; break;
  1306.           default:
  1307.         s = "binary";
  1308.         }
  1309.         printf("Session Log: %s, %s (%d) \r\n",sesfil,s,sessft);
  1310.     }
  1311.     if (debses) printf("Debugging Display...)\r\n");
  1312.     }
  1313.  
  1314. /* Condition console terminal and communication line */
  1315.  
  1316.     if (conbin((char)escape) < 0) {
  1317.     printf("Sorry, can't condition console terminal\n");
  1318.     fflush(stdout);
  1319.     return(0);
  1320.     }
  1321.     debug(F101,"CONNECT cmask","",cmask);
  1322.     debug(F101,"CONNECT cmdmsk","",cmdmsk);
  1323.     debug(F101,"CONNECT speed before ttvt","",speed);
  1324.     if ((n = ttvt(speed,flow)) < 0) {    /* Enter "virtual terminal" mode */
  1325.     if (!network) {
  1326.         debug(F101,"CONNECT ttvt","",n);
  1327.         tthang();            /* Hang up and close the device. */
  1328.         ttclos(0);
  1329.         dologend();
  1330.         if (ttopen(ttname,        /* Open it again... */
  1331.                &local,
  1332.                network ? -nettype : mdmtyp,
  1333.                0
  1334.                ) < 0) {
  1335.         cx_status = CSX_INTERNAL;
  1336.         ckmakmsg(temp,TMPLEN,"Sorry, can't reopen ",ttname,NULL,NULL);
  1337.         perror(temp);
  1338.         return(0);
  1339.         }
  1340. #ifdef IKS_OPTION
  1341.         if (TELOPT_SB(TELOPT_KERMIT).kermit.u_start) {
  1342.         cx_status = CSX_IKSD;
  1343.         return(0);
  1344.         }
  1345. #endif /* IKS_OPTION */
  1346.  
  1347.         if (ttvt(speed,flow) < 0) {    /* Try virtual terminal mode again. */
  1348.         conres();        /* Failure this time is fatal. */
  1349.         printf("Sorry, Can't condition communication line\n");
  1350.         cx_status = CSX_INTERNAL;
  1351.         return(0);
  1352.         }
  1353.     }
  1354.     }
  1355.     debug(F101,"CONNECT ttvt ok, escape","",escape);
  1356.  
  1357.     /* Despite ttvt() this is still needed in HP-UX */
  1358.     /* because of the HP-9000 <RESET> key.*/
  1359.  
  1360.     signal(SIGINT, SIG_IGN);
  1361.     signal(SIGQUIT, SIG_IGN);
  1362.  
  1363.     debug(F101,"CONNECT carrier-watch","",carrier);
  1364.     if ((!network 
  1365. #ifdef TN_COMPORT
  1366.         || istncomport()
  1367. #endif /* TN_COMPORT */
  1368.     ) && (carrier != CAR_OFF)) {
  1369.     int x;
  1370.     x = ttgmdm();
  1371.     debug(F100,"CONNECT ttgmdm","",x);
  1372.     if ((x > -1) && !(x & BM_DCD)) {
  1373. #ifndef NOHINTS
  1374.         extern int hints;
  1375. #endif /* NOHINTS */
  1376.         debug(F100,"CONNECT ttgmdm CD test fails","",x);
  1377.         conres();
  1378.         printf("?Carrier required but not detected.\n");
  1379. #ifndef NOHINTS
  1380.         cx_status = CSX_CARRIER;
  1381.         if (!hints)
  1382.           return(0);
  1383.         printf("***********************************\n");
  1384.         printf(" Hint: To CONNECT to a serial device that\n");
  1385.         printf(" is not presenting the Carrier Detect signal,\n");
  1386.         printf(" first tell C-Kermit to:\n\n");
  1387.         printf("   SET CARRIER-WATCH OFF\n\n");
  1388.         printf("***********************************\n\n");
  1389. #endif /* NOHINTS */
  1390.         return(0);
  1391.     }
  1392.     debug(F100,"CONNECT ttgmdm ok","",0);
  1393.     }
  1394.  
  1395.     /* Now we are connected. */
  1396.  
  1397.     if (msgflg || printbar)
  1398.       printf("----------------------------------------------------\r\n");
  1399.     fflush(stdout);
  1400.  
  1401. #ifndef NOCSETS
  1402. /* Set up character set translations */
  1403.  
  1404.     unicode = 0;            /* Assume Unicode won't be involved */
  1405.     tcs = 0;                /* "Transfer" or "Other" charset */
  1406.     sxo = rxo = NULL;            /* Initialize byte-to-byte functions */
  1407.     sxi = rxi = NULL;
  1408.  
  1409.     if (tcsr != tcsl) {            /* Remote and local sets differ... */
  1410. #ifdef UNICODE
  1411.     if (tcsr == FC_UTF8 ||        /* Remote charset is UTF-8 */
  1412.         tcsl == FC_UTF8) {        /* or local one is. */
  1413.         xuf = xl_ufc[tcsl];        /* Incoming Unicode to local */
  1414.         if (xuf || tcsl == FC_UTF8) {
  1415.         tcs = (tcsr == FC_UTF8) ? tcsl : tcsr; /* The "other" set */
  1416.         xfu = xl_fcu[tcs];    /* Local byte to remote Unicode */
  1417.         if (xfu)
  1418.           unicode = (tcsr == FC_UTF8) ? 1 : 2;
  1419.         }
  1420.         tcssize = fcsinfo[tcs].size; /* Size of other character set. */
  1421.     } else {
  1422. #endif /* UNICODE */
  1423.         tcs = gettcs(tcsr,tcsl);    /* Get intermediate set. */
  1424.         sxo = xls[tcs][tcsl];    /* translation function */
  1425.         rxo = xlr[tcs][tcsr];    /* pointers for output functions */
  1426.         sxi = xls[tcs][tcsr];    /* and for input functions. */
  1427.         rxi = xlr[tcs][tcsl];
  1428. #ifdef UNICODE
  1429.     }
  1430. #endif /* UNICODE */
  1431.     }
  1432. /*
  1433.   This is to prevent use of zmstuff() and zdstuff() by translation functions.
  1434.   They only work with disk i/o, not with communication i/o.  Luckily Russian
  1435.   translation functions don't do any stuffing...
  1436. */
  1437.     langsv = language;
  1438. #ifndef NOCYRIL
  1439.     if (language != L_RUSSIAN)
  1440. #endif /* NOCYRIL */
  1441.       language = L_USASCII;
  1442.  
  1443. #ifdef COMMENT
  1444. #ifdef DEBUG
  1445.     if (deblog) {
  1446.     debug(F101,"CONNECT tcs","",tcs);
  1447.     debug(F101,"CONNECT tcsl","",tcsl);
  1448.     debug(F101,"CONNECT tcsr","",tcsr);
  1449.     debug(F101,"CONNECT fcsinfo[tcsl].size","",fcsinfo[tcsl].size);
  1450.     debug(F101,"CONNECT fcsinfo[tcsr].size","",fcsinfo[tcsr].size);
  1451.     debug(F101,"CONNECT unicode","",unicode);
  1452.     }
  1453. #endif /* DEBUG */
  1454. #endif /* COMMENT */
  1455.  
  1456. #ifdef CK_XYZ
  1457. #ifndef XYZ_INTERNAL
  1458.     {
  1459.     extern int binary;        /* See about ZMODEM autodownloads */
  1460.     char * s;
  1461.     s = binary ? ptab[PROTO_Z].p_b_rcmd : ptab[PROTO_Z].p_t_rcmd;
  1462.     if (!s) s = "";
  1463.     zmdlok = (*s != NUL);        /* OK if we have external commands */
  1464.     }
  1465. #endif /* XYZ_INTERNAL */
  1466. #endif /* CK_XYZ */
  1467.  
  1468. #ifndef NOESCSEQ
  1469. /*
  1470.   We need to activate the escape-sequence recognition feature when:
  1471.    (a) translation is elected, AND
  1472.    (b) the local and/or remote set is a 7-bit set other than US ASCII;
  1473.   Or:
  1474.    SET SESSION-LOG is TEXT (so we can strip escape sequences out of the log);
  1475.   Or:
  1476.    SET TERMINAL APC is not OFF (handled in the next statement).
  1477. */
  1478.     escseq = (tcs != TC_TRANSP) &&    /* Not transparent */
  1479.       (fcsinfo[tcsl].size == 128 || fcsinfo[tcsr].size == 128) && /* 7 bits */
  1480.     (fcsinfo[tcsl].code != FC_USASCII); /* But not ASCII */
  1481. #endif /* NOESCSEQ */
  1482. #endif /* NOCSETS */
  1483.  
  1484. #ifndef NOESCSEQ
  1485.     if (!escseq) {            /* 2009/10/22 */
  1486.     if (seslog && !sessft)
  1487.       escseq = 1;
  1488.     }
  1489. #ifdef CK_APC
  1490.     escseq = escseq || (apcstatus & APC_ON);
  1491.     apcactive = 0;            /* An APC command is not active */
  1492.     apclength = 0;            /* ... */
  1493. #endif /* CK_APC */
  1494. #ifdef XPRINT
  1495.     escseq |= tt_print;
  1496. #endif /* XPRINT */
  1497.     /* Initial state of recognizer */
  1498.     inesc[0] = ES_NORMAL;        /* Remote to screen */
  1499.     inesc[1] = ES_NORMAL;        /* Keyboard to remote */
  1500.     debug(F101,"CONNECT escseq","",escseq);
  1501. #endif /* NOESCSEQ */
  1502.  
  1503.     if (ttyfd > -1) {            /* (just in case...) */
  1504.     what = W_CONNECT;        /* Keep track of what we're doing */
  1505.     active = 1;
  1506.     }
  1507. #ifdef CKLEARN
  1508.     if (learning) {            /* Learned script active... */
  1509.     learnbp = 0;            /* INPUT buffer pointer */
  1510.     learnbc = 0;            /* INPUT buffer count */
  1511.     learnst = 0;            /* State (0 = neutral, none) */
  1512.     learnt1 = (ULONG) time(0);
  1513.     }
  1514. #endif /* CKLEARN */
  1515.  
  1516. #ifdef CKTIDLE
  1517.     idlelimit = tt_idlelimit;
  1518. #endif /* CKTIDLE */
  1519.  
  1520.     while (active) {            /* Big loop... */
  1521.     debug(F100,"CONNECT top of loop","",0);
  1522.     FD_ZERO(&in);            /* Clear select() structs */
  1523.     FD_ZERO(&out);
  1524.     FD_ZERO(&err);
  1525.     gotkbd = 0;
  1526.     gotnet = ttpeek();        /* Something sitting in ckutio buf */
  1527.     debug(F101,"CONNECT ttpeek","",gotnet);
  1528.  
  1529.     if (
  1530. #ifndef NOSETKEY
  1531.         !kmptr            /* Check for key macro active */
  1532. #else
  1533.         1
  1534. #endif /* NOSETKEY */
  1535.         ) {
  1536.         if (obc) {            /* No key macro - set up for select */
  1537.         FD_SET(ttyfd, &out);    /* Have stuff to send to net */
  1538.         } else {
  1539.         FD_SET(kbin, &in);    /* Need to read stuff from keyboard */
  1540.         }
  1541. #ifdef BEBOX
  1542.         if (!(ibc || gotnet > 0))
  1543.         FD_SET(ttyfd, &in);    /* Need to read stuff from net */
  1544. #else /* BEBOX */
  1545.         if (ibc || gotnet > 0) {
  1546.         FD_SET(scrnout, &out);    /* Have stuff to put on screen */
  1547.         } else {
  1548.         FD_SET(ttyfd, &in);    /* Need to read stuff from net */
  1549.         }
  1550. #endif /* BEBOX */
  1551.             FD_SET(ttyfd, &err);
  1552. #ifdef CK_FORWARD_X
  1553.             fwdx_init_fd_set(&in);
  1554. #endif /* CK_FORWARD_X */
  1555.  
  1556.         /* Wait till the first one of the above is ready for i/o */
  1557.         /* or TERM IDLE-SEND is active and we time out. */
  1558.  
  1559.         errno = 0;
  1560. #ifdef CKTIDLE
  1561.         /* This really could be moved out of the loop... */
  1562.         if (idlelimit) {        /* Idle timeout set */
  1563.         struct timeval tv;
  1564.         if (idlelimit > 0) {    /* Positive = sec */
  1565.             tv.tv_sec = (long) idlelimit;
  1566.             tv.tv_usec = 0L;
  1567.         } else {        /* Negative = millisec */
  1568.             long u = (0 - idlelimit);
  1569.             tv.tv_sec = u / 1000L;
  1570.             tv.tv_usec = ((u % 1000L) * 1000L);
  1571.         }
  1572. #ifdef INTSELECT
  1573.         c = select(FD_SETSIZE,(int *)&in,(int *)&out,(int *)&err, &tv);
  1574. #else
  1575.         c = select(FD_SETSIZE, &in, &out, &err, &tv);
  1576. #endif /* INTSELECT */
  1577.         } else
  1578. #endif /* CKTIDLE */
  1579. #ifdef INTSELECT
  1580.           c = select(FD_SETSIZE, (int *)&in, (int *)&out, (int *)&err, 0);
  1581. #else
  1582.           c = select(FD_SETSIZE, &in, &out, &err, 0);
  1583. #endif /* INTSELECT */
  1584.         if (c < 1) {
  1585. #ifdef CKTIDLE
  1586.         if (c == 0) {        /* Timeout */
  1587.             debug(F101,"CONNECT select() timeout","",tt_idleact);
  1588.             switch (tt_idleact) {
  1589.               case IDLE_HANG: {    /* Hang up */
  1590.               int x = 0;
  1591. #ifndef NODIAL
  1592.               if (dialmhu)
  1593.                 x = mdmhup();
  1594.               if (x < 1)
  1595. #endif /* NODIAL */
  1596.                 tthang();    /* fall thru deliberately... */
  1597.               }
  1598.               case IDLE_RET:    /* Return to command mode */
  1599.             cx_status = CSX_IDLE;
  1600.             active = 0;
  1601.             continue;
  1602.               case IDLE_OUT:    /* OUTPUT a string */
  1603.             if (tt_idlestr) {
  1604.                 int len = strlen(tt_idlestr);
  1605.                 if (len > 0)
  1606.                   ttol((CHAR *)tt_idlestr,len);
  1607.                 else
  1608.                   ttoc(NUL); /* No string, send a NUL */
  1609.             } else
  1610.               ttoc(NUL);    /* No string, send a NUL */
  1611.             continue;
  1612.               case IDLE_EXIT:    /* Exit from Kermit */
  1613.             doexit(GOOD_EXIT,xitsta);
  1614. #ifdef TNCODE
  1615.               case IDLE_TAYT:    /* Send Telnet Are You There? */
  1616.             if (network && IS_TELNET()) {
  1617.                 tnopt[0] = (CHAR) IAC;
  1618.                 tnopt[1] = (CHAR) TN_AYT;
  1619.                 tnopt[2] = NUL;
  1620.                 if (ttol((CHAR *)tnopt,2) < 0)
  1621.                   active = 0;
  1622.             }
  1623.             continue;
  1624.  
  1625.               case IDLE_TNOP:    /* Send Telnet NOP */
  1626.             if (network && IS_TELNET()) {
  1627.                 tnopt[0] = (CHAR) IAC;
  1628.                 tnopt[1] = (CHAR) TN_NOP;
  1629.                 tnopt[2] = NUL;
  1630.                 if (ttol((CHAR *)tnopt,2) < 0)
  1631.                   active = 0;
  1632.             }
  1633.             continue;
  1634. #endif /* TNCODE */
  1635.             }
  1636.         }
  1637. #endif /* CKTIDLE */
  1638.  
  1639.         debug(F101,"CONNECT select() errno","",errno);
  1640.         /* A too-big first arg to select() gets EBADF */
  1641. #ifdef EINTR
  1642.         if (c == -1) {
  1643.             if (errno == EINTR) {
  1644.             continue;
  1645.             }
  1646.         }
  1647. #endif /* EINTR */
  1648.         sleep(1);
  1649.         continue;
  1650.         }
  1651. #ifndef BEBOX
  1652. #ifdef DEBUG
  1653.         if (FD_ISSET(scrnout, &out)) {
  1654.         debug(F100,"CONNECT SELECT scrnout","",0);
  1655.         }
  1656. #endif /* DEBUG */
  1657. #endif /* BEBOX */
  1658.  
  1659. #ifdef CK_FORWARD_X
  1660.             fwdx_check_sockets(&in);
  1661. #endif /* CK_FORWARD_X */
  1662.  
  1663.         if (FD_ISSET(ttyfd, &in)) {    /* Read from net? */
  1664.         debug(F110,"CONNECT SELECT ttyfd","in",0);
  1665.         FD_CLR(ttyfd, &in);
  1666.         gotnet = 1;        /* Net is ready */
  1667.         }
  1668.         if (FD_ISSET(kbin, &in)) {    /* Read from keyboard? */
  1669.         debug(F100,"CONNECT SELECT kbin","",0);
  1670.         FD_CLR(kbin, &in);
  1671.         gotkbd = 1;        /* Keyboard is ready */
  1672.         }
  1673.             if (FD_ISSET(ttyfd, &err)) {
  1674.         debug(F110,"CONNECT SELECT ttyfd","err",0);
  1675.         FD_CLR(ttyfd, &err);
  1676. #ifdef NETPTY
  1677. #ifdef HAVE_PTYTRAP
  1678.         /* Special handling for HP-UX pty i/o */
  1679.                 if (ttpty) {
  1680.                     if (pty_trap_handler(ttyfd) > 0) {
  1681.                         ttclos(0);
  1682.                         goto conret1;
  1683.                     }
  1684.                     continue;
  1685.                 }
  1686. #endif /* HAVE_PTYTRAP */
  1687. #endif /* NETPTY */
  1688.         gotnet = 1;        /* Net is ready (don't set if pty) */
  1689.             }
  1690.     }
  1691. #ifdef DEBUG
  1692.     if (deblog) {
  1693.         debug(F101,"CONNECT gotkbd","",gotkbd);
  1694.         debug(F101,"CONNECT kbc","",kbc);
  1695. #ifdef COMMENT
  1696. #ifndef NOSETKEY
  1697.         debug(F101,"CONNECT kmptr","",kmptr);
  1698. #endif /* NOSETKEY */
  1699. #endif    /* COMMENT */
  1700.     }
  1701. #endif /* DEBUG */
  1702.  
  1703.     while (gotkbd || kbc > 0    /* If we have keyboard chars */
  1704. #ifndef NOSETKEY
  1705.            || kmptr
  1706. #endif /* NOSETKEY */
  1707.            ) {
  1708. #ifndef NOSETKEY
  1709.         if (kmptr) {        /* Have current macro? */
  1710.         debug(F100,"CONNECT kmptr non NULL","",0);
  1711.         if ((c = (CHAR) *kmptr++) == NUL) { /* Get char from it */
  1712.             debug(F100,"CONNECT macro empty, continuing","",0);
  1713.             kmptr = NULL;    /* If no more chars,  */
  1714.             continue;        /* Reset pointer and continue */
  1715.         }
  1716.         debug(F000,"CONNECT char from macro","",c);
  1717.         } else {            /* No macro... */
  1718. #endif /* NOSETKEY */
  1719. #ifdef BEBOX
  1720.         {
  1721.             int rc = 0;
  1722.             if ((rc = recv(kbin,buf,1,0)) > 0)
  1723.               c = buf[0];
  1724.             else
  1725.               c = -1;
  1726.             debug(F111,"recv","rc",rc);
  1727.             printf("\r\nrecv: %c rc=%d\r\n",buf[0],rc);
  1728.         }
  1729. #else /* BEBOX */
  1730.         c = CONGKS();        /* Yes, read from keyboard */
  1731. #endif /* BEBOX */
  1732.         gotkbd = 0;        /* Turn off select() result flag */
  1733. #ifndef NOSETKEY
  1734.         }
  1735. #endif /* NOSETKEY */
  1736.         if (c == -1) {
  1737. #ifdef EINTR
  1738.         if (errno == EINTR)
  1739.           continue;
  1740. #endif /* EINTR */
  1741.         cx_status = CSX_IOERROR;
  1742.         conoc(BEL);
  1743.         goto conret0;
  1744.         }
  1745.         c &= cmdmsk;        /* Do any requested masking */
  1746.  
  1747. #ifndef NOSETKEY
  1748. /*
  1749.   Note: kmptr is NULL if we got character c from the keyboard, and it is
  1750.   not NULL if it came from a macro.  In the latter case, we must avoid
  1751.   expanding it again.
  1752. */
  1753.         if (!kmptr && macrotab[c]) { /* Macro definition for c? */
  1754.         debug(F000,"CONNECT macro key",macrotab[c],c);
  1755.         kmptr = macrotab[c];    /* Yes, set up macro pointer */
  1756.         continue;        /* and restart the loop, */
  1757.         } else c = keymap[c];    /* else use single-char keymap */
  1758. #endif /* NOSETKEY */
  1759.         if (
  1760. #ifndef NOSETKEY
  1761.         !kmptr &&
  1762. #endif /* NOSETKEY */
  1763.         (tt_escape && ((c & 0xff) == escape))) { /* Escape char? */
  1764.         debug(F000,"CONNECT got escape","",c);
  1765. #ifdef BEBOX
  1766.         if (recv(kbin,buf,1,0)>=0)
  1767.           c = buf[0];
  1768.         else
  1769.           c = -1;
  1770. #else /* BEBOX */
  1771.         c = CONGKS() & 0x7f;    /* Read argument */
  1772. #endif /* BEBOX */
  1773.         doesc((char) c);    /* Handle it */
  1774.         continue;        /* Back to loop */
  1775.         }
  1776.         csave = c;            /* Save it before translation */
  1777.                         /* for local echoing. */
  1778. #ifdef CKLEARN
  1779.         crflag = (c == CR);        /* Remember if it was CR. */
  1780. #endif /* CKLEARN */
  1781.  
  1782. #ifndef NOCSETS
  1783.         if (inesc[1] == ES_NORMAL) { /* If not inside escape seq.. */
  1784.         /* Translate character sets */
  1785. #ifdef UNICODE
  1786.         int x;
  1787.         if (unicode == 1) {    /* Remote is UTF-8 */
  1788.             outxcount = b_to_u((CHAR)c,outxbuf,OUTXBUFSIZ,tcssize);
  1789.             outxbuf[outxcount] = NUL;
  1790.         } else if (unicode == 2) { /* Local is UTF-8 */
  1791.             
  1792.             x = u_to_b((CHAR)c);
  1793.             if (x < 0)
  1794.               continue;
  1795.             outxbuf[0] = (unsigned)(x & 0xff);
  1796.             outxcount = 1;
  1797.             outxbuf[outxcount] = NUL;
  1798.         } else {
  1799. #endif /* UNICODE */
  1800.             if (sxo) c = (*sxo)((char)c); /* Local-intermediate */
  1801.             if (rxo) c = (*rxo)((char)c); /* Intermediate-remote */
  1802.             outxbuf[0] = c;
  1803.             outxcount = 1;
  1804.             outxbuf[outxcount] = NUL;
  1805. #ifdef UNICODE
  1806.         }
  1807. #endif /* UNICODE */
  1808.         } else {
  1809.         outxbuf[0] = c;
  1810.         outxcount = 1;
  1811.         outxbuf[outxcount] = NUL;
  1812.         }
  1813.         if (escseq)
  1814.           apcrc = chkaes((char)c,1);
  1815. #else  /* NOCSETS */
  1816.         outxbuf[0] = c;
  1817.         outxcount = 1;
  1818.         outxbuf[outxcount] = NUL;
  1819. #endif /* NOCSETS */
  1820.  
  1821.         debug(F111,"OUTXBUF",outxbuf,outxcount);
  1822.  
  1823.         for (i = 0; i < outxcount; i++) {
  1824.         c = outxbuf[i];
  1825. /*
  1826.  If Shift-In/Shift-Out is selected and we have a 7-bit connection,
  1827.  handle shifting here.
  1828. */
  1829.         if (sosi) {             /* Shift-In/Out selected? */
  1830.             if (cmask == 0177) {     /* In 7-bit environment? */
  1831.             if (c & 0200) {         /* 8-bit character? */
  1832.                 if (outshift == 0) { /* If not shifted, */
  1833.                 ttoc(dopar(SO)); /* shift. */
  1834.                 outshift = 1;
  1835.                 }
  1836.             } else {
  1837.                 if (outshift == 1) { /* 7-bit character */
  1838.                 ttoc(dopar(SI)); /* If shifted, */
  1839.                 outshift = 0;    /* unshift. */
  1840.                 }
  1841.             }
  1842.             }
  1843.             if (c == SO) outshift = 1; /* User typed SO */
  1844.             if (c == SI) outshift = 0; /* User typed SI */
  1845.         }
  1846.         c &= cmask;        /* Apply Kermit-to-host mask now. */
  1847.         if (c == '\015') {    /* Carriage Return */
  1848.             int stuff = -1;
  1849.             if (tnlm) {        /* TERMINAL NEWLINE ON */
  1850.             stuff = LF;     /* Stuff LF */
  1851. #ifdef TNCODE
  1852.             } else if (network && /* TELNET NEWLINE ON/OFF/RAW */
  1853.                    IS_TELNET()) {
  1854.             switch (!TELOPT_ME(TELOPT_BINARY) ? tn_nlm : tn_b_nlm){
  1855.               case TNL_CRLF:
  1856.                 stuff = LF;
  1857.                 break;
  1858.               case TNL_CRNUL:
  1859.                 stuff = NUL;
  1860.                 break;
  1861.             }
  1862. #endif /* TNCODE */
  1863.             }
  1864.             if (stuff > -1) {
  1865.             ttoc(dopar('\015'));    /* Send CR */
  1866.             if (duplex) conoc('\015'); /* Maybe echo CR */
  1867.             c = stuff;    /* Char to stuff */
  1868.             csave = c;
  1869.             }
  1870.         }
  1871. #ifdef TNCODE
  1872. /* If user types the 0xff character (TELNET IAC), it must be doubled. */
  1873.         else        /* Not CR */
  1874.           if ((dopar((CHAR) c) == IAC) && /* IAC (0xff) */
  1875.               network && IS_TELNET()) { /* Send one now */
  1876.               ttoc((char)IAC); /* and the other one just below. */
  1877.           }
  1878. #endif /* TNCODE */
  1879.         /* Send the character */
  1880.  
  1881.         x = ttoc((char)dopar((CHAR) c));
  1882.         if (x > -1) {
  1883. #ifdef CKLEARN
  1884.             if (learning) {    /* Learned script active */
  1885.             if (crflag) {    /* User typed CR */
  1886.                 learnchar(CR); /* Handle CR */
  1887.                 learnst = 0;   /* Shift to Neutral */
  1888.             } else {
  1889.                 learnchar(c);  /* Not CR */
  1890.                 learnst = 2;   /* Change state to Keyboard */
  1891.             }
  1892.             }
  1893. #endif /* CKLEARN */
  1894.             if (duplex) {    /* If half duplex, must echo */
  1895.             if (debses)
  1896.               conol(dbchr(csave)); /* the original char */
  1897.             else        /* not the translated one */
  1898.               conoc((char)csave);
  1899.             if (seslog) {    /* And maybe log it too */
  1900.                 c2 = csave;
  1901.                 if (sessft == 0 && csave == '\r')
  1902.                   c2 = '\n';
  1903.                 LOGCHAR((char)c2);
  1904.             }
  1905.             }
  1906.         } else {
  1907.             perror("\r\nCan't send character");
  1908.             cx_status = CSX_IOERROR;
  1909.             active = 0;
  1910.             break;
  1911.         }
  1912.         }
  1913.     }
  1914.     if (FD_ISSET(ttyfd, &out)) {
  1915.         FD_CLR(ttyfd, &out);
  1916.     }
  1917.     while (gotnet > 0 || ibc > 0) {
  1918.         gotnet = 0;
  1919.         prev = c;
  1920.         c = ckcgetc(0);        /* Get next character */
  1921.         if (c < 0) {        /* Failed... */
  1922.         ckcputf();        /* Flush CONNECT output buffer */
  1923.         if (msgflg) {
  1924.             printf("\r\nCommunications disconnect ");
  1925. #ifdef COMMENT
  1926.             if (c == -3
  1927. #ifdef ultrix
  1928. /* This happens on Ultrix if there's no carrier */
  1929.             && errno != EIO
  1930. #endif /* ultrix */
  1931. #ifdef UTEK
  1932. /* This happens on UTEK if there's no carrier */
  1933.             && errno != EWOULDBLOCK
  1934. #endif /* UTEK */
  1935.             )
  1936.               perror("\r\nCan't read character");
  1937. #endif /* COMMENT */
  1938.         }
  1939. #ifdef NOSETBUF
  1940.         fflush(stdout);
  1941. #endif /* NOSETBUF */
  1942.         dologend();
  1943.         tthang();        /* Hang up the connection */
  1944.         debug(F111,"CONNECT i/o error 1",ck_errstr(),errno);
  1945.         cx_status = CSX_HOSTDISC;
  1946.         goto conret0;
  1947.         }
  1948. #ifdef TNCODE
  1949.         tx = 0;
  1950.         if ((c == NUL) && network && IS_TELNET()) {
  1951.         if (prev == CR) {    /* Discard <NUL> of <CR><NUL> if peer */
  1952.             if (!TELOPT_U(TELOPT_BINARY)) {  /* not in binary mode */
  1953.             debug(F111,"CONNECT NUL",ckitoa(prev),c);
  1954.             ckcputf();    /* Flush screen output buffer */
  1955.             break;
  1956.             }
  1957.         }
  1958.         }
  1959.         debug(F111,"CONNECT","c",c);
  1960.         debug(F111,"CONNECT","network",network);
  1961.         debug(F111,"CONNECT","IS_TELNET",IS_TELNET());
  1962.         if ((c == IAC) && network && IS_TELNET()) {
  1963. #ifdef CK_ENCRYPTION
  1964.         int x_auth = TELOPT_ME(TELOPT_AUTHENTICATION);
  1965. #else
  1966.         int x_auth = 0;
  1967. #endif /* CK_ENCRYPTION */
  1968.         int me_bin = TELOPT_ME(TELOPT_BINARY);
  1969.         int u_bin = TELOPT_U(TELOPT_BINARY);
  1970.         debug(F100,"CONNECT got IAC","",0);
  1971.         ckcputf();        /* Dump screen-output buffer */
  1972.         if ((tx = tn_doop((CHAR)(c & 0xff),duplex,ckcgetc)) == 0) {
  1973.             if (me_bin != TELOPT_ME(TELOPT_BINARY)) {
  1974.             me_bin = TELOPT_ME(TELOPT_BINARY);
  1975.             } else if (u_bin != TELOPT_U(TELOPT_BINARY)) {
  1976.             u_bin = TELOPT_U(TELOPT_BINARY);
  1977. #ifdef CK_ENCRYPTION
  1978. /*
  1979.   Here we have to push back any bytes we have read using block reads, so we
  1980.   can read them again using single-character reads, so they can be decrypted
  1981.   in case there was a switch to encryption in the block.  Note that we can't
  1982.   handle switches in the encryption state itself this way -- which would be
  1983.   nice, since it would eliminate the need for single-character reads.  Why?
  1984.   Because if a series of characters has already been decrypted that shouldn't
  1985.   have been, then (a) it's ruined, and (b) so is the state of the decryption
  1986.   machine.  Too bad.
  1987. */
  1988.             } else if (TELOPT_ME(TELOPT_AUTHENTICATION) != 0 &&
  1989.                    TELOPT_ME(TELOPT_AUTHENTICATION) != x_auth
  1990.                    ) {
  1991.             if (ttpushback((CHAR *)ibp,ibc) > -1) {
  1992.                 ibc = 0;
  1993.                 ibp = ibuf;
  1994.             }
  1995. #endif /* CK_ENCRYPTION */
  1996.             }
  1997.             continue;
  1998.         } else if (tx == -1) {    /* I/O error */
  1999.             if (msgflg)
  2000.               printf("\r\nCommunications disconnect ");
  2001. #ifdef NOSETBUF
  2002.             fflush(stdout);
  2003. #endif /* NOSETBUF */
  2004.             dologend();
  2005.             debug(F111,"CONNECT i/o error 2",ck_errstr(),errno);
  2006.             cx_status = CSX_IOERROR;
  2007.             goto conret0;
  2008.         } else if (tx == -2) {    /* I/O error */
  2009.             if (msgflg)
  2010.               printf("\r\nConnection closed by peer");
  2011. #ifdef NOSETBUF
  2012.             fflush(stdout);
  2013. #endif /* NOSETBUF */
  2014.             dologend();
  2015.             debug(F111,"CONNECT i/o error 3",ck_errstr(),errno);
  2016.             cx_status = CSX_IOERROR;
  2017.             goto conret0;
  2018.         } else if (tx == -3) {    /* I/O error */
  2019.             if (msgflg)
  2020.               printf("\r\nConnection closed due to telnet policy");
  2021. #ifdef NOSETBUF
  2022.             fflush(stdout);
  2023. #endif /* NOSETBUF */
  2024.             dologend();
  2025.             debug(F111,"CONNECT i/o error 4",ck_errstr(),errno);
  2026.             cx_status = CSX_IOERROR;
  2027.             goto conret0;
  2028.         } else if ((tx == 1) && (!duplex)) { /* ECHO change */
  2029.             duplex = 1;        /* Turn on local echo */
  2030.             continue;
  2031.         } else if ((tx == 2) && (duplex)) { /* ECHO change */
  2032.             duplex = 0;
  2033.             continue;
  2034.         } else if (tx == 3) {    /* Quoted IAC */
  2035.             c = parity ? 127 : 255;
  2036.         }
  2037. #ifdef IKS_OPTION
  2038.                 else if (tx == 4) {   /* IKS State Change */
  2039.                     if (TELOPT_SB(TELOPT_KERMIT).kermit.u_start &&
  2040.             !tcp_incoming
  2041.             ) {
  2042.                         /* here we need to print a msg that the other */
  2043.                         /* side is in SERVER mode and that REMOTE     */
  2044.                         /* commands should be used.  And CONNECT mode */
  2045.                         /* should be ended.                           */
  2046.             cx_status = CSX_IKSD;
  2047.             active = 0;
  2048.                     }
  2049.                 }
  2050. #endif /* IKS_OPTION */
  2051.                 else if (tx == 6) {
  2052.                     /* DO LOGOUT was received */
  2053.             if (msgflg)
  2054.               printf("\r\nRemote Logout ");
  2055. #ifdef NOSETBUF
  2056.             fflush(stdout);
  2057. #endif /* NOSETBUF */
  2058.             debug(F100,"CONNECT Remote Logout","",0);
  2059.             cx_status = CSX_TRIGGER;
  2060.             goto conret0;
  2061.                 } else
  2062.           continue;        /* Negotiation OK, get next char. */
  2063.         } else if (parity)
  2064.           c &= 0x7f;
  2065.  
  2066.         /* I'm echoing for the remote */
  2067.             if (TELOPT_ME(TELOPT_ECHO) && tn_rem_echo)
  2068.           ttoc((char)c);
  2069. #endif /* TNCODE */
  2070.  
  2071. #ifdef CKLEARN
  2072.      /* Learned script: Record incoming chars if not in Keyboard state */
  2073.  
  2074.         if (learning && learnst != 2) { /* Learned script active */
  2075.         learnbuf[learnbp++] = c;    /* Save for INPUT command */
  2076.         if (learnbp >= LEARNBUFSIZ) /* in circular buffer */
  2077.           learnbp = 0;              /* wrapping if at end. */
  2078.         learnbc++;                  /* Count this byte. */
  2079.         learnst = 1;                /* State is Net. */
  2080.         }
  2081. #endif /* CKLEARN */
  2082.  
  2083.         if (debses) {        /* Output character to screen */
  2084.         char *s;        /* Debugging display... */
  2085.         s = dbchr(c);        /* Make char into string */
  2086.         while (*s) {        /* Output each char from string */
  2087.             ckcputc(*s);
  2088.             if (seslog)        /* And maybe log it. */
  2089.               LOGCHAR((char)*s);
  2090.             s++;
  2091.         }
  2092.         } else {            /* Regular display ... */
  2093.         c &= cmask;        /* Apply Kermit-to-remote mask */
  2094.         if (seslog && sessft)    /* If binary session log */
  2095.           LOGCHAR((char)c);    /* log the character now. */
  2096. #ifndef NOXFER
  2097. #ifdef CK_AUTODL
  2098. /*
  2099.   Autodownload.  Check for Kermit S packet prior to translation, since that
  2100.   can change the packet and make it unrecognizable (as when the terminal
  2101.   character set is an ISO 646 one)...  Ditto for Zmodem start packet.
  2102. */
  2103.         if (autodl        /* Autodownload enabled? */
  2104. #ifdef IKS_OPTION
  2105.             || TELOPT_SB(TELOPT_KERMIT).kermit.me_start
  2106. #endif /* IKS_OPTION */
  2107.             ) {
  2108.             int k = 0;
  2109.  
  2110.             if (kstartactive || c == stchr /* Kermit S or I packet? */
  2111. #ifdef COMMENT
  2112.             || adl_kmode == ADLSTR /* Not used in C-Kermit */
  2113. #endif /* COMMENT */
  2114.             )
  2115.               k = kstart((CHAR)c);
  2116. #ifdef CK_XYZ
  2117.             if (!k && zmdlok)    /* Or an "sz" start? */
  2118.               k = zstart((CHAR)c);
  2119. #endif /* CK_XYZ */
  2120.             if (k) {
  2121.             int ksign = 0;
  2122.             debug(F101,"CONNECT autodownload k","",k);
  2123.             if (k < 0) { /* Minus-Protocol? */
  2124. #ifdef NOSERVER
  2125.                 goto noserver; /* Need server mode for this */
  2126. #else
  2127.                 ksign = 1; /* Remember */
  2128.                 k = 0 - k; /* Convert to actual protocol */
  2129.                 justone = 1; /* Flag for protocol module */
  2130. #endif /* NOSERVER */
  2131.             } else
  2132.               justone = 0;
  2133.             k--;        /* Adjust [kz]start's return value */
  2134.             if (k == PROTO_K
  2135. #ifdef CK_XYZ
  2136.                 || k == PROTO_Z
  2137. #endif /* CK_XYZ */
  2138.                 ) {
  2139.                             /* Damage the packet so that it doesn't trigger */
  2140.                 /* autodownload detection downstream. */
  2141.                             if (k == PROTO_K) {
  2142.                                 int i, len = strlen((char *)ksbuf);
  2143.                                 for (i = 0; i < len; i++)
  2144.                   ckcputc(BS);
  2145.                             }
  2146. #ifdef CK_XYZ
  2147.                             else {
  2148.                                 int i;
  2149.                                 for (i = 0; i < 3; i++)
  2150.                   ckcputc(CAN);
  2151.                             }
  2152. #endif /* CK_XYZ */
  2153.  
  2154. #ifndef NOICP
  2155.                 /* sprintf is safe here (builtin keywords) */
  2156.                 sprintf(apcbuf,
  2157.                     "set proto %s, %s, set proto %s",
  2158.                     ptab[k].p_name,
  2159.                     ksign ? "server" : "receive",
  2160.                     ptab[protocol].p_name
  2161.                     );
  2162.                 apclength = strlen(apcbuf);
  2163.                 debug(F111,"CONNECT ksbuf",ksbuf,k);
  2164.                 debug(F110,"CONNECT autodownload",apcbuf,0);
  2165.                 apcactive = APC_LOCAL;
  2166.                 ckcputf();    /* Force screen update */
  2167.                 cx_status = CSX_APC;
  2168.                 goto conret1;
  2169. #else
  2170. /*
  2171.   Here's another way that doesn't require APC, but then we'll have to change
  2172.   all the other CONNECT modules, and then the mainline code that calls them.
  2173. */
  2174.                 {
  2175.                 extern char sstate;
  2176.                 sstate = ksign ? 'x' : 'v';
  2177.                 proto();
  2178.                 }
  2179. #endif /* NOICP */
  2180.             }
  2181.             }
  2182.         }
  2183. #ifdef NOSERVER
  2184.           noserver:
  2185. #endif /* NOSERVER */
  2186.  
  2187. #endif /* CK_AUTODL */
  2188. #endif /* NOXFER */
  2189.         if (sosi) {        /* Handle SI/SO */
  2190.             if (c == SO) {    /* Shift Out */
  2191.             inshift = 1;
  2192.             continue;
  2193.             } else if (c == SI) { /* Shift In */
  2194.             inshift = 0;
  2195.             continue;
  2196.             }
  2197.             if (inshift) c |= 0200;
  2198.         }
  2199.         inxbuf[0] = c;        /* In case there is no translation */
  2200.         inxcount = 1;        /* ... */
  2201. #ifndef NOCSETS
  2202.         if (inesc[0] == ES_NORMAL /* If not in an escape sequence */
  2203.             && !printing    /* and not in transparent print */
  2204.             ) {            /* Translate character sets */
  2205. #ifdef UNICODE
  2206.             int x;
  2207.             if (unicode == 1) {    /* Remote is UTF-8 */
  2208.             x = u_to_b((CHAR)c);
  2209.             if (x == -1)
  2210.               continue;
  2211.             else if (x == -2) { /* LS or PS */
  2212.                 inxbuf[0] = CR;
  2213.                 inxbuf[1] = LF;
  2214.                 inxcount = 2;
  2215.             } else if (x == -9) { /* UTF-8 error */
  2216.                 inxbuf[0] = '?';
  2217.                 inxbuf[1] = u_to_b2();
  2218.                 inxcount = 2;
  2219.             } else {
  2220.                 inxbuf[0] = (unsigned)(x & 0xff);
  2221.             }
  2222.             c = inxbuf[0];
  2223.             } else if (unicode == 2) { /* Local is UTF-8 */
  2224.             inxcount = b_to_u((CHAR)c,inxbuf,OUTXBUFSIZ,tcssize);
  2225.             c = inxbuf[0];
  2226.             } else {
  2227. #endif /* UNICODE */
  2228.             if (sxi) c = (*sxi)((CHAR)c);
  2229.             if (rxi) c = (*rxi)((CHAR)c);
  2230.             inxbuf[0] = c;
  2231. #ifdef UNICODE
  2232.             }
  2233. #endif /* UNICODE */
  2234.         }
  2235. #endif /* NOCSETS */
  2236.  
  2237. #ifndef NOESCSEQ
  2238.         if (escseq) {        /* If handling escape sequences */
  2239.             oldprt = printing;         /* remember printer state */
  2240.             apcrc = chkaes((char)c,0); /* and update escseq state. */
  2241.             if (printing && !oldprt) /* If printer was turned on */
  2242.               continue;        /* don't print final char of escseq */
  2243.         }
  2244. #ifdef CK_APC
  2245. /*
  2246.   If we are handling APCs, we have several possibilities at this point:
  2247.    1. Ordinary character to be written to the screen.
  2248.    2. An Esc; we can't write it because it might be the beginning of an APC.
  2249.    3. The character following an Esc, in which case we write Esc, then char,
  2250.       but only if we have not just entered an APC sequence.
  2251. */
  2252.         if (escseq && (apcstatus & APC_ON)) {
  2253.             if (inesc[0] == ES_GOTESC) /* Don't write ESC yet */
  2254.               continue;
  2255.             else if (oldesc[0] == ES_GOTESC && !apcactive) {
  2256.             ckcputc(ESC);    /* Write saved ESC */
  2257.             if (seslog && !sessft) LOGCHAR((char)ESC);
  2258.             } else if (apcrc) {    /* We have an APC */
  2259.             debug(F111,"CONNECT APC complete",apcbuf,apclength);
  2260.             ckcputf();    /* Force screen update */
  2261.             cx_status = CSX_APC;
  2262.             goto conret1;
  2263.             }
  2264.         }
  2265. #endif /* CK_APC */
  2266. #endif /* NOESCSEQ */
  2267.  
  2268.         debug(F111,"INXBUF",inxbuf,inxcount);
  2269.         for (i = 0; i < inxcount; i++) { /* Loop thru */
  2270.             c = inxbuf[i];    /* input expansion buffer... */
  2271.             if (
  2272. #ifdef CK_APC
  2273.             !apcactive &&    /* Don't display APC sequences */
  2274. #endif /* CK_APC */
  2275.             !printing    /* or transparent print material */
  2276.  
  2277.             ) {
  2278.             c &= cmdmsk;    /* Apply command mask. */
  2279.  
  2280.             /* Handle bare carriage returns and linefeeds */
  2281.  
  2282.             if (c == CR && tt_crd) { /* SET TERM CR-DISPLA CRLF? */
  2283.                 ckcputc(c);    /* Yes, output CR */
  2284.                 if (seslog && !sessft) LOGCHAR((char)c);
  2285.                 c = LF;    /* and insert a linefeed */
  2286.             }
  2287.             if (c == LF && tt_lfd) { /* SET TERM CR-DISPLA CRLF? */
  2288.                 ckcputc(CR); /* Yes, output CR */
  2289.                 if (seslog && !sessft) LOGCHAR((char)CR);
  2290.             }
  2291. #ifndef NOESCSEQ
  2292.             if (dontprint)    { /* Do transparent printing. */
  2293.                 dontprint = 0;
  2294.                 continue;
  2295.             } else
  2296. #endif    /* NOESCSEQ */
  2297.             ckcputc(c);    /* Write character to screen */
  2298.             }
  2299.             if (seslog && !sessft) { /* Handle session log. */
  2300.             LOGCHAR((char)c);
  2301.             }
  2302. #ifdef XPRINT
  2303.             if (printing && !inesc[0]) {
  2304.             /* zchout() can't be used because */
  2305.             /* it's buffered differently. */
  2306.             cbuf[0] = c;
  2307.             zsoutx(ZMFILE,(char *)cbuf,1);
  2308.             }
  2309. #endif /* XPRINT */
  2310.  
  2311. #ifdef CK_TRIGGER
  2312.             /* Check for trigger string */
  2313.             if (tt_trigger[0]) {
  2314.             int i;
  2315.             if ((i = autoexitchk((CHAR)c)) > -1) {
  2316.                 makestr(&triggerval,tt_trigger[i]);
  2317.                 ckcputf();    /* Force screen update */
  2318. #ifdef NOSETBUF
  2319.                 fflush(stdout); /* I mean really force it */
  2320. #endif /* NOSETBUF */
  2321.                 cx_status = CSX_TRIGGER;
  2322.                 goto conret1;
  2323.             }
  2324.             }
  2325. #endif /* CK_TRIGGER */
  2326.         }
  2327.         }
  2328.     }
  2329. #ifndef BEBOX
  2330.     if (FD_ISSET(scrnout, &out)) {
  2331.         FD_CLR(scrnout, &out);
  2332.     }
  2333. #endif /* BEBOX */
  2334.     } /* End of big loop */
  2335.   conret1:                /* Come here to succeed */
  2336.     rc = 1;
  2337.   conret0:                /* Common exit point */
  2338. #ifdef BEBOX
  2339.     {
  2340.     long ret_val;
  2341.     closesocket(pair[0]);
  2342.     closesocket(pair[1]);
  2343.     x = kill(tid,SIGKILLTHR);    /* Kill thread */
  2344.     wait_for_thread (tid, &ret_val);
  2345.     }
  2346. #endif /* BEBOX */
  2347.  
  2348. #ifdef CKLEARN
  2349.     if (learning && learnfp)
  2350.       fputs("\n",learnfp);
  2351. #endif /* CKLEARN */
  2352.  
  2353.     conres();
  2354.     if (dohangup > 0) {
  2355. #ifdef NETCONN
  2356.     if (network
  2357. #ifdef TNCODE
  2358.         && !TELOPT_ME(TELOPT_COMPORT)
  2359. #endif /* TNCODE */
  2360.         )
  2361.       ttclos(0);
  2362. #endif /* NETCONN */
  2363.  
  2364. #ifndef COMMENT
  2365. /*
  2366.   This is bad because if they said SET MODEM HANGUP-METHOD MODEM-COMMAND,
  2367.   they mean it -- we shouldn't fall back on tthang() if mdmhup() fails,
  2368.   because maybe they have some special kind of connection.  On the other
  2369.   hand, making this change prevents dialing from working at all in some
  2370.   cases.  Further study needed.
  2371. */
  2372. #ifndef NODIAL
  2373.     if (dohangup > 1)        /* User asked for it */
  2374.       if (mdmhup() < 1)        /* Maybe hang up via modem */
  2375. #endif /* NODIAL */
  2376.         tthang();            /* And make sure we don't hang up */
  2377. #else
  2378.     if (!network) {            /* Serial connection. */
  2379. #ifndef NODIAL
  2380.         if (dialmhu)        /* Hang up the way they said to. */
  2381.           mdmhup();
  2382.         else
  2383. #endif /* NODIAL */
  2384.           tthang();
  2385.     }
  2386. #endif /* COMMENT */
  2387.     dologend();
  2388.     dohangup = 0;            /* again unless requested again. */
  2389.     }
  2390.     if (quitnow)            /* Exit now if requested. */
  2391.       doexit(GOOD_EXIT,xitsta);
  2392.     if (msgflg
  2393. #ifdef CK_APC
  2394.     && !apcactive
  2395. #endif /* CK_APC */
  2396.     )
  2397.       printf("(Back at %s)", *myhost ? myhost : "local UNIX system");
  2398. #ifdef CK_APC
  2399.     if (!apcactive)
  2400. #endif /* CK_APC */
  2401.       printf("\n");
  2402.     what = W_NOTHING;            /* So console modes set right. */
  2403. #ifndef NOCSETS
  2404.     language = langsv;            /* Restore language */
  2405. #endif /* NOCSETS */
  2406. #ifdef CK_APC
  2407.     debug(F101,"CONNECT exit apcactive","",apcactive);
  2408.     debug(F101,"CONNECT exit justone","",justone);
  2409. #endif /* CK_APC */
  2410.     if (msgflg) {
  2411. #ifdef CK_APC
  2412.     if (apcactive == APC_LOCAL)
  2413.       printf("\n");
  2414. #endif /* CK_APC */
  2415.     printf("----------------------------------------------------\n");
  2416.     printbar = 1;
  2417.     } else
  2418.     printbar = 0;
  2419.     fflush(stdout);
  2420.     return(rc);
  2421. }
  2422.  
  2423. /*  H C O N N E  --  Give help message for connect.  */
  2424.  
  2425. #define CXM_SER 1            /* Serial connections only */
  2426. #define CXM_NET 2            /* Network only (but not Telnet) */
  2427. #define CXM_TEL 4            /* Telnet only */
  2428.  
  2429. static struct hmsgtab {
  2430.     char * hmsg;
  2431.     int hflags;
  2432. } hlpmsg[] = {
  2433.     {"  ? or H for this message",                0},
  2434.     {"  0 (zero) to send the NUL (0) character", 0},
  2435.     {"  B to send a BREAK signal (0.275sec)",  CXM_SER},
  2436. #ifdef NETCONN
  2437.     {"  B to send a network BREAK",            CXM_NET},
  2438.     {"  B to send a Telnet BREAK",             CXM_TEL},
  2439. #endif /* NETCONN */
  2440. #ifdef CK_LBRK
  2441.     {"  L to send a Long BREAK (1.5sec)",      CXM_SER},
  2442. #endif /* CK_LBRK */
  2443. #ifdef NETCONN
  2444.     {"  I to send a network interrupt packet", CXM_NET},
  2445.     {"  I to send a Telnet Interrupt request", CXM_TEL},
  2446. #ifdef TNCODE
  2447.     {"  A to send Telnet Are-You-There?",      CXM_TEL},
  2448. #endif /* TNCODE */
  2449. #endif /* NETCONN */
  2450.     {"  U to hangup and close the connection", 0},
  2451.     {"  Q to hangup and quit Kermit",          0},
  2452.     {"  S for status",                         0},
  2453. #ifdef NOPUSH
  2454.     {"  ! to push to local shell (disabled)",  0},
  2455.     {"  Z to suspend (disabled)",              0},
  2456. #else
  2457.     {"  ! to push to local shell",             0},
  2458. #ifdef NOJC
  2459.     {"  Z to suspend (disabled)",              0},
  2460. #else
  2461.     {"  Z to suspend",                         0},
  2462. #endif /* NOJC */
  2463. #endif /* NOPUSH */
  2464.     {"  \\ backslash code:",                   0},
  2465.     {"    \\nnn  decimal character code",      0},
  2466.     {"    \\Onnn octal character code",        0},
  2467.     {"    \\Xhh  hexadecimal character code;", 0},
  2468.     {"    terminate with Carriage Return.",    0},
  2469.     {"  Type the escape character again to send the escape character itself,",
  2470.        0},
  2471.     {"  or press the space-bar to resume the CONNECT session.", 0},
  2472.     {NULL, 0}
  2473. };
  2474.  
  2475. int
  2476. hconne() {
  2477.     int c, i, cxtype;
  2478.     if (network)
  2479.       cxtype = IS_TELNET() ? CXM_TEL : CXM_NET;
  2480.     else
  2481.       cxtype = CXM_SER;
  2482.  
  2483.     conol("\r\n----------------------------------------------------\r\n");
  2484.     conoll("Press:");
  2485.     conol("  C to return to ");
  2486.     conoll(*myhost ? myhost : "the C-Kermit prompt");
  2487.     for (i = 0; hlpmsg[i].hmsg; i++) {
  2488.     if (!(hlpmsg[i].hflags) || (hlpmsg[i].hflags == cxtype))
  2489.       conoll(hlpmsg[i].hmsg);
  2490.     }
  2491.     conol("Press a key>");        /* Prompt for command. */
  2492.     c = CONGKS() & 0177;        /* Get character, strip any parity. */
  2493.     /* No key mapping or translation here */
  2494.     if (c != CMDQ)
  2495.       conoll("");
  2496.     conoll("----------------------------------------------------");
  2497.     return(c);                /* Return it. */
  2498. }
  2499.  
  2500.  
  2501. /*  D O E S C  --  Process an escape character argument  */
  2502.  
  2503. VOID
  2504. #ifdef CK_ANSIC
  2505. doesc(char c)
  2506. #else
  2507. doesc(c) char c;
  2508. #endif /* CK_ANSIC */
  2509. /* doesc */ {
  2510.     CHAR d;
  2511.  
  2512.     debug(F101,"CONNECT doesc","",c);
  2513.     while (1) {
  2514.     if (c == escape) {        /* Send escape character */
  2515.         d = dopar((CHAR) c); ttoc((char) d); return;
  2516.         } else                /* Or else look it up below. */
  2517.         if (isupper(c)) c = tolower(c);
  2518.  
  2519.     switch(c) {
  2520.  
  2521.       case 'c':            /* Escape back to prompt */
  2522.       case '\03':
  2523.         cx_status = CSX_ESCAPE;
  2524. #ifdef NOICP
  2525.         conoll("");
  2526.         conoll("");
  2527.         conoll(
  2528. "  WARNING: This version of C-Kermit has no command processor to escape"
  2529.            );
  2530.         conoll(
  2531. "  back to.  To return to your local system, log out from the remote and/or"
  2532.            );
  2533.         conoll(
  2534. "  use the escape character followed by the letter U to close (hang Up) the"
  2535.            );
  2536.         conoll(
  2537. "  connection.  Resuming your session..."
  2538.            );
  2539.         conoll("");
  2540.         return;
  2541. #else
  2542.         active = 0; conol("\r\n"); return;
  2543. #endif /* NOICP */
  2544.  
  2545.       case 'b':            /* Send a BREAK signal */
  2546.       case '\02':
  2547. #ifdef CKLEARN
  2548.         learnchar(-7);
  2549. #endif /* CKLEARN */
  2550.         ttsndb(); return;
  2551.  
  2552. #ifdef NETCONN
  2553.       case 'i':            /* Send Interrupt */
  2554.       case '\011':
  2555. #ifdef TCPSOCKET
  2556.         if (network && IS_TELNET()) { /* TELNET */
  2557.         temp[0] = (CHAR) IAC;    /* I Am a Command */
  2558.         temp[1] = (CHAR) TN_IP;    /* Interrupt Process */
  2559.         temp[2] = NUL;
  2560.         ttol((CHAR *)temp,2);
  2561.         } else
  2562. #endif /* TCPSOCKET */
  2563.           conoc(BEL);
  2564.         return;
  2565.  
  2566. #ifdef TCPSOCKET
  2567.       case 'a':            /* "Are You There?" */
  2568.       case '\01':
  2569.         if (network && IS_TELNET()) {
  2570.         temp[0] = (CHAR) IAC;    /* I Am a Command */
  2571.         temp[1] = (CHAR) TN_AYT; /* Are You There? */
  2572.         temp[2] = NUL;
  2573.         ttol((CHAR *)temp,2);
  2574.         } else conoc(BEL);
  2575.         return;
  2576. #endif /* TCPSOCKET */
  2577. #endif /* NETCONN */
  2578.  
  2579. #ifdef CK_LBRK
  2580.       case 'l':            /* Send a Long BREAK signal */
  2581. #ifdef CKLEARN
  2582.         learnchar(-8);
  2583. #endif /* CKLEARN */
  2584.         ttsndlb(); return;
  2585. #endif /* CK_LBRK */
  2586.  
  2587.       case 'u':            /* Hangup */
  2588.        /* case '\010': */        /* No, too dangerous */
  2589.         cx_status = CSX_USERDISC;
  2590.         dohangup = 2; active = 0; conol("\r\nHanging up "); return;
  2591.  
  2592.       case 'q':            /* Quit */
  2593.         cx_status = CSX_USERDISC;
  2594.         dohangup = 2; quitnow = 1; active = 0; conol("\r\n"); return;
  2595.  
  2596.       case 's':            /* Status */
  2597.         conoll("");
  2598.         conoll("----------------------------------------------------");
  2599. #ifdef PTYORPIPE
  2600.         if (ttpipe)
  2601.           ckmakmsg(temp,TMPLEN," Pipe: \"",ttname,"\"",NULL);
  2602.         else if (ttpty)
  2603.           ckmakmsg(temp,TMPLEN," Pty: \"",ttname,"\"",NULL);
  2604.         else
  2605. #endif /* PTYORPIPE */
  2606.           ckmakmsg(temp,
  2607.                TMPLEN,
  2608.                " ",
  2609.                (network ? "Host" : "Device"),
  2610.                ": ",
  2611.                ttname
  2612.                );
  2613.         conoll(temp);
  2614.  
  2615.         /* The following sprintf's are safe, temp[] size is at least 200 */
  2616.  
  2617.         if (!network && speed >= 0L) {
  2618.         sprintf(temp,"Speed %ld", speed);
  2619.         conoll(temp);
  2620.         }
  2621.         sprintf(temp," Terminal echo: %s", duplex ? "local" : "remote");
  2622.         conoll(temp);
  2623.         sprintf(temp," Terminal bytesize: %d", (cmask == 0177) ? 7 : 8);
  2624.         conoll(temp);
  2625.         sprintf(temp," Command bytesize: %d", (cmdmsk == 0177) ? 7 : 8);
  2626.         conoll(temp);
  2627.             if (hwparity)
  2628.               sprintf(temp," Parity[hardware]: %s",parnam(hwparity));
  2629.             else        
  2630.               sprintf(temp," Parity: %s", parnam(parity));
  2631.         conoll(temp);
  2632. #ifndef NOXFER
  2633.         sprintf(temp," Autodownload: %s", autodl ? "on" : "off");
  2634.         conoll(temp);
  2635. #endif /* NOXFER */
  2636.         ckmakmsg(temp,        /* (would not be safe for sprintf) */
  2637.              TMPLEN,
  2638.              " Session log: ",
  2639.              *sesfil ? sesfil : "(none)",
  2640.              NULL,
  2641.              NULL
  2642.              );
  2643.         conoll(temp);
  2644. #ifndef NOSHOW
  2645.         if (!network) shomdm();
  2646. #endif /* NOSHOW */
  2647. #ifdef CKLOGDIAL
  2648.         {
  2649.         long z;
  2650.         z = dologshow(0);
  2651.         if (z > -1L) {
  2652.             sprintf(temp," Elapsed time: %s",hhmmss(z));
  2653.             conoll(temp);
  2654.         }
  2655.         }
  2656. #endif /* CKLOGDIAL */
  2657.         conoll("----------------------------------------------------");
  2658.         return;
  2659.  
  2660.       case 'h':            /* Help */
  2661.       case '?':            /* Help */
  2662.         c = hconne(); continue;
  2663.  
  2664.       case '0':            /* Send a null */
  2665.         c = '\0'; d = dopar((CHAR) c); ttoc((char) d); return;
  2666.  
  2667.       case 'z': case '\032':    /* Suspend */
  2668. #ifndef NOPUSH
  2669.         if (!nopush)
  2670.           stptrap(0);
  2671.         else
  2672.           conoc(BEL);
  2673. #else
  2674.         conoc(BEL);
  2675. #endif /* NOPUSH */
  2676.         return;
  2677.  
  2678.       case '@':            /* Start inferior command processor */
  2679.       case '!':
  2680. #ifndef NOPUSH
  2681.         if (!nopush) {
  2682.         conres();              /* Put console back to normal */
  2683.         zshcmd("");              /* Fork a shell. */
  2684.         if (conbin((char)escape) < 0) {
  2685.             cx_status = CSX_INTERNAL;
  2686.             printf("Error resuming CONNECT session\n");
  2687.             active = 0;
  2688.         }
  2689.         } else conoc(BEL);
  2690. #else
  2691.         conoc(BEL);
  2692. #endif /* NOPUSH */
  2693.         return;
  2694.  
  2695.       case SP:            /* Space, ignore */
  2696.         return;
  2697.  
  2698.       default:            /* Other */
  2699.         if (c == CMDQ) {        /* Backslash escape */
  2700.         int x;
  2701.         ecbp = ecbuf;
  2702.         *ecbp++ = c;
  2703.         while (((c = (CONGKS() & cmdmsk)) != '\r') && (c != '\n'))
  2704.           *ecbp++ = c;
  2705.         *ecbp = NUL; ecbp = ecbuf;
  2706.         x = xxesc(&ecbp);    /* Interpret it */
  2707.         if (x >= 0) {        /* No key mapping here */
  2708.             c = dopar((CHAR) x);
  2709.             ttoc((char) c);
  2710.             return;
  2711.         } else {        /* Invalid backslash code. */
  2712.             conoc(BEL);
  2713.             return;
  2714.         }
  2715.         }
  2716.         conoc(BEL); return;     /* Invalid esc arg, beep */
  2717.         }
  2718.     }
  2719. }
  2720. #endif /* NOLOCAL */
  2721.