home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / old / ckermit60 / ckucon.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  69KB  |  2,211 lines
  1. #include "ckcsym.h"
  2. #ifdef NOLOCAL
  3. char *connv = "";
  4. #else
  5. char *connv = "CONNECT Command for UNIX, 6.0.083, 6 Sep 96";
  6.  
  7. /*  C K U C O N  --  Terminal connection to remote system, for UNIX  */
  8. /*
  9.   Author: Frank da Cruz <fdc@columbia.edu>,
  10.   Columbia University Academic Information Systems, New York City.
  11.  
  12.   Copyright (C) 1985, 1996, Trustees of Columbia University in the City of New
  13.   York.  The C-Kermit software may not be, in whole or in part, licensed or
  14.   sold for profit as a software product itself, nor may it be included in or
  15.   distributed with commercial products or otherwise distributed by commercial
  16.   concerns to their clients or customers without written permission of the
  17.   Office of Kermit Development and Distribution, Columbia University.  This
  18.   copyright notice must not be removed, altered, or obscured.
  19.  
  20.   Special thanks to Eduard Vopicka, Prague University of Economics,
  21.   Czech Republic, for valuable contributions to this module in July 1994,
  22.   and to Neal P. Murphy of the Motorola Cellular Infrastructure Group
  23.   for rearranging the code to allow operation on the BeBox, yet still work
  24.   in regular UNIX.
  25. */
  26. #include "ckcdeb.h"            /* Common things first */
  27.  
  28. #ifdef BEBOX
  29. static double time_started = 0.0;
  30. #include <kernel/OS.h>
  31. _PROTOTYP( static long concld, (void *) );
  32. #else
  33. _PROTOTYP( static VOID concld, (void) );
  34. #endif /* BEBOX */
  35.  
  36. #ifdef NEXT
  37. #undef NSIG
  38. #include <sys/wait.h>            /* For wait() */
  39. #endif /* NEXT */
  40.  
  41. #include <signal.h>            /* Signals */
  42. #include <errno.h>            /* Error numbers */
  43.  
  44. #ifdef ZILOG                /* Longjumps */
  45. #include <setret.h>
  46. #else
  47. #include <setjmp.h>
  48. #endif /* ZILOG */
  49. #include "ckcsig.h"
  50.  
  51. /* Kermit-specific includes */
  52.  
  53. #include "ckcasc.h"            /* ASCII characters */
  54. #include "ckcker.h"            /* Kermit things */
  55. #include "ckucmd.h"            /* For xxesc() prototype */
  56. #include "ckcnet.h"            /* Network symbols */
  57. #ifndef NOCSETS
  58. #include "ckcxla.h"            /* Character set translation */
  59. #endif /* NOCSETS */
  60.  
  61. /* Internal function prototypes */
  62.  
  63. _PROTOTYP( VOID ttflux, (void) );
  64. _PROTOTYP( VOID doesc, (char) );
  65. _PROTOTYP( static VOID logchar, (char) );
  66. _PROTOTYP( int hconne, (void) );
  67. _PROTOTYP( VOID shomdm, (void) );
  68. _PROTOTYP( static int kbget, (void) );
  69. _PROTOTYP( static int pipemsg, (int) );
  70. _PROTOTYP( static VOID ck_sndmsg, (void) );
  71. _PROTOTYP( static int ckcputf, (void) );
  72. _PROTOTYP( static VOID ck_sndmsg, (void) );
  73.  
  74. /*
  75.   For inter-fork signaling.  Normally we use SIGUSR1, except on SCO, where 
  76.   we use SIGUSR2 because SIGUSR1 is used by the system.  You can define
  77.   CK_FORK_SIG to be whatever other signal you might want to use at compile
  78.   time.  We don't use SIGUSR2 everywhere because in some systems, like
  79.   UnixWare, the default action for SIGUSR2 is to kill the process that gets it.
  80. */
  81. #ifndef CK_FORK_SIG
  82.  
  83. #ifndef SIGUSR1                /* User-defined signals */
  84. #define SIGUSR1 30
  85. #endif /* SIGUSR1 */
  86.  
  87. #ifndef SIGUSR2
  88. #define SIGUSR2 31
  89. #endif /* SIGUSR2 */
  90.  
  91. #ifdef M_UNIX
  92. #define CK_FORK_SIG SIGUSR2        /* SCO - use SIGUSR2 */
  93. #else
  94. #define CK_FORK_SIG SIGUSR1        /* Others - use SIGUSR1 */
  95. #endif /* M_UNIX */
  96.  
  97. #endif /* CK_FORK_SIG */
  98.  
  99. /* External variables */
  100.  
  101. extern struct ck_p ptab[];
  102.  
  103. extern int local, escape, duplex, parity, flow, seslog, sessft, debses,
  104.  mdmtyp, ttnproto, cmask, cmdmsk, network, nettype, deblog, sosi, tnlm,
  105.  xitsta, what, ttyfd, quiet, backgrd, pflag, tt_crd, tn_nlm, ttfdflg,
  106.  tt_escape, justone;
  107.  
  108. extern long speed;
  109. extern char ttname[], sesfil[], myhost[], *ccntab[];
  110. #ifdef TNCODE
  111. extern int tn_b_nlm, me_binary, u_binary;
  112. #endif /* TNCODE */
  113.  
  114. extern int nopush;
  115.  
  116. #ifdef CK_APC
  117. extern int apcactive;            /* Application Program Command (APC) */
  118. extern int apcstatus;            /* items ... */
  119. static int apclength = 0;          
  120. #ifdef DCMDBUF
  121. extern char *apcbuf;
  122. #else
  123. extern char apcbuf[];
  124. #endif /* DCMDBUF */
  125. static int apcbuflen = APCBUFLEN - 2;
  126. extern int autodl, protocol;        /* Auto download */
  127. #endif /* CK_APC */
  128.  
  129. #ifdef CK_XYZ
  130. #ifdef XYZ_INTERNAL
  131. static int zmdlok = 1;            /* Zmodem autodownloads available */
  132. #else
  133. static int zmdlok = 0;            /* Depends on external protocol def */
  134. #endif /* XYZ_INTERNAL */
  135. #else
  136. static int zmdlok = 0;            /* Not available at all */
  137. #endif /* CK_XYZ */
  138.  
  139. #ifndef NOSETKEY            /* Keyboard mapping */
  140. extern KEY *keymap;            /* Single-character key map */
  141. extern MACRO *macrotab;            /* Key macro pointer table */
  142. static MACRO kmptr = NULL;        /* Pointer to current key macro */
  143. #endif /* NOSETKEY */
  144.  
  145. /* Global variables local to this module */
  146.  
  147. static int
  148.   quitnow = 0,                /* <esc-char>Q was typed */
  149.   jbset = 0,                /* Flag whether jmp buf is set. */
  150.   dohangup = 0,                /* <esc-char>H was typed */
  151.   sjval,                /* Setjump return value */
  152.   goterr = 0,                /* Fork/pipe creation error flag */
  153. #ifndef SUNX25
  154.   active = 0,                /* Lower fork active flag */
  155. #endif /* SUNX25 */
  156.   inshift = 0,                /* SO/SI shift states */
  157.   outshift = 0;
  158.  
  159. static PID_T parent_id = (PID_T)0;    /* Process ID of keyboard fork */
  160.  
  161. static char ecbuf[10], *ecbp;        /* Escape char buffer & pointer */
  162.  
  163. #ifdef pdp11
  164. #define IBUFL 1536            /* Input buffer length */
  165. #else
  166. #define IBUFL 4096
  167. #endif /* pdp11 */
  168.  
  169. static int obc = 0;            /* Output buffer count */
  170.  
  171. #ifndef OXOS
  172. #define OBUFL 1024            /* Output buffer length */
  173. #else
  174. #define OBUFL IBUFL
  175. #endif /* OXOS */
  176.  
  177. #define TMPLEN 200            /* Temporary message buffer length */
  178. #ifdef DYNAMIC
  179. static char *ibuf = NULL, *obuf = NULL, *temp = NULL; /* Buffers */
  180. #else
  181. static char ibuf[IBUFL], obuf[OBUFL], temp[TMPLEN];
  182. #endif /* DYNAMIC */
  183.  
  184. #ifdef DYNAMIC
  185. static char *ibp;            /* Input buffer pointer */
  186. #else
  187. static char *ibp = ibuf;        /* Input buffer pointer */
  188. #endif /*DYNAMIC */
  189. static int ibc = 0;            /* Input buffer count */
  190.  
  191. #ifdef DYNAMIC
  192. static char *obp;            /* Output buffer pointer */
  193. #else
  194. static char *obp = obuf;        /* Output buffer pointer */
  195. #endif /* DYNAMIC */
  196.  
  197. /* SunLink X.25 items */
  198.  
  199. #ifdef SUNX25
  200. static char *p;                /* General purpose pointer */
  201. char x25ibuf[MAXIX25];            /* Input buffer */
  202. char x25obuf[MAXOX25];            /* Output buffer */
  203. int active = 0;                /* Lower fork active flag */
  204. int ibufl;                /* Length of input buffer */
  205. int obufl;                /* Length of output buffer */
  206. unsigned char tosend = 0;
  207. int linkid, lcn;
  208. static int dox25clr = 0;
  209. extern CHAR padparms[];
  210. #endif /* SUNX25 */
  211.  
  212. static int xpipe[2] = {-1, -1};    /* Pipe descriptor for child-parent messages */
  213. static PID_T pid;        /* Process ID of child */
  214.  
  215. /* Character-set items */
  216.  
  217. #ifndef NOCSETS
  218. #ifdef CK_ANSIC /* ANSI C prototypes... */
  219. extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* Character set */
  220. extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* translation functions */
  221. static CHAR (*sxo)(CHAR);    /* Local translation functions */
  222. static CHAR (*rxo)(CHAR);    /* for output (sending) terminal chars */
  223. static CHAR (*sxi)(CHAR);    /* and for input (receiving) terminal chars. */
  224. static CHAR (*rxi)(CHAR);
  225. #else /* Not ANSI C... */
  226. extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])();    /* Character set */
  227. extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])();    /* translation functions. */
  228. static CHAR (*sxo)();        /* Local translation functions */
  229. static CHAR (*rxo)();        /* for output (sending) terminal chars */
  230. static CHAR (*sxi)();        /* and for input (receiving) terminal chars. */
  231. static CHAR (*rxi)();
  232. #endif /* CK_ANSIC */
  233. extern int language;        /* Current language. */
  234. static int langsv;        /* For remembering language setting. */
  235. extern struct csinfo fcsinfo[]; /* File character set info. */
  236. extern int tcsr, tcsl;        /* Terminal character sets, remote & local. */
  237. static int tcs;            /* Intermediate ("transfer") character set. */
  238. #endif /* NOCSETS */
  239.  
  240. /*
  241.   We do not need to parse and recognize escape sequences if we are being built
  242.   without character-set support AND without APC support.
  243. */
  244. #ifdef NOCSETS                /* No character sets */
  245. #ifndef CK_APC                /* No APC */
  246. #ifndef NOESCSEQ
  247. #define NOESCSEQ            /* So no escape sequence recognizer */
  248. #endif /* NOESCSEQ */
  249. #endif /* CK_APC */
  250. #endif /* NOCSETS */
  251. /*
  252.   Child process events / messages
  253. */
  254. #define CEV_NO  0            /* No event */
  255. #define CEV_HUP 1            /* Communications hangup */
  256. #define CEV_PAD 2            /* X.25 - change PAD parameters */
  257. #define CEV_DUP 3            /* Toggle duplex */
  258. #define CEV_APC 4            /* Execute APC */
  259. #ifdef TNCODE
  260. #define CEV_MEBIN 5            /* Change of me_binary */
  261. #define CEV_UBIN 6            /* Change of u_binary */
  262. #endif /* TNCODE */
  263. #define CEV_ADL 7            /* Autodownload */
  264. #define CEV_AUL 8            /* Autoupload */
  265.  
  266. #ifdef NOESCSEQ
  267. #define chkaes(x) 0
  268. #else
  269. /*
  270.   As of edit 178, the CONNECT command will skip past ANSI escape sequences
  271.   to avoid translating the characters within them.  This allows the CONNECT
  272.   command to work correctly when connected to a remote host that uses a
  273.   7-bit ISO 646 national character set, in which characters like '[' would
  274.   normally be translated into accented characters, ruining the terminal's
  275.   interpretation (and generation) of escape sequences.
  276.  
  277.   As of edit 190, the CONNECT command responds to APC escape sequences
  278.   (ESC _ text ESC \) if the user SETs TERMINAL APC ON or UNCHECKED, and the
  279.   program was built with CK_APC defined.
  280.  
  281.   Non-ANSI/ISO-compliant escape sequences are not handled.
  282. */
  283.  
  284. /*
  285.   States for the escape-sequence recognizer.
  286. */
  287. #define ES_NORMAL 0            /* Normal, not in an escape sequence */
  288. #define ES_GOTESC 1            /* Current character is ESC */
  289. #define ES_ESCSEQ 2            /* Inside an escape sequence */
  290. #define ES_GOTCSI 3            /* Inside a control sequence */
  291. #define ES_STRING 4            /* Inside DCS,OSC,PM, or APC string */
  292. #define ES_TERMIN 5            /* 1st char of string terminator */
  293.  
  294. static int
  295.   escseq = 0,                /* 1 = Recognizer is active */
  296.   inesc = ES_NORMAL,            /* State of sequence recognizer */
  297.   oldesc = -1;                /* Previous state of recognizer */
  298. /*
  299.   ANSI escape sequence handling.  Only the 7-bit form is treated, because
  300.   translation is not a problem in the 8-bit environment, in which all GL
  301.   characters are ASCII and no translation takes place.  So we don't check
  302.   for the 8-bit single-character versions of CSI, DCS, OSC, APC, or ST.
  303.   Here is the ANSI sequence recognizer state table, followed by the code
  304.   that implements it.
  305.  
  306.   Definitions:
  307.     CAN = Cancel                       01/08         Ctrl-X
  308.     SUB = Substitute                   01/10         Ctrl-Z
  309.     DCS = Device Control Sequence      01/11 05/00   ESC P
  310.     CSI = Control Sequence Introducer  01/11 05/11   ESC [
  311.     ST  = String Terminator            01/11 05/12   ESC \
  312.     OSC = Operating System Command     01/11 05/13   ESC ]
  313.     PM  = Privacy Message              01/11 05/14   ESC ^
  314.     APC = Application Program Command  01/11 05/15   ESC _
  315.  
  316.   ANSI escape sequence recognizer:
  317.  
  318.     State    Input  New State  ; Commentary
  319.  
  320.     NORMAL   (start)           ; Start in NORMAL state
  321.  
  322.     (any)    CAN    NORMAL     ; ^X cancels
  323.     (any)    SUB    NORMAL     ; ^Z cancels
  324.  
  325.     NORMAL   ESC    GOTESC     ; Begin escape sequence
  326.     NORMAL   other             ; NORMAL control or graphic character
  327.  
  328.     GOTESC   ESC               ; Start again
  329.     GOTESC   [      GOTCSI     ; CSI
  330.     GOTESC   P      STRING     ; DCS introducer, consume through ST
  331.     GOTESC   ]      STRING     ; OSC introducer, consume through ST
  332.     GOTESC   ^      STRING     ; PM  introducer, consume through ST
  333.     GOTESC   _      STRING     ; APC introducer, consume through ST
  334.     GOTESC   0..~   NORMAL     ; 03/00 through 17/14 = Final character
  335.     GOTESC   other  ESCSEQ     ; Intermediate or ignored control character
  336.  
  337.     ESCSEQ   ESC    GOTESC     ; Start again
  338.     ESCSEQ   0..~   NORMAL     ; 03/00 through 17/14 = Final character
  339.     ESCSEQ   other             ; Intermediate or ignored control character
  340.  
  341.     GOTCSI   ESC    GOTESC     ; Start again
  342.     GOTCSI   @..~   NORMAL     ; 04/00 through 17/14 = Final character
  343.     GOTCSI   other             ; Intermediate char or ignored control char
  344.  
  345.     STRING   ESC    TERMIN     ; Maybe have ST
  346.     STRING   other             ; Consume all else
  347.  
  348.     TERMIN   \      NORMAL     ; End of string
  349.     TERMIN   other  STRING     ; Still in string
  350. */
  351. /*
  352.   chkaes() -- Check ANSI Escape Sequence.
  353.   Call with EACH character in input stream.
  354.   Sets global inesc variable according to escape sequence state.
  355.   Returns 0 normally, 1 if an APC sequence is to be executed.
  356. */
  357. int
  358. #ifdef CK_ANSIC
  359. chkaes(char c)
  360. #else
  361. chkaes(c) char c;
  362. #endif /* CK_ANSIC */
  363. /* chkaes */ {
  364.  
  365.     oldesc = inesc;            /* Remember previous state */
  366.     if (c == CAN || c == SUB)        /* CAN and SUB cancel any sequence */
  367.       inesc = ES_NORMAL;
  368.     else                /* Otherwise */
  369.       switch (inesc) {            /* enter state switcher */
  370.  
  371.     case ES_NORMAL:            /* NORMAL state */
  372.       if (c == ESC)            /* Got an ESC */
  373.         inesc = ES_GOTESC;        /* Change state to GOTESC */
  374.       break;            /* Otherwise stay in NORMAL state */
  375.  
  376.     case ES_GOTESC:            /* GOTESC state */
  377.       if (c == '[')            /* Left bracket after ESC is CSI */
  378.         inesc = ES_GOTCSI;        /* Change to GOTCSI state */
  379.       else if (c == 'P' || (c > 0134 && c < 0140)) { /* P, [, ^, or _ */
  380.           inesc = ES_STRING;    /* Switch to STRING-absorption state */
  381. #ifdef CK_APC
  382.           if (c == '_' && pid == 0 && /* APC handled in child only */
  383.           apcstatus != APC_OFF) { /* and only if not disabled. */
  384.           debug(F100,"APC begin","",0);
  385.           apcactive = 1;    /* Set APC-Active flag */
  386.           apclength = 0;    /* and reset APC buffer pointer */
  387.           }
  388. #endif /* CK_APC */
  389.       } else if (c > 057 && c < 0177) /* Final character '0' thru '~' */
  390.         inesc = ES_NORMAL;        /* Back to normal */
  391.       else if (c != ESC)        /* ESC in an escape sequence... */
  392.         inesc = ES_ESCSEQ;        /* starts a new escape sequence */
  393.       break;            /* Intermediate or ignored ctrl char */
  394.  
  395.     case ES_ESCSEQ:            /* ESCSEQ -- in an escape sequence */
  396.       if (c > 057 && c < 0177)    /* Final character '0' thru '~' */
  397.         inesc = ES_NORMAL;        /* Return to NORMAL state. */
  398.       else if (c == ESC)        /* ESC ... */
  399.         inesc = ES_GOTESC;        /* starts a new escape sequence */
  400.       break;            /* Intermediate or ignored ctrl char */
  401.  
  402.     case ES_GOTCSI:            /* GOTCSI -- In a control sequence */
  403.       if (c > 077 && c < 0177)    /* Final character '@' thru '~' */
  404.         inesc = ES_NORMAL;        /* Return to NORMAL. */
  405.       else if (c == ESC)        /* ESC ... */
  406.         inesc = ES_GOTESC;        /* starts over. */
  407.       break;            /* Intermediate or ignored ctrl char */
  408.  
  409.     case ES_STRING:            /* Inside a string */
  410.       if (c == ESC)            /* ESC may be 1st char of terminator */
  411.         inesc = ES_TERMIN;        /* Go see. */
  412. #ifdef CK_APC
  413.       else if (apcactive && (apclength < apcbuflen)) /* If in APC, */
  414.         apcbuf[apclength++] = c;    /* deposit this character. */
  415.       else {            /* Buffer overrun */
  416.           apcactive = 0;        /* Discard what we got */
  417.           apclength = 0;        /* and go back to normal */
  418.           apcbuf[0] = 0;        /* Not pretty, but what else */
  419.           inesc = ES_NORMAL;    /* can we do?  (ST might not come) */
  420.       }
  421. #endif /* CK_APC */
  422.       break;            /* Absorb all other characters. */
  423.  
  424.     case ES_TERMIN:            /* May have a string terminator */
  425.       if (c == '\\') {        /* which must be backslash */
  426.           inesc = ES_NORMAL;    /* If so, back to NORMAL */
  427. #ifdef CK_APC
  428.           if (apcactive) {        /* If it was an APC string, */
  429.           debug(F101,"APC terminated","",c);
  430.           apcbuf[apclength] = NUL; /* terminate it and then ... */
  431.           return(1);
  432.           }
  433. #endif /* CK_APC */
  434.       } else {            /* Otherwise */
  435.           inesc = ES_STRING;    /* Back to string absorption. */
  436. #ifdef CK_APC
  437.           if (apcactive && (apclength+1 < apcbuflen)) { /* In APC string */
  438.           apcbuf[apclength++] = ESC; /* deposit the Esc character */
  439.           apcbuf[apclength++] = c;   /* and this character too */
  440.           }
  441. #endif /* CK_APC */
  442.       }
  443.       }
  444.     return(0);
  445. }
  446. #endif /* NOESCSEQ */
  447.  
  448. /* Connect state parent/child communication signal handlers */
  449.  
  450. /* Routines used by the child process */
  451.  
  452. static int
  453. pipemsg(n) int n; {            /* Send message ID to parent */
  454.     int code = n & 255;
  455.     return(write(xpipe[1], &code, sizeof(code)));
  456. }
  457.  
  458. /* Environment pointer for CK_FORK_SIG signal handling in child... */
  459.  
  460. #ifdef CK_POSIX_SIG
  461. static sigjmp_buf sig_env;
  462. #else
  463. static jmp_buf sig_env;
  464. #endif /* CK_POSIX_SIG */
  465.  
  466. static SIGTYP                /* CK_FORK_SIG handling in child ... */
  467. forkint(foo) int foo; {
  468.     /* It is important to disable CK_FORK_SIG before longjmp */
  469.     signal(CK_FORK_SIG, SIG_IGN);    /* Set to ignore CK_FORK_SIG */
  470.     debug(F100, "forkint - CK_FORK_SIG", "", 0);
  471.     /* Force return from ck_sndmsg() */
  472.     cklongjmp(sig_env, 1);
  473.     /* NOTREACHED */
  474. }
  475.  
  476. static VOID
  477. ck_sndmsg() {                /* Executed by child only ... */
  478.     debug(F100, "ck_sndmsg - notifying parent", "", 0);
  479.     if (
  480. #ifdef CK_POSIX_SIG
  481.     sigsetjmp(sig_env,1)
  482. #else
  483.     setjmp(sig_env)
  484. #endif /* CK_POSIX_SIG */
  485.     == 0) {
  486.         signal(CK_FORK_SIG, forkint);    /* Set up signal handler */
  487.         kill(parent_id, CK_FORK_SIG);    /* Kick the parent */
  488.         for (;;) pause();        /* Wait for CK_FORK_SIG or SIGKILL */
  489.     /* NOTREACHED */
  490.     }
  491.     /* We come here from forkint() via [sig]cklongjmp(sig_env,1) */
  492.     debug(F100, "ck_sndmsg - returning", "", 0);
  493. }
  494.  
  495. /* Routines used by the parent process */
  496.  
  497. #ifdef CK_POSIX_SIG         /* Environment pointer for CONNECT errors */
  498. static sigjmp_buf con_env;
  499. #else
  500. static jmp_buf con_env;
  501. #endif /* CK_POSIX_SIG */
  502. /*
  503.   pipeint() handles CK_FORK_SIG signals from the lower (port) fork.
  504.   It reads a function code from the pipe that connects the two forks,
  505.   then reads additional data from the pipe, then handles it.
  506. */
  507. static SIGTYP
  508. pipeint(arg) int arg; {            /* Dummy argument */
  509.     int code;
  510. #ifndef NOCCTRAP
  511.     extern ckjmpbuf cmjbuf;
  512. #endif /* NOCCTRAP */
  513.     /*
  514.       IMPORTANT: At this point, the child fork is waiting for CK_FORK_SIG
  515.       (eventually for SIGKILL) inside of ck_sndmsg().  So we can't get any
  516.       subsequent CK_FORK_SIG from child before we send it CK_FORK_SIG.
  517.     */
  518.     signal(CK_FORK_SIG, SIG_IGN);    /* Ignore CK_FORK_SIG now */
  519.     debug(F101,"pipeint arg","",arg);
  520.  
  521.     read(xpipe[0], &code, sizeof(code)); /* Get function code from pipe */
  522.     debug(F101,"pipeint code","",code);
  523.  
  524. #ifndef NOCCTRAP
  525. #ifndef NOICP
  526. #define USECCJMPBUF
  527. #endif /* NOICP */
  528. #endif /* NOCCTRAP */
  529. /*
  530.   The CEV_HUP case is executed when the other side has hung up on us.
  531.   In some cases, this happens before we have had a chance to execute the
  532.   setjmp(con_env,1) call, and in that case we'd better not take the longjmp!
  533.   A good example is when you TELNET to port 13 on the local host; it prints
  534.   its asctime() string (26 chars) and then closes the connection.
  535. */
  536.     switch (code & 255) {
  537.       case CEV_HUP:
  538.         sjval = CEV_HUP;        /* Set global variable. */
  539.     if (jbset) {            /* jmp_buf is initialized */
  540.         cklongjmp(con_env,sjval);    /* so do the right thing. */
  541.     } else {
  542. #ifdef USECCJMPBUF
  543.         /* jmp_buf not init'd yet a close approximation... */
  544.         ttclos(0);            /* Close our end of the connection */
  545. #ifdef BEBOX
  546.         {
  547.         long ret_val;
  548.         if (pid) kill(pid,SIGKILLTHR);    /* Kill lower fork */
  549.         wait_for_thread (pid, &ret_val);
  550.         }
  551. #else
  552. #ifdef Plan9
  553.         if (pid) kill(pid, SIGKILL); /* (should always use this really) */
  554. #else
  555.         if (pid) kill(pid,9);    /* Kill lower fork (history) */
  556. #endif /* Plan9 */
  557. #endif /* BEBOX */
  558.         conres();            /* Reset the console. */
  559.         if (!quiet) {
  560.         printf("\r\n(Back at %s)\r\n",
  561.                *myhost ? myhost :
  562. #ifdef UNIX
  563.                "local UNIX system"
  564. #else
  565.                "local system"
  566. #endif /* UNIX */
  567.                );
  568.         }
  569.         what = W_NOTHING;        /* So console modes are set right. */
  570.         printf("\r\n");        /* prevent prompt-stomping */
  571.         cklongjmp(cmjbuf,0);    /* Do what the Ctrl-C handler does */
  572. #else
  573.         printf("\r\nLongjump failure - fatal\r\n");
  574.         doexit(1);            /* Better than dumping core... */
  575. #endif /* USECCJMPBUF */
  576.     }
  577. #ifdef USECCJMPBUF
  578. #undef USECCJMPBUF
  579. #endif /* USECCJMPBUF */
  580.  
  581.       case CEV_DUP:            /* Child sends duplex change */
  582.     read(xpipe[0], (char *)&duplex, sizeof(duplex));
  583.     debug(F101,"pipeint duplex","",duplex);
  584.     break;
  585. #ifdef TNCODE
  586.       case CEV_MEBIN:            /* Child sends me_binary change */
  587.     read(xpipe[0], (char *)&me_binary, sizeof(me_binary));
  588.     debug(F101,"pipeint me_binary","",me_binary);
  589.     break;
  590.       case CEV_UBIN:            /* Child sends u_binary change */
  591.     read(xpipe[0], (char *)&u_binary, sizeof(u_binary));
  592.     debug(F101,"pipeint u_binary","",u_binary);
  593.     break;
  594. #endif /* TNCODE */
  595.  
  596. #ifdef CK_APC
  597.       case CEV_AUL:            /* Autoupload */
  598.     justone = 1;
  599.     debug(F100,"autoupload at parent","",0);
  600.       case CEV_ADL:            /* Autodownload */
  601.     apcstatus = APC_LOCAL;
  602.     if (!justone) debug(F100,"autodownload at parent","",0);
  603.       case CEV_APC:            /* Application Program Command */
  604.     read(xpipe[0], (char *)&apclength, sizeof(apclength));
  605.     read(xpipe[0], apcbuf, apclength+1); /* Include trailing zero byte */
  606.     debug(F111,"APC at parent",apcbuf,apclength);
  607.     read(xpipe[0], (char *)&ibc, sizeof(ibc)); /* Copy child's */
  608.     if (ibc > 0) {                   /* input buffer. */
  609.         read(xpipe[0], (char *)&ibp, sizeof(ibp));
  610.         read(xpipe[0], ibp, ibc);
  611.     }
  612.     obc = 0; obp = obuf; *obuf = NUL; /* Because port fork flushed */
  613.     sjval = CEV_APC;
  614.     cklongjmp(con_env,sjval);
  615.     /* NOTREACHED */
  616. #endif /* CK_APC */
  617.  
  618. #ifdef SUNX25
  619.       case CEV_PAD:            /* X.25 PAD parameter change */
  620.     debug(F100,"pipeint PAD change","",0);
  621.     read(xpipe[0],padparms,MAXPADPARMS);
  622.     sjval = CEV_PAD;        /* Set global variable. */
  623. #ifdef COMMENT                /* We might not need to do this... */
  624.     cklongjmp(con_env,sjval);
  625.     /* NOTREACHED */
  626. #else  /* COMMENT */
  627.     break;
  628. #endif /* COMMENT */
  629. #endif /* SUNX25 */
  630.     }
  631.     signal(CK_FORK_SIG, pipeint);    /* Set up signal handler */
  632.     kill(pid, CK_FORK_SIG);        /* Signal the port fork ... */
  633. }
  634.  
  635. /*  C K C P U T C  --  C-Kermit CONNECT Put Character to Screen  */
  636. /*
  637.   Output is buffered to avoid slow screen writes on fast connections.
  638.   NOTE: These could (easily?) become macros ...
  639. */
  640. static int
  641. ckcputf() {                /* Dump the output buffer */
  642.     int x = 0;
  643.     if (obc > 0)            /* If we have any characters, */
  644.       x = conxo(obc,obuf);        /* dump them, */
  645.     obp = obuf;                /* reset the pointer */
  646.     obc = 0;                /* and the counter. */
  647.     return(x);                /* Return conxo's return code */
  648. }
  649.  
  650. int
  651. ckcputc(c) int c; {
  652.     int x;
  653.  
  654.     *obp++ = c & 0xff;            /* Deposit the character */
  655.     obc++;                /* Count it */
  656.     if (ibc == 0 ||            /* If input buffer about empty */
  657.     obc == OBUFL) {            /* or output buffer full */
  658.     debug(F101,"CKCPUTC obc","",obc);
  659.     x = conxo(obc,obuf);        /* dump the buffer, */
  660.     obp = obuf;            /* reset the pointer */
  661.     obc = 0;            /* and the counter. */
  662.     return(x);            /* Return conxo's return code */
  663.     } else return(0);
  664. }
  665.  
  666. /*  C K C G E T C  --  C-Kermit CONNECT Get Character  */
  667. /*
  668.   Buffered read from communication device.
  669.   Returns the next character, refilling the buffer if necessary.
  670.   On error, returns ttinc's return code (see ttinc() description).
  671.   Dummy argument for compatible calling conventions with ttinc().
  672.   NOTE: We don't have a macro for this because we have to pass
  673.   a pointer to this function as an argument to tn_doop().
  674. */
  675. int
  676. ckcgetc(dummy) int dummy; {
  677.     int c, n;
  678.  
  679.     debug(F101,"CKCGETC 1 ibc","",ibc); /* Log */
  680.     if (ibc < 1) {            /* Need to refill buffer? */
  681.     ibc = 0;            /* Yes, reset count */
  682.     ibp = ibuf;            /* and buffer pointer */
  683.     debug(F100,"CKCGETC 1 calling ttinc(0)","",0); /* Log */
  684.     c = ttinc(0);            /* Read one character, blocking */
  685.     debug(F101,"CKCGETC 1 ttinc(0)","",c); /* Log */
  686.     if (c < 0) {            /* If error, return error code */
  687.         return(c);
  688.     } else {            /* Otherwise, got one character */
  689.         *ibp++ = c;            /* Advance buffer pointer */
  690.         ibc++;            /* and count. */
  691.     }
  692.  
  693.     /* Now quickly read any more that might have arrived */
  694.  
  695.     if ((n = ttchk()) > 0) {    /* Any more waiting? */
  696.         if (n > (IBUFL - ibc))    /* Get them all at once. */
  697.           n = IBUFL - ibc;        /* Don't overflow buffer */
  698.         if ((n = ttxin(n,(CHAR *)ibp)) > 0)
  699.           ibc += n;            /* Advance counter */
  700.     }
  701.     debug(F101,"CKCGETC 2 ibc","",ibc); /* Log how many */
  702.     ibp = ibuf;
  703.     }
  704.     c = *ibp++ & 0xff;            /* Get next character from buffer */
  705.     ibc--;                /* Reduce buffer count */
  706.     return(c);                /* Return the character */
  707. }
  708.  
  709. /*
  710.    Keyboard handling, buffered for speed, which is needed when C-Kermit is
  711.    in CONNECT mode between two other computers that are transferring data.
  712. */
  713. static char *kbp;            /* Keyboard input buffer pointer */
  714. static int kbc;                /* Keyboard input buffer count */
  715.  
  716. #ifdef pdp11                /* Keyboard input buffer length */
  717. #define KBUFL 32            /* Small for PDP-11 UNIX */
  718. #else
  719. #define KBUFL 257            /* Regular kernel size for others */
  720. #endif /* pdp11 */
  721.  
  722. #ifdef DYNAMIC
  723. static char *kbuf = NULL;
  724. #else
  725. static char kbuf[KBUFL];
  726. #endif /* DYNAMIC */
  727.  
  728. /* Macro for reading keystrokes. */
  729.  
  730. #define CONGKS() (((--kbc)>=0) ? ((int)(*kbp++) & 0377) : kbget())
  731.  
  732. /*
  733.   Note that we call read() directly here, normally a no-no, but in this case
  734.   we know it's UNIX and we're only doing what coninc(0) would have done,
  735.   except we're reading a block of characters rather than just one.  There is,
  736.   at present, no conxin() analog to ttxin() for chunk reads, and instituting
  737.   one would only add function-call overhead as it would only be a wrapper for
  738.   a read() call anyway.
  739. */
  740. /*
  741.   Another note: We stick in this read() till the user types something.
  742.   But the other (lower) fork is running too, and on TELNET connections,
  743.   it will signal us to indicate echo-change negotiations, and this can
  744.   interrupt the read().  Some UNIXes automatically restart the interrupted
  745.   system call, others return from it with errno == EINTR.
  746. */
  747. static int                /* Keyboard buffer filler */
  748. kbget() {
  749. #ifdef EINTR
  750.     int tries = 10;            /* If read() is interrupted, */
  751.     int ok = 0;
  752.     while (tries-- > 0) {        /* try a few times... */
  753. #endif /* EINTR */
  754.     if ((kbc = conchk()) < 1)    /* How many chars waiting? */
  755.       kbc = 1;            /* If none or dunno, wait for one. */
  756.     else if (kbc > KBUFL)        /* If too many, */
  757.       kbc = KBUFL;            /* only read this many. */
  758.     if ((kbc = read(0, kbuf, kbc)) < 1) { /* Now read it/them. */
  759.         debug(F101,"kbget errno","",errno);    /* Got an error. */
  760. #ifdef EINTR
  761.         if (errno == EINTR)        /* Interrupted system call. */
  762.           continue;            /* Try again, up to limit. */
  763.         else            /* Something else. */
  764. #endif /* EINTR */
  765.           return(-1);        /* Pass along read() error. */
  766.     }
  767. #ifdef EINTR
  768.     else { ok = 1; break; }
  769.     }
  770.     if (!ok) return(-1);
  771. #endif /* EINTR */
  772.     kbp = kbuf;                /* Adjust buffer pointer, */
  773.     kbc--;                /* count, */
  774.     return((int)(*kbp++) & 0377);    /* and return first character. */
  775. }
  776.  
  777. /*  C O N C L D --  Interactive terminal connection child function */
  778.  
  779. static
  780. #ifdef BEBOX
  781. long
  782. #else
  783. VOID
  784. #endif /* BEBOX */
  785. concld (
  786. #ifdef BEBOX
  787.        void *bevoid
  788. #endif /* BEBOX */
  789.        ) {
  790.     int    n;            /* General purpose counter */
  791.  
  792.     int c;            /* c is a character, but must be signed 
  793.                    integer to pass thru -1, which is the
  794.                    modem disconnection signal, and is
  795.                    different from the character 0377 */
  796.     int c2;            /* A copy of c */
  797.     int csave;            /* Another copy of c */
  798.     int tx;            /* tn_doop() return code */
  799. #ifdef SUNX25
  800.     int i;                /* Worker for X.25 code */
  801. #endif /* SUNX25 */
  802. #ifdef NETCONN
  803.  
  804. #endif /* NETCONN */
  805. #ifndef NOESCSEQ
  806.     int apcrc;
  807. #endif /* NOESCSEQ */
  808.  
  809.  
  810.     int conret = 0;            /* Return value from conect() */
  811.     /* jbchksum = -1L; */
  812.     jbset = 0;                /* jmp_buf not set yet, don't use it */
  813.     debug(F101,"CONCLD entry","",CK_FORK_SIG);
  814.      /* *** */        /* Inferior reads, prints port input */
  815.  
  816.     if (priv_can()) {            /* Cancel all privs */
  817.     printf("?setuid error - fatal\n");
  818.     doexit(BAD_EXIT,-1);
  819.     }
  820.     signal(SIGINT, SIG_IGN);        /* In case these haven't been */
  821.     signal(SIGQUIT, SIG_IGN);        /* inherited from above... */
  822.     signal(CK_FORK_SIG, SIG_IGN);    /* CK_FORK_SIG not expected yet */
  823.  
  824.     inshift = outshift = 0;        /* Initial SO/SI shift state. */
  825.     {                    /* Wait for parent's setup */
  826.     int i;
  827.     while ((i = read(xpipe[0], &c, 1)) <= 0) {
  828.         if (i < 0) {
  829.         pipemsg(CEV_HUP);    /* Read error - hangup */
  830.         ck_sndmsg();        /* Send and wait to be killed */
  831.         /* NOTREACHED */
  832.         } /* Restart interrupted read() */
  833.     }
  834.     }
  835.     close(xpipe[0]); xpipe[0] = -1;    /* Child - prevent future reads */
  836. #ifdef DEBUG
  837.     if (deblog) {
  838.     debug(F100,"CONNECT starting port fork","",0);
  839.     debug(F101,"CONNECT port fork ibc","",ibc);
  840.     debug(F101,"CONNECT port fork obc","",obc);
  841.     }
  842. #endif /* DEBUG */
  843.     what = W_CONNECT;
  844.  
  845.     while (1) {                /* Fresh read, wait for a character. */
  846. #ifdef SUNX25
  847.     if (network && (nettype == NET_SX25)) {
  848.         bzero(x25ibuf,sizeof(x25ibuf)) ;
  849.         if ((ibufl = ttxin(MAXIX25,(CHAR *)x25ibuf)) < 0) {
  850.         if (ibufl == -2) {  /* PAD parms changes */
  851.             pipemsg(CEV_PAD);
  852.             write(xpipe[1],padparms,MAXPADPARMS);
  853.             ck_sndmsg();
  854.         } else {
  855.             if (!quiet)
  856.               printf("\r\nCommunications disconnect ");
  857.             pipemsg(CEV_HUP);
  858.             ck_sndmsg();        /* Wait to be killed */
  859.             /* NOTREACHED */
  860.         }
  861.         /* pause(); <--- SHOULD BE OBSOLETE NOW! */
  862.         /* BECAUSE pause() is done inside of ck_sndmsg() */
  863.         }
  864.         if (debses) {        /* Debugging output */
  865.         p = x25ibuf ;
  866.         while (ibufl--) { c = *p++; conol(dbchr(c)); }
  867.         } else {
  868.         if (sosi
  869. #ifndef NOCSETS
  870.             || tcsl != tcsr
  871. #endif /* NOCSETS */
  872.             ) { /* Character at a time */
  873.             for (i = 1; i < ibufl; i++) {
  874.             c = x25ibuf[i] & cmask;
  875.             if (sosi) { /* Handle SI/SO */
  876.                 if (c == SO) {
  877.                 inshift = 1;
  878.                 continue;
  879.                 } else if (c == SI) {
  880.                 inshift = 0;
  881.                 continue;
  882.                 }
  883.                 if (inshift)
  884.                   c |= 0200;
  885.             }
  886. #ifndef NOCSETS
  887. #ifdef NOESCSEQ
  888.             /* Translate character sets */
  889.             /* From local to intermediate. */
  890.             if (sxo) c = (*sxo)(c);
  891.             /* From intermediate to remote. */
  892.             if (rxo) c = (*rxo)(c);
  893. #else
  894.             /* If not inside escape sequence... */
  895.             if (inesc == ES_NORMAL) {
  896.                 /* Translate character sets */
  897.                 if (sxo) c = (*sxo)(c);
  898.                 if (rxo) c = (*rxo)(c);
  899.             }
  900.                 if (escseq) apcrc = chkaes(c);
  901. #endif /* NOESCSEQ */
  902. #endif /* NOCSETS */
  903.             c &= cmdmsk; /* Apply command mask. */
  904.             conoc(c);    /* Output to screen */
  905.             logchar(c);  /* and session log */
  906.             }
  907.         } else {        /* All at once */
  908.             for (i = 1; i < ibufl; i++)
  909.               x25ibuf[i] &= (cmask & cmdmsk);
  910.             conxo(ibufl,x25ibuf);
  911.             if (seslog) zsoutx(ZSFILE,x25ibuf,ibufl);
  912.         }
  913.         }
  914.         continue;
  915.  
  916.     } else {            /* Not X.25... */
  917. #endif /* SUNX25 */
  918. /*
  919.   Get the next communication line character from our internal buffer.
  920.   If the buffer is empty, refill it.
  921. */
  922.         c = ckcgetc(0);        /* Get next character */
  923.         /* debug(F101,"CONNECT c","",c); */
  924.         if (c < 0) {        /* Failed... */
  925.         debug(F101,"CONNECT disconnect ibc","",ibc);
  926.         debug(F101,"CONNECT disconnect obc","",obc);
  927.         ckcputf();        /* Flush CONNECT output buffer */
  928.         if (!quiet) {
  929.             printf("\r\nCommunications disconnect ");
  930.             if ( c == -3
  931. #ifdef ultrix
  932. /* This happens on Ultrix if there's no carrier */
  933.             && errno != EIO
  934. #endif /* ultrix */
  935. #ifdef UTEK
  936. /* This happens on UTEK if there's no carrier */
  937.             && errno != EWOULDBLOCK
  938. #endif /* UTEK */
  939.             )
  940.               perror("\r\nCan't read character");
  941.         }
  942. #ifdef NOSETBUF
  943.         fflush(stdout);
  944. #endif /* NOSETBUF */
  945.         tthang();        /* Hang up the connection */
  946.         pipemsg(CEV_HUP);
  947.         ck_sndmsg();        /* Wait to be killed */
  948.         }
  949.         debug(F101,"** PORT","",c); /* Got character c OK. */
  950. #ifdef TNCODE
  951.         /* Handle TELNET negotiations... */
  952.  
  953.         if (c == IAC && network && ttnproto == NP_TELNET) {
  954.         int me_bin = me_binary;
  955.         int u_bin = u_binary;
  956.         debug(F100,"CONNECT got IAC","",0);
  957.         ckcputf();        /* Dump screen-output buffer */
  958.         if ((tx = tn_doop((CHAR)(c & 0xff),duplex,ckcgetc)) == 0) {
  959.             if (me_bin != me_binary) {
  960.             debug(F101,"CONNECT TELNET me_bin","",me_binary);
  961.             pipemsg(CEV_MEBIN); /* Tell parent */
  962.             write(xpipe[1], &me_binary, sizeof(me_binary));
  963.             ck_sndmsg();    /* Tell the parent fork */
  964.             } else if (u_bin != u_binary) {
  965.             debug(F101,"CONNECT TELNET u_bin","",u_binary);
  966.             pipemsg(CEV_UBIN); /* Tell parent */
  967.             write(xpipe[1], &u_binary, sizeof(u_binary));
  968.             ck_sndmsg();    /* Tell the parent fork */
  969.             }
  970.             continue;
  971.         } else if (tx == -1) {    /* I/O error */
  972.             if (!quiet)
  973.               printf("\r\nCommunications disconnect ");
  974. #ifdef NOSETBUF
  975.             fflush(stdout);
  976. #endif /* NOSETBUF */
  977.             pipemsg(CEV_HUP);
  978.             ck_sndmsg();        /* Wait to be killed */
  979.             /* NOTREACHED */
  980.         } else if ((tx == 1) && (!duplex)) { /* ECHO change */
  981.             duplex = 1;        /* Turn on local echo */
  982.             debug(F101,"CONNECT TELNET duplex change","",duplex);
  983.             pipemsg(CEV_DUP);    /* Tell parent */
  984.             write(xpipe[1], &duplex, sizeof(duplex));
  985.             ck_sndmsg();    /* Tell the parent fork */
  986.             continue;
  987.         } else if ((tx == 2) && (duplex)) { /* ECHO change */
  988.             duplex = 0;
  989.             debug(F101,"CONNECT TELNET duplex change","",duplex);
  990.             pipemsg(CEV_DUP);
  991.             write(xpipe[1], &duplex, sizeof(duplex));
  992.             ck_sndmsg();
  993.             continue;
  994.         } else if (tx == 3) { /* Quoted IAC */
  995.             c = parity ? 127 : 255;
  996.         } else continue;    /* Negotiation OK, get next char. */
  997.         } else if (parity)
  998.           c &= 0x7f;
  999.  
  1000. #endif /* TNCODE */
  1001.         if (debses) {        /* Output character to screen */
  1002.         char *s;        /* Debugging display... */
  1003.         s = dbchr(c);
  1004.         while (*s)
  1005.           ckcputc(*s++);
  1006.         } else {            /* Regular display ... */
  1007.         c &= cmask;        /* Apply Kermit-to-remote mask */
  1008. #ifdef CK_APC
  1009. /*
  1010.   Autodownload.  Check for Kermit S packet prior to translation, since that
  1011.   can change the packet and make it unrecognizable (as when the terminal
  1012.   character set is an ISO 646 one)...  Ditto for Zmodem start packet.
  1013. */
  1014.         if (autodl) {        /* Autodownload enabled? */
  1015.             int k;
  1016.             k = kstart((CHAR)c); /* Kermit S or I packet? */
  1017. #ifdef CK_XYZ            
  1018.             if (!k && zmdlok) /* Or an "sz" start? */
  1019.               k = zstart((CHAR)c);
  1020. #endif /* CK_XYZ */
  1021.             if (k) {
  1022.             extern CHAR mystch, seol;
  1023.             CHAR buf[6];
  1024.             int ksign = 0;
  1025.             if (k < 0) { /* Minus-Protocol? */
  1026. #ifdef NOSERVER
  1027.                 goto noserver; /* Need server mode for this */
  1028. #else
  1029.                 ksign = 1; /* Remember */
  1030.                 k = 0 - k; /* Convert to actual protocol */
  1031.                 justone = 1; /* Flag for protocol module */
  1032. #endif /* NOSERVER */
  1033.             } else
  1034.               justone = 0;
  1035.             k--;        /* Adjust [kz]start's return value */
  1036.             if (k == PROTO_K
  1037. #ifdef CK_XYZ
  1038.                 || k == PROTO_Z
  1039. #endif /* CK_XYZ */
  1040.                 ) {
  1041.                 /* Temporarily switch protocol */
  1042.                 sprintf(apcbuf,
  1043.                     "set proto %s, %s, set proto %s",
  1044.                     ptab[k].p_name,
  1045.                     ksign ? "server" : "receive",
  1046.                     ptab[protocol].p_name
  1047.                     );
  1048.                 apclength = strlen(apcbuf);
  1049.                 debug(F110,"autodownload",apcbuf,0);
  1050.                 apcactive = APC_LOCAL;
  1051.                 if (k == PROTO_K) { /* Kermit */
  1052.                 /* Send a NAK to make them resend S pkt */
  1053.                 sprintf((char *)buf,
  1054.                     "%c%s%c",
  1055.                     mystch,
  1056.                     "# N3",
  1057.                     seol
  1058.                     );
  1059.                 ttol(buf,6);
  1060.                 }
  1061.                 ckcputf();    /* Force screen update */
  1062.                 /* Notify parent */
  1063.                 pipemsg(justone ? CEV_AUL : CEV_ADL);
  1064.                 /* Write buffer including trailing NUL byte */
  1065.                 write(xpipe[1],
  1066.                   (char *)&apclength,
  1067.                   sizeof(apclength)
  1068.                   );
  1069.                 write(xpipe[1], apcbuf, apclength+1);
  1070.  
  1071.                 /* Copy our input buffer to the parent fork */
  1072.  
  1073.                 debug(F101,"autodownload complete ibc","",ibc);
  1074.                 debug(F101,"autodownload complete obc","",obc);
  1075.                 write(xpipe[1], (char *)&ibc, sizeof(ibc));
  1076.                 if (ibc > 0) {
  1077.                 write(xpipe[1], (char *)&ibp, sizeof(ibp));
  1078.                 write(xpipe[1], ibp, ibc);
  1079.                 }            
  1080.                 debug(F101,"autodownload justone","",justone);
  1081.                 ck_sndmsg(); /* Wait to be killed */
  1082.                 /* NOTREACHED */
  1083.             }
  1084.             }
  1085.         }
  1086. #ifdef NOSERVER
  1087.           noserver:
  1088. #endif /* NOSERVER */
  1089. #endif /* CK_APC */
  1090.         if (sosi) {        /* Handle SI/SO */
  1091.             if (c == SO) {    /* Shift Out */
  1092.             inshift = 1;
  1093.             continue;
  1094.             } else if (c == SI) { /* Shift In */
  1095.             inshift = 0;
  1096.             continue;
  1097.             }
  1098.             if (inshift) c |= 0200; 
  1099.         }
  1100. #ifndef NOCSETS
  1101.         if (
  1102. #ifndef NOESCSEQ
  1103.             inesc == ES_NORMAL /* If not in an escape sequence */
  1104. #else
  1105.             1
  1106. #endif /* NOESCSEQ */
  1107.             ) {            /* Translate character sets */
  1108.             if (sxi) c = (*sxi)((CHAR)c);
  1109.             if (rxi) c = (*rxi)((CHAR)c);
  1110.         }
  1111. #endif /* NOCSETS */
  1112.  
  1113. #ifndef NOESCSEQ
  1114.         if (escseq)        /* If handling escape sequences */
  1115.           apcrc = chkaes((char)c); /* update our state */
  1116. #ifdef CK_APC
  1117. /*
  1118.   If we are handling APCs, we have several possibilities at this point:
  1119.    1. Ordinary character to be written to the screen.
  1120.    2. An Esc; we can't write it because it might be the beginning of an APC.
  1121.    3. The character following an Esc, in which case we write Esc, then char,
  1122.       but only if we have not just entered an APC sequence.
  1123. */
  1124.         if (escseq && apcstatus != APC_OFF) {
  1125.             if (inesc == ES_GOTESC)    /* Don't write ESC yet */
  1126.               continue;
  1127.             else if (oldesc == ES_GOTESC && !apcactive) {
  1128.             ckcputc(ESC);    /* Write saved ESC */
  1129.             if (seslog) logchar((char)ESC);
  1130.             } else if (apcrc) {    /* We have an APC */
  1131.             debug(F111,"APC complete",apcbuf,apclength);
  1132.             ckcputf();        /* Force screen update */
  1133.             pipemsg(CEV_APC);    /* Notify parent */
  1134.             write(xpipe[1],
  1135.                   (char *)&apclength,
  1136.                   sizeof(apclength)
  1137.                   );
  1138.             /* Write buffer including trailing NUL byte */
  1139.  
  1140.             write(xpipe[1], apcbuf, apclength+1);
  1141.  
  1142.             /* Copy our input buffer to the parent fork */
  1143.  
  1144.             debug(F101,"APC complete ibc","",ibc);
  1145.             debug(F101,"APC complete obc","",obc);
  1146.             write(xpipe[1], (char *)&ibc, sizeof(ibc));
  1147.             if (ibc > 0) {
  1148.                 write(xpipe[1], (char *)&ibp, sizeof(ibp));
  1149.                 write(xpipe[1], ibp, ibc);
  1150.             }            
  1151.             ck_sndmsg();    /* Wait to be killed */
  1152.             /* NOTREACHED */
  1153.             }
  1154.         }
  1155. #endif /* CK_APC */
  1156. #endif /* NOESCSEQ */
  1157.  
  1158.         if (
  1159. #ifdef CK_APC
  1160.             !apcactive        /* Ignore APC sequences */
  1161. #else
  1162.             1
  1163. #endif /* CK_APC */
  1164.             ) {
  1165.             c &= cmdmsk;    /* Apply command mask. */
  1166.             if (c == CR && tt_crd) { /* SET TERM CR-DISPLA CRLF? */
  1167.             ckcputc(c);         /* Yes, output CR */
  1168.             if (seslog) logchar((char)c);
  1169.             c = LF;        /* and insert a linefeed */
  1170.             }
  1171.             ckcputc(c);        /* Write character to screen */
  1172.         }
  1173.         if (seslog) logchar((char)c); /* Handle session log */
  1174.         }
  1175. #ifdef SUNX25
  1176.     }   
  1177. #endif /* SUNX25 */    
  1178.     }
  1179. }
  1180.  
  1181.  
  1182. /*  C O N E C T  --  Interactive terminal connection  */
  1183.  
  1184. int
  1185. conect() {
  1186.     int    n;            /* General purpose counter */
  1187.  
  1188.     int c;            /* c is a character, but must be signed 
  1189.                    integer to pass thru -1, which is the
  1190.                    modem disconnection signal, and is
  1191.                    different from the character 0377 */
  1192.     int c2;            /* A copy of c */
  1193.     int csave;            /* Another copy of c */
  1194. #ifdef SUNX25
  1195.     int i;                /* Worker for X.25 code */
  1196. #endif /* SUNX25 */
  1197. #ifdef NETCONN
  1198.  
  1199. #endif /* NETCONN */
  1200. #ifndef NOESCSEQ
  1201.     int apcrc;
  1202. #endif /* NOESCSEQ */
  1203.  
  1204.     int conret = 0;            /* Return value from conect() */
  1205.     /* jbchksum = -1L; */
  1206.     jbset = 0;                /* jmp_buf not set yet, don't use it */
  1207.  
  1208.     debug(F101,"CONNECT fork signal","",CK_FORK_SIG);
  1209.     signal(CK_FORK_SIG, SIG_IGN);    /* Initial CK_FORK_SIG handling, */
  1210. /*
  1211.   The following ttimoff() call should not be necessary, but evidently there
  1212.   are cases where a timer is left active and then goes off, taking a longjmp
  1213.   to nowhere after the program's stack has changed.  In any case, this is
  1214.   safe because the CONNECT module uses no timer of any kind, and no other timer
  1215.   should be armed while Kermit is in CONNECT mode.
  1216. */
  1217.     ttimoff();                /* Turn off any timer interrupts */
  1218.  
  1219.     if (!local) {
  1220. #ifdef NETCONN
  1221.     printf("Sorry, you must SET LINE or SET HOST first\n");
  1222. #else
  1223.     printf("Sorry, you must SET LINE first\n");
  1224. #endif /* NETCONN */
  1225.     goto conret0;
  1226.     }
  1227.     if (speed < 0L && network == 0 && ttfdflg == 0) {
  1228.     printf("Sorry, you must SET SPEED first\n");
  1229.     goto conret0;
  1230.     }
  1231. #ifdef TCPSOCKET
  1232.     if (network && (nettype != NET_TCPB)
  1233. #ifdef SUNX25
  1234.         && (nettype != NET_SX25)
  1235. #endif /* SUNX25 */
  1236.     ) {
  1237.     printf("Sorry, network type not supported\n");
  1238.     goto conret0;
  1239.     }
  1240. #endif /* TCPSOCKET */
  1241.  
  1242. #ifdef DYNAMIC
  1243.     if (!ibuf) {
  1244.     if (!(ibuf = malloc(IBUFL+1))) { /* Allocate input line buffer */
  1245.         printf("Sorry, CONNECT input buffer can't be allocated\n");
  1246.         goto conret0;
  1247.     } else {
  1248.         ibp = ibuf;
  1249.         ibc = 0;
  1250.     }
  1251.     }
  1252.     if (!obuf) {
  1253.     if (!(obuf = malloc(OBUFL+1))) {    /* Allocate output line buffer */
  1254.         printf("Sorry, CONNECT output buffer can't be allocated\n");
  1255.         goto conret0;
  1256.     } else {
  1257.         obp = obuf;
  1258.         obc = 0;
  1259.     }
  1260.     }
  1261.     if (!kbuf) {
  1262.     if (!(kbuf = malloc(KBUFL+1))) { /* Allocate keyboard input buffer */
  1263.         printf("Sorry, CONNECT keyboard buffer can't be allocated\n");
  1264.         goto conret0;
  1265.     }
  1266.     }
  1267.     if (!temp) {
  1268.     if (!(temp = malloc(TMPLEN+1))) { /* Allocate temporary buffer */
  1269.         printf("Sorry, CONNECT temporary buffer can't be allocated\n");
  1270.         goto conret0;
  1271.     }
  1272.     }
  1273. #else
  1274. #ifdef COMMENT
  1275.     ibp = ibuf;                
  1276.     ibc = 0;
  1277. #endif /* COMMENT */
  1278.     obp = obuf;
  1279.     obc = 0;
  1280. #endif /* DYNAMIC */
  1281.  
  1282.     kbp = kbuf;                /* Always clear these. */
  1283.     *kbp = NUL;                /* No need to preserve them between */
  1284.     kbc = 0;                /* CONNECT sessions. */
  1285.  
  1286. #ifdef DEBUG
  1287.     if (deblog) {
  1288.     debug(F101,"ckucon entry ttyfd","",ttyfd);
  1289.     debug(F101,"ckucon entry ibc","",ibc);
  1290.     debug(F101,"ckucon entry obc","",obc);
  1291.     debug(F101,"ckucon entry kbc","",kbc);
  1292.     if (ttyfd > -1) {
  1293.         n = ttchk();
  1294.         debug(F101,"ckucon entry ttchk","",n);
  1295.     }
  1296.     }    
  1297. #endif /* DEBUG */    
  1298.  
  1299.     if (ttyfd < 0) {            /* If communication device not open */
  1300.     debug(F111,"ckucon opening",ttname,0); /* Open it now */
  1301.     if (ttopen(ttname,
  1302.            &local,
  1303.            network ? -nettype : mdmtyp,
  1304.            0
  1305.            ) < 0) {
  1306.         sprintf(temp,"Sorry, can't open %s",ttname);
  1307.         perror(temp);
  1308.         debug(F110,"ckucon open failure",ttname,0);
  1309.         goto conret0;
  1310.     }
  1311.     }
  1312.     dohangup = 0;            /* Hangup not requested yet */
  1313. #ifdef SUNX25
  1314.     dox25clr = 0;            /* X.25 clear not requested yet */
  1315. #endif /* SUNX25 */
  1316.  
  1317.     if (!quiet
  1318. #ifdef CK_APC
  1319.     && !apcactive
  1320. #endif /* CK_APC */
  1321.     ) {
  1322. #ifdef NETCONN
  1323.     if (network) {
  1324.         printf("Connecting to host %s",ttname);
  1325. #ifdef SUNX25
  1326.         if (nettype == NET_SX25)
  1327.           printf(", Link ID %d, LCN %d",linkid,lcn);
  1328. #endif /* SUNX25 */
  1329.     } else {
  1330. #endif /* NETCONN */
  1331.         printf("Connecting to %s",ttname);
  1332.         if (speed > -1L) printf(", speed %ld",speed);
  1333. #ifdef NETCONN
  1334.     }
  1335. #endif /* NETCONN */
  1336.     if (tt_escape) {
  1337.         printf(".\r\nThe escape character is Ctrl-%c (ASCII %d, %s)\r\n",
  1338.            ctl(escape), escape,
  1339.            (escape == 127 ? "DEL" : ccntab[escape]));
  1340.         printf("Type the escape character followed by C to get back,\r\n");
  1341.         printf("or followed by ? to see other options.\r\n");
  1342.     } else {
  1343.         printf(".\r\n\nESCAPE CHARACTER IS DISABLED\r\n\n");
  1344.     }
  1345.     if (seslog) {
  1346.         printf("(Session logged to %s, ",sesfil);
  1347.         printf("%s)\r\n", sessft ? "binary" : "text");
  1348.     }
  1349.     if (debses) printf("Debugging Display...)\r\n");
  1350.     fflush(stdout);
  1351.     }
  1352.  
  1353. /* Condition console terminal and communication line */        
  1354.  
  1355.     if (conbin((char)escape) < 0) {
  1356.     printf("Sorry, can't condition console terminal\n");
  1357.     goto conret0;
  1358.     }
  1359.     debug(F101,"CONNECT cmask","",cmask);
  1360.     debug(F101,"CONNECT cmdmsk","",cmdmsk);
  1361.     debug(F101,"CONNECT speed before ttvt","",speed);
  1362.     if ((n = ttvt(speed,flow)) < 0) {    /* Enter "virtual terminal" mode */
  1363.     debug(F101,"CONNECT ttvt","",n);
  1364.     tthang();            /* Hang up and close the device. */
  1365.     ttclos(0);
  1366.     if (ttopen(ttname,        /* Open it again... */
  1367.            &local,
  1368.            network ? -nettype : mdmtyp,
  1369.            0
  1370.            ) < 0) {
  1371.         sprintf(temp,"Sorry, can't reopen %s",ttname);
  1372.         perror(temp);
  1373.         goto conret0;
  1374.     }
  1375.     if (ttvt(speed,flow) < 0) {    /* Try virtual terminal mode again. */
  1376.         conres();            /* Failure this time is fatal. */
  1377.         printf("Sorry, Can't condition communication line\n");
  1378.         goto conret0;
  1379.     }
  1380.     }
  1381.     debug(F101,"CONNECT ttvt ok, escape","",escape);
  1382.  
  1383. #ifndef NOCSETS
  1384. /* Set up character set translations */
  1385.  
  1386.     tcs = gettcs(tcsr,tcsl);        /* Get intermediate set. */
  1387.  
  1388.     if (tcsr == tcsl) {            /* Remote and local sets the same? */
  1389.     sxo = rxo = NULL;        /* If so, no translation. */
  1390.     sxi = rxi = NULL;
  1391.     } else {                /* Otherwise, set up */
  1392.     sxo = xls[tcs][tcsl];        /* translation function */
  1393.     rxo = xlr[tcs][tcsr];        /* pointers for output functions */
  1394.     sxi = xls[tcs][tcsr];        /* and for input functions. */
  1395.     rxi = xlr[tcs][tcsl];
  1396.     }
  1397. /*
  1398.   This is to prevent use of zmstuff() and zdstuff() by translation functions.
  1399.   They only work with disk i/o, not with communication i/o.  Luckily Russian
  1400.   translation functions don't do any stuffing...
  1401. */
  1402.     langsv = language;
  1403. #ifndef NOCYRIL
  1404.     if (language != L_RUSSIAN)
  1405. #endif /* NOCYRIL */
  1406.       language = L_USASCII;
  1407.  
  1408. #ifdef COMMENT
  1409. #ifdef DEBUG
  1410.     if (deblog) {
  1411.     debug(F101,"tcs","",tcs);
  1412.     debug(F101,"tcsl","",tcsl);
  1413.     debug(F101,"tcsr","",tcsr);
  1414.     debug(F101,"fcsinfo[tcsl].size","",fcsinfo[tcsl].size);
  1415.     debug(F101,"fcsinfo[tcsr].size","",fcsinfo[tcsr].size);
  1416.     }
  1417. #endif /* DEBUG */
  1418. #endif /* COMMENT */
  1419.  
  1420. #ifdef CK_XYZ
  1421. #ifndef XYZ_INTERNAL
  1422.     {
  1423.     extern int binary;        /* See about ZMODEM autodownloads */
  1424.     char * s;
  1425.     s = binary ? ptab[PROTO_Z].p_b_rcmd : ptab[PROTO_Z].p_t_rcmd;
  1426.     if (!s) s = "";
  1427.     zmdlok = (*s != NUL);        /* OK if we have external commands */
  1428.     }
  1429. #endif /* XYZ_INTERNAL */
  1430. #endif /* CK_XYZ */
  1431.  
  1432. #ifndef NOESCSEQ
  1433. /*
  1434.   We need to activate the escape-sequence recognition feature when:
  1435.    (a) translation is elected, AND
  1436.    (b) the local and/or remote set is a 7-bit set other than US ASCII.
  1437.  Or:
  1438.    SET TERMINAL APC is not OFF (handled in the next statement).
  1439. */
  1440.     escseq = (tcs != TC_TRANSP) &&    /* Not transparent */
  1441.       (fcsinfo[tcsl].size == 128 || fcsinfo[tcsr].size == 128) && /* 7 bits */
  1442.     (fcsinfo[tcsl].code != FC_USASCII); /* But not ASCII */
  1443. #endif /* NOESCSEQ */
  1444. #endif /* NOCSETS */
  1445.  
  1446. #ifndef NOESCSEQ
  1447. #ifdef CK_APC
  1448.     escseq = escseq || (apcstatus != APC_OFF);
  1449.     apcactive = 0;            /* An APC command is not active */
  1450.     apclength = 0;            /* ... */
  1451. #endif /* CK_APC */
  1452.     inesc = ES_NORMAL;            /* Initial state of recognizer */
  1453.     debug(F101,"escseq","",escseq);
  1454. #endif /* NOESCSEQ */
  1455.  
  1456. /*
  1457.   This is a label we jump back to when the lower fork sensed the need
  1458.   to change modes.  As of 5A(178), this is used only by X.25 code
  1459.   (perhaps unnecessarily? -- The X.25 code needs a lot of testing and
  1460.   cleaning up...)  As of 5A(190), it is not used at all, good.
  1461. */
  1462. #ifdef COMMENT
  1463. newfork:
  1464.     debug(F100,"CONNECT newfork","",0);
  1465. #endif /* COMMENT */
  1466.  
  1467.     parent_id = getpid();        /* Get parent's pid for signalling */
  1468.     debug(F101,"CONNECT parent pid","",parent_id);
  1469.  
  1470.     if (xpipe[0] > -1)            /* If old pipe hanging around, close */
  1471.       close(xpipe[0]);
  1472.     xpipe[0] = -1;
  1473.     if (xpipe[1] > -1)
  1474.       close(xpipe[1]);
  1475.     xpipe[1] = -1;
  1476.     goterr = 0;                /* Error flag for pipe & fork */
  1477.     if (pipe(xpipe) != 0) {        /* Create new pipe to pass info */
  1478.     perror("Can't make pipe");    /* between forks. */
  1479.     debug(F101,"CONNECT pipe error","",errno);
  1480.     goterr = 1;
  1481.     } else
  1482. #ifdef BEBOX
  1483.     {
  1484.         pid = spawn_thread(concld, "Lower Fork", B_NORMAL_PRIORITY, NULL);
  1485.         resume_thread(pid);
  1486.     }
  1487. #else
  1488.     if ((pid = fork()) == (PID_T) -1) { /* Pipe OK, make port fork. */
  1489.     perror("Can't make port fork");
  1490.     debug(F101,"CONNECT fork error","",errno);
  1491.     goterr = 1;    
  1492.     }
  1493. #endif /* BEBOX */
  1494.     if (goterr) {            /* Failed to make pipe or fork */
  1495.     conres();            /* Reset the console. */
  1496.     if (!quiet) {
  1497.         printf("\r\nCommunications disconnect (Back at %s)\r\n",
  1498.            *myhost ?
  1499.            myhost :
  1500. #ifdef UNIX
  1501.            "local UNIX system"
  1502. #else
  1503.            "local system"
  1504. #endif /* UNIX */
  1505.            );
  1506.     }
  1507.     printf("\n");
  1508.     what = W_NOTHING;        /* So console modes are set right. */
  1509. #ifndef NOCSETS
  1510.     language = langsv;        /* Restore language */
  1511. #endif /* NOCSETS */
  1512.     parent_id = (PID_T) 0;        /* Clean up */
  1513.     goto conret1;
  1514.     }
  1515.     debug(F101,"CONNECT fork pid","",pid);
  1516.  
  1517. /* Upper fork (KEYB fork) reads keystrokes and sends them out. */
  1518.  
  1519.     if (pid) {                /* pid != 0, so I am the upper fork. */
  1520. /*
  1521.   Before doing anything significant, the child fork must wait for a go-ahead
  1522.   character from xpipe[0].  Before starting to wait, we have enough time to
  1523.   clear buffers and set up the signal handler.  When done with this, we will
  1524.   allow the child to continue by satisfying its pending read.
  1525.  
  1526.   Remember the child and parent have separate address space.  The child has
  1527.   its own copy of input buffers, so we must clear the input buffers in the
  1528.   parent.  Otherwise strange effects may occur, like chunks of characters
  1529.   repeatedly echoed on terminal screen.  The child process is designed to
  1530.   empty its input buffers by reading all available characters and either
  1531.   echoing them on the terminal screen or saving them for future use in the
  1532.   parent.  The latter case happens during APC processing - see the code around
  1533.   CEV_APC occurrences to see how the child passes its ibuf etc to parent via
  1534.   xpipe, for preservation until the next entry to this module, to ensure that
  1535.   no characters are lost between CONNECT sessions.
  1536. */
  1537.  
  1538. /*
  1539.   This one needs a bit of extra explanation...  In addition to the CONNECT
  1540.   module's own buffers, which are communicated and synchronized via xpipe,
  1541.   the low-level UNIX communication routines (ttinc, ttxin, etc) are also
  1542.   buffered, statically, in the ckutio.c module.  But when the two CONNECT
  1543.   forks split off, the lower fork is updating this buffer's pointers and
  1544.   counts, but the upper fork never finds out about it and still has the old
  1545.   ones.  The following UNIX-specific call to the ckutio.c module takes care
  1546.   of this...  Without it, we get dual echoing of incoming characters.
  1547. */
  1548.     ttflux();
  1549. /*
  1550.   At this point, perhaps you are wondering why we use forks at all.  It is
  1551.   simply because there is no other method portable among all UNIX variations.
  1552.   Not threads, not select(), ...
  1553. */
  1554.     ibp = ibuf;            /* Clear ibuf[]. */
  1555.     ibc = 0;            /* Child now has its own copy */
  1556.     signal(CK_FORK_SIG, pipeint);    /* Handler for messages from child. */
  1557.     write(xpipe[1], ibuf, 1);    /* Allow child to proceed */
  1558.     close(xpipe[1]); xpipe[1] = -1; /* Parent - prevent future writes */
  1559.  
  1560.     what = W_CONNECT;        /* Keep track of what we're doing */
  1561.     active = 1;
  1562.     debug(F101,"CONNECT keyboard fork duplex","",duplex);
  1563. /*
  1564.   Catch communication errors or mode changes in lower fork.
  1565.  
  1566.   Note: Some C compilers (e.g. Cray UNICOS) interpret the ANSI C standard
  1567.   about setjmp() in a way that disallows constructions like:
  1568.  
  1569.         if ((var = [sig]setjmp(env)) == 0) ...
  1570.  
  1571.   which prevents the value returned by cklongjmp() from being used at all.
  1572.   So the signal handlers set a global variable, sjval, instead.
  1573. */
  1574.     if (
  1575. #ifdef CK_POSIX_SIG
  1576.         sigsetjmp(con_env,1)
  1577. #else
  1578.         setjmp(con_env)
  1579. #endif /* CK_POSIX_SIG */
  1580.         == 0) {            /* Normal entry... */
  1581.         jbset = 1;            /* Now we have a longjmp buffer */
  1582.         sjval = CEV_NO;        /* Initialize setjmp return code. */
  1583.  
  1584.         debug(F101,"CONNECT setjmp normal entry","",sjval);
  1585.  
  1586. #ifdef SUNX25
  1587.         if (network && nettype == NET_SX25) {
  1588.         obufl = 0;
  1589.         bzero (x25obuf,sizeof(x25obuf));
  1590.         }
  1591. #endif /* SUNX25 */
  1592. /*
  1593.   Here is the big loop that gets characters from the keyboard and sends them
  1594.   out the communication device.  There are two components to the communication
  1595.   path: the connection from the keyboard to C-Kermit, and from C-Kermit to
  1596.   the remote computer.  The treatment of the 8th bit of keyboard characters 
  1597.   is governed by SET COMMAND BYTESIZE (cmdmsk).  The treatment of the 8th bit
  1598.   of characters sent to the remote is governed by SET TERMINAL BYTESIZE
  1599.   (cmask).   This distinction was introduced in edit 5A(164).
  1600. */
  1601.         while (active) {
  1602. #ifndef NOSETKEY
  1603.         if (kmptr) {        /* Have current macro? */
  1604.             debug(F100,"kmptr non NULL","",0);
  1605.             if ((c = (CHAR) *kmptr++) == NUL) { /* Get char from it */
  1606.             kmptr = NULL;    /* If no more chars,  */
  1607.             debug(F100,"macro empty, continuing","",0);
  1608.             continue;    /* reset pointer and continue */
  1609.             }
  1610.             debug(F000,"char from macro","",c);
  1611.         } else            /* No macro... */
  1612. #endif /* NOSETKEY */
  1613.           c = CONGKS();        /* Read from keyboard */
  1614.  
  1615.         debug(F101,"** KEYB","",c);
  1616.  
  1617.                 if (c == -1) {        /* If read() got an error... */
  1618.             debug(F101,"CONNECT keyboard read errno","",errno);
  1619. #ifdef COMMENT
  1620. /*
  1621.  This seems to cause problems.  If read() returns -1, the signal has already
  1622.  been delivered, and nothing will wake up the pause().
  1623. */
  1624.             pause();        /* Wait for transmitter to finish. */
  1625. #else
  1626. #ifdef A986
  1627. /*
  1628.   On Altos machines with Xenix 3.0, pressing DEL in connect mode brings us
  1629.   here (reason unknown).  The console line discipline at this point has
  1630.   intr = ^C.  The communications tty has intr = DEL but we get here after
  1631.   pressing DEL on the keyboard, even when the remote system has been set not
  1632.   to echo.  With A986 defined, we stay in the read loop and beep only if the
  1633.   offending character is not DEL.
  1634. */
  1635.             if ((c & 127) != 127) conoc(BEL);
  1636. #else
  1637. #ifdef EINTR
  1638. /*
  1639.    This can be caused by the other fork signalling this one about 
  1640.    an echoing change during TELNET negotiations.
  1641. */
  1642.             if (errno == EINTR)
  1643.               continue;
  1644. #endif /* EINTR */
  1645.             conoc(BEL);        /* Otherwise, beep */
  1646.             active = 0;        /* and terminate the read loop */
  1647.             continue;
  1648. #endif /* A986 */
  1649. #endif /* COMMENT */
  1650.         }
  1651.         c &= cmdmsk;        /* Do any requested masking */
  1652. #ifndef NOSETKEY
  1653. /*
  1654.   Note: kmptr is NULL if we got character c from the keyboard, and it is
  1655.   not NULL if it came from a macro.  In the latter case, we must avoid
  1656.   expanding it again.
  1657. */
  1658.         if (!kmptr && macrotab[c]) { /* Macro definition for c? */
  1659.             kmptr = macrotab[c];     /* Yes, set up macro pointer */
  1660.             continue;             /* and restart the loop, */
  1661.         } else c = keymap[c];         /* else use single-char keymap */
  1662. #endif /* NOSETKEY */
  1663.         if (
  1664. #ifndef NOSETKEY
  1665.             !kmptr &&
  1666. #endif /* NOSETKEY */
  1667.             (tt_escape && (c & 0x7f) == escape)) { /* Escape char? */
  1668.             debug(F000,"CONNECT got escape","",c);
  1669.             c = CONGKS() & 0177; /* Got esc, get its arg */
  1670.             /* No key mapping here */
  1671.             doesc((char) c);    /* Now process it */
  1672.  
  1673.         } else {        /* It's not the escape character */
  1674.             csave = c;        /* Save it before translation */
  1675.                     /* for local echoing. */
  1676. #ifndef NOCSETS
  1677. #ifdef NOESCSEQ
  1678.             /* Translate character sets */
  1679.             if (sxo) c = (*sxo)(c); /* From local to intermediate. */
  1680.             if (rxo) c = (*rxo)(c); /* From intermediate to remote. */
  1681. #else
  1682.             if (inesc == ES_NORMAL) { /* If not inside escape seq.. */
  1683.             /* Translate character sets */
  1684.             if (sxo) c = (*sxo)((char)c); /* Local-intermediate */
  1685.             if (rxo) c = (*rxo)((char)c); /* Intermediate-remote */
  1686.             }
  1687.             if (escseq) apcrc = chkaes((char)c);
  1688. #endif /* NOESCSEQ */
  1689. #endif /* NOCSETS */
  1690. /*
  1691.  If Shift-In/Shift-Out is selected and we have a 7-bit connection,
  1692.  handle shifting here.
  1693. */
  1694.             if (sosi) {             /* Shift-In/Out selected? */
  1695.             if (cmask == 0177) { /* In 7-bit environment? */
  1696.                 if (c & 0200) {          /* 8-bit character? */
  1697.                 if (outshift == 0) { /* If not shifted, */
  1698.                     ttoc(dopar(SO)); /* shift. */
  1699.                     outshift = 1;
  1700.                 }
  1701.                 } else {
  1702.                 if (outshift == 1) { /* 7-bit character */
  1703.                     ttoc(dopar(SI)); /* If shifted, */
  1704.                     outshift = 0;    /* unshift. */
  1705.                 }
  1706.                 }
  1707.             }
  1708.             if (c == SO) outshift = 1;   /* User typed SO */
  1709.             if (c == SI) outshift = 0;   /* User typed SI */
  1710.             }
  1711.             c &= cmask;        /* Apply Kermit-to-host mask now. */
  1712. #ifdef SUNX25
  1713.                     if (network && nettype == NET_SX25) {
  1714.                         if (padparms[PAD_ECHO]) {
  1715.                             if (debses)
  1716.                   conol(dbchr(c)) ;
  1717.                             else
  1718.                   if ((c != padparms[PAD_CHAR_DELETE_CHAR])   &&
  1719.                   (c != padparms[PAD_BUFFER_DELETE_CHAR]) &&
  1720.                   (c != padparms[PAD_BUFFER_DISPLAY_CHAR]))
  1721.                                 conoc(c) ;
  1722.                             if (seslog) logchar(c);
  1723.                         }
  1724.             if (c == CR && (padparms[PAD_LF_AFTER_CR] == 4 ||
  1725.                     padparms[PAD_LF_AFTER_CR] == 5)) {
  1726.                             if (debses)
  1727.                   conol(dbchr(LF)) ;
  1728.                             else
  1729.                   conoc(LF) ;
  1730.                             if (seslog) logchar(LF);
  1731.                         }
  1732.                         if (c == padparms[PAD_BREAK_CHARACTER])
  1733.               breakact();
  1734.                         else if (padparms[PAD_DATA_FORWARD_TIMEOUT]) {
  1735.                             tosend = 1;
  1736.                             x25obuf [obufl++] = c;
  1737.                         } else if (((c == padparms[PAD_CHAR_DELETE_CHAR])  ||
  1738.                     (c == padparms[PAD_BUFFER_DELETE_CHAR]) ||
  1739.                     (c == padparms[PAD_BUFFER_DISPLAY_CHAR])) 
  1740.                    && (padparms[PAD_EDITING]))
  1741.               if (c == padparms[PAD_CHAR_DELETE_CHAR])
  1742.                 if (obufl > 0) {
  1743.                 conol("\b \b"); obufl--;
  1744.                 } else {}
  1745.               else if (c == padparms[PAD_BUFFER_DELETE_CHAR]) {
  1746.                   conol ("\r\nPAD Buffer Deleted\r\n");
  1747.                   obufl = 0;
  1748.               }
  1749.               else if (c == padparms[PAD_BUFFER_DISPLAY_CHAR]) {
  1750.                   conol("\r\n");
  1751.                   conol(x25obuf);
  1752.                   conol("\r\n");
  1753.               } else {} 
  1754.                         else {
  1755.                             x25obuf [obufl++] = c;
  1756.                             if (obufl == MAXOX25) tosend = 1;
  1757.                             else if (c == CR) tosend = 1;
  1758.                         }
  1759.                         if (tosend) 
  1760.               if (ttol((CHAR *)x25obuf,obufl) < 0) {
  1761.                   perror ("\r\nCan't send characters");
  1762.                   active = 0;
  1763.               } else {
  1764.                   bzero (x25obuf,sizeof(x25obuf));
  1765.                   obufl = 0;
  1766.                   tosend = 0;
  1767.               } else {};
  1768.                     } else {
  1769. #endif /* SUNX25 */ 
  1770.             if (c == '\015') {        /* Carriage Return */
  1771.             int stuff = -1;
  1772.             if (tnlm) {        /* TERMINAL NEWLINE ON */
  1773.                 stuff = LF;     /* Stuff LF */
  1774. #ifdef TNCODE
  1775.             } else if (network &&    /* TELNET NEWLINE ON/OFF/RAW */
  1776.                    (ttnproto == NP_TELNET)) {
  1777.                 switch (!me_binary ? tn_nlm : tn_b_nlm) {
  1778.                 case TNL_CRLF:
  1779.                 stuff = LF;
  1780.                 break;
  1781.                 case TNL_CRNUL:
  1782.                 stuff = NUL;
  1783.                 break;
  1784.                 }
  1785. #endif /* TNCODE */
  1786.             }
  1787.             if (stuff > -1) {
  1788.                 ttoc(dopar('\015'));    /* Send CR */
  1789.                 if (duplex) conoc('\015');    /* Maybe echo CR */
  1790.                 c = stuff;            /* Char to stuff */
  1791.                 csave = c;
  1792.             }
  1793.             }
  1794. #ifdef TNCODE
  1795. /* If user types the 0xff character (TELNET IAC), it must be doubled. */
  1796.             else        /* Not CR */
  1797.               if ((dopar((CHAR) c) == IAC) && /* IAC (0xff) */
  1798.               network && (ttnproto == NP_TELNET)) {
  1799.                     /* Send one copy now */
  1800.             ttoc((char)IAC); /* and the other one just below. */
  1801.             }
  1802. #endif /* TNCODE */
  1803.             /* Send the character */
  1804.  
  1805.             if (ttoc((char)dopar((CHAR) c)) > -1) {
  1806.                 if (duplex) {    /* If half duplex, must echo */
  1807.                 if (debses)
  1808.                   conol(dbchr(csave)); /* the original char */
  1809.                 else               /* not the translated one */
  1810.                   conoc((char)csave);
  1811.                 if (seslog) { /* And maybe log it too */
  1812.                 c2 = csave;
  1813.                 if (sessft == 0 && csave == '\r')
  1814.                   c2 = '\n';
  1815.                 logchar((char)c2);
  1816.                 }
  1817.             }
  1818.                     } else {
  1819.             perror("\r\nCan't send character");
  1820.             active = 0;
  1821.             }
  1822. #ifdef SUNX25
  1823.         } 
  1824. #endif /* SUNX25 */
  1825.         }
  1826.         }
  1827.  
  1828.         /* now active == 0 */
  1829.             signal(CK_FORK_SIG, SIG_IGN); /* Turn off CK_FORK_SIG */
  1830.         sjval = CEV_NO;        /* Set to hangup */
  1831.     }                /* Come here on termination of child */
  1832.  
  1833. /* cklongjmp() executed in pipeint() (parent only!) comes here */
  1834.  
  1835. /*
  1836.   Now the child fork is gone or is waiting for CK_FORK_SIG in ck_sndmsg().
  1837.   So we can't get (in the parent) any subsequent CK_FORK_SIG signals until
  1838.   we signal the child with CK_FORK_SIG.
  1839. */
  1840.     debug(F100,"CONNECT signaling port fork","",0);
  1841.     signal(CK_FORK_SIG, SIG_IGN);    /* Turn this off */
  1842.     debug(F100,"CONNECT killing port fork","",0);
  1843. #ifdef BEBOX
  1844.     {
  1845.         long ret_val;
  1846.         if (pid) kill(pid,SIGKILLTHR); /* Kill lower fork */
  1847.         wait_for_thread (pid, &ret_val);
  1848.     }
  1849. #else
  1850. #ifdef Plan9
  1851.     if (pid) kill(pid,SIGKILL);    /* Kill lower fork */
  1852. #else
  1853.     if (pid) kill(pid,9);        /* Kill lower fork */
  1854. #endif /* Plan9 */
  1855. #endif /* BEBOX */
  1856.     debug(F100,"CONNECT killed port fork","",0);
  1857.     pid = -1;
  1858.     wait((WAIT_T *)0);        /* Wait till gone. */
  1859.     
  1860.     if (sjval == CEV_HUP) {        /* Read error on comm device */
  1861.         dohangup = 1;        /* so we want to hang up our side */
  1862. #ifdef NETCONN
  1863.         if (network) {        /* and/or close network connection */
  1864.         ttclos(0);
  1865. #ifdef SUNX25
  1866.         if (nettype == NET_SX25) /* If X.25, restore the PAD params */
  1867.           initpad();
  1868. #endif /* SUNX25 */
  1869.         }
  1870. #endif /* NETCONN */
  1871.     }
  1872. #ifdef SUNX25
  1873. #ifdef COMMENT
  1874.     /* Not used, should not be needed -- see pipeint()... */
  1875.     if (sjval == CEV_PAD)        /* If it was a mode change, go back */
  1876.       goto newfork;            /* and coordinate with other fork. */
  1877. #endif /* COMMENT */
  1878. #endif /* SUNX25 */
  1879.  
  1880. #ifdef CK_APC
  1881.     if (sjval == CEV_APC) {        /* Application Program Command rec'd */
  1882.         apcactive = 1;        /* Flag APC as active */
  1883.         active = 0;            /* Flag CONNECT as inactive */
  1884.     }
  1885. #endif /* CK_APC */
  1886.     conres();            /* Reset the console. */
  1887.     if (dohangup > 0) {        /* If hangup requested, do that. */
  1888. #ifndef NODIAL
  1889.         if (dohangup > 1)        /* User asked for it */
  1890.           if (mdmhup() < 1)        /* Maybe hang up via modem */
  1891. #endif /* NODIAL */
  1892.         tthang();        /* And make sure we don't hang up */
  1893.         dohangup = 0;        /* again unless requested again. */
  1894.     }
  1895.  
  1896. #ifdef COMMENT
  1897. #ifdef NETCONN
  1898. #ifdef SIGPIPE
  1899.     if (network && sigpiph)        /* Restore previous SIGPIPE handler */
  1900.       (VOID) signal(SIGPIPE, sigpiph);
  1901. #endif /* SIGPIPE */
  1902. #endif /* NETCONN */
  1903. #endif /* COMMENT */
  1904.  
  1905. #ifdef SUNX25
  1906.     if (dox25clr) {            /* If X.25 Clear requested */
  1907.         x25clear();            /* do that. */
  1908.         initpad();
  1909.         dox25clr = 0;        /* But only once. */
  1910.     }
  1911. #endif /* SUNX25 */
  1912.  
  1913.     if (quitnow) doexit(GOOD_EXIT,xitsta); /* Exit now if requested. */
  1914.       if (!quiet
  1915. #ifdef CK_APC
  1916.         && !apcactive
  1917. #endif /* CK_APC */
  1918.         )
  1919.       printf("(Back at %s)", *myhost ? myhost : "local UNIX system");
  1920. #ifdef CK_APC
  1921.         if (!apcactive)
  1922. #endif /* CK_APC */
  1923.       printf("\n");
  1924.     what = W_NOTHING;        /* So console modes set right. */
  1925. #ifndef NOCSETS
  1926.     language = langsv;        /* Restore language */
  1927. #endif /* NOCSETS */
  1928.     parent_id = (PID_T) 0;
  1929.     goto conret1;
  1930.  
  1931.     }
  1932. #ifndef BEBOX
  1933.     else {    /* *** */        /* Inferior reads, prints port input */
  1934.         concld(/* (void *)&pid */);
  1935.     }
  1936. #endif /* BEBOX */
  1937.  
  1938. conret1:
  1939.     conret = 1;
  1940. conret0:
  1941.     signal(CK_FORK_SIG, SIG_IGN);    /* In case this wasn't done already */
  1942.     debug(F101,"ckucon exit ibc","",ibc);
  1943.     debug(F101,"ckucon exit obc","",obc);
  1944.     close(xpipe[0]); xpipe[0] = -1;    /* Close the pipe */
  1945.     close(xpipe[1]); xpipe[1] = -1;
  1946.     return(conret);
  1947. }
  1948.  
  1949.  
  1950. /*  H C O N N E  --  Give help message for connect.  */
  1951.  
  1952. int
  1953. hconne() {
  1954.     int c;
  1955.     static char *hlpmsg[] = {
  1956. "\r\n  ? for this message",
  1957. "\r\n  0 (zero) to send a null",
  1958. "\r\n  B to send a BREAK",
  1959. #ifdef CK_LBRK
  1960. "\r\n  L to send a Long BREAK",
  1961. #endif /* CK_LBRK */
  1962. #ifdef NETCONN
  1963. "\r\n  I to send a network interrupt packet",
  1964. #ifdef TCPSOCKET
  1965. "\r\n  A to send Are You There?",
  1966. #endif /* TCPSOCKET */
  1967. #ifdef SUNX25
  1968. "\r\n  R to reset X.25 virtual circuit",
  1969. #endif /* SUNX25 */
  1970. #endif /* NETCONN */
  1971. "\r\n  U to hangup and close the connection",
  1972. "\r\n  Q to hangup and quit Kermit",
  1973. "\r\n  S for status",
  1974. #ifdef NOPUSH
  1975. "\r\n  ! to push to local shell (disabled)",
  1976. "\r\n  Z to suspend (disabled)",
  1977. #else
  1978. "\r\n  ! to push to local shell",
  1979. #ifdef NOJC
  1980. "\r\n  Z to suspend (disabled)",
  1981. #else
  1982. "\r\n  Z to suspend",
  1983. #endif /* NOJC */
  1984. #endif /* NOPUSH */
  1985. "\r\n  \\ backslash code:",
  1986. "\r\n    \\nnn  decimal character code",
  1987. "\r\n    \\Onnn octal character code",
  1988. "\r\n    \\Xhh  hexadecimal character code",
  1989. "\r\n    terminate with carriage return.",
  1990. "\r\n Type the escape character again to send the escape character, or",
  1991. "\r\n press the space-bar to resume the CONNECT command.\r\n\r\n",
  1992. "" };
  1993.     conol("\r\nPress C to return to ");
  1994.     conol(*myhost ? myhost : "the C-Kermit prompt");
  1995.     conol(", or:");
  1996.     conola(hlpmsg);            /* Print the help message. */
  1997.     conol("Command>");            /* Prompt for command. */
  1998.     c = CONGKS() & 0177;        /* Get character, strip any parity. */
  1999.     /* No key mapping or translation here */
  2000.     if (c != CMDQ)
  2001.       conoll(""); 
  2002.    return(c);                /* Return it. */
  2003. }
  2004.  
  2005.  
  2006. /*  D O E S C  --  Process an escape character argument  */
  2007.  
  2008. VOID
  2009. #ifdef CK_ANSIC
  2010. doesc(char c)
  2011. #else
  2012. doesc(c) char c;
  2013. #endif /* CK_ANSIC */
  2014. /* doesc */ {
  2015.     CHAR d;
  2016.   
  2017.     debug(F101,"doesc","",c);
  2018.     while (1) {
  2019.     if (c == escape) {        /* Send escape character */
  2020.         d = dopar((CHAR) c); ttoc((char) d); return;
  2021.         } else                /* Or else look it up below. */
  2022.         if (isupper(c)) c = tolower(c);
  2023.  
  2024.     switch(c) {
  2025.  
  2026.     case 'c':            /* Escape back to prompt */
  2027.     case '\03':
  2028.         active = 0; conol("\r\n"); return;
  2029.  
  2030.     case 'b':            /* Send a BREAK signal */
  2031.     case '\02':
  2032.         ttsndb(); return;
  2033.  
  2034. #ifdef NETCONN
  2035.     case 'i':            /* Send Interrupt */
  2036.     case '\011':
  2037. #ifdef TCPSOCKET
  2038. #ifndef IP
  2039. #define IP 244
  2040. #endif /* IP */
  2041.         if (network && ttnproto == NP_TELNET) { /* TELNET */
  2042.         temp[0] = (CHAR) IAC;    /* I Am a Command */
  2043.         temp[1] = (CHAR) IP;    /* Interrupt Process */
  2044.         temp[2] = NUL;
  2045.         ttol((CHAR *)temp,2);
  2046.         } else 
  2047. #endif /* TCPSOCKET */
  2048. #ifdef SUNX25
  2049.             if (network && (nettype == NET_SX25)) { /* X.25 */
  2050.         (VOID) x25intr(0);                /* X.25 interrupt packet */
  2051.         conol("\r\n");
  2052.         } else
  2053. #endif /* SUNX25 */
  2054.           conoc(BEL);
  2055.         return;
  2056.  
  2057. #ifdef TCPSOCKET
  2058.     case 'a':            /* "Are You There?" */
  2059.     case '\01':
  2060. #ifndef AYT
  2061. #define AYT 246
  2062. #endif /* AYT */
  2063.         if (network && ttnproto == NP_TELNET) {
  2064.         temp[0] = (CHAR) IAC;    /* I Am a Command */
  2065.         temp[1] = (CHAR) AYT;    /* Are You There? */
  2066.         temp[2] = NUL;
  2067.         ttol((CHAR *)temp,2);
  2068.         } else conoc(BEL);
  2069.         return;
  2070. #endif /* TCPSOCKET */
  2071. #endif /* NETCONN */
  2072.  
  2073. #ifdef CK_LBRK
  2074.     case 'l':            /* Send a Long BREAK signal */
  2075.         ttsndlb(); return;
  2076. #endif /* CK_LBRK */
  2077.  
  2078.     case 'u':            /* Hangup */
  2079.      /*    case '\010': */            /* No, too dangerous */
  2080. #ifdef SUNX25
  2081.             if (network && (nettype == NET_SX25)) dox25clr = 1;
  2082.             else
  2083. #endif /* SUNX25 */
  2084.         dohangup = 2; active = 0; conol("\r\nHanging up "); return;
  2085.  
  2086. #ifdef SUNX25
  2087.         case 'r':                       /* Reset the X.25 virtual circuit */
  2088.         case '\022':
  2089.             if (network && (nettype == NET_SX25)) (VOID) x25reset(0,0);
  2090.             conol("\r\n"); return;
  2091. #endif /* SUNX25 */
  2092.  
  2093.     case 'q':            /* Quit */
  2094.         dohangup = 2; quitnow = 1; active = 0; conol("\r\n"); return;
  2095.  
  2096.     case 's':            /* Status */
  2097.         sprintf(temp,
  2098.             "\r\nConnected %s %s", network ? "to" : "through", ttname);
  2099.         conol(temp);
  2100. #ifdef SUNX25
  2101.             if (network && (nettype == NET_SX25)) {
  2102.                 sprintf(temp,", Link ID %d, LCN %d",linkid,lcn); conol(temp);
  2103.         }
  2104. #endif /* SUNX25 */
  2105.         if (speed >= 0L) {
  2106.         sprintf(temp,", speed %ld", speed);
  2107.         conoll(temp);
  2108.         } else conoll("");
  2109.         sprintf(temp,
  2110.             "Terminal bytesize: %d, Command bytesize: %d, Parity: ",
  2111.             (cmask  == 0177) ? 7 : 8,
  2112.             (cmdmsk == 0177) ? 7 : 8 );
  2113.         conol(temp);
  2114.  
  2115.         switch (parity) {
  2116.           case  0:  conoll("none");  break;
  2117.           case 'e': conoll("even");  break;
  2118.           case 'o': conoll("odd");   break;
  2119.           case 's': conoll("space"); break;
  2120.           case 'm': conoll("mark");  break;
  2121.         }
  2122.         sprintf(temp,"Terminal echo: %s", duplex ? "local" : "remote");
  2123.         conoll(temp);
  2124.         if (seslog) {
  2125.         conol("Logging to: "); conoll(sesfil);
  2126.             }
  2127.         if (!network) shomdm();
  2128.         return;
  2129.  
  2130.     case 'h':            /* Help */
  2131.     case '?':            /* Help */
  2132.         c = hconne(); continue;
  2133.  
  2134.     case '0':            /* Send a null */
  2135.         c = '\0'; d = dopar((CHAR) c); ttoc((char) d); return;
  2136.  
  2137.     case 'z': case '\032':        /* Suspend */
  2138. #ifndef NOPUSH
  2139.         if (!nopush)
  2140.           stptrap(0);
  2141.         else
  2142.           conoc(BEL);
  2143. #else
  2144.         conoc(BEL);
  2145. #endif /* NOPUSH */
  2146.         return;
  2147.  
  2148.     case '@':            /* Start inferior command processor */
  2149.     case '!':
  2150. #ifndef NOPUSH
  2151.         if (!nopush) {
  2152.         conres();              /* Put console back to normal */
  2153.         zshcmd("");              /* Fork a shell. */
  2154.         if (conbin((char)escape) < 0) {
  2155.             printf("Error resuming CONNECT session\n");
  2156.             active = 0;
  2157.         }
  2158.         } else conoc(BEL);
  2159. #else
  2160.         conoc(BEL);
  2161. #endif /* NOPUSH */
  2162.         return;
  2163.  
  2164.     case SP:            /* Space, ignore */
  2165.         return;
  2166.  
  2167.     default:            /* Other */
  2168.         if (c == CMDQ) {        /* Backslash escape */
  2169.         int x;
  2170.         ecbp = ecbuf;
  2171.         *ecbp++ = c;
  2172.         while (((c = (CONGKS() & cmdmsk)) != '\r') && (c != '\n'))
  2173.           *ecbp++ = c;
  2174.         *ecbp = NUL; ecbp = ecbuf;
  2175.         x = xxesc(&ecbp);    /* Interpret it */
  2176.         if (x >= 0) {        /* No key mapping here */
  2177.             c = dopar((CHAR) x);
  2178.             ttoc((char) c);
  2179.             return;
  2180.         } else {        /* Invalid backslash code. */
  2181.             conoc(BEL);
  2182.             return;
  2183.         }
  2184.         }
  2185.         conoc(BEL); return;     /* Invalid esc arg, beep */
  2186.         }
  2187.     }
  2188. }
  2189.  
  2190. static
  2191. VOID
  2192. #ifdef CK_ANSIC
  2193. logchar(char c)
  2194. #else
  2195. logchar(c) char c;
  2196. #endif /* CK_ANSIC */
  2197. /* logchar */ {            /* Log character c to session log */
  2198.     if (seslog) 
  2199.       if ((sessft != 0) ||
  2200.       (c != '\r' &&
  2201.        c != '\0' &&
  2202.        c != XON &&
  2203.        c != XOFF))
  2204.     if (zchout(ZSFILE,c) < 0) {
  2205.         conoll("");
  2206.         conoll("ERROR WRITING SESSION LOG, LOG CLOSED!");
  2207.         seslog = 0;
  2208.     }
  2209. }
  2210. #endif /* NOLOCAL */
  2211.