home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / c-kermit / ckuus7.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  519KB  |  15,324 lines
  1. #include "ckcsym.h"
  2.  
  3. /*  C K U U S 7 --  "User Interface" for C-Kermit, part 7  */
  4.  
  5. /*
  6.   Authors:
  7.     Frank da Cruz <fdc@columbia.edu>,
  8.       The Kermit Project, Columbia University, New York City
  9.     Jeffrey E Altman <jaltman@secure-endpoints.com>
  10.       Secure Endpoints Inc., New York City
  11.  
  12.   Copyright (C) 1985, 2011,
  13.     Trustees of Columbia University in the City of New York.
  14.     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  15.     copyright text in the ckcmai.c module for disclaimer and permissions.
  16. */
  17.  
  18. /*
  19.   This file created from parts of ckuus3.c, which became too big for
  20.   Mark Williams Coherent compiler to handle.
  21. */
  22.  
  23. /*
  24.   Definitions here supersede those from system include files.
  25. */
  26. #include "ckcdeb.h"                     /* Debugging & compiler things */
  27. #include "ckcasc.h"                     /* ASCII character symbols */
  28. #include "ckcker.h"                     /* Kermit application definitions */
  29. #include "ckcxla.h"                     /* Character set translation */
  30. #include "ckcnet.h"                     /* Network symbols */
  31. #include "ckuusr.h"                     /* User interface symbols */
  32. #include "ckucmd.h"
  33. #include "ckclib.h"
  34.  
  35. #ifdef VMS
  36. #ifndef TCPSOCKET
  37. #include <errno.h>
  38. #endif /* TCPSOCKET */
  39. #endif /* VMS */
  40.  
  41. #ifdef OS2
  42. #ifndef NT
  43. #define INCL_NOPM
  44. #define INCL_VIO                        /* Needed for ckocon.h */
  45. #define INCL_DOSMODULEMGR
  46. #include <os2.h>
  47. #undef COMMENT
  48. #else /* NT */
  49. #define APIRET ULONG
  50. #include <windows.h>
  51. #include <tapi.h>
  52. #include "cknwin.h"
  53. #include "ckntap.h"
  54. #endif /* NT */
  55. #include "ckowin.h"
  56. #include "ckocon.h"
  57. #include "ckodir.h"
  58. #ifdef OS2MOUSE
  59. #include "ckokey.h"
  60. #endif /* OS2MOUSE */
  61. #ifdef KUI
  62. #include "ikui.h"
  63. #endif /* KUI */
  64. #ifdef putchar
  65. #undef putchar
  66. #endif /* putchar */
  67. #define putchar(x) conoc(x)
  68. extern int mskkeys;
  69. extern int mskrename;
  70. #endif /* OS2 */
  71.  
  72. #ifdef CK_AUTHENTICATION
  73. #include "ckuath.h"
  74. #endif /* CK_AUTHENTICATION */
  75. #ifdef CK_SSL
  76. #include "ck_ssl.h"
  77. #endif /* CK_SSL */
  78. #ifdef SSHBUILTIN
  79. #include "ckossh.h"
  80. #endif /* SSHBUILTIN */
  81. #ifdef STRATUS                          /* Stratus Computer, Inc.  VOS */
  82. #ifdef putchar
  83. #undef putchar
  84. #endif /* putchar */
  85. #define putchar(x) conoc(x)
  86. #ifdef getchar
  87. #undef getchar
  88. #endif /* getchar */
  89. #define getchar(x) coninc(0)
  90. #endif /* STRATUS */
  91.  
  92. char * slmsg = NULL;
  93.  
  94. static int x, y = 0, z;
  95. static char *s;
  96.  
  97. extern CHAR feol;
  98. extern int g_matchdot, hints, xcmdsrc, rcdactive;
  99.  
  100. extern char * k_info_dir;
  101.  
  102. #ifdef CK_LOGIN
  103. #ifdef CK_PAM
  104. int gotemptypasswd = 0;   /* distinguish empty passwd from none given */
  105. #endif /* CK_PAM */
  106. #endif /* CK_LOGIN */
  107.  
  108. #ifndef NOSPL
  109. extern int nmac;
  110. extern struct mtab *mactab;
  111. #endif /* NOSPL */
  112.  
  113. #ifndef NOXFER
  114. #ifdef CK_SPEED
  115. extern short ctlp[];                    /* Control-char prefixing table */
  116. #endif /* CK_SPEED */
  117.  
  118. #ifdef PIPESEND
  119. extern char * sndfilter, * g_sfilter;
  120. extern char * rcvfilter, * g_rfilter;
  121. #endif /* PIPESEND */
  122.  
  123. extern char * snd_move;
  124. extern char * snd_rename;
  125. extern char * g_snd_move;
  126. extern char * g_snd_rename;
  127. extern char * rcv_move;
  128. extern char * rcv_rename;
  129. extern char * g_rcv_move;
  130. extern char * g_rcv_rename;
  131.  
  132. #ifdef PATTERNS
  133. extern char *binpatterns[], *txtpatterns[];
  134. extern int patterns;
  135. #endif /* PATTERNS */
  136.  
  137. extern char * remdest;
  138. #ifdef CK_TMPDIR
  139. char * dldir = NULL;
  140. #endif /* CK_TMPDIR */
  141.  
  142. extern struct ck_p ptab[];
  143.  
  144. extern int protocol, remfile, rempipe, remappd, reliable, xreliable, fmask,
  145.   fncnv, frecl, maxrps, wslotr, bigsbsiz, bigrbsiz, urpsiz, rpsiz, spsiz,
  146.   bctr, npad, timef, timint, spsizr, spsizf, maxsps, spmax, nfils, displa,
  147.   atcapr, pkttim, rtimo, fncact, mypadn, fdispla, f_save, pktpaus, setreliable,
  148.   fnrpath, fnspath, atenci, atenco, atdati, atdato, atleni, atleno, atblki,
  149.   atblko, attypi, attypo, atsidi, atsido, atsysi, atsyso, atdisi, atdiso;
  150.  
  151. extern int stathack;
  152.  
  153. extern int atfrmi, atfrmo;
  154. #ifdef STRATUS
  155. extern int atcrei, atcreo, atacti, atacto;
  156. #endif /* STRATUS */
  157. #ifdef CK_PERMS
  158. extern int atlpri, atlpro, atgpri, atgpro;
  159. #endif /* CK_PERMS */
  160.  
  161. extern CHAR
  162.   sstate, eol, seol, stchr, mystch, mypadc, padch, ctlq, myctlq;
  163.  
  164. #ifdef IKSD
  165. extern int inserver;
  166. #ifdef IKSDCONF
  167. extern int iksdcf;
  168. #endif /* IKSDCONF */
  169. #endif /* IKSD */
  170.  
  171. extern char *cmarg, *cmarg2;
  172.  
  173. #ifndef NOFRILLS
  174. extern char optbuf[];                   /* Buffer for MAIL or PRINT options */
  175. extern int rprintf;                     /* REMOTE PRINT flag */
  176. #endif /* NOFRILLS */
  177. #endif /* NOXFER */
  178.  
  179. #ifdef CK_TRIGGER
  180. extern char * tt_trigger[];
  181. #endif /* CK_TRIGGER */
  182.  
  183. extern int tcs_transp;
  184. #ifdef PCTERM
  185. extern int tt_pcterm;
  186. #endif /* PCTERM */
  187. #ifdef NT
  188. extern int tt_vtnt;
  189. #endif /* NT */
  190.  
  191. #ifdef SSHBUILTIN
  192. int sl_ssh_xfw = 0;
  193. int sl_ssh_xfw_saved = 0;
  194. int sl_ssh_ver = 0;
  195. int sl_ssh_ver_saved = 0;
  196. #endif /* SSHBUILTIN */
  197.  
  198. #ifdef CK_AUTHENTICATION
  199. extern int auth_type_user[];
  200. int sl_auth_type_user[AUTHTYPLSTSZ] = {AUTHTYPE_NULL, AUTHTYPE_NULL};
  201. int sl_auth_saved = 0;
  202. int sl_topt_a_su = 0;
  203. int sl_topt_a_s_saved = 0;
  204. int sl_topt_a_cm = 0;
  205. int sl_topt_a_c_saved = 0;
  206. #endif /* CK_AUTHENTICATION */
  207. #ifdef CK_ENCRYPTION
  208. extern int cx_type;
  209. int sl_cx_type = 0;
  210. int sl_cx_saved = 0;
  211. int sl_topt_e_su = 0;
  212. int sl_topt_e_sm = 0;
  213. int sl_topt_e_s_saved = 0;
  214. int sl_topt_e_cu = 0;
  215. int sl_topt_e_cm = 0;
  216. int sl_topt_e_c_saved = 0;
  217. #endif /* CK_ENCRYPTION */
  218. extern char uidbuf[];
  219. static int uidflag = 0;
  220. char sl_uidbuf[UIDBUFLEN] = { NUL, NUL };
  221. int  sl_uid_saved = 0;
  222. #ifdef TNCODE
  223. int  sl_tn_wait = 0;
  224. int  sl_tn_saved = 0;
  225. #endif /* TNCODE */
  226.  
  227. #ifdef TNCODE
  228. extern int tn_wait_flg;
  229. #endif /* TNCODE */
  230.  
  231. VOID
  232. slrestor() {
  233. #ifdef CK_AUTHENTICATION
  234.     int x;
  235.     if (sl_auth_saved) {
  236.         for (x = 0; x < AUTHTYPLSTSZ; x++)
  237.           auth_type_user[x] = sl_auth_type_user[x];
  238.         sl_auth_saved = 0;
  239.     }
  240.     if (sl_topt_a_s_saved) {
  241.         TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = sl_topt_a_su;
  242.         sl_topt_a_s_saved = 0;
  243.     }
  244.     if (sl_topt_a_c_saved) {
  245.         TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = sl_topt_a_cm;
  246.         sl_topt_a_c_saved = 0;
  247.     }
  248. #endif /* CK_AUTHENTICATION */
  249. #ifdef CK_ENCRYPTION
  250.     if (sl_cx_saved) {
  251.         cx_type = sl_cx_type;
  252.         sl_cx_saved = 0;
  253.     }
  254.     if (sl_topt_e_s_saved) {
  255.         TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION)  = sl_topt_e_su;
  256.         TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) = sl_topt_e_sm;
  257.         sl_topt_e_s_saved = 0;
  258.     }
  259.     if (sl_topt_e_c_saved) {
  260.         TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION)  = sl_topt_e_cu;
  261.         TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) = sl_topt_e_cm;
  262.         sl_topt_e_c_saved = 0;
  263.     }
  264. #endif /* CK_ENCRYPTION */
  265.     if (sl_uid_saved) {
  266.         ckstrncpy(uidbuf,sl_uidbuf,UIDBUFLEN);
  267.         sl_uid_saved = 0;
  268.     }
  269. #ifdef TNCODE
  270.     if (sl_tn_saved) {
  271.         tn_wait_flg = sl_tn_wait;
  272.         sl_tn_saved = 0;
  273.     }
  274. #endif /* TNCODE */
  275. #ifdef SSHBUILTIN
  276.     if (sl_ssh_xfw_saved) {
  277.         ssh_xfw = sl_ssh_xfw;
  278.         sl_ssh_xfw_saved = 0;
  279.     }
  280.     if (sl_ssh_ver_saved) {
  281.         ssh_ver = sl_ssh_ver;
  282.         sl_ssh_ver_saved = 0;
  283.     }
  284. #endif /* SSHBUILTIN */
  285. }
  286.  
  287. int oldplex = -1;                       /* Duplex holder around network */
  288.  
  289. #ifndef NOICP
  290. #ifdef LOCUS
  291. extern int locus, autolocus;
  292. #endif /* LOCUS */
  293. #ifndef NODIAL
  294. extern int dialsta;
  295. #endif /* NODIAL */
  296.  
  297. /* Note: gcc -Wall wants braces around each keyword table entry. */
  298.  
  299. static struct keytab psltab[] = {       /* SET LINE/PORT command options */
  300.     { "/connect", SL_CNX, 0 },
  301. #ifdef OS2ORVMS
  302.     { "/noshare", SL_NSH, 0 },
  303. #endif /* OS2ORVMS */
  304.     { "/server",  SL_SRV, 0 },
  305. #ifdef OS2ORVMS
  306.     { "/share",   SL_SHR, 0 },
  307. #endif /* OS2ORVMS */
  308.     { "", 0, 0 }
  309. };
  310. static int npsltab = sizeof(psltab)/sizeof(struct keytab) - 1;
  311.  
  312. #ifdef NETCONN
  313. static struct keytab shtab[] = {        /* SET HOST command options */
  314. #ifdef NETCMD
  315.     /* (COMMAND is also a network type) */
  316.     { "/command",      SL_CMD,    CM_INV },
  317. #endif /* NETCMD */
  318.     { "/connect",      SL_CNX,    0 },
  319.     { "/network-type", SL_NET,    CM_ARG },
  320.     { "/nowait",       SL_NOWAIT, 0 },
  321. #ifndef NOSPL
  322. #ifdef CK_AUTHENTICATION
  323.     { "/password",     SL_PSW,    CM_ARG },
  324. #endif /* CK_AUTHENTICATION */
  325. #endif /* NOSPL */
  326. #ifdef NETCMD
  327.     { "/pipe",         SL_CMD,    0 },
  328. #endif /* NETCMD */
  329. #ifdef NETPTY
  330.     { "/pty",          SL_PTY,    0 },
  331. #endif /* NETPTY */
  332.     { "/server",       SL_SRV,    0 },
  333.     { "/timeout",      SL_TMO,    CM_ARG },
  334.     { "/userid",       SL_UID,    CM_ARG },
  335.     { "/wait",         SL_WAIT,   0 },
  336.     { "", 0, 0 }
  337. };
  338. static int nshtab = sizeof(shtab)/sizeof(struct keytab) - 1;
  339.  
  340. static struct keytab shteltab[] = {     /* TELNET command options */
  341. #ifdef CK_AUTHENTICATION
  342.     { "/auth",         SL_AUTH,   CM_ARG },
  343. #endif /* CK_AUTHENTICATION */
  344. #ifdef CK_ENCRYPTION
  345.     { "/encrypt",      SL_ENC,    CM_ARG },
  346. #endif /* CK_ENCRYPTION */
  347.     { "/nowait",       SL_NOWAIT, 0 },
  348. #ifndef NOSPL
  349. #ifdef CK_AUTHENTICATION
  350.     { "/password",     SL_PSW,    CM_ARG },
  351. #endif /* CK_AUTHENTICATION */
  352. #endif /* NOSPL */
  353.     { "/timeout",      SL_TMO,    CM_ARG },
  354.     { "/userid",       SL_UID,    CM_ARG },
  355.     { "/wait",         SL_WAIT,   0 },
  356.     { "", 0 ,0 }
  357. };
  358. static int nshteltab = sizeof(shteltab)/sizeof(struct keytab) - 1;
  359.  
  360. #ifdef RLOGCODE
  361. static struct keytab shrlgtab[] = {     /* SET HOST RLOGIN command options */
  362. #ifdef CK_KERBEROS
  363. #ifdef CK_ENCRYPTION
  364.     { "/encrypt",      SL_ENC, 0 },
  365. #endif /* CK_ENCRYPTION */
  366.     { "/k4",           SL_KRB4, CM_INV },
  367.     { "/k5",           SL_KRB5, CM_INV },
  368.     { "/kerberos4",    SL_KRB4, 0 },
  369.     { "/kerberos5",    SL_KRB5, 0 },
  370.     { "/kerberos_iv",  SL_KRB4, CM_INV },
  371.     { "/kerberos_v",   SL_KRB5, CM_INV },
  372.     { "/krb4",         SL_KRB4, CM_INV },
  373.     { "/krb5",         SL_KRB5, CM_INV },
  374. #endif /* CK_KERBEROS */
  375.     { "", 0 ,0 }
  376. };
  377. static int nshrlgtab = sizeof(shrlgtab)/sizeof(struct keytab)-1;
  378. #endif /* RLOGCODE */
  379.  
  380. extern struct keytab netcmd[];
  381. extern int nnets;
  382. #ifndef NODIAL
  383. extern int dirline;
  384. extern int nnetdir;                     /* Network services directory */
  385. extern char *netdir[];
  386. _PROTOTYP( VOID ndreset, (void) );
  387. char *nh_p[MAXDNUMS + 1];               /* Network directory entry pointers */
  388. char *nh_p2[MAXDNUMS + 1];              /* Network directory entry nettype */
  389. char *nh_px[4][MAXDNUMS + 1];           /* Network-specific stuff... */
  390. #endif /* NODIAL */
  391. int nhcount = 0;
  392. int ndinited = 0;
  393. char * n_name = NULL;                   /* Network name pointer */
  394. #endif /* NETCONN */
  395.  
  396. _PROTOTYP(int remtxt, (char **) );
  397. _PROTOTYP(VOID rmsg, (void) );
  398. _PROTOTYP(static int remcfm, (void) );
  399.  
  400. extern int nopush;
  401.  
  402. int mdmsav = -1;                        /* Save modem type around network */
  403. extern int isguest;                     /* Global flag for anonymous login */
  404.  
  405. extern xx_strp xxstring;
  406.  
  407. extern int success, binary, b_save, ckwarn, msgflg, quiet, cmask, pflag, local,
  408.   nettype, escape, mdmtyp, duplex, dfloc, network, cdtimo, autoflow, tnlm,
  409.   sosi, tlevel, lf_opts, backgrd, flow, debses, parity, ttnproto, ckxech,
  410.   x_ifnum, cmflgs, haveline, cxtype, cxflow[], maclvl;
  411.  
  412. #ifdef DCMDBUF
  413. extern struct cmdptr *cmdstk;           /* The command stack itself */
  414. #else
  415. extern struct cmdptr cmdstk[];          /* The command stack itself */
  416. #endif /* DCMDBUF */
  417. extern FILE * tfile[];
  418. extern char * macp[];
  419.  
  420. extern char psave[];                    /* For saving & restoring prompt */
  421. extern int sprmlen, rprmlen;
  422.  
  423. #ifdef OS2
  424. static struct keytab strmkeytab[] = {
  425.     { "clear",   0, 0 },
  426.     { "default", 1, 0 }
  427. };
  428. static int nstrmkeytab = sizeof(strmkeytab)/sizeof(struct keytab);
  429.  
  430. static struct keytab strmswitab[] = {
  431.     { "/literal", 0, 0 }
  432. };
  433. static int nstrmswitab = sizeof(strmswitab)/sizeof(struct keytab);
  434.  
  435. static struct keytab normrev[] = {
  436.     { "dark-display", 0, 0 },
  437.     { "light-display", 1, 0 },
  438.     { "normal",   0, 0 },
  439.     { "reverse",  1, 0 }
  440. };
  441.  
  442. static struct keytab prnmtab[] = {
  443.     { "auto", 1, 0 },
  444.     { "copy", 2, 0 },
  445.     { "off",  0, 0 },
  446.     { "on",   1, CM_INV },              /* Compatibility with XPRINT version */
  447.     { "user", 3, 0 },
  448.     { "transparent", 3, CM_INV }        /* not really transparent */
  449. };
  450. static int nprnmtab = sizeof(prnmtab)/sizeof(struct keytab);
  451.  
  452. extern int tt_diff_upd;
  453.  
  454. #ifdef NT
  455. #define stricmp _stricmp
  456. extern int tt_attr_bug;
  457. #endif /* NT */
  458. extern int tt_rows[], tt_cols[];
  459. extern int tt_cols_usr;
  460. extern int tt_szchng[VNUM];
  461. int tt_modechg = TVC_ENA;
  462. extern int tt_url_hilite, tt_url_hilite_attr;
  463. extern struct _vtG G[4];
  464. extern int priority;
  465. extern bool send_c1;
  466. int send_c1_usr = FALSE;
  467. extern int sgrcolors;
  468. extern int marginbell, marginbellcol;
  469. extern int autoscroll, wy_autopage;
  470. extern int tt_sac;
  471. extern int dec_nrc, dec_lang, dec_kbd;
  472. #else /* OS2 */
  473. extern int tt_rows, tt_cols;
  474. #endif /*  OS2 */
  475.  
  476. extern int tt_escape;
  477. extern long speed;
  478.  
  479. extern char *dftty;
  480.  
  481. extern char *tp, *lp;                   /* Temporary buffer & pointers */
  482. extern char ttname[];
  483.  
  484. #ifdef CK_TAPI
  485. int tttapi = 0;                         /* is Line TAPI? */
  486. struct keytab * tapilinetab = NULL;
  487. struct keytab * _tapilinetab = NULL;
  488. int ntapiline = 0;
  489. #endif /* CK_TAPI */
  490.  
  491. #ifdef NETCONN                          /* Network items */
  492.  
  493. #ifdef ANYX25
  494. extern int revcall, closgr, cudata, nx25;
  495. extern char udata[];
  496. extern struct keytab x25tab[];
  497. #ifndef IBMX25
  498. extern int npadx3;
  499. extern CHAR padparms[];
  500. extern struct keytab padx3tab[];
  501. #endif /* IBMX25 */
  502. #endif /* ANYX25 */
  503.  
  504. #ifdef OS2
  505. extern bool ttshare;
  506. #ifndef NT
  507. extern bool ttslip,ttppp;
  508. #endif /* NT */
  509. #endif /* OS2 */
  510. #ifdef NPIPE
  511. extern char pipename[];
  512. #endif /* NPIPE */
  513.  
  514. #ifdef TCPSOCKET
  515. static struct keytab tcprawtab[] = {    /* SET HOST options */
  516.     { "/default",    NP_DEFAULT,    CM_INV },
  517. #ifdef CK_AUTHENTICATION
  518. #ifdef CK_KERBEROS
  519. #ifdef RLOGCODE
  520.     { "/ek4login",    NP_EK4LOGIN,    0 },
  521.     { "/ek5login",    NP_EK5LOGIN,    0 },
  522.     { "/k4login",     NP_K4LOGIN,     0 },
  523.     { "/k5login",     NP_K5LOGIN,     0 },
  524. #endif /* RLOGCODE */
  525. #ifdef KRB5_U2U
  526.     { "/k5user2user", NP_K5U2U,       0 },
  527. #endif /* KRB5_U2U */
  528. #endif /* CK_KERBEROS */
  529. #endif /* CK_AUTHENTICATION */
  530.     { "/no-telnet-init", NP_NONE,   0 },
  531.     { "/none",       NP_NONE,   CM_INV },
  532.     { "/raw-socket", NP_TCPRAW, 0 },
  533. #ifdef RLOGCODE
  534.     { "/rlogin",     NP_RLOGIN, 0 },
  535. #endif /* RLOGCODE */
  536. #ifdef CK_SSL
  537.     { "/ssl",        NP_SSL,    0 },
  538.     { "/ssl-raw",    NP_SSL_RAW, 0 },
  539.     { "/ssl-telnet", NP_SSL_TELNET, 0 },
  540. #endif /* CK_SSL */
  541.     { "/telnet",     NP_TELNET, 0 },
  542. #ifdef CK_SSL
  543.     { "/tls",        NP_TLS,    0 },
  544.     { "/tls-raw",    NP_TLS_RAW, 0 },
  545.     { "/tls-telnet", NP_TLS_TELNET, 0 },
  546. #endif /* CK_SSL */
  547.     { "", 0, 0 }
  548. };
  549. static int ntcpraw = (sizeof(tcprawtab) / sizeof(struct keytab)) - 1;
  550.  
  551. #ifdef RLOGCODE
  552. _PROTOTYP( int rlog_naws, (void) );
  553. #endif /* RLOGCODE */
  554. #endif /* TCPSOCKET */
  555.  
  556. #ifdef SUPERLAT
  557. extern char slat_pwd[18];
  558. #endif /* SUPERLAT */
  559. #endif /* NETCONN */
  560.  
  561. #ifdef COMMENT
  562. #ifndef NOSETKEY
  563. extern KEY *keymap;
  564. #ifndef OS2
  565. #define mapkey(x) keymap[x]
  566. #endif /* OS2 */
  567. extern MACRO *macrotab;
  568. #ifndef NOKVERBS
  569. extern struct keytab kverbs[];
  570. extern int nkverbs;
  571. #endif /* NOKVERBS */
  572. #endif /* NOSETKEY */
  573. #else
  574. #ifndef NOSETKEY
  575. extern KEY *keymap;
  576. extern MACRO *macrotab;
  577. #ifndef NOKVERBS
  578. extern struct keytab kverbs[];
  579. extern int nkverbs;
  580. #endif /* NOKVERBS */
  581. #endif /* NOSETKEY */
  582. #endif /* COMMENT */
  583.  
  584. #ifdef OS2                              /* AUTODOWNLOAD parameters */
  585. extern int    adl_kmode, adl_zmode;     /* Match Packet to signal download */
  586. extern char * adl_kstr;                 /* KERMIT Download String */
  587. extern char * adl_zstr;                 /* ZMODEM Download String */
  588. extern int adl_kc0, adl_zc0;            /* Process ADL C0s in emulation */
  589. #endif /* OS2 */
  590.  
  591. /* Keyword tables ... */
  592.  
  593. extern struct keytab onoff[], rltab[];
  594. extern int nrlt;
  595.  
  596. #ifndef NOCSETS
  597. static struct keytab fdfltab[] = {
  598.     { "7bit-character-set", 7, 0 },
  599.     { "8bit-character-set", 8, 0 }
  600. };
  601. static int nfdflt = (sizeof(fdfltab) / sizeof(struct keytab));
  602. #endif /* NOCSETS */
  603.  
  604. /* SET FILE parameters */
  605.  
  606. static struct keytab filtab[] = {
  607. #ifndef NOXFER
  608. #ifdef PATTERNS
  609.     { "binary-patterns",   XYFIBP,  0 },
  610. #endif /* PATTERNS */
  611.     { "bytesize",         XYFILS,   0 },
  612. #ifndef NOCSETS
  613.     { "character-set",    XYFILC,   0 },
  614. #endif /* NOCSETS */
  615.     { "collision",        XYFILX,   0 },
  616.     { "default",          XYF_DFLT, 0 },
  617.     { "destination",      XYFILY,   0 },
  618.     { "display",          XYFILD,   CM_INV },
  619. #ifdef CK_TMPDIR
  620.     { "download-directory", XYFILG, 0 },
  621. #endif /* CK_TMPDIR */
  622. #endif /* NOXFER */
  623.     { "end-of-line",      XYFILA,   0 },
  624.     { "eol",              XYFILA,   CM_INV },
  625. #ifdef CK_CTRLZ
  626.     { "eof",              XYFILV,   0 },
  627. #endif /* CK_CTRLZ */
  628. #ifndef NOXFER
  629.     { "fastlookups",      9997,     CM_INV },
  630.     { "incomplete",       XYFILI,   0 },
  631. #ifndef datageneral
  632.     { "inspection",       XYF_INSP, CM_INV },
  633. #endif /* datageneral */
  634. #ifdef CK_LABELED
  635.     { "label",            XYFILL, 0 },
  636. #endif /* CK_LABELED */
  637.  
  638. #ifdef UNIX
  639. #ifdef DYNAMIC
  640.     { "listsize",         XYF_LSIZ, 0 },
  641. #endif /* DYNAMIC */
  642. #endif /* UNIX */
  643.  
  644.     { "names",            XYFILN, 0 },
  645. #ifdef UNIX
  646.     { "output",           XYFILH, 0 },
  647. #endif /* UNIX */
  648. #ifdef PATTERNS
  649.     { "patterns",         XYFIPA, 0 },
  650. #endif /* PATTERNS */
  651. #ifdef COMMENT /* Not implemented (but see CHMOD) */
  652.     { "permissions",      XYF_PRM, CM_INV },
  653.     { "protection",       XYF_PRM, 0 },
  654. #endif /* COMMENt */
  655. #ifdef VMS
  656.     { "record-length",    XYFILR, 0 },
  657. #endif /* VMS */
  658. #ifndef datageneral
  659.     { "scan",             XYF_INSP, 0 },
  660. #endif /* datageneral */
  661.  
  662. #ifdef UNIX
  663. #ifdef DYNAMIC
  664.     { "stringspace",      XYF_SSPA, 0 },
  665. #endif /* DYNAMIC */
  666. #endif /* UNIX */
  667.  
  668. #ifdef PATTERNS
  669.     { "t",                XYFILT, CM_INV|CM_ABR },
  670.     { "text-patterns",    XYFITP, 0 },
  671. #endif /* PATTERNS */
  672. #endif /* NOXFER */
  673.     { "type",             XYFILT, 0 },
  674. #ifdef UNICODE
  675.     { "ucs",              XYFILU, 0 },
  676. #endif /* UNICODE */
  677. #ifndef NOXFER
  678.     { "warning",          XYFILW, CM_INV }
  679. #endif /* NOXFER */
  680. };
  681. static int nfilp = (sizeof(filtab) / sizeof(struct keytab));
  682.  
  683. struct keytab pathtab[] = {
  684.     { "absolute",  PATH_ABS,  0      },
  685.     { "none",      PATH_OFF,  CM_INV },
  686.     { "off",       PATH_OFF,  0      },
  687.     { "on",        PATH_ABS,  CM_INV },
  688.     { "relative",  PATH_REL,  0      }
  689. };
  690. int npathtab = (sizeof(pathtab) / sizeof(struct keytab));
  691.  
  692. struct keytab rpathtab[] = {
  693.     { "absolute",  PATH_ABS,  0      },
  694.     { "auto",      PATH_AUTO, 0      },
  695.     { "none",      PATH_OFF,  CM_INV },
  696.     { "off",       PATH_OFF,  0      },
  697.     { "on",        PATH_ABS,  CM_INV },
  698.     { "relative",  PATH_REL,  0      }
  699. };
  700. int nrpathtab = (sizeof(rpathtab) / sizeof(struct keytab));
  701.  
  702. #ifdef CK_CTRLZ
  703. struct keytab eoftab[] = {              /* EOF detection method */
  704.     { "ctrl-z",          1, 0      },
  705.     { "length",          0, 0      },
  706.     { "noctrl-z",        0, CM_INV }
  707. };
  708. #endif /* CK_CTRLZ */
  709.  
  710. struct keytab fttab[] = {               /* File types for SET FILE TYPE */
  711.     { "ascii",     XYFT_T, CM_INV },
  712. #ifdef VMS
  713.     { "b",         XYFT_B, CM_INV|CM_ABR },
  714. #endif /* VMS */
  715.     { "binary",    XYFT_B, 0 },
  716. #ifdef VMS
  717.     { "block",     XYFT_I, CM_INV },
  718.     { "image",     XYFT_I, 0 },
  719. #endif /* VMS */
  720. #ifdef CK_LABELED
  721.     { "labeled",   XYFT_L, 0 },
  722. #endif /* CK_LABELED */
  723. #ifdef MAC
  724.     { "macbinary", XYFT_M, 0 },
  725. #endif /* MAC */
  726.     { "text",      XYFT_T, 0 }
  727. };
  728. int nfttyp = (sizeof(fttab) / sizeof(struct keytab));
  729.  
  730. static struct keytab rfttab[] = {       /* File types for REMOTE SET FILE */
  731.     { "ascii",     XYFT_T, CM_INV },
  732.     { "binary",    XYFT_B, 0 },
  733. #ifdef VMS
  734.     { "labeled",   XYFT_L, 0 },
  735. #else
  736. #ifdef OS2
  737.     { "labeled",   XYFT_L, 0 },
  738. #endif /* OS2 */
  739. #endif /* VMS */
  740.     { "text",      XYFT_T, 0 }
  741. };
  742. static int nrfttyp = (sizeof(rfttab) / sizeof(struct keytab));
  743.  
  744. #ifdef OS2ORUNIX
  745. #define ZOF_BLK  0
  746. #define ZOF_NBLK 1
  747. #define ZOF_BUF  2
  748. #define ZOF_NBUF 3
  749. static struct keytab zoftab[] = {
  750.     { "blocking",    ZOF_BLK,  0 },
  751.     { "buffered",    ZOF_BUF,  0 },
  752.     { "nonblocking", ZOF_NBLK, 0 },
  753.     { "unbuffered",  ZOF_NBUF, 0 }
  754. };
  755. static int nzoftab = (sizeof(zoftab) / sizeof(struct keytab));
  756. #endif /* OS2ORUNIX */
  757.  
  758. extern int query;                       /* Global flag for QUERY active */
  759.  
  760. #ifndef NOSPL
  761. #ifndef NOXFER
  762. static struct keytab vartyp[] = {       /* Variable types for REMOTE QUERY */
  763.     { "global",   (int) 'G', CM_INV },
  764.     { "kermit",   (int) 'K', 0 },
  765.     { "system",   (int) 'S', 0 },
  766.     { "user",     (int) 'G', 0 }
  767. };
  768. static int nvartyp = (sizeof(vartyp) / sizeof(struct keytab));
  769. #endif /* NOXFER */
  770. #endif /* NOSPL */
  771.  
  772. #ifdef CK_TIMERS
  773. static struct keytab timotab[] = {      /* Timer types */
  774.     { "dynamic", 1, 0 },
  775.     { "fixed",   0, 0 }
  776. };
  777. #endif /* CK_TIMERS */
  778.  
  779. #ifdef DCMDBUF
  780. extern char *atxbuf, *atmbuf;           /* Atom buffer */
  781. extern char *cmdbuf;                    /* Command buffer */
  782. extern char *line, *tmpbuf;             /* Character buffers for anything */
  783. extern int *intime;                     /* INPUT TIMEOUT */
  784.  
  785. #else  /* Not DCMDBUF ... */
  786.  
  787. extern char atxbuf[], atmbuf[];         /* Atom buffer */
  788. extern char cmdbuf[];                   /* Command buffer */
  789. extern char line[], tmpbuf[];           /* Character buffer for anything */
  790. extern int intime[];
  791.  
  792. #endif /* DCMDBUF */
  793.  
  794. #ifndef NOCSETS
  795. extern struct keytab fcstab[];          /* For SET FILE CHARACTER-SET */
  796. extern struct csinfo fcsinfo[];         /* File character set info. */
  797. extern struct keytab ttcstab[];
  798. extern int nfilc, fcharset, tcharset, ntermc, tcsr, tcsl, dcset7, dcset8;
  799. #ifdef CKOUNI
  800. extern int tt_utf8;
  801. #endif /* CKOUNI */
  802. #ifdef OS2
  803. _PROTOTYP( int os2setcp, (int) );
  804. _PROTOTYP( int os2getcp, (void) );
  805. _PROTOTYP( void os2debugoff, (void) );
  806. #endif /* OS2 */
  807. #endif /* NOCSETS */
  808.  
  809. extern int cmdlvl;                      /* Overall command level */
  810.  
  811. #ifndef NOSPL
  812. #ifdef DCMDBUF
  813. extern int *inpcas;                     /* INPUT CASE setting on cmd stack */
  814. #else
  815. extern int inpcas[];
  816. #endif /* DCMDBUF */
  817. #endif /* NOSPL */
  818.  
  819. #ifdef CK_CURSES
  820. #ifndef VMS
  821. _PROTOTYP(int tgetent,(char *, char *));
  822. #else
  823. #ifdef __DECC
  824. _PROTOTYP(int tgetent,(char *, char *));
  825. #endif /* __DECC */
  826. #endif /* VMS */
  827. #endif /* CK_CURSES */
  828.  
  829. #ifndef NOXMIT
  830. #define XMITF 0                         /* SET TRANSMIT values */
  831. #define XMITL 1                         /* (Local to this module) */
  832. #define XMITP 2
  833. #define XMITE 3
  834. #define XMITX 4
  835. #define XMITS 5
  836. #define XMITW 6
  837. #define XMITT 7
  838.  
  839. #define XMBUFL 50
  840. extern int xmitf, xmitl, xmitp, xmitx, xmits, xmitw, xmitt;
  841. char xmitbuf[XMBUFL+1] = { NUL };       /* TRANSMIT eof string */
  842.  
  843. struct keytab xmitab[] = {              /* SET TRANSMIT */
  844.     { "echo",          XMITX, 0 },
  845.     { "eof",           XMITE, 0 },
  846.     { "fill",          XMITF, 0 },
  847.     { "linefeed",      XMITL, 0 },
  848.     { "locking-shift", XMITS, 0 },
  849.     { "pause",         XMITW, 0 },
  850.     { "prompt",        XMITP, 0 },
  851.     { "timeout",       XMITT, 0 }
  852. };
  853. int nxmit = (sizeof(xmitab) / sizeof(struct keytab));
  854. #endif /* NOXMIT */
  855.  
  856. /* For SET FILE COLLISION */
  857. /* Some of the following may be possible for some C-Kermit implementations */
  858. /* but not others.  Those that are not possible for your implementation */
  859. /* should be ifdef'd out. */
  860.  
  861. struct keytab colxtab[] = { /* SET FILE COLLISION options */
  862. #ifndef MAC
  863.     { "append",    XYFX_A, 0 },         /* append to old file */
  864. #endif /* MAC */
  865. #ifdef COMMENT
  866.     { "ask",       XYFX_Q, 0 },         /* ask what to do (not implemented) */
  867. #endif
  868.     { "backup",    XYFX_B, 0 },         /* rename old file */
  869. #ifndef MAC
  870.     /* This crashes Mac Kermit. */
  871.     { "discard",   XYFX_D, CM_INV },    /* don't accept new file */
  872.     { "no-supersede", XYFX_D, CM_INV }, /* ditto (MSK compatibility) */
  873. #endif /* MAC */
  874.     { "overwrite", XYFX_X, 0 },         /* overwrite the old file */
  875.     { "reject",    XYFX_D, 0 },        /* (better word than discard) */
  876.     { "rename",    XYFX_R, 0 },         /* rename the incoming file */
  877. #ifndef MAC                             /* This crashes Mac Kermit. */
  878.     { "update",    XYFX_U, 0 },         /* replace if newer */
  879. #endif /* MAC */
  880.     { "", 0, 0 }
  881. };
  882. int ncolx = (sizeof(colxtab) / sizeof(struct keytab)) - 1;
  883.  
  884. static struct keytab rfiltab[] = {      /* for REMOTE SET FILE */
  885. #ifndef NOCSETS
  886.     { "character-set", XYFILC, 0 },
  887. #endif /* NOCSETS */
  888.     { "collision",     XYFILX, 0 },
  889.     { "incomplete",    XYFILI, 0 },
  890.     { "names",         XYFILN, 0 },
  891.     { "record-length", XYFILR, 0 },
  892.     { "type",          XYFILT, 0 }
  893. };
  894. int nrfilp = (sizeof(rfiltab) / sizeof(struct keytab));
  895.  
  896. struct keytab eoltab[] = {              /* File eof delimiters */
  897.     { "cr",        XYFA_C, 0 },
  898.     { "crlf",      XYFA_2, 0 },
  899.     { "lf",        XYFA_L, 0 }
  900. };
  901. static int neoltab = (sizeof(eoltab) / sizeof(struct keytab));
  902.  
  903. struct keytab fntab[] = {               /* File naming */
  904.     { "converted", XYFN_C, 0      },
  905.     { "literal",   XYFN_L, 0      },
  906.     { "standard",  XYFN_C, CM_INV }
  907. };
  908. int nfntab = (sizeof(fntab) / sizeof(struct keytab));
  909.  
  910. #ifndef NOLOCAL
  911. /* Terminal parameters table */
  912. static struct keytab trmtab[] = {
  913. #ifdef OS2
  914.     { "answerback",    XYTANS,    0 },
  915. #endif /* OS2 */
  916. #ifdef CK_APC
  917.     { "apc",           XYTAPC,    0 },
  918. #endif /* CK_APC */
  919. #ifdef OS2
  920.     { "arrow-keys",    XYTARR,    0 },
  921. #endif /* OS2 */
  922. #ifdef NT
  923.     { "at",            XYTATTR,   CM_INV|CM_ABR },
  924.     { "att",           XYTATTR,   CM_INV|CM_ABR },
  925.     { "attr",          XYTATTR,   CM_INV|CM_ABR },
  926.     { "attr-bug",      XYTATTBUG, CM_INV },
  927. #endif /* NT */
  928. #ifdef OS2
  929.     { "attribute",     XYTATTR,   0 },
  930. #endif /* OS2 */
  931. #ifdef CK_APC
  932. #ifdef CK_AUTODL
  933.    { "autodownload",   XYTAUTODL, 0, },
  934. #endif /* CK_AUTODL */
  935. #endif /* CK_APC */
  936. #ifdef OS2
  937.     { "autopage",      XYTAPAGE,  0 },
  938.     { "autoscroll",    XYTASCRL,  0 },
  939.     { "bell",          XYTBEL,    CM_INV },
  940. #endif /* OS2 */
  941.     { "bytesize",      XYTBYT,    0 },
  942. #ifndef NOCSETS
  943.     { "character-set", XYTCS,     0 },
  944. #endif /* NOCSETS */
  945. #ifdef OS2
  946.     { "code-page",     XYTCPG,    0 },
  947.     { "color",         XYTCOL,    0 },
  948.     { "controls",      XYTCTRL,   0 },
  949. #endif /* OS2 */
  950.     { "cr-display",    XYTCRD,    0 },
  951. #ifdef OS2
  952.     { "cursor",        XYTCUR,    0 },
  953. #endif /* OS2 */
  954.     { "debug",         XYTDEB,    0 },
  955. #ifdef OS2
  956.     { "dg-unix-mode",  XYTUNX,    0 },
  957. #endif /* OS2 */
  958.     { "echo",          XYTEC,     0 },
  959.     { "escape-character", XYTESC, 0 },
  960. #ifdef OS2
  961. #ifdef PCFONTS
  962.     { "font",          XYTFON,    0 },
  963. #else
  964. #ifdef KUI
  965.     { "font",          XYTFON,    0 },
  966. #endif /* KUI */
  967. #endif /* PCFONTS */
  968. #endif /* OS2 */
  969.     { "height",        XYTHIG,    0 },
  970. #ifdef CKTIDLE
  971.     { "idle-action",   XYTIACT,   0 },
  972.     { "idle-limit",    XYTITMO,   CM_INV },
  973.     { "idle-send",     XYTIDLE,   CM_INV },
  974.     { "idle-timeout",  XYTITMO,   0 },
  975. #endif /* CKTIDLE */
  976. #ifdef OS2
  977. #ifndef NOCSETS
  978.     { "kbd-follows-gl/gr", XYTKBDGL, 0 },
  979. #endif /* NOCSETS */
  980.     { "key",           XYTKEY,    0 },
  981.     { "keyboard-mode", XYTKBMOD,  0 },
  982.     { "keypad-mode",   XYTKPD,    0 },
  983. #endif /* OS2 */
  984.     { "lf-display",    XYTLFD,    0 },
  985. #ifndef NOCSETS
  986. #ifdef OS2
  987. #ifndef KUI
  988.     { "line-spacing",  XYTLSP,    CM_INV },
  989.     { "local-character-set", XYTLCS,  0 },
  990. #else
  991.     { "line-spacing",  XYTLSP,    0 },
  992.     { "local-character-set", XYTLCS,  CM_INV },
  993. #endif /* KUI */
  994. #else
  995.     { "local-character-set", XYTLCS,  CM_INV },
  996. #endif /* OS2 */
  997. #endif /* NOCSETS */
  998.     { "locking-shift", XYTSO,     0 },
  999. #ifdef OS2
  1000.     { "margin-bell",   XYTMBEL,   0 },
  1001. #endif /* OS2 */
  1002. #ifdef OS2MOUSE
  1003.     { "mouse",         XYTMOU,    CM_INV },
  1004. #endif /* OS2MOUSE */
  1005.     { "newline-mode",  XYTNL,     0 },
  1006. #ifdef OS2
  1007.     { "output-pacing", XYTPAC,    0 },
  1008. #ifdef PCTERM
  1009.     { "pcterm",        XYTPCTERM, 0 },
  1010. #endif /* PCTERM */
  1011. #endif /* OS2 */
  1012. #ifdef OS2ORUNIX
  1013.     { "print",         XYTPRN,    0 },
  1014. #endif /* OS2ORUNIX */
  1015. #ifndef NOCSETS
  1016. #ifdef OS2
  1017.     { "remote-character-set", XYTRCS,  0 },
  1018. #else
  1019.     { "remote-character-set", XYTRCS,  CM_INV },
  1020. #endif /* OS2 */
  1021. #endif /* NOCSETS */
  1022. #ifdef OS2
  1023.     { "roll-mode",       XYTROL, 0 },
  1024.     { "s",               XYTUPD, CM_ABR|CM_INV },
  1025.     { "sc",              XYTUPD, CM_ABR|CM_INV },
  1026.     { "scr",             XYTUPD, CM_ABR|CM_INV },
  1027.     { "scree",           XYTUPD, CM_ABR|CM_INV },
  1028.     { "screen",          XYTUPD, CM_ABR|CM_INV },
  1029.     { "screen-",         XYTUPD, CM_ABR|CM_INV },
  1030.     { "screen-mode",     XYTSCNM,   0 },
  1031.     { "screen-optimize", XYTOPTI,   0 },
  1032.     { "screen-update",   XYTUPD,    0 },
  1033.     { "scrollback",      XYSCRS,    0 },
  1034.     { "send-data",         XYTSEND, 0 },
  1035.     { "send-end-of-block", XYTSEOB, 0 },
  1036.     { "sgr-colors",            XYTSGRC,  0 },
  1037.     { "sni-ch.code",           XYTSNICC, 0 },
  1038.     { "sni-firmware-versions", XYTSNIFV, 0 },
  1039.     { "sni-language",          XYTVTLNG, 0 },
  1040.     { "sni-pagemode",          XYTSNIPM, CM_INV },
  1041.     { "sni-scrollmode",              XYTSNISM, CM_INV },
  1042.     { "spacing-attribute-character", XYTSAC,   CM_INV },
  1043.     { "statusline",                  XYTSTAT,  0 },
  1044.     { "tra",                         XYTCTS,   CM_INV|CM_ABR },
  1045.     { "transmit-timeout",            XYTCTS,   0 },
  1046. #endif /* OS2 */
  1047.  
  1048. #ifdef OS2ORUNIX
  1049.     { "transparent-print", XYTPRN,   CM_INV },
  1050. #endif /* OS2ORUNIX */
  1051.  
  1052. #ifdef CK_TRIGGER
  1053.     { "trigger",           XYTRIGGER,0 },
  1054. #endif /* CK_TRIGGER */
  1055. #ifdef OS2
  1056.     { "type",              XYTTYP,   0 },
  1057. #else
  1058.     { "type",              XYTTYP,   CM_INV },
  1059. #endif /* OS2 */
  1060.  
  1061. #ifndef NOCSETS
  1062. #ifdef UNICODE
  1063. #ifdef CKOUNI
  1064.     { "unicode",           XYTUNI,   CM_INV },
  1065. #endif /* CKOUNI */
  1066. #endif /* UNICODE */
  1067. #endif /* NOCSETS */
  1068. #ifdef OS2
  1069.     { "unix-mode",         XYTUNX,   CM_INV },
  1070.     { "url-highlight",     XYTURLHI, 0 },
  1071. #ifdef NT
  1072.     { "video-change",      XYTVCH,   0 },
  1073. #endif /* NT */
  1074.     { "vt-language",       XYTVTLNG, 0 },
  1075.     { "vt-nrc-mode",       XYTVTNRC, 0 },
  1076. #endif /* OS2 */
  1077.     { "width",             XYTWID,   0 },
  1078. #ifdef OS2
  1079.     { "wrap",              XYTWRP,   0 },
  1080. #endif /* OS2 */
  1081.     { "", 0, 0 }
  1082. };
  1083. int ntrm = (sizeof(trmtab) / sizeof(struct keytab)) - 1;
  1084.  
  1085. #ifdef OS2
  1086. struct keytab termctrl[] = {    /* SET TERM CONTROLS */
  1087.     { "7",      7, 0 },
  1088.     { "8",      8, 0 }
  1089. };
  1090. int ntermctrl = (sizeof(termctrl) / sizeof(struct keytab));
  1091.  
  1092. struct keytab curontab[] = {    /* SET TERM CURSOR */
  1093. #ifdef KUI
  1094.     { "noblink", 2, 0 },
  1095. #else
  1096.     { "noblink", 2, CM_INV },
  1097. #endif /* KUI */
  1098.     { "off",     0, 0 },
  1099.     { "on",      1, 0 }
  1100. };
  1101. int ncuron = (sizeof(curontab) / sizeof(struct keytab));
  1102.  
  1103. struct keytab rolltab[] = {   /* Set TERM Roll Options */
  1104.     { "insert",    TTR_INSERT, 0      },
  1105.     { "keystrokes",TTR_KEYS,   0      },
  1106.     { "off",       TTR_OVER,   CM_INV },
  1107.     { "on",        TTR_INSERT, CM_INV },
  1108.     { "overwrite", TTR_OVER,   0      }
  1109. };
  1110. int nroll = (sizeof(rolltab) / sizeof(struct keytab));
  1111.  
  1112. struct keytab rollkeytab[] = {        /* Set TERM ROLL KEYSTROKES */
  1113.     { "ignore",            TTRK_IGN, 0 },
  1114.     { "restore-and-send",  TTRK_RST, 0 },
  1115.     { "send",              TTRK_SND, 0 }
  1116. };
  1117. int nrollkey = (sizeof(rollkeytab) / sizeof(struct keytab));
  1118.  
  1119. #define TT_GR_ALL 4
  1120. #define TT_GR_G0  0
  1121. #define TT_GR_G1  1
  1122. #define TT_GR_G2  2
  1123. #define TT_GR_G3  3
  1124. #define TT_GR_KBD 4
  1125. struct keytab graphsettab[] = {  /* DEC VT Graphic Sets */
  1126.     { "all",      TT_GR_ALL, 0 },
  1127.     { "g0",       TT_GR_G0,  0 },
  1128.     { "g1",       TT_GR_G1,  0 },
  1129.     { "g2",       TT_GR_G2,  0 },
  1130.     { "g3",       TT_GR_G3,  0 },
  1131.     { "keyboard", TT_GR_KBD, 0 }
  1132. };
  1133. int ngraphset = (sizeof(graphsettab) / sizeof(struct keytab));
  1134. #endif /* OS2 */
  1135.  
  1136. struct keytab adltab[] = {              /* Autodownload Options */
  1137.     { "ask",     TAD_ASK, 0 },
  1138.     { "error",   TAD_ERR, 0 },
  1139. #ifdef OS2
  1140.     { "kermit",  TAD_K,   0 },
  1141. #endif /* OS2 */
  1142.     { "off",     TAD_OFF, 0 },
  1143.     { "on",      TAD_ON,  0 },
  1144. #ifdef OS2
  1145.     { "zmodem",  TAD_Z,   0 },
  1146. #endif /* OS2 */
  1147.     { "", 0, 0 }
  1148. };
  1149. int nadltab = (sizeof(adltab) / sizeof(struct keytab)) - 1;
  1150.  
  1151. struct keytab adlerrtab[] = {           /* Autodownload Error Options */
  1152.     { "continue", 0, 0 },
  1153.     { "go",       0, CM_INV },
  1154.     { "stop",     1, 0 }
  1155. };
  1156. int nadlerrtab = (sizeof(adlerrtab) / sizeof(struct keytab));
  1157.  
  1158. #ifdef OS2
  1159. struct keytab adlxtab[] = {             /* Autodownload Options */
  1160.     { "c0-conflicts",     TAD_X_C0,     0 },
  1161.     { "detection-method", TAD_X_DETECT, 0 },
  1162.     { "string",           TAD_X_STR,    0 }
  1163. };
  1164. int nadlxtab = (sizeof(adlxtab) / sizeof(struct keytab));
  1165.  
  1166. struct keytab adldtab[] = {             /* Auto-dl Detection Methods */
  1167.     { "packet",           ADL_PACK,     0 },
  1168.     { "string",           ADL_STR,      0 }
  1169. };
  1170. int nadldtab = (sizeof(adldtab) / sizeof(struct keytab));
  1171.  
  1172. struct keytab adlc0tab[] = {            /* Auto-dl Detection Methods */
  1173.     { "ignored-by-emulator",    0,      0 },
  1174.     { "processed-by-emulator",  1,      0 }
  1175. };
  1176. int nadlc0tab = (sizeof(adlc0tab) / sizeof(struct keytab));
  1177.  
  1178. #ifndef NOCSETS
  1179. struct keytab vtlangtab[] = {
  1180.     { "belgian",        VTL_BELGIAN , 0 },
  1181.     { "british",        VTL_BRITISH , 0 },
  1182.     { "canadian",       VTL_CANADIAN, 0 },
  1183.     { "czech",          VTL_CZECH   , 0 },
  1184.     { "danish",         VTL_DANISH  , 0 },
  1185.     { "dutch",          VTL_DUTCH   , 0 },
  1186.     { "finnish",        VTL_FINNISH , 0 },
  1187.     { "french",         VTL_FRENCH  , 0 },
  1188.     { "french-canadian",VTL_FR_CAN  , 0 },
  1189.     { "german",         VTL_GERMAN  , 0 },
  1190.     { "greek",          VTL_GREEK   , 0 },
  1191.     { "hebrew",         VTL_HEBREW  , 0 },
  1192.     { "hungarian",      VTL_HUNGARIA, 0 },
  1193.     { "italian",        VTL_ITALIAN , 0 },
  1194.     { "latin-american", VTL_LATIN_AM, 0 },
  1195.     { "north-american", VTL_NORTH_AM, 0 },
  1196.     { "norwegian",      VTL_NORWEGIA, 0 },
  1197.     { "polish",         VTL_POLISH  , 0 },
  1198.     { "portugese",      VTL_PORTUGES, 0 },
  1199.     { "romanian",       VTL_ROMANIAN, 0 },
  1200.     { "russian",        VTL_RUSSIAN , 0 },
  1201.     { "scs",            VTL_SCS     , CM_INV },
  1202.     { "slovak",         VTL_SLOVAK  , 0 },
  1203.     { "spanish",        VTL_SPANISH , 0 },
  1204.     { "swedish",        VTL_SWEDISH , 0 },
  1205.     { "swiss-french",   VTL_SW_FR   , 0 },
  1206.     { "swiss-german",   VTL_SW_GR   , 0 },
  1207.     { "turkish-f",      VTL_TURK_F  , CM_INV },
  1208.     { "turkish-q",      VTL_TURK_Q  , CM_INV }
  1209. };
  1210. int nvtlangtab = (sizeof(vtlangtab) / sizeof(struct keytab));
  1211. #endif /* NOCSETS */
  1212. #endif /* OS2 */
  1213.  
  1214. struct keytab crdtab[] = {              /* Carriage-return display */
  1215.     { "crlf",        1, 0 },
  1216.     { "normal",      0, 0 }
  1217. };
  1218. extern int tt_crd;                      /* Carriage-return display variable */
  1219. extern int tt_lfd;            /* Linefeed display variable */
  1220.  
  1221. #ifdef CK_APC
  1222. extern int apcstatus, apcactive;
  1223. static struct keytab apctab[] = {       /* Terminal APC parameters */
  1224.     {  "no-input", APC_ON|APC_NOINP,0 },
  1225.     { "off",       APC_OFF,  0 },
  1226.     { "on",        APC_ON,   0 },
  1227.     { "unchecked", APC_ON|APC_UNCH, 0 },
  1228.     { "unchecked-no-input", APC_ON|APC_NOINP|APC_UNCH, 0 }
  1229. };
  1230. int napctab = (sizeof(apctab) / sizeof(struct keytab));
  1231. #endif /* CK_APC */
  1232. #endif /* NOLOCAL */
  1233.  
  1234. extern int autodl, adl_err, adl_ask;
  1235.  
  1236. struct keytab beltab[] = {              /* Terminal bell mode */
  1237. #ifdef OS2
  1238.     { "audible", XYB_AUD,  0 },
  1239.     { "none",    XYB_NONE, 0 },
  1240. #else
  1241.     { "audible", XYB_AUD,  CM_INV },
  1242.     { "none",    XYB_NONE, CM_INV },
  1243. #endif /* OS2 */
  1244. #ifdef OS2
  1245.     { "off",     XYB_NONE, CM_INV },
  1246.     { "on",      XYB_AUD,  CM_INV },
  1247. #else
  1248.     { "off",     XYB_NONE, 0 },
  1249.     { "on",      XYB_AUD,  0 },
  1250. #endif /* OS2 */
  1251. #ifdef OS2
  1252.     { "visible", XYB_VIS,  0 },
  1253. #endif /* OS2 */
  1254.     { "", 0, 0 }
  1255. };
  1256. int nbeltab = sizeof(beltab)/sizeof(struct keytab) - 1;
  1257.  
  1258. int tt_unicode = 1;                     /* Use Unicode if possible */
  1259. #ifdef CKTIDLE
  1260. int tt_idlesnd_tmo = 0;                 /* Idle Send Timeout, disabled */
  1261. char * tt_idlesnd_str = NULL;           /* Idle Send String, none */
  1262. char * tt_idlestr = NULL;
  1263. extern int tt_idleact, tt_idlelimit;
  1264. #endif /* CKTIDLE */
  1265.  
  1266. #ifdef OS2
  1267. #ifndef NOLOCAL
  1268. /*
  1269.   OS/2 serial communication devices.
  1270. */
  1271. struct keytab os2devtab[] = {
  1272.     { "1",    1, CM_INV },                      /* Invisible synonyms, like */
  1273.     { "2",    2, CM_INV },                      /* "set port 1" */
  1274.     { "3",    3, CM_INV },
  1275.     { "4",    4, CM_INV },
  1276.     { "5",    5, CM_INV },
  1277.     { "6",    6, CM_INV },
  1278.     { "7",    7, CM_INV },
  1279.     { "8",    8, CM_INV },
  1280.     { "com1", 1, 0 },                   /* Real device names */
  1281.     { "com2", 2, 0 },
  1282.     { "com3", 3, 0 },
  1283.     { "com4", 4, 0 },
  1284.     { "com5", 5, 0 },
  1285.     { "com6", 6, 0 },
  1286.     { "com7", 7, 0 },
  1287.     { "com8", 8, 0 },
  1288. #ifdef OS2ONLY
  1289.     { "slipcom1", 1, 0 },                       /* For use with SLIP driver */
  1290.     { "slipcom2", 2, 0 },                       /* shared access */
  1291.     { "slipcom3", 3, 0 },
  1292.     { "slipcom4", 4, 0 },
  1293.     { "slipcom5", 5, 0 },
  1294.     { "slipcom6", 6, 0 },
  1295.     { "slipcom7", 7, 0 },
  1296.     { "slipcom8", 8, 0 },
  1297.     { "pppcom1", 1, 0 },                        /* For use with PPP driver */
  1298.     { "pppcom2", 2, 0 },                        /* shared access */
  1299.     { "pppcom3", 3, 0 },
  1300.     { "pppcom4", 4, 0 },
  1301.     { "pppcom5", 5, 0 },
  1302.     { "pppcom6", 6, 0 },
  1303.     { "pppcom7", 7, 0 },
  1304.     { "pppcom8", 8, 0 }
  1305. #endif /* OS2ONLY */
  1306. };
  1307. int nos2dev = (sizeof(os2devtab) / sizeof(struct keytab)) - 1;
  1308.  
  1309. #ifdef OS2ONLY
  1310. struct keytab os2ppptab[] = {
  1311.     { "0",    0, CM_INV },
  1312.     { "1",    1, CM_INV },                      /* Invisible synonyms, like */
  1313.     { "2",    2, CM_INV },                      /* "set port 1" */
  1314.     { "3",    3, CM_INV },
  1315.     { "4",    4, CM_INV },
  1316.     { "5",    5, CM_INV },
  1317.     { "6",    6, CM_INV },
  1318.     { "7",    7, CM_INV },
  1319.     { "8",    8, CM_INV },
  1320.     { "9",    9, CM_INV },
  1321.     { "ppp0", 0, 0 },
  1322.     { "ppp1", 1, 0 },                   /* For use with PPP driver */
  1323.     { "ppp2", 2, 0 },                   /* shared access */
  1324.     { "ppp3", 3, 0 },
  1325.     { "ppp4", 4, 0 },
  1326.     { "ppp5", 5, 0 },
  1327.     { "ppp6", 6, 0 },
  1328.     { "ppp7", 7, 0 },
  1329.     { "ppp8", 8, 0 },
  1330.     { "ppp9", 9, 0 }
  1331. };
  1332. int nos2ppp = (sizeof(os2ppptab) / sizeof(struct keytab));
  1333. #endif /* OS2ONLY */
  1334.  
  1335. /*
  1336.   Terminal parameters that can be set by SET commands.
  1337.   Used by the ck?con.c terminal emulator code.
  1338.   For now, only used for #ifdef OS2.  Should add these for Macintosh.
  1339. */
  1340. int tt_arrow = TTK_NORM;                /* Arrow key mode: normal (cursor) */
  1341. int tt_keypad = TTK_NORM;               /* Keypad mode: normal (numeric) */
  1342. int tt_shift_keypad = 0;                /* Keypad Shift mode: Off */
  1343. int tt_wrap = 1;                        /* Terminal wrap, 1 = On */
  1344. int tt_type = TT_VT220;                 /* Terminal type, initially VT220 */
  1345. int tt_type_mode = TT_VT220;            /* Terminal type set by host command */
  1346. int tt_cursor = 0;                      /* Terminal cursor, 0 = Underline */
  1347. int tt_cursor_usr = 0;                  /* Users Terminal cursor type */
  1348. int tt_cursorena_usr = 1;               /* Users Terminal cursor enabled */
  1349. int tt_cursor_blink = 1;                /* Terminal Cursor Blink */
  1350. int tt_answer = 0;                      /* Terminal answerback (disabled) */
  1351. int tt_scrsize[VNUM] = {512,512,512,1}; /* Terminal scrollback buffer size */
  1352. int tt_roll[VNUM] = {1,1,1,1};          /* Terminal roll (on) */
  1353. int tt_rkeys[VNUM] = {1,1,1,1};        /* Terminal roll keys (send) */
  1354. int tt_pacing = 0;                      /* Terminal output-pacing (none) */
  1355. int tt_ctstmo = 15;                     /* Terminal transmit-timeout */
  1356. int tt_codepage = -1;                   /* Terminal code-page */
  1357. int tt_update = 100;                    /* Terminal screen-update interval */
  1358. int tt_updmode = TTU_FAST;              /* Terminal screen-update mode FAST */
  1359. extern int updmode;
  1360. #ifndef KUI
  1361. int tt_status[VNUM] = {1,1,0,0};        /* Terminal status line displayed */
  1362. int tt_status_usr[VNUM] = {1,1,0,0};
  1363. #else  /* KUI */
  1364. extern CKFLOAT floatval;
  1365. CKFLOAT tt_linespacing[VNUM] = {1.0,1.0,1.0,1.0};
  1366. #ifdef K95G
  1367. int tt_status[VNUM] = {1,1,0,0};        /* Terminal status line displayed */
  1368. int tt_status_usr[VNUM] = {1,1,0,0};
  1369. #else /* K95G */
  1370. int tt_status[VNUM] = {0,0,0,0};        /* Terminal status line displayed */
  1371. int tt_status_usr[VNUM] = {0,0,0,0};
  1372. #endif /* K95G */
  1373. #endif /* KUI */
  1374. int tt_senddata = 0;                    /* Let host read terminal data */
  1375. extern int wy_blockend;                 /* Terminal Send Data EOB type */
  1376. int tt_hidattr = 1;                     /* Attributes are hidden */
  1377.  
  1378. extern unsigned char colornormal, colorselect,
  1379. colorunderline, colorstatus, colorhelp, colorborder,
  1380. colorgraphic, colordebug, colorreverse, coloritalic;
  1381.  
  1382. extern int trueblink, trueunderline, truereverse, trueitalic, truedim;
  1383.  
  1384. extern int bgi, fgi;
  1385. extern int scrninitialized[];
  1386.  
  1387. struct keytab audibletab[] = {          /* Terminal Bell Audible mode */
  1388.     { "beep",          XYB_BEEP, 0 },   /* Values ORd with bell mode */
  1389.     { "system-sounds", XYB_SYS,  0 }
  1390. };
  1391. int naudibletab = sizeof(audibletab)/sizeof(struct keytab);
  1392.  
  1393. struct keytab akmtab[] = {              /* Arrow key mode */
  1394.     { "application", TTK_APPL, 0 },
  1395.     { "cursor",      TTK_NORM, 0 }
  1396. };
  1397. struct keytab kpmtab[] = {              /* Keypad mode */
  1398.     { "application", TTK_APPL, 0 },
  1399.     { "numeric",     TTK_NORM, 0 }
  1400. };
  1401.  
  1402. struct keytab ttcolmodetab[] = {
  1403.     { "current-color", 0, 0 },
  1404.     { "default-color", 1, 0 }
  1405. };
  1406. int ncolmode = sizeof(ttcolmodetab)/sizeof(struct keytab);
  1407.  
  1408. #define TTCOLNOR  0
  1409. #define TTCOLREV  1
  1410. #define TTCOLUND  2
  1411. #define TTCOLSTA  3
  1412. #define TTCOLHLP  4
  1413. #define TTCOLBOR  5
  1414. #define TTCOLSEL  6
  1415. #define TTCOLDEB  7
  1416. #define TTCOLGRP  8
  1417. #define TTCOLITA  9
  1418. #define TTCOLRES  10
  1419. #define TTCOLERA  11
  1420.  
  1421. struct keytab ttycoltab[] = {                   /* Terminal Screen coloring */
  1422.     { "border",             TTCOLBOR, 0 },      /* Screen border color */
  1423.     { "debug-terminal",     TTCOLDEB, 0 },      /* Debug color */
  1424.     { "erase",              TTCOLERA, 0 },      /* Erase mode */
  1425.     { "graphic",            TTCOLGRP, 0 },      /* Graphic Color */
  1426.     { "help-text",          TTCOLHLP, 0 },      /* Help screens */
  1427.     { "italic",             TTCOLITA, 0 },      /* Italic Color */
  1428.     { "normal",             TTCOLNOR, CM_INV }, /* Normal screen text */
  1429.     { "reset-on-esc[0m",    TTCOLRES, 0 },      /* Reset on ESC [ 0 m */
  1430.     { "reverse-video",      TTCOLREV, 0 },      /* Reverse video */
  1431.     { "status-line",        TTCOLSTA, 0 },      /* Status line */
  1432.     { "selection",          TTCOLSEL, 0 },      /* Selection color */
  1433.     { "terminal-screen",    TTCOLNOR, 0 },      /* Better name than "normal" */
  1434.     { "underlined-text",    TTCOLUND, 0 }       /* Underlined text */
  1435. };
  1436. int ncolors = (sizeof(ttycoltab) / sizeof(struct keytab));
  1437.  
  1438. #define TTATTNOR  0
  1439. #define TTATTBLI  1
  1440. #define TTATTREV  2
  1441. #define TTATTUND  3
  1442. #define TTATTPRO  4
  1443. #define TTATTBLD  5
  1444. #define TTATTDIM  6
  1445. #define TTATTINV  7
  1446. #define TTATTITA  8
  1447. #define TTATTDONE 9
  1448.  
  1449. struct keytab ttyattrtab[] = {
  1450.     { "blink",     TTATTBLI, 0 },
  1451.     { "dim",       TTATTDIM, 0 },
  1452.     { "italic",    TTATTITA, 0 },
  1453.     { "protected", TTATTPRO, 0 },
  1454.     { "reverse",   TTATTREV, 0 },
  1455.     { "underline", TTATTUND, 0 }
  1456. };
  1457. int nattrib = (sizeof(ttyattrtab) / sizeof(struct keytab));
  1458.  
  1459. struct keytab ttyprotab[] = {
  1460.     { "blink",       TTATTBLI,  0 },
  1461.     { "bold",        TTATTBLD,  0 },
  1462.     { "dim",         TTATTDIM,  0 },
  1463.     { "done",        TTATTDONE, CM_INV },
  1464.     { "invisible",   TTATTINV,  0 },
  1465.     { "italic",      TTATTITA,  0 },
  1466.     { "normal",      TTATTNOR,  0 },
  1467.     { "reverse",     TTATTREV,  0 },
  1468.     { "underlined",  TTATTUND,  0 }
  1469.  
  1470. };
  1471. int nprotect = (sizeof(ttyprotab) / sizeof(struct keytab));
  1472.  
  1473. struct keytab ttyseobtab[] = {
  1474.     { "crlf_etx",  1, 0 },
  1475.     { "us_cr",     0, 0 }
  1476. };
  1477.  
  1478. struct keytab ttyclrtab[] = {           /* Colors */
  1479.     { "black",         0, 0      },
  1480.     { "blue",          1, 0      },
  1481.     { "brown",         6, 0      },
  1482.     { "cyan",          3, 0      },
  1483.     { "darkgray",      8, CM_INV },
  1484.     { "dgray",         8, 0      },
  1485.     { "green",         2, 0      },
  1486.     { "lblue",         9, CM_INV },
  1487.     { "lcyan",        11, CM_INV },
  1488.     { "lgray",         7, CM_INV },
  1489.     { "lgreen",       10, CM_INV },
  1490.     { "lightblue",     9, 0      },
  1491.     { "lightcyan",    11, 0      },
  1492.     { "lightgray",     7, 0      },
  1493.     { "lightgreen",   10, 0      },
  1494.     { "lightmagenta", 13, 0      },
  1495.     { "lightred",     12, 0      },
  1496.     { "lmagenta",     13, CM_INV },
  1497.     { "lred",         12, CM_INV },
  1498.     { "magenta",       5, 0      },
  1499.     { "red",           4, 0      },
  1500.     { "white",        15, 0      },
  1501.     { "yellow",       14, 0      }
  1502. };
  1503. int nclrs = (sizeof (ttyclrtab) / sizeof (struct keytab));
  1504.  
  1505. struct keytab ttycurtab[] = {
  1506.     { "full",        TTC_BLOCK, 0 },
  1507.     { "half",        TTC_HALF,  0 },
  1508.     { "underline",   TTC_ULINE, 0 }
  1509. };
  1510. int ncursors = 3;
  1511.  
  1512. struct keytab ttyptab[] = {
  1513.     { "aaa",      TT_AAA,     CM_INV },     /* AnnArbor */
  1514.     { "adm3a",    TT_ADM3A,   0 },          /* LSI ADM-3A */
  1515.     { "adm5",     TT_ADM5,    0 },          /* LSI ADM-5 */
  1516.     { "aixterm",  TT_AIXTERM, 0 },          /* IBM AIXterm */
  1517.     { "annarbor", TT_AAA,     0 },          /* AnnArbor */
  1518.     { "ansi-bbs", TT_ANSI,    0 },          /* ANSI.SYS (BBS) */
  1519.     { "at386",    TT_AT386,   0 },          /* Unixware ANSI */
  1520.     { "avatar/0+",TT_ANSI,    0 },          /* AVATAR/0+ */
  1521.     { "ba80",     TT_BA80,    0 },          /* Nixdorf BA80 */
  1522.     { "be",       TT_BEOS,    CM_INV|CM_ABR },
  1523.     { "beos-ansi",TT_BEOS,    CM_INV },     /* BeOS ANSI */
  1524.     { "beterm",   TT_BEOS,    0 },          /* BeOS Terminal (as of PR2 ) */
  1525.     { "d200",     TT_DG200,   CM_INV|CM_ABR }, /* Data General DASHER 200 */
  1526.     { "d210",     TT_DG210,   CM_INV|CM_ABR }, /* Data General DASHER 210 */
  1527.     { "d217",     TT_DG217,   CM_INV|CM_ABR }, /* Data General DASHER 217 */
  1528.     { "dg200",    TT_DG200,   0 },          /* Data General DASHER 200 */
  1529.     { "dg210",    TT_DG210,   0 },          /* Data General DASHER 210 */
  1530.     { "dg217",    TT_DG217,   0 },          /* Data General DASHER 217 */
  1531.     { "h1500",    TT_HZL1500, CM_INV },     /* Hazeltine 1500 */
  1532.     { "h19",      TT_H19,     CM_INV },     /* Heath-19 */
  1533.     { "heath19",  TT_H19,     0 },          /* Heath-19 */
  1534.     { "hft",      TT_HFT,     0 },          /* IBM High Function Terminal */
  1535.     { "hp2621a",  TT_HP2621,  0 },          /* HP 2621A */
  1536.     { "hpterm",   TT_HPTERM,  0 },          /* HP TERM */
  1537.     { "hz1500",   TT_HZL1500, 0 },          /* Hazeltine 1500 */
  1538.     { "ibm3151",  TT_IBM31,   0 },          /* IBM 3101-xx,3161 */
  1539.     { "linux",    TT_LINUX,   0 },          /* Linux */
  1540.     { "qansi",    TT_QANSI,   0 },          /* QNX ANSI */
  1541.     { "qnx",      TT_QNX,     0 },          /* QNX Console */
  1542.     { "scoansi",  TT_SCOANSI, 0 },          /* SCO ANSI */
  1543.     { "sni-97801",TT_97801,   0 },          /* SNI 97801 */
  1544.     { "sun",      TT_SUN,     0 },          /* SUN Console */
  1545. /*
  1546.   The idea of NONE is to let the console driver handle the escape sequences,
  1547.   which, in theory at least, would give not only ANSI emulation, but also any
  1548.   other kind of emulation that might be provided by alternative console
  1549.   drivers, if any existed.
  1550.  
  1551.   For this to work, ckocon.c would need to be modified to make higher-level
  1552.   calls, like VioWrtTTY(), DosWrite(), or (simply) write(), rather than
  1553.   VioWrt*Cell() and similar, and it would also have to give up its rollback
  1554.   feature, and its status line and help screens would also have to be
  1555.   forgotten or else done in an ANSI way.
  1556.  
  1557.   As matters stand, we already have perfectly good ANSI emulation built in,
  1558.   and there are no alternative console drivers available, so there is no point
  1559.   in having a terminal type of NONE, so it is commented out.  However, should
  1560.   you uncomment it, it will work like a "glass tty" -- no escape sequence
  1561.   interpretation at all; somewhat similar to debug mode, except without the
  1562.   debugging (no highlighting of control chars or escape sequences); help
  1563.   screens, status line, and rollback will still work.
  1564. */
  1565. #ifdef OS2PM
  1566. #ifdef COMMENT
  1567.     { "tek4014", TT_TEK40,  0 },
  1568. #endif /* COMMENT */
  1569. #endif /* OS2PM */
  1570.     { "tty",     TT_NONE,   0 },
  1571.     { "tvi910+", TT_TVI910, 0 },
  1572.     { "tvi925",  TT_TVI925, 0 },
  1573.     { "tvi950",  TT_TVI950, 0 },
  1574.     { "vc404",   TT_VC4404, 0 },
  1575.     { "vc4404",  TT_VC4404, CM_INV },
  1576.     { "vip7809", TT_VIP7809,0 },
  1577.     { "vt100",   TT_VT100,  0 },
  1578.     { "vt102",   TT_VT102,  0 },
  1579.     { "vt220",   TT_VT220,  0 },
  1580.     { "vt220pc", TT_VT220PC,0 },
  1581.     { "vt320",   TT_VT320,  0 },
  1582.     { "vt320pc", TT_VT320PC,0 },
  1583.     { "vt52",    TT_VT52,   0 },
  1584. #ifdef NT
  1585.     { "vtnt",    TT_VTNT,   0 },
  1586. #else /* NT */
  1587.     { "vtnt",    TT_VTNT,  CM_INV },
  1588. #endif /* NT */
  1589.     { "wy160",   TT_WY160,  0 },
  1590.     { "wy30",    TT_WY30,   0 },
  1591.     { "wy370",   TT_WY370,  0 },
  1592.     { "wy50",    TT_WY50,   0 },
  1593.     { "wy60",    TT_WY60,   0 },
  1594.     { "wyse30",  TT_WY30,   CM_INV },
  1595.     { "wyse370", TT_WY370,  CM_INV },
  1596.     { "wyse50",  TT_WY50,   CM_INV },
  1597.     { "wyse60",  TT_WY60,   CM_INV }
  1598. };
  1599. int nttyp = (sizeof(ttyptab) / sizeof(struct keytab));
  1600.  
  1601. struct keytab ttkeytab[] = {
  1602.     { "aaa",       TT_AAA,        CM_INV },        /* AnnArbor */
  1603.     { "adm3a",     TT_ADM3A,      0 },             /* LSI ADM-3A */
  1604.     { "adm5",      TT_ADM5,       0 },             /* LSI ADM-5 */
  1605.     { "aixterm",   TT_AIXTERM,    0 },             /* IBM AIXterm */
  1606.     { "annarbor",  TT_AAA,        0 },             /* AnnArbor */
  1607.     { "ansi-bbs",  TT_ANSI,       0 },             /* ANSI.SYS (BBS) */
  1608.     { "at386",     TT_AT386,      0 },             /* Unixware ANSI */
  1609.     { "avatar/0+", TT_ANSI,       0 },             /* AVATAR/0+ */
  1610.     { "ba80",      TT_BA80,       0 },             /* Nixdorf BA80 */
  1611.     { "be",        TT_BEOS,       CM_INV|CM_ABR },
  1612.     { "beos-ansi", TT_BEOS,       CM_INV },        /* BeOS ANSI */
  1613.     { "beterm",    TT_BEOS,       0 },             /* BeOS Terminal (DR2) */
  1614.     { "d200",      TT_DG200,      CM_INV|CM_ABR }, /* DG DASHER 200 */
  1615.     { "d210",      TT_DG210,      CM_INV|CM_ABR }, /* DG DASHER 210 */
  1616.     { "d217",      TT_DG217,      CM_INV|CM_ABR }, /* DG DASHER 217 */
  1617.     { "dg200",     TT_DG200,      0 },             /* DG DASHER 200 */
  1618.     { "dg210",     TT_DG210,      0 },             /* DG DASHER 210 */
  1619.     { "dg217",     TT_DG217,      0 },             /* DG DASHER 217 */
  1620.     { "emacs",     TT_KBM_EMACS,  0 },             /* Emacs mode */
  1621.     { "h19",       TT_H19,        CM_INV },        /* Heath-19 */
  1622.     { "heath19",   TT_H19,        0 },             /* Heath-19 */
  1623.     { "hebrew",    TT_KBM_HEBREW, 0 },             /* Hebrew mode */
  1624.     { "hft",       TT_HFT,        0 },             /* IBM High Function Term */
  1625.     { "hp2621a",   TT_HP2621,     0 },             /* HP 2621A */
  1626.     { "hpterm",    TT_HPTERM,     0 },             /* HP TERM */
  1627.     { "hz1500",    TT_HZL1500,    0 },             /* Hazeltine 1500 */
  1628.     { "ibm3151",   TT_IBM31,      0 },             /* IBM 3101-xx,3161 */
  1629.     { "linux",     TT_LINUX,      0 },             /* Linux */
  1630.     { "qansi",     TT_QANSI,      0 },             /* QNX ANSI */
  1631.     { "qnx",       TT_QNX,        0 },             /* QNX */
  1632.     { "russian",   TT_KBM_RUSSIAN,0 },             /* Russian mode */
  1633.     { "scoansi",   TT_SCOANSI,    0 },             /* SCO ANSI */
  1634.     { "sni-97801", TT_97801,      0 },             /* SNI 97801 */
  1635.     { "sun",       TT_SUN,        0 },             /* SUN Console */
  1636. #ifdef OS2PM
  1637. #ifdef COMMENT
  1638.     { "tek4014",   TT_TEK40,      0 },
  1639. #endif /* COMMENT */
  1640. #endif /* OS2PM */
  1641.     { "tty",       TT_NONE,       0 },
  1642.     { "tvi910+",   TT_TVI910,     0 },
  1643.     { "tvi925",    TT_TVI925,     0 },
  1644.     { "tvi950",    TT_TVI950,     0 },
  1645.     { "vc404",     TT_VC4404,     0 },
  1646.     { "vc4404",    TT_VC4404,     CM_INV },
  1647.     { "vip7809",   TT_VIP7809,    0 },
  1648.     { "vt100",     TT_VT100,      0 },
  1649.     { "vt102",     TT_VT102,      0 },
  1650.     { "vt220",     TT_VT220,      0 },
  1651.     { "vt220pc",   TT_VT220PC,    0 },
  1652.     { "vt320",     TT_VT320,      0 },
  1653.     { "vt320pc",   TT_VT320PC,    0 },
  1654.     { "vt52",      TT_VT52,       0 },
  1655.     { "vtnt",      TT_VTNT,       CM_INV },
  1656.     { "wp",        TT_KBM_WP,     0 },             /* Word Perfect mode */
  1657.     { "wy160",     TT_WY160,      0 },
  1658.     { "wy30",      TT_WY30,       0 },
  1659.     { "wy370",     TT_WY370,      0 },
  1660.     { "wy50",      TT_WY50,       0 },
  1661.     { "wy60",      TT_WY60,       0 },
  1662.     { "wyse30",    TT_WY30,       CM_INV },
  1663.     { "wyse370",   TT_WY370,      CM_INV },
  1664.     { "wyse50",    TT_WY50,       CM_INV },
  1665.     { "wyse60",    TT_WY60,       CM_INV }
  1666. };
  1667. int nttkey = (sizeof(ttkeytab) / sizeof(struct keytab));
  1668.  
  1669. #ifndef NOSETKEY
  1670. struct keytab kbmodtab[] = {
  1671.     { "emacs",   KBM_EM, 0      },
  1672.     { "english", KBM_EN, CM_INV },
  1673.     { "hebrew",  KBM_HE, 0      },
  1674.     { "normal",  KBM_EN, 0      },
  1675.     { "none",    KBM_EN, CM_INV },
  1676.     { "russian", KBM_RU, 0      },
  1677.     { "wp",      KBM_WP, 0      }
  1678. };
  1679. int nkbmodtab = (sizeof(kbmodtab) / sizeof(struct keytab));
  1680. #endif /* NOSETKEY */
  1681. #endif /* NOLOCAL */
  1682.  
  1683. int tt_inpacing = 0;                    /* input-pacing (none) */
  1684.  
  1685. struct keytab prtytab[] = { /* OS/2 Priority Levels */
  1686.     { "foreground-server", XYP_SRV, 0       },
  1687.     { "idle",              XYP_IDLE, CM_INV },
  1688.     { "regular",           XYP_REG, 0       },
  1689.     { "time-critical",     XYP_RTP, 0       }
  1690. };
  1691. int nprty = (sizeof(prtytab) / sizeof(struct keytab));
  1692. #endif /* OS2 */
  1693.  
  1694. #ifdef NT
  1695. struct keytab win95tab[] = { /* Win95 work-arounds */
  1696.     { "8.3-filenames",         XYW8_3,    0 },
  1697.     { "alt-gr",                XYWAGR,    0 },
  1698.     { "horizontal-scan-line-substitutions", XYWHSL, 0 },
  1699.     { "keyboard-translation",  XYWKEY,    0 },
  1700.     { "lucida-substitutions",  XYWLUC,    0 },
  1701.     { "overlapped-io",         XYWOIO,    0 },
  1702.     { "popups",                XYWPOPUP,  0 },
  1703.     { "select-bug",            XYWSELECT, 0 }
  1704. };
  1705. int nwin95 = (sizeof(win95tab) / sizeof(struct keytab));
  1706. #endif /* NT */
  1707.  
  1708. #ifdef OS2MOUSE
  1709. extern int wideresult;
  1710. int tt_mouse = 1;                       /* Terminal mouse on/off */
  1711.  
  1712. struct keytab mousetab[] = {            /* Mouse items */
  1713.     { "activate", XYM_ON,     0 },
  1714.     { "button",   XYM_BUTTON, 0 },
  1715.     { "clear",    XYM_CLEAR,  0 },
  1716.     { "debug",    XYM_DEBUG,  0 }
  1717. };
  1718. int nmtab = (sizeof(mousetab)/sizeof(struct keytab));
  1719.  
  1720. struct keytab mousebuttontab[] = {      /* event button */
  1721.     { "1",             XYM_B1, 0 },
  1722.     { "2",             XYM_B2, 0 },
  1723.     { "3",             XYM_B3, 0 },
  1724.     { "one",           XYM_B1, CM_INV },
  1725.     { "three",         XYM_B3, CM_INV },
  1726.     { "two",           XYM_B2, CM_INV }
  1727. };
  1728. int nmbtab = (sizeof(mousebuttontab) / sizeof(struct keytab));
  1729.  
  1730. struct keytab mousemodtab[] = {         /* event button key modifier */
  1731.     { "alt",              XYM_ALT,   0 },
  1732.     { "alt-shift",        XYM_SHIFT|XYM_ALT, 0 },
  1733.     { "ctrl",             XYM_CTRL,  0 },
  1734.     { "ctrl-alt",         XYM_CTRL|XYM_ALT, 0 },
  1735.     { "ctrl-alt-shift",   XYM_CTRL|XYM_SHIFT|XYM_ALT, 0 },
  1736.     { "ctrl-shift",       XYM_CTRL|XYM_SHIFT, 0 },
  1737.     { "none",             0, 0 },
  1738.     { "shift",            XYM_SHIFT, 0 }
  1739. };
  1740. int nmmtab = (sizeof(mousemodtab) / sizeof(struct keytab));
  1741.  
  1742. struct keytab mclicktab[] = {           /* event button click modifier */
  1743.     { "click",        XYM_C1,   0 },
  1744.     { "drag",         XYM_DRAG, 0 },
  1745.     { "double-click", XYM_C2,   0 }
  1746. };
  1747. int nmctab = (sizeof(mclicktab) / sizeof(struct keytab));
  1748.  
  1749. #ifndef NOKVERBS
  1750. extern int nkverbs;
  1751. extern struct keytab kverbs[];
  1752. #endif /* NOKVERBS */
  1753. #endif /* OS2MOUSE */
  1754.  
  1755. /* #ifdef VMS */
  1756. struct keytab fbtab[] = {               /* Binary record types for VMS */
  1757.     { "fixed",     XYFT_B, 0 },         /* Fixed is normal for binary */
  1758.     { "undefined", XYFT_U, 0 }          /* Undefined if they ask for it */
  1759. };
  1760. int nfbtyp = (sizeof(fbtab) / sizeof(struct keytab));
  1761. /* #endif */
  1762.  
  1763. #ifdef VMS
  1764. struct keytab lbltab[] = {              /* Labeled File info */
  1765.     { "acl",         LBL_ACL, 0 },
  1766.     { "backup-date", LBL_BCK, 0 },
  1767.     { "name",        LBL_NAM, 0 },
  1768.     { "owner",       LBL_OWN, 0 },
  1769.     { "path",        LBL_PTH, 0 }
  1770. };
  1771. int nlblp = (sizeof(lbltab) / sizeof(struct keytab));
  1772. #else
  1773. #ifdef OS2
  1774. struct keytab lbltab[] = {              /* Labeled File info */
  1775.     { "archive",   LBL_ARC, 0 },
  1776.     { "extended",  LBL_EXT, 0 },
  1777.     { "hidden",    LBL_HID, 0 },
  1778.     { "read-only", LBL_RO,  0 },
  1779.     { "system",    LBL_SYS, 0 }
  1780. };
  1781. int nlblp = (sizeof(lbltab) / sizeof(struct keytab));
  1782. #endif /* OS2 */
  1783. #endif /* VMS */
  1784.  
  1785. #ifdef CK_CURSES
  1786. #ifdef CK_PCT_BAR
  1787. static struct keytab fdftab[] = {       /* SET FILE DISPLAY FULL options */
  1788.     { "thermometer",    1, 0, },
  1789.     { "no-thermometer", 0, 0  }
  1790. };
  1791. extern int thermometer;
  1792. #endif /* CK_PCT_BAR */
  1793. #endif /* CK_CURSES */
  1794.  
  1795. static struct keytab fdtab[] = {        /* SET FILE DISPLAY options */
  1796. #ifdef MAC                              /* Macintosh */
  1797.     { "fullscreen", XYFD_R,      0 },   /* Full-screen but not curses */
  1798.     { "none",       XYFD_N,      0 },
  1799.     { "off",        XYFD_N, CM_INV },
  1800.     { "on",         XYFD_R, CM_INV },
  1801.     { "quiet",      XYFD_N, CM_INV },
  1802. #else                                   /* Not Mac */
  1803.     { "brief", XYFD_B, 0 },             /* Brief */
  1804.     { "crt", XYFD_S, 0 },               /* CRT display */
  1805. #ifdef CK_CURSES
  1806. #ifdef COMMENT
  1807.     { "curses",     XYFD_C,  CM_INV },  /* Full-screen, curses */
  1808. #endif /* COMMENT */
  1809.     { "fullscreen", XYFD_C,  0 },       /* Full-screen, whatever the method */
  1810. #endif /* CK_CURSES */
  1811. #ifdef KUI
  1812.     { "gui",    XYFD_G, 0 },            /* GUI */
  1813. #endif /* KUI */        
  1814.     { "none",   XYFD_N, 0      },       /* No display */
  1815.     { "off",    XYFD_N, CM_INV },       /* Ditto */
  1816.     { "on",     XYFD_R, CM_INV },       /* On = Serial */
  1817.     { "quiet",  XYFD_N, CM_INV },       /* No display */
  1818.     { "serial", XYFD_R, 0      },       /* Serial */
  1819. #endif /* MAC */
  1820.     { "", 0, 0 }
  1821. };
  1822. int nfdtab = (sizeof(fdtab) / sizeof(struct keytab)) - 1;
  1823.  
  1824. struct keytab rsrtab[] = {              /* For REMOTE SET RECEIVE */
  1825.     { "packet-length", XYLEN,  0 },
  1826.     { "timeout",       XYTIMO, 0 }
  1827. };
  1828. int nrsrtab = (sizeof(rsrtab) / sizeof(struct keytab));
  1829.  
  1830. /* Send/Receive Parameters */
  1831.  
  1832. struct keytab srtab[] = {
  1833.     { "backup", XYBUP, 0 },
  1834. #ifndef NOCSETS
  1835.     { "character-set-selection", XYCSET, 0 },
  1836. #endif /* NOCSETS */
  1837.     { "control-prefix", XYQCTL, 0 },
  1838. #ifdef CKXXCHAR
  1839.     { "double-character", XYDBL, 0 },
  1840. #endif /* CKXXCHAR */
  1841.     { "end-of-packet", XYEOL, 0 },
  1842. #ifdef PIPESEND
  1843.     { "filter", XYFLTR, 0 },
  1844. #endif /* PIPESEND */
  1845. #ifdef CKXXCHAR
  1846.     { "ignore-character", XYIGN, 0 },
  1847. #endif /* CKXXCHAR */
  1848.     { "i-packets", 993, 0 },
  1849.     { "move-to", XYMOVE, 0 },
  1850.     { "negotiation-string-max-length", XYINIL, CM_INV },
  1851.     { "packet-length", XYLEN, 0 },
  1852.     { "pad-character", XYPADC, 0 },
  1853.     { "padding", XYNPAD, 0 },
  1854.     { "pathnames", XYFPATH, 0 },
  1855.     { "pause", XYPAUS, 0 },
  1856. #ifdef CK_PERMS
  1857.     { "permissions", 994, 0},        /* 206 */
  1858. #endif /* CK_PERMS */
  1859.     { "quote", XYQCTL, CM_INV },        /* = CONTROL-PREFIX */
  1860.     { "rename-to", XYRENAME, 0 },
  1861.     { "start-of-packet", XYMARK, 0 },
  1862.     { "timeout", XYTIMO, 0 },
  1863. #ifdef VMS
  1864.     { "version-numbers", 887, 0 },      /* VMS version numbers */
  1865. #endif /* VMS */
  1866.     { "", 0, 0 }
  1867. };
  1868. int nsrtab = (sizeof(srtab) / sizeof(struct keytab)) - 1;
  1869.  
  1870. #ifdef UNICODE
  1871. #define UCS_BOM 1
  1872. #define UCS_BYT 2
  1873. static struct keytab ucstab[] = {
  1874.     { "bom",        UCS_BOM, 0 },
  1875.     { "byte-order", UCS_BYT, 0 },
  1876.     { "", 0, 0 }
  1877. };
  1878. int nucstab = (sizeof(ucstab) / sizeof(struct keytab)) - 1;
  1879.  
  1880. static struct keytab botab[] = {
  1881.     { "big-endian",    0, 0 },
  1882.     { "little-endian", 1, 0 }
  1883. };
  1884. static int nbotab = 2;
  1885. #endif /* UNICODE */
  1886.  
  1887. /* REMOTE SET */
  1888.  
  1889. struct keytab rmstab[] = {
  1890.     { "attributes",  XYATTR, 0      },
  1891.     { "block-check", XYCHKT, 0      },
  1892.     { "file",        XYFILE, 0      },
  1893.     { "incomplete",  XYIFD,  CM_INV },  /* = REMOTE SET FILE INCOMPLETE */
  1894.     { "match",       XYMATCH,0      },
  1895.     { "receive",     XYRECV, 0      },
  1896.     { "retry",       XYRETR, 0      },
  1897.     { "server",      XYSERV, 0      },
  1898.     { "transfer",    XYXFER, 0      },
  1899.     { "window",      XYWIND, 0      },
  1900.     { "xfer",        XYXFER, CM_INV }
  1901. };
  1902. int nrms = (sizeof(rmstab) / sizeof(struct keytab));
  1903.  
  1904. struct keytab attrtab[] = {
  1905. #ifdef STRATUS
  1906.     { "account",       AT_ACCT, 0 },
  1907. #endif /* STRATUS */
  1908.     { "all",           AT_XALL, 0 },
  1909. #ifdef COMMENT
  1910.     { "blocksize",     AT_BLKS, 0 },    /* (not used) */
  1911. #endif /* COMMENT */
  1912. #ifndef NOCSETS
  1913.     { "character-set", AT_ENCO, 0 },
  1914. #endif /* NOCSETS */
  1915. #ifdef STRATUS
  1916.     { "creator",       AT_CREA, 0 },
  1917. #endif /* STRATUS */
  1918.     { "date",          AT_DATE, 0 },
  1919.     { "disposition",   AT_DISP, 0 },
  1920.     { "encoding",      AT_ENCO, CM_INV },
  1921.     { "format",        AT_RECF, CM_INV },
  1922.     { "length",        AT_LENK, 0 },
  1923.     { "off",           AT_ALLN, 0 },
  1924.     { "on",            AT_ALLY, 0 },
  1925. #ifdef COMMENT
  1926.     { "os-specific",   AT_SYSP, 0 },    /* (not used by UNIX or VMS) */
  1927. #endif /* COMMENT */
  1928. #ifdef CK_PERMS
  1929.     { "protection",    AT_LPRO, 0 },
  1930.     { "permissions",   AT_LPRO, CM_INV },
  1931. #endif /* CK_PERMS */
  1932.     { "record-format", AT_RECF, 0 },
  1933.     { "system-id",     AT_SYSI, 0 },
  1934.     { "type",          AT_FTYP, 0 }
  1935. };
  1936. int natr = (sizeof(attrtab) / sizeof(struct keytab)); /* how many attributes */
  1937.  
  1938. #ifdef CKTIDLE
  1939. struct keytab idlacts[] = {
  1940.     { "exit",       IDLE_EXIT, 0 },
  1941.     { "hangup",     IDLE_HANG, 0 },
  1942.     { "output",     IDLE_OUT,  0 },
  1943.     { "return",     IDLE_RET,  0 },
  1944. #ifdef TNCODE
  1945.     { "telnet-nop", IDLE_TNOP, 0 },
  1946.     { "telnet-ayt", IDLE_TAYT, 0 },
  1947. #endif /* TNCODE */
  1948.     { "", 0, 0 }
  1949. };
  1950. int nidlacts = (sizeof(idlacts) / sizeof(struct keytab)) - 1;
  1951. #endif /* CKTIDLE */
  1952.  
  1953. #ifndef NOSPL
  1954. extern int indef, inecho, insilence, inbufsize, inautodl, inintr;
  1955. #ifdef CKFLOAT
  1956. extern CKFLOAT inscale;
  1957. #endif    /* CKFLOAT */
  1958. extern char * inpbuf, * inpbp;
  1959. #ifdef OS2
  1960. extern int interm;
  1961. #endif /* OS2 */
  1962. struct keytab inptab[] = {              /* SET INPUT parameters */
  1963. #ifdef CK_AUTODL
  1964.     { "autodownload",    IN_ADL, 0 },
  1965. #endif /* CK_AUTODL */
  1966.     { "buffer-length",   IN_BUF, 0 },
  1967.     { "cancellation",    IN_CAN, 0 },
  1968.     { "case",            IN_CAS, 0 },
  1969.     { "default-timeout", IN_DEF, CM_INV }, /* There is no default timeout */
  1970.     { "echo",            IN_ECH, 0 },
  1971. #ifdef OS2
  1972.     { "pacing",          IN_PAC, CM_INV },
  1973. #endif /* OS2 */
  1974.     { "scale-factor",    IN_SCA, 0 },
  1975.     { "silence",         IN_SIL, 0 },
  1976. #ifdef OS2
  1977.     { "terminal",        IN_TRM, 0 },
  1978. #endif /* OS2 */
  1979.     { "timeout-action",  IN_TIM, 0 }
  1980. };
  1981. int ninp = (sizeof(inptab) / sizeof(struct keytab));
  1982.  
  1983. struct keytab intimt[] = {              /* SET INPUT TIMEOUT parameters */
  1984.     { "proceed", 0, 0 },                /* 0 = proceed */
  1985.     { "quit",    1, 0 }                 /* 1 = quit */
  1986. };
  1987.  
  1988. struct keytab incast[] = {              /* SET INPUT CASE parameters */
  1989.     { "ignore",  0, 0 },                /* 0 = ignore */
  1990.     { "observe", 1, 0 }                 /* 1 = observe */
  1991. };
  1992. #endif /* NOSPL */
  1993.  
  1994. struct keytab nabltab[] = {             /* For any command that needs */
  1995.     { "disabled", 0, 0 },
  1996.     { "enabled",  1, 0 },
  1997.     { "off",      0, CM_INV },          /* these keywords... */
  1998.     { "on",       1, CM_INV }
  1999. };
  2000. int nnabltab = sizeof(nabltab) / sizeof(struct keytab);
  2001.  
  2002. #ifdef OS2
  2003. struct keytab tvctab[] = {              /* SET TERM VIDEO-CHANGE */
  2004.     { "disabled",     TVC_DIS, 0 },
  2005.     { "enabled",      TVC_ENA, 0 },
  2006. #ifdef NT
  2007.     { "win95-safe",   TVC_W95, 0 },
  2008. #endif /* NT */
  2009.     { "", 0, 0 }
  2010. };
  2011. int ntvctab = (sizeof(tvctab) / sizeof(struct keytab)) - 1;
  2012.  
  2013. struct keytab msktab[] = { /* SET MS-DOS KERMIT compatibilities */
  2014. #ifdef COMMENT
  2015.     { "color",    MSK_COLOR,  0 },
  2016. #endif /* COMMENT */
  2017.     { "file-renaming", MSK_REN, 0 },
  2018.     { "keycodes", MSK_KEYS,   0 }
  2019. };
  2020. int nmsk = (sizeof(msktab) / sizeof(struct keytab));
  2021.  
  2022. struct keytab scrnupd[] = {             /* SET TERMINAL SCREEN-UPDATE */
  2023.     { "fast",   TTU_FAST,   0 },
  2024.     { "smooth", TTU_SMOOTH, 0 }
  2025. };
  2026. int nscrnupd = (sizeof(scrnupd) / sizeof(struct keytab));
  2027.  
  2028. #ifdef PCFONTS
  2029. /* This definition of the term_font[] table is only for     */
  2030. /* the OS/2 Full Screen Session and is not used on Windows */
  2031. struct keytab term_font[] = {           /* SET TERMINAL FONT */
  2032. #ifdef COMMENT
  2033.     { "cp111", TTF_111, 0 },
  2034.     { "cp112", TTF_112, 0 },
  2035.     { "cp113", TTF_113, 0 },
  2036. #endif /* COMMENT */
  2037.     { "cp437", TTF_437, 0 },
  2038.     { "cp850", TTF_850, 0 },
  2039. #ifdef COMMENT
  2040.     { "cp851", TTF_851, 0 },
  2041. #endif /* COMMENT */
  2042.     { "cp852", TTF_852, 0 },
  2043. #ifdef COMMENT
  2044.     { "cp853", TTF_853, 0 },
  2045.     { "cp860", TTF_860, 0 },
  2046.     { "cp861", TTF_861, 0 },
  2047. #endif /* COMMENT */
  2048.     { "cp862", TTF_862, 0 },
  2049. #ifdef COMMENT
  2050.     { "cp863", TTF_863, 0 },
  2051.     { "cp864", TTF_864, 0 },
  2052.     { "cp865", TTF_865, 0 },
  2053. #endif /* COMMENT */
  2054.     { "cp866", TTF_866, 0 },
  2055. #ifdef COMMENT
  2056.     { "cp880", TTF_880, 0 },
  2057.     { "cp881", TTF_881, 0 },
  2058.     { "cp882", TTF_882, 0 },
  2059.     { "cp883", TTF_883, 0 },
  2060.     { "cp884", TTF_884, 0 },
  2061.     { "cp885", TTF_885, 0 },
  2062. #endif /* COMMENT */
  2063.     { "default",TTF_ROM,0 }
  2064. };
  2065. int ntermfont = (sizeof(term_font) / sizeof(struct keytab));
  2066. int tt_font = TTF_ROM;                  /* Terminal screen font */
  2067. #else /* PCFONTS */
  2068. #ifdef NT
  2069. #ifdef KUI
  2070. struct keytab * term_font = NULL;
  2071. struct keytab * _term_font = NULL;
  2072. char * tt_facename = NULL;
  2073. int ntermfont = 0;
  2074. int tt_font = 0;
  2075. int tt_font_size = 0;
  2076. #endif /* KUI */
  2077. #endif /* NT */
  2078. #endif /* PCFONTS */
  2079.  
  2080. struct keytab anbktab[] = {             /* For any command that needs */
  2081.     { "message", 2, 0 },                /* these keywords... */
  2082.     { "off",     0, 0 },
  2083.     { "on",      1, 0 },
  2084.     { "unsafe-messag0", 99, CM_INV },
  2085.     { "unsafe-message", 3,  CM_INV }
  2086. };
  2087. int nansbk = (sizeof(anbktab) / sizeof(struct keytab));
  2088.  
  2089. int win95_popup = 1;
  2090. #ifdef NT
  2091. #ifdef KUI
  2092. int win95lucida = 0;
  2093. int win95hsl = 1;
  2094. #else /* KUI */
  2095. int win95lucida = 1;
  2096. int win95hsl = 1;
  2097. #endif /* KUI */
  2098. #else /* NT */
  2099. int win95lucida = 0;
  2100. int win95hsl = 1;
  2101. #endif /* NT */
  2102. #ifdef NT
  2103. int win95altgr  = 0;
  2104. extern int win95selectbug;
  2105. extern int win95_8_3;
  2106.  
  2107. #ifdef COMMENT
  2108. extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(CHAR);
  2109. extern struct keytab tcstab[];
  2110. extern int ntcs;
  2111. #endif /* COMMENT */
  2112. extern int maxow, maxow_usr; owwait;    /* Overlapped I/O variables */
  2113. #endif /* NT */
  2114. #endif /* OS2 */
  2115.  
  2116.  
  2117. /* The following routines broken out of doprm() to give compilers a break. */
  2118.  
  2119. /*  S E T O N  --  Parse on/off (default on), set parameter to result  */
  2120.  
  2121. int
  2122. seton(prm) int *prm; {
  2123.     int x, y;
  2124.     if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  2125.     if ((x = cmcfm()) < 0) return(x);
  2126.     *prm = y;
  2127.     return(1);
  2128. }
  2129.  
  2130. /*  S E T O N A U T O --  Parse on/off/auto (default auto) & set result */
  2131.  
  2132. struct keytab onoffaut[] = {
  2133.     { "auto", SET_AUTO, 0 },            /* 2 */
  2134.     { "off",  SET_OFF,  0 },            /* 0 */
  2135.     { "on",   SET_ON,   0 }             /* 1 */
  2136. };
  2137.  
  2138. int
  2139. setonaut(prm) int *prm; {
  2140.     int x, y;
  2141.     if ((y = cmkey(onoffaut,3,"","auto",xxstring)) < 0) return(y);
  2142.     if ((x = cmcfm()) < 0) return(x);
  2143.     *prm = y;
  2144.     return(1);
  2145. }
  2146.  
  2147. /*  S E T N U M  --  Set parameter to result of cmnum() parse.  */
  2148. /*
  2149.  Call with pointer to integer variable to be set,
  2150.    x = number from cnum parse, y = return code from cmnum,
  2151.    max = maximum value to accept, -1 if no maximum.
  2152.  Returns -9 on failure, after printing a message, or 1 on success.
  2153. */
  2154. int
  2155. setnum(prm,x,y,max) int x, y, *prm, max; {
  2156.     debug(F101,"setnum","",y);
  2157.     if (y == -3) {
  2158.         printf("\n?Value required\n");
  2159.         return(-9);
  2160.     }
  2161.     if (y == -2) {
  2162.         printf("%s?Not a number: %s\n",cmflgs == 1 ? "" : "\n", atxbuf);
  2163.         return(-9);
  2164.     }
  2165.     if (y < 0) return(y);
  2166.     if (max > -1 && x > max) {
  2167.         printf("?Sorry, %d is the maximum\n",max);
  2168.         return(-9);
  2169.     }
  2170.     if ((y = cmcfm()) < 0) return(y);
  2171.     *prm = x;
  2172.     return(1);
  2173. }
  2174.  
  2175. /*  S E T C C  --  Set parameter var to an ASCII control character value.  */
  2176. /*
  2177.   Parses a number, or a literal control character, or a caret (^) followed
  2178.   by an ASCII character whose value is 63-95 or 97-122, then gets confirmation,
  2179.   then sets the parameter to the code value of the character given.  If there
  2180.   are any parse errors, they are returned, otherwise on success 1 is returned.
  2181. */
  2182. int
  2183. setcc(dflt,var) char *dflt; int *var; {
  2184.     int x, y;
  2185.     unsigned int c;
  2186.     char *hlpmsg = "Control character,\n\
  2187.  numeric ASCII value,\n\
  2188.  or in ^X notation,\n\
  2189.  or preceded by a backslash and entered literally";
  2190.  
  2191.     /* This is a hack to turn off complaints from expression evaluator. */
  2192.     x_ifnum = 1;
  2193.     y = cmnum(hlpmsg, dflt, 10, &x, xxstring); /* Parse a number */
  2194.     x_ifnum = 0;                               /* Allow complaints again */
  2195.     if (y < 0) {                        /* Parse failed */
  2196.         if (y != -2)                    /* Reparse needed or somesuch */
  2197.           return(y);                    /* Pass failure back up the chain */
  2198.     }
  2199.     /* Real control character or literal 8-bit character... */
  2200.  
  2201.     for (c = strlen(atmbuf) - 1; c > 0; c--) /* Trim */
  2202.       if (atmbuf[c] == SP) atmbuf[c] = NUL;
  2203.  
  2204.     if (y < 0) {                        /* It was not a number */
  2205.         if (((c = atmbuf[0])) && !atmbuf[1]) { /* Literal character? */
  2206.             c &= 0xff;
  2207.             if (((c > 31) && (c < 127)) || (c > 255)) {
  2208.                 printf("\n?%d: Out of range - must be 0-31 or 127-255\n",c);
  2209.                 return(-9);
  2210.             } else {
  2211.                 if ((y = cmcfm()) < 0)  /* Confirm */
  2212.                   return(y);
  2213.                 *var = c;               /* Set the variable */
  2214.                 return(1);
  2215.             }
  2216.         } else if (atmbuf[0] == '^' && !atmbuf[2]) { /* Or ^X notation? */
  2217.             c = atmbuf[1];
  2218.             if (islower((char) c))      /* Uppercase lowercase letters */
  2219.               c = toupper(c);
  2220.             if (c > 62 && c < 96) {     /* Check range */
  2221.                 if ((y = cmcfm()) < 0)
  2222.                   return(y);
  2223.                 *var = ctl(c);          /* OK */
  2224.                 return(1);
  2225.             } else {
  2226.                 printf("?Not a control character - %s\n", atmbuf);
  2227.                 return(-9);
  2228.             }
  2229.         } else {                        /* Something illegal was typed */
  2230.             printf("?Invalid - %s\n", atmbuf);
  2231.             return(-9);
  2232.         }
  2233.     }
  2234.     if (((x > 31) && (x < 127)) || (x > 255)) { /* They typed a number */
  2235.         printf("\n?%d: Out of range - must be 0-31 or 127-255\n",x);
  2236.         return(-9);
  2237.     }
  2238.     if ((y = cmcfm()) < 0)              /* In range, confirm */
  2239.       return(y);
  2240.     *var = x;                           /* Set variable */
  2241.     return(1);
  2242. }
  2243.  
  2244. #ifndef NOSPL                           /* The SORT command... */
  2245.  
  2246. static struct keytab srtswtab[] = {     /* SORT command switches */
  2247.     { "/case",    SRT_CAS, CM_ARG },
  2248.     { "/key",     SRT_KEY, CM_ARG },
  2249.     { "/numeric", SRT_NUM, 0 },
  2250.     { "/range",   SRT_RNG, CM_ARG },
  2251.     { "/reverse", SRT_REV, 0 }
  2252. };
  2253. static int nsrtswtab = sizeof(srtswtab)/sizeof(struct keytab);
  2254.  
  2255. extern char **a_ptr[];                  /* Array pointers */
  2256. extern int a_dim[];                     /* Array dimensions */
  2257.  
  2258. int
  2259. dosort() {                              /* Do the SORT command */
  2260.     char c, *p = NULL, ** ap, ** xp = NULL;
  2261.     struct FDB sw, fl, cm;
  2262.     int hi, lo;
  2263.     int xn = 0, xr = -1, xk = -1, xc = -1, xs = 0;
  2264.     int getval = 0, range[2], confirmed = 0;
  2265.  
  2266.     cmfdbi(&sw,                         /* First FDB - command switches */
  2267.            _CMKEY,                      /* fcode */
  2268.            "Array name or switch",
  2269.            "",                          /* default */
  2270.            "",                          /* addtl string data */
  2271.            nsrtswtab,                   /* addtl numeric data 1: tbl size */
  2272.            4,                           /* addtl numeric data 2: 4 = cmswi */
  2273.            NULL,                        /* Processing function */
  2274.            srtswtab,                    /* Keyword table */
  2275.            &fl                          /* Pointer to next FDB */
  2276.            );
  2277.     cmfdbi(&fl,                         /* Anything that doesn't match */
  2278.            _CMFLD,                      /* fcode */
  2279.            "Array name",                /* hlpmsg */
  2280.            "",                          /* default */
  2281.            "",                          /* addtl string data */
  2282.            0,                           /* addtl numeric data 1 */
  2283.            0,                           /* addtl numeric data 2 */
  2284.            NULL,
  2285.            NULL,
  2286.            &cm
  2287.            );
  2288.     cmfdbi(&cm,                         /* Or premature confirmation */
  2289.            _CMCFM,                      /* fcode */
  2290.            "",                          /* hlpmsg */
  2291.            "",                          /* default */
  2292.            "",                          /* addtl string data */
  2293.            0,                           /* addtl numeric data 1 */
  2294.            0,                           /* addtl numeric data 2 */
  2295.            NULL,
  2296.            NULL,
  2297.            NULL
  2298.            );
  2299.  
  2300.     range[0] = -1;
  2301.     range[1] = -1;
  2302.  
  2303.     while (1) {                         /* Parse 0 or more switches */
  2304.         x = cmfdb(&sw);
  2305.         if (x < 0)
  2306.           return(x);
  2307.         if (cmresult.fcode != _CMKEY)   /* Break out if not a switch */
  2308.           break;
  2309.         c = cmgbrk();
  2310.         getval = (c == ':' || c == '=');
  2311.         if (getval && !(cmresult.kflags & CM_ARG)) {
  2312.             printf("?This switch does not take arguments\n");
  2313.             return(-9);
  2314.         }
  2315.         switch (cmresult.nresult) {
  2316.           case SRT_REV:
  2317.             xr = 1;
  2318.             break;
  2319.           case SRT_KEY:
  2320.             if (getval) {
  2321.                 if ((y = cmnum("Column for comparison (1-based)",
  2322.                                "1",10,&x,xxstring)) < 0)
  2323.                   return(y);
  2324.                 xk = x - 1;
  2325.             } else
  2326.               xk = 0;
  2327.             break;
  2328.           case SRT_CAS:
  2329.             if (getval) {
  2330.                 if ((y = cmkey(onoff,2,"","on",xxstring)) < 0)
  2331.                   return(y);
  2332.                 xc = y;
  2333.             } else
  2334.               xc = 1;
  2335.             break;
  2336.           case SRT_RNG:                 /* /RANGE */
  2337.             if (getval) {
  2338.                 char buf[32];
  2339.                 char buf2[16];
  2340.                 int i;
  2341.                 char * p, * q;
  2342.                 if ((y = cmfld("low:high element","1",&s,NULL)) < 0)
  2343.                   return(y);
  2344.                 s = brstrip(s);
  2345.                 ckstrncpy(buf,s,32);
  2346.                 p = buf;
  2347.                 for (i = 0; *p && i < 2; i++) { /* Get low and high */
  2348.                     q = p;              /* Start of this piece */
  2349.                     while (*p) {        /* Find end of this piece */
  2350.                         if (*p == ':') {
  2351.                             *p = NUL;
  2352.                             p++;
  2353.                             break;
  2354.                         }
  2355.                         p++;
  2356.                     }
  2357.                     y = 15;             /* Evaluate this piece */
  2358.                     s = buf2;
  2359.                     zzstring(q,&s,&y);
  2360.                     s = evalx(buf2);
  2361.                     if (s) if (*s) ckstrncpy(buf2,s,16);
  2362.                     if (!rdigits(buf2)) {
  2363.                         printf("?Not numeric: %s\n",buf2);
  2364.                         return(-9);
  2365.                     }
  2366.                     range[i] = atoi(buf2);
  2367.                 }
  2368.             }
  2369.             break;
  2370.           case SRT_NUM:                 /* /NUMERIC */
  2371.             xn = 1;
  2372.             break;
  2373.           default:
  2374.             return(-2);
  2375.         }
  2376.     }
  2377.     switch (cmresult.fcode) {
  2378.       case _CMCFM:
  2379.         confirmed = 1;
  2380.         break;
  2381.       case _CMFLD:
  2382.         ckstrncpy(line,cmresult.sresult,LINBUFSIZ); /* Safe copy of name */
  2383.         s = line;
  2384.         break;
  2385.       default:
  2386.         printf("?Unexpected function code: %d\n",cmresult.fcode);
  2387.         return(-9);
  2388.     }
  2389.     if (confirmed) {
  2390.         printf("?Array name required\n");
  2391.         return(-9);
  2392.     }
  2393.     ckmakmsg(tmpbuf,TMPBUFSIZ,
  2394.              "Second array to sort according to ",s,NULL,NULL);
  2395.     if ((x = cmfld(tmpbuf,"",&p,NULL)) < 0)
  2396.       if (x != -3)
  2397.         return(x);
  2398.     tmpbuf[0] = NUL;
  2399.     ckstrncpy(tmpbuf,p,TMPBUFSIZ);
  2400.     p = tmpbuf;
  2401.     if ((x = cmcfm()) < 0)              /* Get confirmation */
  2402.       return(x);
  2403.  
  2404.     x = arraybounds(s,&lo,&hi);         /* Get array index & bounds */
  2405.     if (x < 0) {                        /* Check */
  2406.         printf("?Bad array name: %s\n",s);
  2407.         return(-9);
  2408.     }
  2409.     if (lo > -1) range[0] = lo;         /* Set range */
  2410.     if (hi > -1) range[1] = hi;
  2411.     ap = a_ptr[x];                      /* Get pointer to array element list */
  2412.     if (!ap) {                          /* Check */
  2413.         printf("?Array not declared: %s\n", s);
  2414.         return(-9);
  2415.     }
  2416.     if (range[0] < 0)                   /* Starting element */
  2417.       range[0] = 1;
  2418.     if (range[1] < 0)                   /* Final element */
  2419.       range[1] = a_dim[x];
  2420.     if (range[1] > a_dim[x]) {
  2421.         printf("?range %d:%d exceeds array dimension %d\n",
  2422.                range[0],range[1],a_dim[x]
  2423.                );
  2424.         return(-9);
  2425.     }
  2426.     ap += range[0];
  2427.     xs = range[1] - range[0] + 1;       /* Number of elements to sort */
  2428.     if (xs < 1) {                       /* Check */
  2429.         printf("?Bad range: %d:%d\n",range[0],range[1]);
  2430.         return(-9);
  2431.     }
  2432.     if (xk < 0) xk = 0;                 /* Key position */
  2433.     if (xr < 0) xr = 0;                 /* Reverse flag */
  2434.     if (xn)                             /* Numeric flag */
  2435.       xc = 2;
  2436.     else if (xc < 0)                    /* Not numeric */
  2437.       xc = inpcas[cmdlvl];              /* so alpha case option */
  2438.  
  2439.     if (*p) {                           /* Parallel array given? */
  2440.         y = xarray(p);                  /* Yes, get its index. */
  2441.         if (y < 0) {
  2442.             printf("?Bad array name: %s\n", p);
  2443.             return(-9);
  2444.         }
  2445.         if (y != x) {                   /* If the 2 arrays are different  */
  2446.             xp = a_ptr[y];              /* Pointer to 2nd array element list */
  2447.             if (!xp) {
  2448.                 printf("?Array not declared: %s\n", p);
  2449.                 return(-9);
  2450.             }
  2451.             if (a_dim[y] < range[1]) {
  2452.                 printf("?Array %s smaller than %s\n", p, s);
  2453.                 return(-9);
  2454.             }
  2455.             xp += range[0];             /* Set base to same as 1st array */
  2456.         }
  2457.     }
  2458.     sh_sort(ap,xp,xs,xk,xr,xc);         /* Sort the array(s) */
  2459.     return(success = 1);                /* Always succeeds */
  2460. }
  2461. #endif /* NOSPL */
  2462.  
  2463. static struct keytab purgtab[] = {      /* PURGE command switches */
  2464.     { "/after",        PU_AFT,  CM_ARG },
  2465.     { "/ask",          PU_ASK,  0 },
  2466.     { "/before",       PU_BEF,  CM_ARG },
  2467.     { "/delete",       PU_DELE, CM_INV },
  2468. #ifdef UNIXOROSK
  2469.     { "/dotfiles",     PU_DOT,  0 },
  2470. #endif /* UNIXOROSK */
  2471.     { "/except",       PU_EXC,  CM_ARG },
  2472.     { "/heading",      PU_HDG,  0 },
  2473.     { "/keep",         PU_KEEP, CM_ARG },
  2474.     { "/larger-than",  PU_LAR,  CM_ARG },
  2475.     { "/list",         PU_LIST, 0 },
  2476.     { "/log",          PU_LIST, CM_INV },
  2477.     { "/noask",        PU_NASK, 0 },
  2478.     { "/nodelete",     PU_NODE, CM_INV },
  2479. #ifdef UNIXOROSK
  2480.     { "/nodotfiles",   PU_NODOT,0 },
  2481. #endif /* UNIXOROSK */
  2482.     { "/noheading",    PU_NOH,  0 },
  2483.     { "/nol",          PU_NOLI, CM_INV|CM_ABR },
  2484.     { "/nolist",       PU_NOLI, 0 },
  2485.     { "/nolog",        PU_NOLI, CM_INV },
  2486. #ifdef CK_TTGWSIZ
  2487.     { "/nopage",       PU_NOPA, 0 },
  2488. #endif /* CK_TTGWSIZ */
  2489.     { "/not-after",    PU_NAF,  CM_ARG },
  2490.     { "/not-before",   PU_NBF,  CM_ARG },
  2491.     { "/not-since",    PU_NAF,  CM_INV|CM_ARG },
  2492. #ifdef CK_TTGWSIZ
  2493.     { "/page",         PU_PAGE, 0 },
  2494. #endif /* CK_TTGWSIZ */
  2495.     { "/quiet",        PU_QUIE, CM_INV },
  2496. #ifdef RECURSIVE
  2497.     { "/recursive",    PU_RECU, 0 },
  2498. #endif /* RECURSIVE */
  2499.     { "/since",        PU_AFT,  CM_ARG|CM_INV },
  2500.     { "/simulate",     PU_NODE, 0 },
  2501.     { "/smaller-than", PU_SMA,  CM_ARG },
  2502.     { "/verbose",      PU_VERB, CM_INV }
  2503. };
  2504. static int npurgtab = sizeof(purgtab)/sizeof(struct keytab);
  2505.  
  2506.  
  2507.  
  2508.  
  2509.  
  2510. int
  2511. bkupnum(s,i) char * s; int *i; {
  2512.     int k = 0, pos = 0;
  2513.     char * p = NULL, *q;
  2514.     *i = pos;
  2515.     if (!s) s = "";
  2516.     if (!*s)
  2517.       return(-1);
  2518.     if ((k = strlen(s)) < 5)
  2519.       return(-1);
  2520.  
  2521.     if (s[k-1] != '~')
  2522.       return(-1);
  2523.     pos = k - 2;
  2524.     q = s + pos;
  2525.     while (q >= s && isdigit(*q)) {
  2526.         p = q--;
  2527.         pos--;
  2528.     }
  2529.     if (!p)
  2530.       return(-1);
  2531.     if (q < s+2)
  2532.       return(-1);
  2533.     if (*q != '~' || *(q-1) != '.')
  2534.       return(-1);
  2535.     pos--;
  2536.     *i = pos;
  2537.     debug(F111,"bkupnum",s+pos,pos);
  2538.     return(atoi(p));
  2539. }
  2540.  
  2541. #ifdef CKPURGE
  2542. /* Presently only for UNIX because we need direct access to the file array. */
  2543. /* Not needed for VMS anyway, because we don't make backup files there. */
  2544.  
  2545. #define MAXKEEP 32                      /* Biggest /KEEP: value */
  2546.  
  2547. static int
  2548.   pu_keep = 0, pu_list = 0, pu_dot = 0, pu_ask = 0, pu_hdg = 0;
  2549.  
  2550. #ifdef CK_TTGWSIZ
  2551. static int pu_page = -1;
  2552. #else
  2553. static int pu_page = 0;
  2554. #endif /* CK_TTGWSIZ */
  2555.  
  2556. #ifndef NOSHOW
  2557. VOID
  2558. showpurgopts() {                        /* SHOW PURGE command options */
  2559.     int x = 0;
  2560.     extern int optlines;
  2561.     prtopt(&optlines,"PURGE");
  2562.     if (pu_ask > -1) {
  2563.         x++;
  2564.         prtopt(&optlines, pu_ask ? "/ASK" : "/NOASK");
  2565.     }
  2566. #ifdef UNIXOROSK
  2567.     if (pu_dot > -1) {
  2568.         x++;
  2569.         prtopt(&optlines, pu_dot ? "/DOTFILES" : "/NODOTFILES");
  2570.     }
  2571. #endif /* UNIXOROSK */
  2572.     if (pu_keep > -1) {
  2573.         x++;
  2574.         ckmakmsg(tmpbuf,TMPBUFSIZ,"/KEEP:",ckitoa(pu_keep),NULL,NULL);
  2575.         prtopt(&optlines,tmpbuf);
  2576.     }
  2577.     if (pu_list > -1) {
  2578.         x++;
  2579.         prtopt(&optlines, pu_list ? "/LIST" : "/NOLIST");
  2580.     }
  2581.     if (pu_hdg > -1) {
  2582.         x++;
  2583.         prtopt(&optlines, pu_hdg ? "/HEADING" : "/NOHEADING");
  2584.     }
  2585. #ifdef CK_TTGWSIZ
  2586.     if (pu_page > -1) {
  2587.         x++;
  2588.         prtopt(&optlines, pu_page ? "/PAGE" : "/NOPAGE");
  2589.     }
  2590. #endif /* CK_TTGWSIZ */
  2591.     if (!x) prtopt(&optlines,"(no options set)");
  2592.     prtopt(&optlines,"");
  2593. }
  2594. #endif /* NOSHOW */
  2595.  
  2596. int
  2597. setpurgopts() {                         /* Set PURGE command options */
  2598.     int c, z, getval = 0;
  2599.     int
  2600.       x_keep  = -1, x_list = -1, x_page = -1,
  2601.       x_hdg   = -1, x_ask  = -1, x_dot  = -1;
  2602.  
  2603.     while (1) {
  2604.         if ((y = cmswi(purgtab,npurgtab,"Switch","",xxstring)) < 0) {
  2605.             if (y == -3)
  2606.               break;
  2607.             else
  2608.               return(y);
  2609.         }
  2610.         c = cmgbrk();
  2611.         if ((getval = (c == ':' || c == '=')) && !(cmgkwflgs() & CM_ARG)) {
  2612.             printf("?This switch does not take an argument\n");
  2613.             return(-9);
  2614.         }
  2615.         if (!getval && (cmgkwflgs() & CM_ARG)) {
  2616.             printf("?This switch requires an argument\n");
  2617.             return(-9);
  2618.         }
  2619.         switch (y) {
  2620.           case PU_KEEP:
  2621.             z = 1;
  2622.             if (c == ':' || c == '=')
  2623.               if ((y = cmnum("How many backup files to keep",
  2624.                              "1",10,&z,xxstring)) < 0)
  2625.                 return(y);
  2626.             if (z < 0 || z > MAXKEEP) {
  2627.                 printf("?Please specify a number between 0 and %d\n",
  2628.                        MAXKEEP
  2629.                        );
  2630.                 return(-9);
  2631.             }
  2632.             x_keep = z;
  2633.             break;
  2634.           case PU_LIST:
  2635.           case PU_VERB:
  2636.             x_list = 1;
  2637.             break;
  2638.           case PU_QUIE:
  2639.           case PU_NOLI:
  2640.             x_list = 0;
  2641.             break;
  2642. #ifdef CK_TTGWSIZ
  2643.           case PU_PAGE:
  2644.             x_page = 1;
  2645.             break;
  2646.           case PU_NOPA:
  2647.             x_page = 0;
  2648.             break;
  2649. #endif /* CK_TTGWSIZ */
  2650.           case PU_HDG:
  2651.             x_hdg = 1;
  2652.             break;
  2653.           case PU_NOH:
  2654.             x_hdg = 0;
  2655.             break;
  2656.           case PU_ASK:
  2657.             x_ask = 1;
  2658.             break;
  2659.           case PU_NASK:
  2660.             x_ask = 0;
  2661.             break;
  2662. #ifdef UNIXOROSK
  2663.           case PU_DOT:
  2664.             x_dot = 1;
  2665.             break;
  2666.           case PU_NODOT:
  2667.             x_dot = 0;
  2668.             break;
  2669. #endif /* UNIXOROSK */
  2670.           default:
  2671.             printf("?This option can not be set\n");
  2672.             return(-9);
  2673.         }
  2674.     }
  2675.     if ((x = cmcfm()) < 0)              /* Get confirmation */
  2676.       return(x);
  2677.     if (x_keep > -1)                    /* Set PURGE defaults. */
  2678.       pu_keep = x_keep;
  2679.     if (x_list > -1)
  2680.       pu_list = x_list;
  2681. #ifdef CK_TTGWSIZ
  2682.     if (x_page > -1)
  2683.       pu_page = x_page;
  2684. #endif /* CK_TTGWSIZ */
  2685.     if (x_hdg > -1)
  2686.       pu_hdg = x_hdg;
  2687.     if (x_ask > -1)
  2688.       pu_ask = x_ask;
  2689.     if (x_dot > -1)
  2690.       pu_dot = x_dot;
  2691.     return(success = 1);
  2692. }
  2693.  
  2694. int
  2695. dopurge() {                             /* Do the PURGE command */
  2696.     extern char ** mtchs;
  2697.     extern int xaskmore, cmd_rows, recursive;
  2698.     int simulate = 0, asking = 0;
  2699.     int listing = 0, paging = -1, lines = 0, deleting = 1, errors = 0;
  2700.     struct FDB sw, sf, cm;
  2701.     int g, i, j, k, m = 0, n, x, y, z, done = 0, count = 0, flags = 0;
  2702.     int tokeep = 0, getval = 0, havename = 0, confirmed = 0;
  2703.     int xx[MAXKEEP+1];                  /* Array of numbers to keep */
  2704.     int min = -1;
  2705.     int x_hdg = 0, fs = 0, rc = 0;
  2706.     CK_OFF_T minsize = -1L, maxsize = -1L;
  2707.     char namebuf[CKMAXPATH+4];
  2708.     char basebuf[CKMAXPATH+4];
  2709.     char
  2710.       * pu_aft = NULL,
  2711.       * pu_bef = NULL,
  2712.       * pu_naf = NULL,
  2713.       * pu_nbf = NULL,
  2714.       * pu_exc = NULL;
  2715.     char * pxlist[8];                   /* Exception list */
  2716.  
  2717.     if (pu_keep > -1)                   /* Set PURGE defaults. */
  2718.       tokeep = pu_keep;
  2719.     if (pu_list > -1)
  2720.       listing = pu_list;
  2721. #ifdef CK_TTGWSIZ
  2722.     if (pu_page > -1)
  2723.       paging = pu_page;
  2724. #endif /* CK_TTGWSIZ */
  2725.  
  2726.     for (i = 0; i <= MAXKEEP; i++)      /* Clear this number buffer */
  2727.       xx[i] = 0;
  2728.     for (i = 0; i < 8; i++)             /* Initialize these... */
  2729.       pxlist[i] = NULL;
  2730.  
  2731.     g_matchdot = matchdot;              /* Save these... */
  2732.  
  2733.     cmfdbi(&sw,                         /* 1st FDB - PURGE switches */
  2734.            _CMKEY,                      /* fcode */
  2735.            "Filename or switch",        /* hlpmsg */
  2736.            "",                          /* default */
  2737.            "",                          /* addtl string data */
  2738.            npurgtab,                    /* addtl numeric data 1: tbl size */
  2739.            4,                           /* addtl numeric data 2: 4 = cmswi */
  2740.            xxstring,                    /* Processing function */
  2741.            purgtab,                     /* Keyword table */
  2742.            &sf                          /* Pointer to next FDB */
  2743.            );
  2744.     cmfdbi(&sf,                         /* 2nd FDB - filespec to purge */
  2745.            _CMIFI,                      /* fcode */
  2746.            "",
  2747.            "",                          /* default */
  2748.            "",                          /* addtl string data */
  2749.            0,                           /* addtl numeric data 1 */
  2750.            0,                           /* addtl numeric data 2 */
  2751.            xxstring,
  2752.            NULL,
  2753.            &cm
  2754.            );
  2755.     cmfdbi(&cm,                         /* Or premature confirmation */
  2756.            _CMCFM,                      /* fcode */
  2757.            "",                          /* hlpmsg */
  2758.            "",                          /* default */
  2759.            "",                          /* addtl string data */
  2760.            0,                           /* addtl numeric data 1 */
  2761.            0,                           /* addtl numeric data 2 */
  2762.            NULL,
  2763.            NULL,
  2764.            NULL
  2765.            );
  2766.  
  2767.     while (!havename && !confirmed) {
  2768.         x = cmfdb(&sw);                 /* Parse something */
  2769.         if (x < 0) {                    /* Error */
  2770.             rc = x;
  2771.             goto xpurge;
  2772.         } else if (cmresult.fcode == _CMKEY) {
  2773.             char c;
  2774.             c = cmgbrk();
  2775.             if ((getval = (c == ':' || c == '=')) && !(cmgkwflgs() & CM_ARG)) {
  2776.                 printf("?This switch does not take an argument\n");
  2777.                 rc = -9;
  2778.                 goto xpurge;
  2779.             }
  2780.             if (!getval && (cmgkwflgs() & CM_ARG)) {
  2781.                 printf("?This switch requires an argument\n");
  2782.                 rc = -9;
  2783.                 goto xpurge;
  2784.             }
  2785.             switch (k = cmresult.nresult) {
  2786.               case PU_KEEP:
  2787.                 z = 1;
  2788.                 if (c == ':' || c == '=') {
  2789.                     if ((y = cmnum("How many backup files to keep",
  2790.                                    "1",10,&z,xxstring)) < 0) {
  2791.                         rc = y;
  2792.                         goto xpurge;
  2793.                     }
  2794.                 }
  2795.                 if (z < 0 || z > MAXKEEP) {
  2796.                     printf("?Please specify a number between 0 and %d\n",
  2797.                            MAXKEEP
  2798.                            );
  2799.                     rc = -9;
  2800.                     goto xpurge;
  2801.                 }
  2802.                 tokeep = z;
  2803.                 break;
  2804.               case PU_LIST:
  2805.                 listing = 1;
  2806.                 break;
  2807.               case PU_NOLI:
  2808.                 listing = 0;
  2809.                 break;
  2810. #ifdef CK_TTGWSIZ
  2811.               case PU_PAGE:
  2812.                 paging = 1;
  2813.                 break;
  2814.               case PU_NOPA:
  2815.                 paging = 0;
  2816.                 break;
  2817. #endif /* CK_TTGWSIZ */
  2818.               case PU_DELE:
  2819.                 deleting = 1;
  2820.                 break;
  2821.               case PU_NODE:
  2822.                 deleting = 0;
  2823.                 simulate = 1;
  2824.                 listing = 1;
  2825.                 break;
  2826.               case PU_ASK:
  2827.                 asking = 1;
  2828.                 break;
  2829.               case PU_NASK:
  2830.                 asking = 0;
  2831.                 break;
  2832.               case PU_AFT:
  2833.               case PU_BEF:
  2834.               case PU_NAF:
  2835.               case PU_NBF:
  2836.                 if ((x = cmdate("File-time","",&s,0,xxstring)) < 0) {
  2837.                     if (x == -3) {
  2838.                         printf("?Date-time required\n");
  2839.                         rc = -9;
  2840.                     } else
  2841.                       rc = x;
  2842.                     goto xpurge;
  2843.                 }
  2844.                 fs++;
  2845.                 switch (k) {
  2846.                   case PU_AFT: makestr(&pu_aft,s); break;
  2847.                   case PU_BEF: makestr(&pu_bef,s); break;
  2848.                   case PU_NAF: makestr(&pu_naf,s); break;
  2849.                   case PU_NBF: makestr(&pu_nbf,s); break;
  2850.                 }
  2851.                 break;
  2852.               case PU_SMA:
  2853.               case PU_LAR:
  2854.                 if ((x = cmnum("File size in bytes","0",10,&y,xxstring)) < 0) {
  2855.                     rc = x;
  2856.                     goto xpurge;
  2857.                 }
  2858.                 fs++;
  2859.                 switch (cmresult.nresult) {
  2860.                   case PU_SMA: minsize = y; break;
  2861.                   case PU_LAR: maxsize = y; break;
  2862.                 }
  2863.                 break;
  2864.               case PU_DOT:
  2865.                 matchdot = 1;
  2866.                 break;
  2867.               case PU_NODOT:
  2868.                 matchdot = 0;
  2869.                 break;
  2870.               case PU_EXC:
  2871.                 if ((x = cmfld("Pattern","",&s,xxstring)) < 0) {
  2872.                     if (x == -3) {
  2873.                         printf("?Pattern required\n");
  2874.                         rc = -9;
  2875.                     } else
  2876.                       rc = x;
  2877.                     goto xpurge;
  2878.                 }
  2879.                 fs++;
  2880.                 makestr(&pu_exc,s);
  2881.                 break;
  2882.               case PU_HDG:
  2883.                 x_hdg = 1;
  2884.                 break;
  2885. #ifdef RECURSIVE
  2886.               case PU_RECU:             /* /RECURSIVE */
  2887.                 recursive = 2;
  2888.                 break;
  2889. #endif /* RECURSIVE */
  2890.               default:
  2891.                 printf("?Not implemented yet - \"%s\"\n",atmbuf);
  2892.                 rc = -9;
  2893.                 goto xpurge;
  2894.             }
  2895.         } else if (cmresult.fcode == _CMIFI) {
  2896.             havename = 1;
  2897.         } else if (cmresult.fcode == _CMCFM) {
  2898.             confirmed = 1;
  2899.         } else {
  2900.             rc = -2;
  2901.             goto xpurge;
  2902.         }
  2903.     }
  2904.     if (havename) {
  2905. #ifdef CKREGEX
  2906.         ckmakmsg(line,LINBUFSIZ,cmresult.sresult,".~[1-9]*~",NULL,NULL);
  2907. #else
  2908.         ckmakmsg(line,LINBUFSIZ,cmresult.sresult,".~*~",NULL,NULL);
  2909. #endif /* CKREGEX */
  2910.     } else {
  2911. #ifdef CKREGEX
  2912.         ckstrncpy(line,"*.~[1-9]*~",LINBUFSIZ);
  2913. #else
  2914.         ckstrncpy(line,"*.~*~",LINBUFSIZ);
  2915. #endif /* CKREGEX */
  2916.     }
  2917.     if (!confirmed) {
  2918.         if ((x = cmcfm()) < 0) {
  2919.             rc = x;
  2920.             goto xpurge;
  2921.         }
  2922.     }
  2923.     /* Parse finished - now action */
  2924.  
  2925. #ifdef CK_LOGIN
  2926.     if (isguest) {
  2927.         printf("?File deletion by guests not permitted.\n");
  2928.         rc = -9;
  2929.         goto xpurge;
  2930.     }
  2931. #endif /* CK_LOGIN */
  2932.  
  2933. #ifdef CK_TTGWSIZ
  2934.     if (paging < 0)                     /* /[NO]PAGE not given */
  2935.       paging = xaskmore;                /* so use prevailing */
  2936. #endif /* CK_TTGWSIZ */
  2937.  
  2938.     lines = 0;
  2939.     if (x_hdg > 0) {
  2940.         printf("Purging %s, keeping %d...%s\n",
  2941.                s,
  2942.                tokeep,
  2943.                simulate ? " (SIMULATION)" : "");
  2944.         lines += 2;
  2945.     }
  2946.     flags = ZX_FILONLY;
  2947.     if (recursive) flags |= ZX_RECURSE;
  2948.     n = nzxpand(line,flags);            /* Get list of backup files */
  2949.     if (tokeep < 1) {                   /* Deleting all of them... */
  2950.         for (i = 0; i < n; i++) {
  2951.             if (fs) if (fileselect(mtchs[i],
  2952.                                    pu_aft,pu_bef,pu_naf,pu_nbf,
  2953.                                    minsize,maxsize,0,8,pxlist) < 1) {
  2954.                 if (listing > 0) {
  2955.                     printf(" %s (SKIPPED)\n",mtchs[i]);
  2956. #ifdef CK_TTGWSIZ
  2957.                     if (paging)
  2958.                       if (++lines > cmd_rows - 3) {
  2959.                           if (!askmore()) goto xpurge; else lines = 0;
  2960.                       }
  2961. #endif /* CK_TTGWSIZ */
  2962.                 }
  2963.                 continue;
  2964.             }
  2965.             if (asking) {
  2966.                 int x;
  2967.                 ckmakmsg(tmpbuf,TMPBUFSIZ," Delete ",mtchs[i],"?",NULL);
  2968.                 x = getyesno(tmpbuf,1);
  2969.                 switch (x) {
  2970.                   case 0: continue;
  2971.                   case 1: break;
  2972.                   case 2: goto xpurge;
  2973.                 }
  2974.             }
  2975.             x = deleting ? zdelet(mtchs[i]) : 0;
  2976.             if (x > -1) {
  2977.                 if (listing)
  2978.                   printf(" %s (%s)\n", mtchs[i],deleting ? "OK" : "SELECTED");
  2979.                 count++;
  2980.             } else {
  2981.                 errors++;
  2982.                 if (listing)
  2983.                   printf(" %s (FAILED)\n", mtchs[i]);
  2984.             }
  2985. #ifdef CK_TTGWSIZ
  2986.             if (listing && paging)
  2987.               if (++lines > cmd_rows - 3) {
  2988.                   if (!askmore()) goto xpurge; else lines = 0;
  2989.               }
  2990. #endif /* CK_TTGWSIZ */
  2991.         }
  2992.         goto xpurge;
  2993.     }
  2994.     if (n < tokeep) {                   /* Not deleting any */
  2995.         count = 0;
  2996.         if (listing)
  2997.           printf(" Matches = %d: Not enough to purge.\n",n);
  2998.         goto xpurge;
  2999.     }
  3000.  
  3001.     /* General case - delete some but not others */
  3002.  
  3003.     sh_sort(mtchs,NULL,n,0,0,filecase); /* Alphabetize the list (ESSENTIAL) */
  3004.  
  3005.     g = 0;                              /* Start of current group */
  3006.     for (i = 0; i < n; i++) {           /* Go thru sorted file list */
  3007.         x = znext(namebuf);             /* Get next file */
  3008.         if (x < 1 || !namebuf[0] || i == n - 1) /* No more? */
  3009.           done = 1;                     /* NOTE: 'done' must be 0 or 1 only */
  3010.         if (fs) if (fileselect(namebuf,
  3011.                                pu_aft,pu_bef,pu_naf,pu_nbf,
  3012.                                minsize,maxsize,0,8,pxlist) < 1) {
  3013.             if (listing > 0) {
  3014.                 printf(" %s (SKIPPED)\n",namebuf);
  3015.                 if (++lines > cmd_rows - 3)
  3016.                   if (!askmore()) goto xpurge; else lines = 0;
  3017.             }
  3018.             continue;
  3019.         }
  3020.         if (x > 0)
  3021.           if ((m = bkupnum(namebuf,&z)) < 0) /* This file's backup number. */
  3022.             continue;
  3023.         for (j = 0; j < tokeep; j++) {  /* Insert in list. */
  3024.             if (m > xx[j]) {
  3025.                 for (k = tokeep - 1; k > j; k--)
  3026.                   xx[k] = xx[k-1];
  3027.                 xx[j] = m;
  3028.                 break;
  3029.             }
  3030.         }
  3031.         /* New group? */
  3032.         if (done || (i > 0 && ckstrcmp(namebuf,basebuf,z,1))) {
  3033.             if (i + done - g > tokeep) { /* Do we have enough to purge? */
  3034.                 min = xx[tokeep-1];     /* Yes, lowest backup number to keep */
  3035.                 debug(F111,"dopurge group",basebuf,min);
  3036.                 for (j = g; j < i + done; j++) { /* Go through this group */
  3037.                     x = bkupnum(mtchs[j],&z);    /* Get file backup number */
  3038.                     if (x > 0 && x < min) {      /* Below minimum? */
  3039.                         x = deleting ? zdelet(mtchs[j]) : 0;
  3040.                         if (x < 0) errors++;
  3041.                         if (listing)
  3042.                           printf(" %s (%s)\n",
  3043.                                  mtchs[j],
  3044.                                  ((x < 0) ? "ERROR" :
  3045.                                   (deleting ? "DELETED" : "SELECTED"))
  3046.                                  );
  3047.                         count++;
  3048.                     } else if (listing) /* Not below minimum - keep this one */
  3049.                       printf(" %s (KEPT)\n",mtchs[j]);
  3050. #ifdef CK_TTGWSIZ
  3051.                     if (listing && paging)
  3052.                       if (++lines > cmd_rows - 3) {
  3053.                           if (!askmore()) goto xpurge; else lines = 0;
  3054.                       }
  3055. #endif /* CK_TTGWSIZ */
  3056.                 }
  3057.             } else if (listing && paging) { /* Not enough to purge */
  3058.                 printf(" %s.~*~ (KEPT)\n",basebuf);
  3059. #ifdef CK_TTGWSIZ
  3060.                 if (++lines > cmd_rows - 3) {
  3061.                     if (!askmore()) goto xpurge; else lines = 0;
  3062.                 }
  3063. #endif /* CK_TTGWSIZ */
  3064.             }
  3065.             for (j = 0; j < tokeep; j++) /* Clear the backup number list */
  3066.               xx[j] = 0;
  3067.             g = i;                      /* Reset the group pointer */
  3068.         }
  3069.         if (done)                       /* No more files, done. */
  3070.           break;
  3071.         strncpy(basebuf,namebuf,z);     /* Set basename of this file */
  3072.         basebuf[z] = NUL;
  3073.     }
  3074.   xpurge:                               /* Common exit point */
  3075.     if (g_matchdot > -1) {
  3076.         matchdot = g_matchdot;          /* Restore these... */
  3077.         g_matchdot = -1;
  3078.     }
  3079.     if (rc < 0) return(rc);             /* Parse error */
  3080.     if (x_hdg)
  3081.       printf("Files purged: %d%s\n",
  3082.              count,
  3083.              deleting ? "" : " (not really)"
  3084.              );
  3085.     return(success = count > 0 ? 1 : (errors > 0) ? 0 : 1);
  3086. }
  3087. #endif /* CKPURGE */
  3088.  
  3089. #ifndef NOXFER
  3090. #ifndef NOLOCAL
  3091. int
  3092. doxdis(which) int which; {        /* 1 = Kermit, 2 = FTP */
  3093.     extern int nolocal;
  3094.     int x, y = 0, z;
  3095. #ifdef NEWFTP
  3096.     extern int ftp_dis;
  3097. #endif /* NEWFTP */
  3098.  
  3099. #ifdef COMMENT
  3100.     char *s;
  3101. #endif /* COMMENT */
  3102.  
  3103.     if ((x = cmkey(fdtab,nfdtab,"file transfer display style","",
  3104.                    xxstring)) < 0)
  3105.       return(x);
  3106. #ifdef CK_PCT_BAR
  3107.     if ((y = cmkey(fdftab,2,"","thermometer",xxstring)) < 0)
  3108.       return(y);
  3109. #endif /* CK_PCT_BAR */
  3110.     if ((z = cmcfm()) < 0) return(z);
  3111. #ifdef CK_CURSES
  3112.     if (x == XYFD_C) {                  /* FULLSCREEN */
  3113. #ifdef COMMENT
  3114. #ifndef MYCURSES
  3115.         extern char * trmbuf;           /* Real curses */
  3116.         int z;
  3117. #endif /* MYCURSES */
  3118. #endif /* COMMENT */
  3119.  
  3120.         if (nolocal)                    /* Nothing to do in this case */
  3121.       return(success = 1);
  3122.  
  3123. #ifdef COMMENT
  3124. #ifndef MYCURSES
  3125. #ifndef VMS
  3126.         s = getenv("TERM");
  3127.         debug(F110,"doxdis TERM",s,0);
  3128.         if (!s) s = "";
  3129.         fxdinit(x);
  3130.         if (*s && trmbuf) {             /* Don't call tgetent */
  3131.             z = tgetent(trmbuf,s);      /* if trmbuf not allocated */
  3132.             debug(F111,"doxdis tgetent",s,z);
  3133.         } else {
  3134.             z = 0;
  3135.             debug(F110,"doxdis tgetent skipped",s,0);
  3136.         }
  3137.         if (z < 1) {
  3138.             printf("Sorry, terminal type unknown: \"%s\"\n",s);
  3139.             return(success = 0);
  3140.         }
  3141. #endif /* VMS */
  3142. #endif /* MYCURSES */
  3143. #else
  3144.         fxdinit(x);
  3145. #endif /* COMMENT */
  3146.  
  3147. #ifdef CK_PCT_BAR
  3148.         thermometer = y;
  3149. #endif /* CK_PCT_BAR */
  3150.  
  3151.         line[0] = '\0';                 /* (What's this for?) */
  3152.     }
  3153. #endif /* CK_CURSES */
  3154.     if (which == 1)            /* It's OK. */
  3155.       fdispla = x;
  3156. #ifdef NEWFTP
  3157.     else if (which == 2)
  3158.       ftp_dis = x;
  3159. #endif /* NEWFTP */
  3160.     return(success = 1);
  3161. }
  3162. #endif /* NOLOCAL */
  3163. #endif /* NOXFER */
  3164.  
  3165. int
  3166. setfil(rmsflg) int rmsflg; {
  3167. #ifdef COMMENT
  3168.     extern int en_del;
  3169. #endif /* COMMENT */
  3170. #ifndef NOXFER
  3171.     if (rmsflg) {
  3172.         if ((y = cmkey(rfiltab,nrfilp,"Remote file parameter","",
  3173.                        xxstring)) < 0) {
  3174.             if (y == -3) {
  3175.                 printf("?Remote file parameter required\n");
  3176.                 return(-9);
  3177.             } else return(y);
  3178.         }
  3179.     } else {
  3180. #endif /* NOXFER */
  3181.         if ((y = cmkey(filtab,nfilp,"File parameter","",xxstring)) < 0)
  3182.           return(y);
  3183. #ifndef NOXFER
  3184.     }
  3185. #endif /* NOXFER */
  3186.     switch (y) {
  3187. #ifdef COMMENT                          /* Not needed */
  3188.       case XYFILB:                      /* Blocksize */
  3189.         if ((y = cmnum("file block size",ckitoa(DBLKSIZ),10,&z,xxstring)) < 0)
  3190.           return(y);
  3191.         if ((x = cmcfm()) < 0) return(x);
  3192.         if (rmsflg) {
  3193.             sstate = setgen('S', "311", ckitoa(z), "");
  3194.             return((int) sstate);
  3195.         } else {
  3196.             fblksiz = z;
  3197.             return(success = 1);
  3198.         }
  3199. #endif /* COMMENT */
  3200.  
  3201. #ifndef NOXFER
  3202.       case XYFILS:                      /* Byte size */
  3203.         if ((y = cmnum("file byte size (7 or 8)","8",10,&z,xxstring)) < 0)
  3204.           return(y);
  3205.         if (z != 7 && z != 8) {
  3206.             printf("\n?The choices are 7 and 8\n");
  3207.             return(0);
  3208.         }
  3209.         if ((y = cmcfm()) < 0) return(y);
  3210.         if (z == 7) fmask = 0177;
  3211.         else if (z == 8) fmask = 0377;
  3212.         return(success = 1);
  3213.  
  3214. #ifndef NOCSETS
  3215.       case XYFILC: {                    /* Character set */
  3216.           char * csetname = NULL;
  3217.           extern int
  3218.             r_cset, s_cset, afcset[];   /* SEND CHARACTER-SET AUTO or MANUAL */
  3219.  
  3220.           struct FDB kw, fl;
  3221.           cmfdbi(&kw,                   /* First FDB - command switches */
  3222.                  _CMKEY,                /* fcode */
  3223.                  rmsflg ? "server character-set name" : "",  /* help */
  3224.                  "",                    /* default */
  3225.                  "",                    /* addtl string data */
  3226.                  nfilc,                 /* addtl numeric data 1: tbl size */
  3227.                  0,                     /* addtl numeric data 2: 0 = keyword */
  3228.                  xxstring,              /* Processing function */
  3229.                  fcstab,                /* Keyword table */
  3230.                  rmsflg ? &fl : NULL    /* Pointer to next FDB */
  3231.            );
  3232.           cmfdbi(&fl,                   /* Anything that doesn't match */
  3233.                  _CMFLD,                /* fcode */
  3234.                  "",                    /* hlpmsg */
  3235.                  "",                    /* default */
  3236.                  "",                    /* addtl string data */
  3237.                  0,                     /* addtl numeric data 1 */
  3238.                  0,                     /* addtl numeric data 2 */
  3239.                  xxstring,
  3240.                  NULL,
  3241.                  NULL
  3242.                  );
  3243.           if ((x = cmfdb(&kw)) < 0)
  3244.             return(x);
  3245.           if (cmresult.fcode == _CMKEY) {
  3246.               x = cmresult.nresult;
  3247.               csetname = fcsinfo[x].keyword;
  3248.           } else {
  3249.               ckstrncpy(line,cmresult.sresult,LINBUFSIZ);
  3250.               csetname = line;
  3251.           }
  3252.           if ((z = cmcfm()) < 0) return(z);
  3253.           if (rmsflg) {
  3254.               sstate = setgen('S', "320", csetname, "");
  3255.               return((int) sstate);
  3256.           }
  3257.           fcharset = x;
  3258.           if (s_cset == XMODE_A)        /* If SEND CHARACTER-SET is AUTO */
  3259.             if (x > -1 && x <= MAXFCSETS)
  3260.               if (afcset[x] > -1 && afcset[x] <= MAXTCSETS)
  3261.                 tcharset = afcset[x]; /* Pick corresponding xfer charset */
  3262.           setxlatype(tcharset,fcharset); /* Translation type */
  3263.           /* If I say SET FILE CHARACTER-SET blah, I want to be blah! */
  3264.           r_cset = XMODE_M;             /* Don't switch incoming set! */
  3265.           x = fcsinfo[fcharset].size;   /* Also set default x-bit charset */
  3266.           if (x == 128)                 /* 7-bit... */
  3267.             dcset7 = fcharset;
  3268.           else if (x == 256)            /* 8-bit... */
  3269.             dcset8 = fcharset;
  3270.           return(success = 1);
  3271.       }
  3272. #endif /* NOCSETS */
  3273.  
  3274. #ifndef NOLOCAL
  3275.       case XYFILD:                      /* Display */
  3276.         return(doxdis(1));        /* 1 == kermit */
  3277. #endif /* NOLOCAL */
  3278. #endif /* NOXFER */
  3279.  
  3280.       case XYFILA:                      /* End-of-line */
  3281. #ifdef NLCHAR
  3282.         s = "";
  3283.         if (NLCHAR == 015)
  3284.           s = "cr";
  3285.         else if (NLCHAR == 012)
  3286.           s = "lf";
  3287.         if ((x = cmkey(eoltab, neoltab,
  3288.                        "local text-file line terminator",s,xxstring)) < 0)
  3289.           return(x);
  3290. #else
  3291.         if ((x = cmkey(eoltab, neoltab,
  3292.                        "local text-file line terminator","crlf",xxstring)) < 0)
  3293.           return(x);
  3294. #endif /* NLCHAR */
  3295.         if ((z = cmcfm()) < 0) return(z);
  3296.         feol = (CHAR) x;
  3297.         return(success = 1);
  3298.  
  3299. #ifndef NOXFER
  3300.       case XYFILN:                      /* Names */
  3301.         if ((x = cmkey(fntab,nfntab,"how to handle filenames","converted",
  3302.                        xxstring)) < 0)
  3303.           return(x);
  3304.         if ((z = cmcfm()) < 0) return(z);
  3305.         if (rmsflg) {
  3306.             sstate = setgen('S', "301", ckitoa(1 - x), "");
  3307.             return((int) sstate);
  3308.         } else {
  3309.             ptab[protocol].fncn = x;    /* Set structure */
  3310.             fncnv = x;                  /* Set variable */
  3311.             f_save = x;                 /* And set "permanent" variable */
  3312.             return(success = 1);
  3313.         }
  3314.  
  3315.       case XYFILR:                      /* Record length */
  3316.         if ((y = cmnum("file record length",
  3317.                        ckitoa(DLRECL),10,&z,xxstring)) < 0)
  3318.           return(y);
  3319.         if ((x = cmcfm()) < 0) return(x);
  3320.         if (rmsflg) {
  3321.             sstate = setgen('S', "312", ckitoa(z), "");
  3322.             return((int) sstate);
  3323.         } else {
  3324.             frecl = z;
  3325.             return(success = 1);
  3326.         }
  3327.  
  3328. #ifdef COMMENT
  3329.       case XYFILO:                      /* Organization */
  3330.         if ((x = cmkey(forgtab,nforg,"file organization","sequential",
  3331.                        xxstring)) < 0)
  3332.           return(x);
  3333.         if ((y = cmcfm()) < 0) return(y);
  3334.         if (rmsflg) {
  3335.             sstate = setgen('S', "314", ckitoa(x), "");
  3336.             return((int) sstate);
  3337.         } else {
  3338.             forg = x;
  3339.             return(success = 1);
  3340.         }
  3341. #endif /* COMMENT */
  3342.  
  3343. #ifdef COMMENT                          /* Not needed */
  3344.       case XYFILF:                      /* Format */
  3345.         if ((x = cmkey(frectab,nfrec,"file record format","stream",
  3346.                        xxstring)) < 0)
  3347.           return(x);
  3348.         if ((y = cmcfm()) < 0) return(y);
  3349.         if (rmsflg) {
  3350.             sstate = setgen('S', "313", ckitoa(x), "");
  3351.             return((int) sstate);
  3352.         } else {
  3353.             frecfm = x;
  3354.             return(success = 1);
  3355.         }
  3356. #endif /* COMMENT */
  3357.  
  3358. #ifdef COMMENT
  3359.       case XYFILP:                      /* Printer carriage control */
  3360.         if ((x = cmkey(fcctab,nfcc,"file carriage control","newline",
  3361.                        xxstring)) < 0)
  3362.           return(x);
  3363.         if ((y = cmcfm()) < 0) return(y);
  3364.         if (rmsflg) {
  3365.             sstate = setgen('S', "315", ckitoa(x), "");
  3366.             return((int) sstate);
  3367.         } else {
  3368.             fcctrl = x;
  3369.             return(success = 1);
  3370.         }
  3371. #endif /* COMMENT */
  3372. #endif /* NOXFER */
  3373.  
  3374.       case XYFILT:                      /* Type */
  3375.         if ((x = cmkey(rmsflg ? rfttab  : fttab,
  3376.                        rmsflg ? nrfttyp : nfttyp,
  3377.                        "type of file transfer","text",xxstring)) < 0)
  3378.           return(x);
  3379.  
  3380. #ifdef VMS
  3381.         /* Allow VMS users to choose record format for binary files */
  3382.         if ((x == XYFT_B) && (rmsflg == 0)) {
  3383.             if ((x = cmkey(fbtab,nfbtyp,"VMS record format","fixed",
  3384.                            xxstring)) < 0)
  3385.               return(x);
  3386.         }
  3387. #endif /* VMS */
  3388.         if ((y = cmcfm()) < 0) return(y);
  3389.         binary = x;
  3390.         b_save = x;
  3391. #ifdef MAC
  3392.         (void) mac_setfildflg(binary);
  3393. #endif /* MAC */
  3394. #ifndef NOXFER
  3395.         if (rmsflg) {
  3396.             /* Allow for LABELED in VMS & OS/2 */
  3397.             sstate = setgen('S', "300", ckitoa(x), "");
  3398.             return((int) sstate);
  3399.         } else {
  3400. #endif /* NOXFER */
  3401.             return(success = 1);
  3402. #ifndef NOXFER
  3403.         }
  3404. #endif /* NOXFER */
  3405.  
  3406. #ifndef NOXFER
  3407.       case XYFILX:                      /* Collision Action */
  3408.         if ((x = cmkey(colxtab,ncolx,"Filename collision action","backup",
  3409.                        xxstring)) < 0)
  3410.           return(x);
  3411.         if ((y = cmcfm()) < 0) return(y);
  3412. #ifdef CK_LOGIN
  3413.         if (isguest) {
  3414.             /* Don't let guests change existing files */
  3415.             printf("?This command not valid for guests\n");
  3416.             return(-9);
  3417.         }
  3418. #endif /* CK_LOGIN */
  3419. #ifdef COMMENT
  3420.         /* Not appropriate - DISABLE DELETE only refers to server */
  3421.         if ((x == XYFX_X || x == XYFX_B || x == XYFX_U || x == XYFX_A) &&
  3422.             (!ENABLED(en_del))) {
  3423.             printf("?Sorry, file deletion is disabled.\n");
  3424.             return(-9);
  3425.         }
  3426. #endif /* COMMENT */
  3427.         fncact = x;
  3428.         ptab[protocol].fnca = x;
  3429.         if (rmsflg) {
  3430.             sstate = setgen('S', "302", ckitoa(fncact), "");
  3431.             return((int) sstate);
  3432.         } else {
  3433.             if (fncact == XYFX_R) ckwarn = 1; /* FILE WARNING implications */
  3434.             if (fncact == XYFX_X) ckwarn = 0; /* ... */
  3435.             return(success = 1);
  3436.         }
  3437.  
  3438.       case XYFILW:                      /* Warning/Write-Protect */
  3439.         if ((x = seton(&ckwarn)) < 0) return(x);
  3440.         if (ckwarn)
  3441.           fncact = XYFX_R;
  3442.         else
  3443.           fncact = XYFX_X;
  3444.         return(success = 1);
  3445.  
  3446. #ifdef CK_LABELED
  3447.       case XYFILL:                      /* LABELED FILE parameters */
  3448.         if ((x = cmkey(lbltab,nlblp,"Labeled file feature","",
  3449.                        xxstring)) < 0)
  3450.           return(x);
  3451.         if ((success = seton(&y)) < 0)
  3452.           return(success);
  3453.         if (y)                          /* Set or reset the selected bit */
  3454.           lf_opts |= x;                 /* in the options bitmask. */
  3455.         else
  3456.           lf_opts &= ~x;
  3457.         return(success);
  3458. #endif /* CK_LABELED */
  3459.  
  3460.       case XYFILI: {                    /* INCOMPLETE */
  3461.           extern struct keytab ifdatab[];
  3462.           extern int keep;
  3463.           if ((y = cmkey(ifdatab,3,"","auto",xxstring)) < 0) return(y);
  3464.           if ((x = cmcfm()) < 0) return(x);
  3465.           if (rmsflg) {
  3466.               sstate = setgen('S',
  3467.                               "310",
  3468.                               y == 0 ? "0" : (y == 1 ? "1" : "2"),
  3469.                               ""
  3470.                               );
  3471.               return((int) sstate);
  3472.           } else {
  3473.               keep = y;
  3474.               return(success = 1);
  3475.           }
  3476.       }
  3477.  
  3478. #ifdef CK_TMPDIR
  3479.       case XYFILG: {                    /* Download directory */
  3480.           int x;
  3481.           char *s;
  3482. #ifdef ZFNQFP
  3483.           struct zfnfp * fnp;
  3484. #endif /* ZFNQFP */
  3485. #ifdef MAC
  3486.           char temp[34];
  3487. #endif /* MAC */
  3488.  
  3489. #ifdef GEMDOS
  3490.           if ((x = cmdir("Name of local directory, or carriage return",
  3491.                          "",&s,
  3492.                          NULL)) < 0 ) {
  3493.               if (x != -3)
  3494.                 return(x);
  3495.           }
  3496. #else
  3497. #ifdef OS2
  3498.           if ((x = cmdir("Name of PC disk and/or directory,\n\
  3499.        or press the Enter key to use current directory",
  3500.                          "",&s,xxstring)) < 0 ) {
  3501.               if (x != -3)
  3502.                 return(x);
  3503.           }
  3504. #else
  3505. #ifdef MAC
  3506.           x = ckstrncpy(temp,zhome(),32);
  3507.           if (x > 0) if (temp[x-1] != ':') { temp[x] = ':'; temp[x+1] = NUL; }
  3508.           if ((x = cmtxt("Name of Macintosh volume and/or folder,\n\
  3509.  or press the Return key for the desktop on the boot disk",
  3510.                          temp,&s, xxstring)) < 0 )
  3511.             return(x);
  3512. #else
  3513.           if ((x = cmdir("Name of local directory, or carriage return",
  3514.                          "", &s, xxstring)) < 0 ) {
  3515.               if (x != -3)
  3516.                 return(x);
  3517.           }
  3518. #endif /* MAC */
  3519. #endif /* OS2 */
  3520. #endif /* GEMDOS */
  3521.           debug(F110,"download dir",s,0);
  3522.  
  3523. #ifndef MAC
  3524.           if (x == 2) {
  3525.               printf("?Wildcards not allowed in directory name\n");
  3526.               return(-9);
  3527.           }
  3528. #endif /* MAC */
  3529.  
  3530. #ifdef ZFNQFP
  3531.           if ((fnp = zfnqfp(s,TMPBUFSIZ - 1,tmpbuf))) {
  3532.               if (fnp->fpath)
  3533.                 if ((int) strlen(fnp->fpath) > 0)
  3534.                   s = fnp->fpath;
  3535.           }
  3536.           debug(F110,"download zfnqfp",s,0);
  3537. #endif /* ZFNQFP */
  3538.  
  3539.           ckstrncpy(line,s,LINBUFSIZ);  /* Make a safe copy */
  3540. #ifndef MAC
  3541.           if ((x = cmcfm()) < 0)        /* Get confirmation */
  3542.             return(x);
  3543. #endif /* MAC */
  3544.  
  3545. #ifdef CK_LOGIN
  3546.         if (isguest) {
  3547.             /* Don't let guests change existing files */
  3548.             printf("?This command not valid for guests\n");
  3549.             return(-9);
  3550.         }
  3551. #endif /* CK_LOGIN */
  3552.           x = strlen(s);
  3553.  
  3554.           if (x) {
  3555. #ifdef datageneral            /* AOS/VS */
  3556.               if (s[x-1] == ':')        /* homdir ends in colon, */
  3557.                 s[x-1] = NUL;           /* and "dir" doesn't like that... */
  3558. #else
  3559. #ifdef OS2ORUNIX            /* Unix or K-95... */
  3560.           if ((x < (LINBUFSIZ - 2)) && /* Add trailing dirsep */
  3561.           (s[x-1] != '/')) {    /* if none present.  */
  3562.           s[x] = '/';        /* Note that Windows path has */
  3563.           s[x+1] = NUL;        /* been canonicalized to forward */
  3564.           }                        /* slashes at this point. */
  3565. #endif /* OS2ORUNIX */
  3566. #endif /* datageneral */
  3567.               makestr(&dldir,s);
  3568.           } else
  3569.             makestr(&dldir,NULL);       /* dldir is NULL when not assigned */
  3570.  
  3571.           return(success = 1);
  3572.       }
  3573. #endif /* CK_TMPDIR */
  3574.       case XYFILY:
  3575.         return(setdest());
  3576. #endif /* NOXFER */
  3577.  
  3578. #ifdef CK_CTRLZ
  3579.       case XYFILV: {                    /* EOF */
  3580.           extern int eofmethod;
  3581.           if ((x = cmkey(eoftab,3,"end-of-file detection method","",
  3582.                          xxstring)) < 0)
  3583.             return(x);
  3584.           if ((y = cmcfm()) < 0)
  3585.             return(y);
  3586.           eofmethod = x;
  3587.           return(success = 1);
  3588.       }
  3589. #endif /* CK_CTRLZ */
  3590.  
  3591. #ifndef NOXFER
  3592. #ifdef UNIX
  3593.       case XYFILH: {                    /* OUTPUT */
  3594.           extern int zofbuffer, zobufsize, zofblock;
  3595. #ifdef DYNAMIC
  3596.           extern char * zoutbuffer;
  3597. #endif /* DYNAMIC */
  3598.  
  3599.           if ((x = cmkey(zoftab,nzoftab,"output file writing method","",
  3600.                          xxstring)) < 0)
  3601.             return(x);
  3602.           if (x == ZOF_BUF || x == ZOF_NBUF) {
  3603.               if ((y = cmnum("output buffer size","32768",10,&z,xxstring)) < 0)
  3604.                 return(y);
  3605.               if (z < 1) {
  3606.                   printf("?Bad size - %d\n", z);
  3607.                   return(-9);
  3608.               }
  3609.           }
  3610.           if ((y = cmcfm()) < 0) return(y);
  3611.           switch (x) {
  3612.             case ZOF_BUF:
  3613.             case ZOF_NBUF:
  3614.               zofbuffer = (x == ZOF_BUF);
  3615.               zobufsize = z;
  3616.               break;
  3617.             case ZOF_BLK:
  3618.             case ZOF_NBLK:
  3619.               zofblock = (x == ZOF_BLK);
  3620.               break;
  3621.           }
  3622. #ifdef DYNAMIC
  3623.           if (zoutbuffer) free(zoutbuffer);
  3624.           if (!(zoutbuffer = (char *)malloc(z))) {
  3625.               printf("MEMORY ALLOCATION ERROR - FATAL\n");
  3626.               doexit(BAD_EXIT,-1);
  3627.           } else
  3628.             zobufsize = z;
  3629. #else
  3630.           if (z <= OBUFSIZE) {
  3631.               zobufsize = z;
  3632.           } else {
  3633.               printf("?Sorry, %d is too big - %d is the maximum\n",z,OBUFSIZE);
  3634.               return(-9);
  3635.           }
  3636. #endif /* DYNAMIC */
  3637.           return(success = 1);
  3638.       }
  3639. #endif /* UNIX */
  3640.  
  3641. #ifdef PATTERNS
  3642.       case XYFIBP:                      /* BINARY-PATTERN */
  3643.       case XYFITP: {                    /* TEXT-PATTERN */
  3644.           char * tmp[FTPATTERNS];
  3645.           int i, n = 0;
  3646.           while (n < FTPATTERNS) {
  3647.               tmp[n] = NULL;
  3648.               if ((x = cmfld("Pattern","",&s,xxstring)) < 0)
  3649.                 break;
  3650.               ckstrncpy(line,s,LINBUFSIZ);
  3651.               s = brstrip(line);
  3652.               makestr(&(tmp[n++]),s);
  3653.           }
  3654.           if (x == -3) x = cmcfm();
  3655.           for (i = 0; i <= n; i++) {
  3656.               if (x > -1) {
  3657.                   if (y == XYFIBP)
  3658.                     makestr(&(binpatterns[i]),tmp[i]);
  3659.                   else
  3660.                     makestr(&(txtpatterns[i]),tmp[i]);
  3661.               }
  3662.               free(tmp[i]);
  3663.           }
  3664.           if (y == XYFIBP)              /* Null-terminate the list */
  3665.             makestr(&(binpatterns[i]),NULL);
  3666.           else
  3667.             makestr(&(txtpatterns[i]),NULL);
  3668.           return(x);
  3669.       }
  3670.  
  3671.       case XYFIPA:                      /* PATTERNS */
  3672.         if ((x = setonaut(&patterns)) < 0)
  3673.           return(x);
  3674.         return(success = 1);
  3675. #endif /* PATTERNS */
  3676. #endif /* NOXFER */
  3677.  
  3678. #ifdef UNICODE
  3679.       case XYFILU: {                    /* UCS */
  3680.           extern int ucsorder, ucsbom, byteorder;
  3681.           if ((x = cmkey(ucstab,nucstab,"","",xxstring)) < 0)
  3682.             return(x);
  3683.           switch (x) {
  3684.             case UCS_BYT:
  3685.               if ((y = cmkey(botab,nbotab,
  3686.                              "Byte order",
  3687.                              byteorder ? "little-endian" : "big-endian",
  3688.                              xxstring
  3689.                              )
  3690.                    ) < 0)
  3691.                 return(y);
  3692.               if ((x = cmcfm()) < 0)
  3693.                 return(x);
  3694.               ucsorder = y;
  3695.               return(success = 1);
  3696.             case UCS_BOM:
  3697.               if ((y = cmkey(onoff,2,"","on",xxstring)) < 0)
  3698.                 return(y);
  3699.               if ((x = cmcfm()) < 0)
  3700.                 return(x);
  3701.               ucsbom = y;
  3702.               return(success = 1);
  3703.             default:
  3704.               return(-2);
  3705.           }
  3706.       }
  3707. #endif /* UNICODE */
  3708.  
  3709. #ifndef datageneral
  3710.       case XYF_INSP: {                  /* SCAN (INSPECTION) */
  3711.           extern int filepeek, nscanfile;
  3712.           if ((x = cmkey(onoff,2,"","on",xxstring)) < 0)
  3713.             return(x);
  3714.           if (y) {
  3715.               if ((y = cmnum("How much to scan",ckitoa(SCANFILEBUF),
  3716.                              10,&z,xxstring)) < 0)
  3717.                 return(y);
  3718.           }
  3719.           if ((y = cmcfm()) < 0)
  3720.             return(y);
  3721. #ifdef VMS
  3722.           filepeek = 0;
  3723.           nscanfile = 0;
  3724.           return(success = 0);
  3725. #else
  3726.           filepeek = x;
  3727.           nscanfile = z;
  3728.           return(success = 1);
  3729. #endif /* VMS */
  3730.       }
  3731. #endif /* datageneral */
  3732.  
  3733.       case XYF_DFLT:
  3734.         y = 0;
  3735. #ifndef NOCSETS
  3736.         if ((y = cmkey(fdfltab,nfdflt,"","",xxstring)) < 0)
  3737.           return(y);
  3738.         if (y == 7 || y == 8) {
  3739.             if (y == 7)
  3740.               s = fcsinfo[dcset7].keyword;
  3741.             else
  3742.               s = fcsinfo[dcset8].keyword;
  3743.             if ((x = cmkey(fcstab,nfilc,"character-set",s,xxstring)) < 0)
  3744.               return(x);
  3745.         }
  3746.         ckstrncpy(line,fcsinfo[x].keyword,LINBUFSIZ);
  3747.         s = line;
  3748. #endif /* NOCSETS */
  3749.         if ((z = cmcfm()) < 0)
  3750.           return(z);
  3751.         switch (y) {
  3752. #ifndef NOCSETS
  3753.           case 7:
  3754.             if (fcsinfo[x].size != 128) {
  3755.                 printf("%s - Not a 7-bit set\n",s);
  3756.                 return(-9);
  3757.             }
  3758.             dcset7 = x;
  3759.             break;
  3760.           case 8:
  3761.             if (fcsinfo[x].size != 256) {
  3762.                 printf("%s - Not an 8-bit set\n",s);
  3763.                 return(-9);
  3764.             }
  3765.             dcset8 = x;
  3766.             break;
  3767. #endif /* NOCSETS */
  3768.           default:
  3769.             return(-2);
  3770.         }
  3771.         return(success = 1);
  3772.  
  3773. #ifndef NOXFER
  3774.       case 9997:                        /* FASTLOOKUPS */
  3775.         return(success = seton(&stathack));
  3776. #endif /* NOXFER */
  3777.  
  3778. #ifdef UNIX
  3779. #ifdef DYNAMIC
  3780.       case XYF_LSIZ: {                  /* LISTSIZE */
  3781.           int zz;
  3782.           y = cmnum("Maximum number of filenames","",10,&x,xxstring);
  3783.           if ((x = setnum(&zz,x,y,-1)) < 0)
  3784.             return(x);
  3785.           if (zsetfil(zz,3) < 0) {
  3786.               printf("?Memory allocation failure\n");
  3787.               return(-9);
  3788.           }
  3789.           return(success = 1);
  3790.       }
  3791.       case XYF_SSPA: {                  /* STRINGSPACE */
  3792.           int zz;
  3793.           y = cmnum("Number of characters for filename list",
  3794.                     "",10,&x,xxstring);
  3795.           if ((x = setnum(&zz,x,y,-1)) < 0)
  3796.             return(x);
  3797.           if (zsetfil(zz,1) < 0) {
  3798.               printf("?Memory allocation failure\n");
  3799.               return(-9);
  3800.           }
  3801.           return(success = 1);
  3802.       }
  3803.  
  3804. #endif /* DYNAMIC */
  3805. #endif /* UNIX */
  3806.  
  3807.       default:
  3808.         printf("?unexpected file parameter\n");
  3809.         return(-2);
  3810.     }
  3811. }
  3812.  
  3813. #ifdef UNIX
  3814. #ifndef NOPUTENV
  3815. #ifdef BIGBUFOK
  3816. #define NPUTENVS 4096
  3817. #else
  3818. #define NPUTENVS 128
  3819. #endif    /* BIGBUFOK */
  3820. /* environment variables must be static, not automatic */
  3821.  
  3822. static char * putenvs[NPUTENVS];    /* Array of environment var strings */
  3823. static int nputenvs = -1;        /* Pointer into array */
  3824. /*
  3825.   If anyone ever notices the limitation on the number of PUTENVs, the list
  3826.   can be made dynamic, we can recycle entries with the same name, etc.
  3827. */
  3828. int
  3829. doputenv(s1, s2) char * s1; char * s2; {
  3830.     char * s, * t = tmpbuf;        /* Create or alter environment var */
  3831.  
  3832.     if (nputenvs == -1) {        /* Table not used yet */
  3833.     int i;                /* Initialize the pointers */
  3834.     for (i = 0; i < NPUTENVS; i++)
  3835.       putenvs[i] = NULL;
  3836.     nputenvs = 0;
  3837.     }
  3838.     if (!s1) return(1);            /* Nothing to do */
  3839.     if (!*s1) return(1);        /* ditto */
  3840.  
  3841.     if (ckindex("=",s1,0,0,0)) {    /* Does the name contain an '='? */
  3842.     printf(                /* putenv() does not allow this. */
  3843.      /* This also catches the 'putenv name=value' case */
  3844.          "?PUTENV - Equal sign in variable name - 'help putenv' for info.\n");
  3845.         return(-9);
  3846.     }
  3847.     nputenvs++;                /* Point to next free string */
  3848.  
  3849.     debug(F111,"doputenv s1",s1,nputenvs);
  3850.     debug(F111,"doputenv s2",s2,nputenvs);
  3851.  
  3852.     if (nputenvs > NPUTENVS - 1) {    /* Notice the end */
  3853.     printf("?PUTENV - static buffer space exhausted\n");
  3854.     return(-9);
  3855.     }
  3856.     /* Quotes are not needed but we allow them for familiarity */
  3857.     /* but then we strip them, so syntax is same as for Unix shell */
  3858.  
  3859.     if (s2) {
  3860.     s2 = brstrip(s2);
  3861.     } else {
  3862.     s2 = (char *)"";
  3863.     }
  3864.     ckmakmsg(t,TMPBUFSIZ,s1,"=",s2,NULL);
  3865.     debug(F111,"doputenv",t,nputenvs);
  3866.     (VOID) makestr(&(putenvs[nputenvs]),t); /* Make a safe permananent copy */
  3867.     if (!putenvs[nputenvs]) {
  3868.     printf("?PUTENV - memory allocation failure\n");
  3869.     return(-9);
  3870.     }
  3871.     if (putenv(putenvs[nputenvs])) {
  3872.     printf("?PUTENV - %s\n",ck_errstr());
  3873.     return(-9);
  3874.     } else return(success = 1);
  3875. }
  3876. #endif    /* NOPUTENV */
  3877. #endif    /* UNIX */
  3878.  
  3879. int
  3880. settrmtyp() {
  3881. #ifdef OS2
  3882. #ifdef TNCODE
  3883.     extern int ttnum;                    /* Last Telnet Terminal Type sent */
  3884.     extern int ttnumend;                 /* Has end of list been found */
  3885. #endif /* TNCODE */
  3886.     if ((x = cmkey(ttyptab,nttyp,"","vt220",xxstring)) < 0)
  3887.       return(x);
  3888.     if ((y = cmcfm()) < 0)
  3889.       return(y);
  3890.     settermtype(x,1);
  3891. #ifdef TNCODE
  3892.     /* So we send the correct terminal name to the host if it asks for it */
  3893.     ttnum = -1;                         /* Last Telnet Terminal Type sent */
  3894.     ttnumend = 0;                       /* end of list not found */
  3895. #endif /* TNCODE */
  3896.     return(success = 1);
  3897. #else  /* Not OS2 */
  3898. #ifdef UNIX
  3899.     extern int fxd_inited;
  3900.     x = cmtxt("Terminal type name, case sensitive","",&s,NULL);
  3901. #ifdef NOPUTENV
  3902.     success = 1;
  3903. #else
  3904.     success = doputenv("TERM",s);    /* Set the TERM variable */
  3905. #ifdef CK_CURSES
  3906.     fxd_inited = 0;           /* Force reinitialization of curses database */
  3907.     (void)doxdis(0);             /* Re-initialize file transfer display */
  3908.     concb((char)escape);        /* Fix command terminal */
  3909. #endif    /* CK_CURSES */
  3910. #endif    /* NOPUTENV */
  3911.     return(success);
  3912. #else
  3913.     printf(
  3914. "\n Sorry, this version of C-Kermit does not support the SET TERMINAL TYPE\n");
  3915.     printf(
  3916. " command.  Type \"help set terminal\" for further information.\n");
  3917.     return(success = 0);
  3918. #endif    /* UNIX */
  3919. #endif /* OS2 */
  3920. }
  3921.  
  3922. #ifndef NOLOCAL
  3923. #ifdef OS2
  3924. /* MS-DOS KERMIT compatibility modes */
  3925. int
  3926. setmsk() {
  3927.     if ((y = cmkey(msktab,nmsk,"MS-DOS Kermit compatibility mode",
  3928.                     "keycodes",xxstring)) < 0) return(y);
  3929.  
  3930.     switch ( y ) {
  3931. #ifdef COMMENT
  3932.       case MSK_COLOR:
  3933.         return(seton(&mskcolors));
  3934. #endif /* COMMENT */
  3935.       case MSK_KEYS:
  3936.         return(seton(&mskkeys));
  3937.       case MSK_REN:
  3938.         return(seton(&mskrename));
  3939.       default:                          /* Shouldn't get here. */
  3940.         return(-2);
  3941.     }
  3942. }
  3943. #endif /* OS2 */
  3944.  
  3945. #ifdef CKTIDLE
  3946. static char iactbuf[132];
  3947.  
  3948. char *
  3949. getiact() {
  3950.     switch (tt_idleact) {
  3951.       case IDLE_RET:  return("return");
  3952.       case IDLE_EXIT: return("exit");
  3953.       case IDLE_HANG: return("hangup");
  3954. #ifdef TNCODE
  3955.       case IDLE_TNOP: return("Telnet NOP");
  3956.       case IDLE_TAYT: return("Telnet AYT");
  3957. #endif /* TNCODE */
  3958.  
  3959.       case IDLE_OUT: {
  3960.           int c, k, n;
  3961.           char * p, * q, * t;
  3962.           k = ckstrncpy(iactbuf,"output ",132);
  3963.           n = k;
  3964.           q = &iactbuf[k];
  3965.           p = tt_idlestr;
  3966.           if (!p) p = "";
  3967.           if (!*p) return("output NUL");
  3968.           while ((c = *p++) && n < 131) {
  3969.               c &= 0xff;
  3970.               if (c == '\\') {
  3971.                   if (n > 130) break;
  3972.                   *q++ = '\\';
  3973.                   *q++ = '\\';
  3974.                   *q = NUL;
  3975.                   n += 2;
  3976.               } else if ((c > 32 && c < 127) || c > 159) {
  3977.                   *q++ = c;
  3978.                   *q = NUL;
  3979.                   n++;
  3980.               } else {
  3981.                   if (n > (131 - 6))
  3982.                     break;
  3983.                   sprintf(q,"\\{%d}",c);
  3984.                   k = strlen(q);
  3985.                   q += k;
  3986.                   n += k;
  3987.                   *q = NUL;
  3988.               }
  3989.           }
  3990.           *q = NUL;
  3991. #ifdef OS2
  3992.           k = tt_cols[VTERM];
  3993. #else
  3994.           k = tt_cols;
  3995. #endif /* OS2 */
  3996.           if (n > k - 52) {
  3997.               n = k - 52;
  3998.               iactbuf[n-2] = '.';
  3999.               iactbuf[n-1] = '.';
  4000.               iactbuf[n] = NUL;
  4001.           }
  4002.           return(iactbuf);
  4003.       }
  4004.       default: return("unknown");
  4005.     }
  4006. }
  4007. #endif /* CKTIDLE */
  4008.  
  4009. #ifndef NOCSETS
  4010. VOID
  4011. setlclcharset(x) int x; {
  4012.     int i;
  4013.     tcsl = y;                   /* Local character set */
  4014. #ifdef OS2
  4015.     for (i = 0; i < 4; i++) {
  4016.         G[i].init = TRUE;
  4017.         x = G[i].designation;
  4018.         G[i].c1 = (x != tcsl) && cs_is_std(x);
  4019.         x = G[i].def_designation;
  4020.         G[i].def_c1 = (x != tcsl) && cs_is_std(x);
  4021.     }
  4022. #endif /* OS2 */
  4023. }
  4024.  
  4025. VOID
  4026. setremcharset(x, z) int x, z; {
  4027.     int i;
  4028.  
  4029. #ifdef KUI
  4030.     KuiSetProperty( KUI_TERM_REMCHARSET, (long) x, (long) z ) ;
  4031. #endif /* KUI */
  4032. #ifdef UNICODE
  4033.     if (x == TX_TRANSP)
  4034. #else /* UNICODE */
  4035.     if (x == FC_TRANSP)
  4036. #endif /* UNICODE */
  4037.     {                           /* TRANSPARENT? */
  4038. #ifndef OS2
  4039.         tcsr = tcsl;            /* Make both sets the same */
  4040. #else /* OS2 */
  4041. #ifdef CKOUNI
  4042.         tt_utf8 = 0;            /* Turn off UTF8 flag */
  4043.         tcsr = tcsl = dec_kbd = TX_TRANSP; /* No translation */
  4044.         tcs_transp = 1;
  4045.  
  4046.         if (!cs_is_nrc(tcsl)) {
  4047.             G[0].def_designation = G[0].designation = TX_ASCII;
  4048.             G[0].init = TRUE;
  4049.             G[0].def_c1 = G[0].c1 = FALSE;
  4050.             G[0].size = cs94;
  4051.             G[0].national = FALSE;
  4052.         }
  4053.         for (i = cs_is_nrc(tcsl) ? 0 : 1; i < 4; i++) {
  4054.             G[i].def_designation = G[i].designation = tcsl;
  4055.             G[i].init = TRUE;
  4056.             G[i].def_c1 = G[i].c1 = FALSE;
  4057.             switch (cs_size(G[i].designation)) { /* 94, 96, or 128 */
  4058.             case 128:
  4059.             case 96:
  4060.                 G[i].size = G[i].def_size = cs96;
  4061.                 break;
  4062.             case 94:
  4063.                 G[i].size = G[i].def_size = cs94;
  4064.                 break;
  4065.             default:
  4066.                 G[i].size = G[i].def_size = csmb;
  4067.                 break;
  4068.             }
  4069.             G[i].national = cs_is_nrc(x);
  4070.         }
  4071. #else /* CKOUNI */
  4072.         tcsr = tcsl;            /* Make both sets the same */
  4073.         for (i = 0; i < 4; i++) {
  4074.             G[i].def_designation = G[i].designation = FC_TRANSP;
  4075.             G[i].init = FALSE;
  4076.             G[i].size = G[i].def_size = cs96;
  4077.             G[i].c1 = G[i].def_c1 = FALSE;
  4078.             G[i].rtoi = NULL;
  4079.             G[i].itol = NULL;
  4080.             G[i].ltoi = NULL;
  4081.             G[i].itor = NULL;
  4082.             G[i].national = FALSE;
  4083.         }
  4084. #endif /* CKOUNI */
  4085. #endif /* OS2 */
  4086.         return;
  4087.     }
  4088. #ifdef OS2
  4089. #ifdef CKOUNI
  4090.     else if (x == TX_UTF8) {
  4091.         tcs_transp = 0;
  4092.         tt_utf8 = 1;            /* Turn it on if we are UTF8 */
  4093.         return;
  4094.     }
  4095. #endif /* CKOUNI */
  4096.     else {
  4097.         tcs_transp = 0;
  4098.         tcsr = x;                       /* Remote character set */
  4099. #ifdef CKOUNI
  4100.         tt_utf8 = 0;                    /* Turn off UTF8 flag */
  4101. #endif /* CKOUNI */
  4102.  
  4103.         if (z == TT_GR_ALL) {
  4104.             int i;
  4105. #ifdef UNICODE
  4106.             dec_kbd = x;
  4107. #endif /* UNICODE */
  4108.             for (i = 0; i < 4; i++) {
  4109.                 G[i].init = TRUE;
  4110.                 if ( i == 0 && !cs_is_nrc(x) ) {
  4111.                     G[0].designation = G[0].def_designation = FC_USASCII;
  4112.                     G[0].size = G[0].def_size = cs94;
  4113.                     G[0].national = 1;
  4114.                 } else {
  4115.                     G[i].def_designation = G[i].designation = x;
  4116.                     switch (cs_size(x)) {       /* 94, 96, or 128 */
  4117.                     case 128:
  4118.                     case 96:
  4119.                         G[i].size = G[i].def_size = cs96;
  4120.                         break;
  4121.                     case 94:
  4122.                         G[i].size = G[i].def_size = cs94;
  4123.                         break;
  4124.                     default:
  4125.                         G[i].size = G[i].def_size = csmb;
  4126.                         break;
  4127.                     }
  4128.                     G[i].national = cs_is_nrc(x);
  4129.                 }
  4130.                 G[i].c1 = G[i].def_c1 = x != tcsl && cs_is_std(x);
  4131.             }
  4132. #ifdef UNICODE
  4133.         } else if (z == TT_GR_KBD) {    /* Keyboard only */
  4134.             dec_kbd = x;
  4135. #endif /* UNICODE */
  4136.         } else {                        /* Specific Gn */
  4137.             G[z].def_designation = G[z].designation = x;
  4138.             G[z].init = TRUE;
  4139.             switch (cs_size(x)) {       /* 94, 96, or 128 */
  4140.             case 128:
  4141.             case 96:
  4142.                 G[z].size = G[z].def_size = cs96;
  4143.                 break;
  4144.             case 94:
  4145.                 G[z].size = G[z].def_size = cs94;
  4146.                 break;
  4147.             default:
  4148.                 G[z].size = G[z].def_size = csmb;
  4149.                 break;
  4150.             }
  4151.             G[z].c1 = G[z].def_c1 = x != tcsl && cs_is_std(x);
  4152.             G[z].national = cs_is_nrc(x);
  4153.         }
  4154.     }
  4155. #else /* not OS2 */
  4156.     tcsr = x;                   /* Remote character set */
  4157. #endif /* OS2 */
  4158. }
  4159. #endif /* NOCSETS */
  4160.  
  4161. VOID
  4162. setcmask(x) int x; {
  4163.     if (x == 7) {
  4164.         cmask = 0177;
  4165.     } else if (x == 8) {
  4166.         cmask = 0377;
  4167.         parity = 0;
  4168.     }
  4169. #ifdef KUI      
  4170.     KuiSetProperty(KUI_TERM_CMASK,x,0);
  4171. #endif /* KUI */
  4172. }
  4173.  
  4174. #ifdef CK_AUTODL
  4175. VOID
  4176. setautodl(x,y) int x,y; {
  4177.     autodl = x;
  4178.     adl_ask = y;
  4179. #ifdef KUI      
  4180.     KuiSetProperty(KUI_TERM_AUTODOWNLOAD,x?(y?2:1):0,0);
  4181. #endif /* KUI */
  4182. }
  4183. #endif /* CK_AUTODL */
  4184.  
  4185. #ifdef OS2
  4186. VOID
  4187. seturlhl(int x) {
  4188.     tt_url_hilite = x;
  4189. #ifdef KUI      
  4190.     KuiSetProperty(KUI_TERM_URL_HIGHLIGHT,x,0);
  4191. #endif /* KUI */
  4192. }
  4193.  
  4194. VOID
  4195. setaprint(int x) {
  4196.     extern int aprint;
  4197.     aprint = x;
  4198. #ifdef KUI
  4199.     KuiSetProperty(KUI_TERM_PRINTERCOPY,x,0);
  4200. #endif /* KUI */
  4201. }
  4202. #endif /* OS2 */
  4203.  
  4204. int
  4205. settrm() {
  4206.     int i = 0;
  4207. #ifdef OS2
  4208.     extern int colorreset, user_erasemode;
  4209. #endif /* OS2 */
  4210.     if ((y = cmkey(trmtab,ntrm,"", "",xxstring)) < 0) return(y);
  4211. #ifdef MAC
  4212.     printf("\n?Sorry, not implemented yet.  Please use the Settings menu.\n");
  4213.     return(-9);
  4214. #else
  4215. #ifdef IKSD
  4216.     if (inserver) {
  4217.         if ((y = cmcfm()) < 0) return(y);
  4218.         printf("?Sorry, command disabled.\r\n");
  4219.         return(success = 0);
  4220.     }
  4221. #endif /* IKSD */
  4222.  
  4223.     switch (y) {
  4224.       case XYTBYT:                      /* SET TERMINAL BYTESIZE */
  4225.         if ((y = cmnum("bytesize for terminal connection","8",10,&x,
  4226.                        xxstring)) < 0)
  4227.           return(y);
  4228.         if (x != 7 && x != 8) {
  4229.             printf("\n?The choices are 7 and 8\n");
  4230.             return(success = 0);
  4231.         }
  4232.         if ((y = cmcfm()) < 0) return(y);
  4233.         setcmask(x);
  4234. #ifdef OS2
  4235.         if (IS97801(tt_type_mode))
  4236.           SNI_bitmode(x);
  4237. #endif /* OS2 */
  4238.         return(success = 1);
  4239.  
  4240.       case XYTSO:                       /* SET TERMINAL LOCKING-SHIFT */
  4241.         return(seton(&sosi));
  4242.  
  4243.       case XYTNL:                       /* SET TERMINAL NEWLINE-MODE */
  4244.         return(seton(&tnlm));
  4245.  
  4246. #ifdef OS2
  4247.       case XYTCOL:
  4248.         if ((x = cmkey(ttycoltab,ncolors,"","terminal",xxstring)) < 0)
  4249.           return(x);
  4250.         else if (x == TTCOLRES) {
  4251.             if ((y = cmkey(ttcolmodetab,ncolmode,
  4252.                            "","default-color",xxstring)) < 0)
  4253.               return(y);
  4254.             if ((z = cmcfm()) < 0)
  4255.               return(z);
  4256.             colorreset = y;
  4257.             return(success = 1);
  4258.         } else if (x == TTCOLERA) {
  4259.             if ((y = cmkey(ttcolmodetab,ncolmode,"",
  4260.                            "current-color",xxstring)) < 0)
  4261.               return(y);
  4262.             if ((z = cmcfm()) < 0)
  4263.               return(z);
  4264.             user_erasemode = y;
  4265.             return(success=1);
  4266.         } else {                        /* No parse error */
  4267.             int fg = 0, bg = 0;
  4268.             fg = cmkey(ttyclrtab, nclrs,
  4269.                        (x == TTCOLBOR ?
  4270.                         "color for screen border" :
  4271.                         "foreground color and then background color"),
  4272.                        "lgray", xxstring);
  4273.             if (fg < 0)
  4274.               return(fg);
  4275.             if (x != TTCOLBOR) {
  4276.                 if ((bg = cmkey(ttyclrtab,nclrs,
  4277.                                 "background color","blue",xxstring)) < 0)
  4278.                   return(bg);
  4279.             }
  4280.             if ((y = cmcfm()) < 0)
  4281.               return(y);
  4282.             switch (x) {
  4283.               case TTCOLNOR:
  4284.                 colornormal = fg | bg << 4;
  4285.                 fgi = fg & 0x08;
  4286.                 bgi = bg & 0x08;
  4287.                 break;
  4288.               case TTCOLREV:
  4289.                 colorreverse = fg | bg << 4;
  4290.                 break;
  4291.               case TTCOLITA:
  4292.                 coloritalic = fg | bg << 4;
  4293.                 break;
  4294.               case TTCOLUND:
  4295.                 colorunderline = fg | bg << 4;
  4296.                 break;
  4297.               case TTCOLGRP:
  4298.                 colorgraphic = fg | bg << 4;
  4299.                 break;
  4300.               case TTCOLDEB:
  4301.                 colordebug = fg | bg << 4;
  4302.                 break;
  4303.               case TTCOLSTA:
  4304.                 colorstatus = fg | bg << 4;
  4305.                 break;
  4306.               case TTCOLHLP:
  4307.                 colorhelp = fg | bg << 4;
  4308.                 break;
  4309.               case TTCOLBOR:
  4310.                 colorborder = fg;
  4311.                 break;
  4312.               case TTCOLSEL:
  4313.                 colorselect = fg | bg << 4;
  4314.                 break;
  4315.               default:
  4316.                 printf("%s - invalid\n",cmdbuf);
  4317.                 return(-9);
  4318.                 break;
  4319.             }
  4320.             scrninitialized[VTERM] = 0;
  4321.             VscrnInit(VTERM);
  4322.         }
  4323.         return(success = 1);
  4324.  
  4325.       case XYTCUR: {                    /* SET TERMINAL CURSOR */
  4326.           extern int cursorena[];
  4327.           extern int cursoron[] ;       /* Cursor state on/off       */
  4328.           if ((x = cmkey(ttycurtab,ncursors,"","underline",xxstring)) < 0)
  4329.             return(x);
  4330.           if ((z = cmkey(curontab,ncuron,"","on",xxstring)) < 0)
  4331.             return(z);
  4332.           if ((y = cmcfm()) < 0) return(y);
  4333.           tt_cursor = tt_cursor_usr = x;
  4334.           if ( z == 2 ) {
  4335.               cursorena[VTERM] = tt_cursorena_usr = 1;
  4336.               tt_cursor_blink = 0;
  4337.           } else {
  4338.               cursorena[VTERM] = tt_cursorena_usr = z;/* turn cursor on/off */
  4339.               tt_cursor_blink = 1;
  4340.           }
  4341.           cursoron[VTERM] = FALSE; /* Force newcursor to restore the cursor */
  4342.           return(success = 1);
  4343.       }
  4344. #endif /* OS2 */
  4345.  
  4346.       case XYTTYP:                      /* SET TERMINAL TYPE */
  4347.         return(settrmtyp());
  4348.  
  4349. #ifdef OS2
  4350.       case XYTARR:                      /* SET TERMINAL ARROW-KEYS */
  4351.         if ((x = cmkey(akmtab,2,"","",xxstring)) < 0) return(x);
  4352.         if ((y = cmcfm()) < 0) return(y);
  4353.         tt_arrow = x;                   /* TTK_NORM / TTK_APPL; see ckuusr.h */
  4354.         return(success = 1);
  4355.  
  4356.       case XYTKPD:                      /* SET TERMINAL KEYPAD-MODE */
  4357.         if ((x = cmkey(kpmtab,2,"","",xxstring)) < 0) return(x);
  4358.         if ((y = cmcfm()) < 0) return(y);
  4359.         tt_keypad = x;                  /* TTK_NORM / TTK_APPL; see ckuusr.h */
  4360.         return(success = 1);
  4361.  
  4362.       case XYTUNX: {                    /* SET TERM UNIX-MODE (DG) */
  4363.         extern int dgunix,dgunix_usr;
  4364.         x = seton(&dgunix);
  4365.         dgunix_usr = dgunix;
  4366.         return(x);
  4367.       }
  4368.       case XYTKBMOD: {                  /* SET TERM KEYBOARD MODE */
  4369.           extern int tt_kb_mode;
  4370.           if ((x = cmkey(kbmodtab,
  4371.                          nkbmodtab,
  4372.                          "normal",
  4373.                          "special keyboard mode for terminal emulation",
  4374.                          xxstring)
  4375.                ) < 0)
  4376.             return(x);
  4377.           if ((y = cmcfm()) < 0) return(y);
  4378.           tt_kb_mode = x;
  4379.           return(success = 1);
  4380.       }
  4381.  
  4382.       case XYTWRP:                      /* SET TERMINAL WRAP */
  4383.         return(seton(&tt_wrap));
  4384.  
  4385.       case XYSCRS:
  4386.         if ((y = cmnum("CONNECT scrollback buffer size, lines","2000",10,&x,
  4387.                        xxstring)) < 0)
  4388.           return(y);
  4389.         /* The max number of lines is the RAM  */
  4390.         /* we can actually dedicate to a       */
  4391.         /* scrollback buffer given the maximum */
  4392.         /* process memory space of 512MB       */
  4393.         if (x < 256 || x > 2000000L) {
  4394.             printf("\n?The size must be between 256 and 2,000,000.\n");
  4395.             return(success = 0);
  4396.         }
  4397.         if ((y = cmcfm()) < 0) return(y);
  4398.         tt_scrsize[VTERM] = x;
  4399.         VscrnInit(VTERM);
  4400.         return(success = 1);
  4401. #endif /* OS2 */
  4402.  
  4403. #ifndef NOCSETS
  4404.       case XYTCS: {                     /* SET TERMINAL CHARACTER-SET */
  4405.         int eol;
  4406.           /* set terminal character-set <remote> <local> */
  4407.         if ((x = cmkey(
  4408. #ifdef CKOUNI
  4409.                        txrtab,ntxrtab,
  4410. #else  /* CKOUNI */
  4411.                        ttcstab,ntermc,
  4412. #endif /* CKOUNI */
  4413.                        "remote terminal character-set","",xxstring)) < 0)
  4414.           return(x);
  4415.  
  4416. #ifdef UNICODE
  4417.         if (x == TX_TRANSP
  4418. #ifdef CKOUNI
  4419.             || x == TX_UTF8
  4420. #endif /* CKOUNI */
  4421.            ) {
  4422.               if ((y = cmcfm()) < 0)    /* Confirm the command */
  4423.                   return(y);
  4424. #ifdef OS2
  4425.             if ( isunicode() && x == TX_TRANSP ) {
  4426.                 /* If we are in unicode display mode then transparent
  4427.                  * only affects the output direction.  We need to know
  4428.                  * the actual remote character set in order to perform
  4429.                  * the tcsr -> ucs2 translation for display.
  4430.                  */
  4431.                 x = y = tcsl;
  4432.             } else
  4433. #endif /* OS2 */
  4434.                 y = x;
  4435.         }
  4436. #else /* UNICODE */
  4437.         if (x == FC_TRANSP) {
  4438.             if ((y = cmcfm()) < 0)      /* Confirm the command */
  4439.                 return(y);
  4440.             y = x;
  4441.         }
  4442. #endif /* UNICODE */
  4443.  
  4444.         /* Not transparent or UTF8, so get local set to translate it into */
  4445.         s = "";
  4446. #ifdef OS2
  4447.         y = os2getcp();                 /* Default is current code page */
  4448.         switch (y) {
  4449.           case 437: s = "cp437"; break;
  4450.           case 850: s = "cp850"; break;
  4451.           case 852: s = "cp852"; break;
  4452.           case 857: s = "cp857"; break;
  4453.           case 858: s = "cp858"; break;
  4454.           case 862: s = "cp862"; break;
  4455.           case 866: s = "cp866"; break;
  4456.           case 869: s = "cp869"; break;
  4457.           case 1250: s = "cp1250"; break;
  4458.           case 1251: s = "cp1251"; break;
  4459.           case 1252: s = "cp1252"; break;
  4460.           case 1253: s = "cp1253"; break;
  4461.           case 1254: s = "cp1254"; break;
  4462.           case 1255: s = "cp1255"; break;
  4463.           case 1256: s = "cp1256"; break;
  4464.           case 1257: s = "cp1257"; break;
  4465.           case 1258: s = "cp1258"; break;
  4466.         }
  4467. #ifdef PCFONTS
  4468. /*
  4469.    If the user has loaded a font with SET TERMINAL FONT then we want
  4470.    to change the default code page to the font that was loaded.
  4471. */
  4472.         if (tt_font != TTF_ROM) {
  4473.             for (y = 0; y < ntermfont; y++ ) {
  4474.                 if (term_font[y].kwval == tt_font) {
  4475.                     s = term_font[y].kwd;
  4476.                     break;
  4477.                 }
  4478.             }
  4479.         }
  4480. #endif /* PCFONTS */
  4481. #else  /* Not K95... */
  4482.         s = fcsinfo[fcharset].keyword;
  4483. #endif /* OS2 */
  4484.  
  4485.         if ((y = cmkey(
  4486. #ifdef CKOUNI
  4487.                        txrtab,ntxrtab,
  4488. #else /* CKOUNI */
  4489.                        ttcstab,ntermc,
  4490. #endif /* CKOUNI */
  4491.                        "local character-set",s,xxstring)) < 0)
  4492.           return(y);
  4493.  
  4494. #ifdef UNICODE
  4495.         if (y == TX_UTF8) {
  4496.             printf("?UTF8 may not be used as a local character set.\r\n");
  4497.             return(-9);
  4498.         }
  4499. #endif /* UNICODE */
  4500. #ifdef OS2
  4501.         if ((z = cmkey(graphsettab,ngraphset,
  4502.                        "DEC VT intermediate graphic set","all",xxstring)) < 0)
  4503.             return(z);
  4504. #endif /* OS2 */
  4505.         if ((eol = cmcfm()) < 0)
  4506.             return(eol); /* Confirm the command */
  4507.  
  4508.         /* End of command parsing - actions begin */
  4509.         setlclcharset(y);
  4510.         setremcharset(x,z);
  4511.         return(success = 1);
  4512.       }
  4513. #endif /* NOCSETS */
  4514.  
  4515. #ifndef NOCSETS
  4516.       case XYTLCS:                      /* SET TERMINAL LOCAL-CHARACTER-SET */
  4517.         /* set terminal character-set <local> */
  4518.         s = getdcset();                 /* Get display character-set name */
  4519.         if ((y = cmkey(
  4520. #ifdef CKOUNI
  4521.                        txrtab,ntxrtab,
  4522. #else /* CKOUNI */
  4523.                        fcstab,nfilc,
  4524. #endif /* CKOUNI */
  4525.                        "local character-set",s,xxstring)) < 0)
  4526.           return(y);
  4527.  
  4528. #ifdef UNICODE
  4529.           if (y == TX_UTF8) {
  4530.               printf("?UTF8 may not be used as a local character set.\r\n");
  4531.               return(-9);
  4532.           }
  4533. #endif /* UNICODE */
  4534.           if ((z = cmcfm()) < 0) return(z); /* Confirm the command */
  4535.  
  4536.           /* End of command parsing - action begins */
  4537.  
  4538.         setlclcharset(y);
  4539.         return(success = 1);
  4540. #endif /* NOCSETS */
  4541.  
  4542. #ifndef NOCSETS
  4543. #ifdef UNICODE
  4544.       case XYTUNI:                      /* SET TERMINAL UNICODE */
  4545.         return(seton(&tt_unicode));
  4546. #endif /* UNICODE */
  4547.  
  4548.       case XYTRCS:                      /* SET TERMINAL REMOTE-CHARACTER-SET */
  4549.         /* set terminal character-set <remote> <Graphic-set> */
  4550.         if ((x = cmkey(
  4551. #ifdef CKOUNI
  4552.                 txrtab, ntxrtab,
  4553. #else /* CKOUNI */
  4554.                 ttcstab,ntermc,
  4555. #endif /* CKOUNI */
  4556.                        "remote terminal character-set","",xxstring)) < 0)
  4557.           return(x);
  4558.  
  4559. #ifdef UNICODE
  4560.         if (x == TX_TRANSP
  4561. #ifdef CKOUNI
  4562.             || x == TX_UTF8
  4563. #endif /* CKOUNI */
  4564.            ) {
  4565.               if ((y = cmcfm()) < 0)    /* Confirm the command */
  4566.                   return(y);
  4567. #ifdef OS2
  4568.             if ( isunicode() && x == TX_TRANSP ) {
  4569.                 /* If we are in unicode display mode then transparent
  4570.                  * only affects the output direction.  We need to know
  4571.                  * the actual remote character set in order to perform
  4572.                  * the tcsr -> ucs2 translation for display.
  4573.                  */
  4574.                 x = tcsl;
  4575.             }
  4576. #endif /* OS2 */
  4577.         }
  4578. #else /* UNICODE */
  4579.         if (x == FC_TRANSP) {
  4580.           if ((y = cmcfm()) < 0)        /* Confirm the command */
  4581.             return(y);
  4582.         }
  4583. #endif /* UNICODE */
  4584.         else {
  4585. #ifdef OS2
  4586.           if ((z = cmkey(graphsettab,ngraphset,
  4587.                       "DEC VT intermediate graphic set","all",xxstring)) < 0)
  4588.             return(z);
  4589. #endif /* OS2 */
  4590.           if ((y = cmcfm()) < 0)        /* Confirm the command */
  4591.             return(y);
  4592.         }
  4593.         /* Command parsing ends here */
  4594.  
  4595.         setremcharset(x,z);
  4596.         return(success = 1);
  4597. #endif /* NOCSETS */
  4598.  
  4599.       case XYTEC:                       /* SET TERMINAL ECHO */
  4600.         if ((x = cmkey(rltab,nrlt,"which side echos during CONNECT",
  4601.                        "remote", xxstring)) < 0) return(x);
  4602.         if ((y = cmcfm()) < 0) return(y);
  4603. #ifdef NETCONN
  4604.         oldplex = x;
  4605. #endif /* NETCONN */
  4606.         duplex = x;
  4607.         return(success = 1);
  4608.  
  4609.       case XYTESC:                      /* SET TERM ESC */
  4610.         if ((x = cmkey(nabltab,nnabltab,"","enabled",xxstring)) < 0)
  4611.           return(x);
  4612.         if ((y = cmcfm()) < 0) return(y);
  4613.         tt_escape = x;
  4614.         return(1);
  4615.  
  4616.       case XYTCRD:                      /* SET TERMINAL CR-DISPLAY */
  4617.         if ((x = cmkey(crdtab,2,"", "normal", xxstring)) < 0) return(x);
  4618.         if ((y = cmcfm()) < 0) return(y);
  4619.         tt_crd = x;
  4620.         return(success = 1);
  4621.  
  4622.       case XYTLFD:                      /* SET TERMINAL LF-DISPLAY */
  4623.         if ((x = cmkey(crdtab,2,"", "normal", xxstring)) < 0) return(x);
  4624.         if ((y = cmcfm()) < 0) return(y);
  4625.         tt_lfd = x;
  4626.         return(success = 1);
  4627.  
  4628. #ifdef OS2
  4629.       case XYTANS: {                    /* SET TERMINAL ANSWERBACK */
  4630. /*
  4631.   NOTE: We let them enable and disable the answerback sequence, but we
  4632.   do NOT let them change it, and we definitely do not let the host set it.
  4633.   This is a security feature.
  4634.  
  4635.   As of 1.1.8 we allow the SET TERM ANSWERBACK MESSAGE <string> to be
  4636.   used just as MS-DOS Kermit does.  C0 and C1 controls as well as DEL
  4637.   are not allowed to be used as characters.  They are translated to
  4638.   underscore.  This may not be set by APC.
  4639. */
  4640.           if ((x = cmkey(anbktab,nansbk,"", "off", xxstring)) < 0)
  4641.             return(x);
  4642.           if (x < 2) {
  4643.               if ((y = cmcfm()) < 0)
  4644.                 return(y);
  4645.               tt_answer = x;
  4646.               return(success = 1);
  4647.           } else if ( x == 2 || x == 3) {
  4648.               int len = 0;
  4649.               extern int safeanswerbk;
  4650.               extern char useranswerbk[];
  4651.               if ((y = cmtxt("Answerback extension","",&s,xxstring)) < 0)
  4652.                 return(y);
  4653.               if (apcactive == APC_LOCAL ||
  4654.                   (apcactive == APC_REMOTE && !(apcstatus & APC_UNCH)))
  4655.                 return(success = 0);
  4656.               len = strlen(s);
  4657.               if (x == 2) {
  4658.                   /* Safe Answerback's don't have C0/C1 chars */
  4659.                   for (z = 0; z < len; z++) {
  4660.                       if ((s[z] & 0x7F) <= SP || (s[z] & 0x7F) == DEL)
  4661.                         useranswerbk[z] = '_';
  4662.                       else
  4663.                         useranswerbk[z] = s[z];
  4664.                   }
  4665.                   useranswerbk[z] = '\0';
  4666.                   safeanswerbk = 1 ;    /* TRUE */
  4667.               } else {
  4668.                   ckstrncpy(useranswerbk,s,60); /* (see ckocon.c) */
  4669.                   safeanswerbk = 0;     /* FALSE */
  4670.               }
  4671.               updanswerbk();
  4672.               return(success = 1);
  4673.           } else
  4674.             return(success = 0);
  4675.       }
  4676. #endif /* OS2 */
  4677.  
  4678. #ifdef CK_APC
  4679.       case XYTAPC:
  4680.         if ((y = cmkey(apctab,napctab,
  4681.                        "application program command execution","",
  4682.                        xxstring)) < 0)
  4683.           return(y);
  4684.         if ((x = cmcfm()) < 0)
  4685.           return(x);
  4686.         if (apcactive == APC_LOCAL ||
  4687.             (apcactive == APC_REMOTE && !(apcstatus & APC_UNCH)))
  4688.           return(success = 0);
  4689.         apcstatus = y;
  4690.         return(success = 1);
  4691.  
  4692. #ifdef CK_AUTODL
  4693.       case XYTAUTODL:                   /* AUTODOWNLOAD */
  4694.         if ((y = cmkey(adltab,nadltab,"Auto-download options","",
  4695.                        xxstring)) < 0)
  4696.           return(y);
  4697.         switch (y) {
  4698.           case TAD_ON:
  4699.           case TAD_OFF:
  4700.             if ((x = cmcfm()) < 0)
  4701.               return(x);
  4702.             setautodl(y,0);
  4703.             break;
  4704.           case TAD_ASK:
  4705.             if ((x = cmcfm()) < 0)
  4706.               return(x);
  4707.             setautodl(TAD_ON,1);
  4708.             break;
  4709.           case TAD_ERR:
  4710.             if ((y = cmkey(adlerrtab,nadlerrtab,"","", xxstring)) < 0)
  4711.               return(y);
  4712.             if ((x = cmcfm()) < 0)
  4713.               return(x);
  4714.             adl_err = y;
  4715.             break;
  4716. #ifdef OS2
  4717.           case TAD_K:
  4718.             if ((y = cmkey(adlxtab,nadlxtab,"","", xxstring)) < 0)
  4719.               return(y);
  4720.             switch (y) {
  4721.               case TAD_X_C0:
  4722.                 if ((y = cmkey(adlc0tab,nadlc0tab,"",
  4723.                                "processed-by-emulator",xxstring)) < 0)
  4724.                   return(y);
  4725.                 if ((x = cmcfm()) < 0)
  4726.                   return(x);
  4727.                 adl_kc0 = y;
  4728.                 break;
  4729.               case TAD_X_DETECT:
  4730.                 if ((y = cmkey(adldtab,nadldtab,"","packet",xxstring)) < 0)
  4731.                   return(y);
  4732.                 if ((x = cmcfm()) < 0)
  4733.                   return(x);
  4734.                 adl_kmode = y;
  4735.                 break;
  4736.               case TAD_X_STR:
  4737.                 if ((y = cmtxt("Kermit start string","KERMIT READY TO SEND...",
  4738.                                &s,xxstring)) < 0)
  4739.                   return(y);
  4740.                 free(adl_kstr);
  4741.                 adl_kstr = strdup(s);
  4742.                 break;
  4743.             }
  4744.             break;
  4745.  
  4746.           case TAD_Z:
  4747.             if ((y = cmkey(adlxtab,nadlxtab,"","",xxstring)) < 0)
  4748.               return(y);
  4749.             switch (y) {
  4750.               case TAD_X_C0:
  4751.                 if ((y = cmkey(adlc0tab,nadlc0tab,"",
  4752.                                "processed-by-emulator",xxstring)) < 0)
  4753.                   return(y);
  4754.                 if ((x = cmcfm()) < 0)
  4755.                   return(x);
  4756.                 adl_zc0 = y;
  4757.                 break;
  4758.               case TAD_X_DETECT:
  4759.                 if ((y = cmkey(adldtab,nadldtab,"","packet",xxstring)) < 0)
  4760.                   return(y);
  4761.                 if ((x = cmcfm()) < 0)
  4762.                   return(x);
  4763.                 adl_zmode = y;
  4764.                 break;
  4765.               case TAD_X_STR:
  4766.                 if ((y = cmtxt("","rz\\{13}",&s,xxstring)) < 0)
  4767.                   return(y);
  4768.                 free(adl_zstr);
  4769.                 adl_zstr = strdup(s);
  4770.                 break;
  4771.             }
  4772.             break;
  4773. #endif /* OS2 */
  4774.         }
  4775.         return(success = 1);
  4776.  
  4777. #endif /* CK_AUTODL */
  4778. #endif /* CK_APC */
  4779.  
  4780. #ifdef OS2
  4781.       case XYTBEL:
  4782.         return(success = setbell());
  4783.  
  4784.       case XYTMBEL:                     /* MARGIN-BELL */
  4785.         if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  4786.         if (y) {                        /* ON */
  4787.             if ((z = cmnum("Column at which to set margin bell",
  4788.                            "72",10,&x,xxstring)) < 0)
  4789.               return(z);
  4790.         }
  4791.         if ((z = cmcfm()) < 0) return(z);
  4792.         marginbell = y;
  4793.         marginbellcol = x;
  4794.         return(success = 1);
  4795. #endif /* OS2 */
  4796.  
  4797. #ifdef CKTIDLE
  4798.       case XYTIDLE:                     /* IDLE-SEND */
  4799.       case XYTITMO:                     /* IDLE-TIMEOUT */
  4800.         if ((z = cmnum("seconds of idle time to wait, or 0 to disable",
  4801.                        "0",10,&x,xxstring)) < 0)
  4802.           return(z);
  4803.         if (y == XYTIDLE) {
  4804.             if ((y = cmtxt("string to send, may contain kverbs and variables",
  4805.                            "\\v(newline)",&s,xxstring)) < 0)
  4806.               return(y);
  4807.             tt_idlesnd_tmo = x;         /* (old) */
  4808.             tt_idlelimit = x;           /* (new) */
  4809.             makestr(&tt_idlestr,brstrip(s)); /* (new) */
  4810.             tt_idlesnd_str = tt_idlestr; /* (old) */
  4811.             tt_idleact = IDLE_OUT;      /* (new) */
  4812.         } else {
  4813.             if ((y = cmcfm()) < 0)
  4814.               return(y);
  4815.             tt_idlelimit = x;
  4816.         }
  4817. #ifdef OS2
  4818.         puterror(VTERM);
  4819. #endif /* OS2 */
  4820.         return(success = 1);
  4821.  
  4822.       case XYTIACT: {                   /* SET TERM IDLE-ACTION */
  4823.           if ((y = cmkey(idlacts,nidlacts,"","",xxstring)) < 0)
  4824.             return(y);
  4825.           if (y == IDLE_OUT) {
  4826.               if ((x = cmtxt("string to send, may contain kverbs and variables"
  4827.                              , "",&s,xxstring)) < 0)
  4828.                 return(x);
  4829.               makestr(&tt_idlestr,brstrip(s)); /* (new) */
  4830.               tt_idlesnd_str = tt_idlestr; /* (old) */
  4831.           } else {
  4832.               if ((x = cmcfm()) < 0)
  4833.                 return(x);
  4834.           }
  4835.           tt_idleact = y;
  4836.           return(success = 1);
  4837.       }
  4838. #endif /* CKTIDLE */
  4839.  
  4840.       case XYTDEB:                      /* TERMINAL DEBUG */
  4841.         y = seton(&x);                  /* Go parse ON or OFF */
  4842.         if (y > 0)                      /* Command succeeded? */
  4843.           setdebses(x);
  4844.         return(y);
  4845.  
  4846. #ifdef OS2
  4847.       case XYTASCRL:                    /* SET TERMINAL AUTOSCROLL */
  4848.           y = seton(&autoscroll);
  4849.           return(y);
  4850.  
  4851.       case XYTAPAGE:                    /* SET TERMINAL AUTOPAGE */
  4852.           y = seton(&wy_autopage);
  4853.           return(y);
  4854.  
  4855.       case XYTROL:                      /* SET TERMINAL ROLL */
  4856.         if ((y = cmkey(rolltab,nroll,"scrollback mode","insert",xxstring))<0)
  4857.       return(y);
  4858.     if (y == TTR_KEYS) {
  4859.         if ((x = cmkey(rollkeytab,nrollkey,"","send",xxstring))<0)
  4860.           return(x);
  4861.         if ((z = cmcfm()) < 0) return(z);
  4862.         tt_rkeys[VTERM] = x;
  4863.     } else {
  4864.         if ((x = cmcfm()) < 0) return(x);
  4865.         tt_roll[VTERM] = y;
  4866.     }
  4867.         return(success = 1);
  4868.  
  4869.       case XYTCTS:                      /* SET TERMINAL TRANSMIT-TIMEOUT */
  4870.         y = cmnum("Maximum seconds to allow CTS off during CONNECT",
  4871.                   "5",10,&x,xxstring);
  4872.         return(setnum(&tt_ctstmo,x,y,10000));
  4873.  
  4874.       case XYTCPG: {                    /* SET TERMINAL CODE-PAGE */
  4875.         int i;
  4876.         int cp = -1;
  4877.         y = cmnum("PC code page to use during terminal emulation",
  4878.                   ckitoa(os2getcp()),10,&x,xxstring);
  4879.         if ((x = setnum(&cp,x,y,11000)) < 0) return(x);
  4880.         if (os2setcp(cp) != 1) {
  4881. #ifdef NT
  4882.             if (isWin95())
  4883.               printf(
  4884.                  "Sorry, Windows 95 does not support code page switching\n");
  4885.             else
  4886. #endif /* NT */
  4887.               printf(
  4888.                  "Sorry, %d is not a valid code page for this system.\n",cp);
  4889.             return(-9);
  4890.         }
  4891.     /* Force the terminal character-sets conversions to be updated */
  4892.         for ( i = 0; i < 4; i++ )
  4893.           G[i].init = TRUE;
  4894.         return(1);
  4895.     }
  4896.  
  4897.       case XYTPAC:                      /* SET TERMINAL OUTPUT-PACING */
  4898.         y = cmnum(
  4899.            "Pause between sending each character during CONNECT, milliseconds",
  4900.                   "-1",10,&x,xxstring);
  4901.         return(setnum(&tt_pacing,x,y,10000));
  4902.  
  4903. #ifdef OS2MOUSE
  4904.       case XYTMOU: {                    /* SET TERMINAL MOUSE */
  4905.           int old_mou = tt_mouse;
  4906.           if ((x = seton(&tt_mouse)) < 0)
  4907.             return(x);
  4908.           if (tt_mouse != old_mou)
  4909.             if (tt_mouse)
  4910.               os2_mouseon();
  4911.             else
  4912.               os2_mouseoff();
  4913.           return(1);
  4914.       }
  4915. #endif /* OS2MOUSE */
  4916. #endif /* OS2 */
  4917.  
  4918.       case XYTWID: {
  4919.           if ((y = cmnum(
  4920. #ifdef OS2
  4921.                          "number of columns in display window during CONNECT",
  4922. #else
  4923.                          "number of columns on your screen",
  4924. #endif /* OS2 */
  4925.                          "80",10,&x,xxstring)) < 0)
  4926.             return(y);
  4927.           if ((y = cmcfm()) < 0) return(y);
  4928. #ifdef OS2
  4929.           return(success = os2_settermwidth(x));
  4930. #else  /* Not OS/2 */
  4931.           tt_cols = x;
  4932.           return(success = 1);
  4933. #endif /* OS2 */
  4934.       }
  4935.  
  4936.       case XYTHIG:
  4937.         if ((y = cmnum(
  4938. #ifdef OS2
  4939.  "number of rows in display window during CONNECT, not including status line",
  4940.  tt_status[VTERM]?"24":"25",
  4941. #else
  4942.  "24","number of rows on your screen",
  4943. #endif /* OS2 */
  4944.                        10,&x,xxstring)) < 0)
  4945.           return(y);
  4946.         if ((y = cmcfm()) < 0) return(y);
  4947.  
  4948. #ifdef OS2
  4949.         return (success = os2_settermheight(x));
  4950. #else  /* Not OS/2 */
  4951.         tt_rows = x;
  4952.         return(success = 1);
  4953. #endif /* OS2 */
  4954.  
  4955. #ifdef OS2
  4956.       case XYTPRN: {                    /* Print Mode */
  4957.           extern bool xprint, aprint, cprint, uprint;
  4958.           if ((y = cmkey(prnmtab,nprnmtab,"","off", xxstring)) < 0) return(y);
  4959.           if ((x = cmcfm()) < 0) return(x);
  4960.           switch (y) {
  4961.             case 0:
  4962.               if (cprint || uprint || aprint || xprint)
  4963.                 printeroff();
  4964.               cprint = xprint = uprint = 0;
  4965.               setaprint(0);
  4966.               break;
  4967.             case 1:
  4968.               if (!(cprint || uprint || aprint || xprint))
  4969.                 printeron();
  4970.               setaprint(1);
  4971.               cprint = xprint = uprint = 0;
  4972.               break;
  4973.             case 2:
  4974.               if (!(cprint || uprint || aprint || xprint))
  4975.                 printeron();
  4976.               cprint = 1;
  4977.               setaprint(0);
  4978.           xprint = uprint = 0;
  4979.               break;
  4980.             case 3:
  4981.               if (!(cprint || uprint || aprint || xprint))
  4982.                 printeron();
  4983.               uprint = 1;
  4984.               setaprint(0);
  4985.               xprint = cprint = 0;
  4986.               break;
  4987.           }
  4988.           return(1);
  4989.       }
  4990. #else
  4991. #ifdef XPRINT
  4992.       case XYTPRN: {
  4993.           extern int tt_print;
  4994.           if ((x = seton(&tt_print)) < 0)
  4995.             return(x);
  4996.           return(success = 1);
  4997.       }
  4998. #endif /* XPRINT */
  4999. #endif /* OS2 */
  5000.  
  5001. #ifdef OS2
  5002.       case XYTSCNM: {
  5003.           extern int decscnm, decscnm_usr;
  5004.           if ((y = cmkey(normrev,4,"",
  5005.                          decscnm_usr?"reverse":"normal",
  5006.                          xxstring)
  5007.                ) < 0)
  5008.             return(y);
  5009.           if ((x = cmcfm()) < 0) return(x);
  5010.           decscnm_usr = y;
  5011.           if (decscnm != decscnm_usr)
  5012.             flipscreen(VTERM);
  5013.           return(1);
  5014.     }
  5015.     case XYTOPTI:
  5016.         if ((y = cmkey(onoff,2,"",tt_diff_upd?"on":"off",
  5017.                         xxstring)) < 0) return(y);
  5018.         if ((x = cmcfm()) < 0) return(x);
  5019.         tt_diff_upd = y;
  5020.         return(1);
  5021.     case XYTUPD: {
  5022.         int mode, delay;
  5023.         if ((mode = cmkey(scrnupd,nscrnupd,"","fast",xxstring)) < 0) {
  5024.             return(mode);
  5025.         } else {
  5026.             y = cmnum(
  5027.             "Pause between FAST screen updates in CONNECT mode, milliseconds",
  5028.                       "100",10,&x,xxstring
  5029.                       );
  5030.             if (x < 0 || x > 1000 ) {
  5031.                 printf(
  5032.             "\n?The update rate must be between 0 and 1000 milliseconds.\n"
  5033.                        );
  5034.                 return(success = 0);
  5035.             }
  5036.             if ((y = cmcfm()) < 0) return(y);
  5037.  
  5038.             updmode = tt_updmode = mode;
  5039.             return(setnum(&tt_update,x,y,10000));
  5040.         }
  5041.     }
  5042.     case XYTCTRL:
  5043.           if ((x = cmkey(termctrl,ntermctrl,"","7",xxstring)) < 0) {
  5044.               return(x);
  5045.           } else {
  5046.               if ((y = cmcfm()) < 0)
  5047.                   return(y);
  5048.               switch ( x ) {
  5049.               case 8:
  5050.                   send_c1 = send_c1_usr = TRUE;
  5051.                   break;
  5052.               case 7:
  5053.               default:
  5054.                   send_c1 = send_c1_usr = FALSE;
  5055.                   break;
  5056.               }
  5057.           }
  5058.           return(success = TRUE);
  5059.           break;
  5060.  
  5061. #ifdef PCFONTS
  5062.       case XYTFON:
  5063.         if ( !IsOS2FullScreen() ) {
  5064.             printf(
  5065.         "\n?SET TERMINAL FONT is only supported in Full Screen sessions.\n");
  5066.             return(success = FALSE);
  5067.         }
  5068.  
  5069.         if ((x = cmkey(term_font,ntermfont,"","default",xxstring)) < 0) {
  5070.             return(x);
  5071.         } else {
  5072.             if ((y = cmcfm()) < 0) return(y);
  5073.             if ( !os2LoadPCFonts() ) {
  5074.                 tt_font = x;
  5075.                 return(success = TRUE);
  5076.             } else {
  5077.                 printf(
  5078.       "\n?PCFONTS.DLL is not available in CKERMIT executable directory.\n");
  5079.                 return(success = FALSE);
  5080.             }
  5081.         }
  5082.         break;
  5083. #else /* PCFONTS */
  5084. #ifdef NT
  5085. #ifdef KUI
  5086.     case XYTFON:
  5087.         return(setguifont());           /* ckuus3.c */
  5088. #endif /* KUI */
  5089. #endif /* NT */
  5090. #endif /* PCFONTS */
  5091.  
  5092.       case XYTVCH: {
  5093.           extern int pheight, marginbot, cmd_rows, cmd_cols;
  5094.           if ((x = cmkey(tvctab,ntvctab,"",isWin95()?"win95-safe":"enabled",
  5095.                          xxstring)) < 0)
  5096.             return(x);
  5097.           if ((y = cmcfm()) < 0) return(y);
  5098. #ifndef KUI
  5099.           if (x != tt_modechg) {
  5100.               switch (x) {
  5101.                 case TVC_DIS:
  5102.                   /* When disabled the heights of all of the virtual screens */
  5103.                   /* must be equal to the physical height of the console     */
  5104.                   /* window and may not be changed.                          */
  5105.                   /* The width of the window may not be altered.             */
  5106.                   tt_modechg = TVC_ENA;                 /* Temporary */
  5107.                   if (marginbot > pheight-(tt_status[VTERM]?1:0))
  5108.                     marginbot = pheight-(tt_status[VTERM]?1:0);
  5109.                   tt_szchng[VCMD] = 1 ;
  5110.                   tt_rows[VCMD] = pheight;
  5111.                   VscrnInit(VCMD);
  5112.                   SetCols(VCMD);
  5113.                   cmd_rows = y;
  5114.  
  5115.                   tt_szchng[VTERM] = 2 ;
  5116.                   tt_rows[VTERM] = pheight - (tt_status[VTERM]?1:0);
  5117.                   VscrnInit(VTERM);
  5118.  
  5119.                   break;
  5120.  
  5121.                 case TVC_ENA:
  5122.                   /* When enabled the physical height of the console windows */
  5123.                   /* should be adjusted to the height of the virtual screen  */
  5124.                   /* The width may be set to anything.                       */
  5125.                   /* nothing to do                                           */
  5126.                   break;
  5127.  
  5128.               case TVC_W95:
  5129.                   /* Win95-safe mode allows the physical height to change    */
  5130.                   /* but restricts it to a width of 80 and a height equal to */
  5131.                   /* 25, 43, or 50.  Must be adjusted now.                   */
  5132.                   /* The virtual heights must be equal to the above.         */
  5133.                   if (pheight != 25 && pheight != 43 && pheight != 50) {
  5134.                       if (pheight < 25)
  5135.                         y = 25;
  5136.                       else if (pheight < 43)
  5137.                         y = 43;
  5138.                       else
  5139.                         y = 50;
  5140.                   } else
  5141.                     y = pheight;
  5142.  
  5143.                   tt_modechg = TVC_ENA; /* Temporary */
  5144.  
  5145.                   tt_szchng[VCMD] = 1;
  5146.                   tt_rows[VCMD] = y;
  5147.                   tt_cols[VCMD] = 80;
  5148.                   VscrnInit(VCMD);
  5149.                   SetCols(VCMD);
  5150.                   cmd_rows = y;
  5151.                   cmd_cols = 80;
  5152.  
  5153.                   marginbot = y-(tt_status[VTERM]?1:0);
  5154.                   tt_szchng[VTERM] = 2;
  5155.                   tt_rows[VTERM] = y - (tt_status[VTERM]?1:0);
  5156.                   tt_cols[VTERM] = 80;
  5157.                   VscrnInit(VTERM);
  5158.                   break;
  5159.               }
  5160.               tt_modechg = x;
  5161.           }
  5162.           return(success = 1);
  5163. #else
  5164.           return(success = 0);
  5165. #endif /* KUI */
  5166.       }
  5167.       case XYTSTAT: {
  5168.           extern int marginbot;
  5169.           if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5170.           if ((x = cmcfm()) < 0) return(x);
  5171.           if (y != tt_status[VTERM] || y != tt_status_usr[VTERM]) {
  5172.               /* Might need to fixup the margins */
  5173.               if ( marginbot == VscrnGetHeight(VTERM)-(tt_status[VTERM]?1:0) )
  5174.                 if (y) {
  5175.                     marginbot--;
  5176.                 } else {
  5177.                     marginbot++;
  5178.                 }
  5179.               tt_status_usr[VTERM] = tt_status[VTERM] = y;
  5180.               if (y) {
  5181.                     tt_szchng[VTERM] = 2;
  5182.                     tt_rows[VTERM]--;
  5183.                     VscrnInit(VTERM);  /* Height set here */
  5184. #ifdef TNCODE
  5185.                     if (TELOPT_ME(TELOPT_NAWS))
  5186.                       tn_snaws();
  5187. #endif /* TNCODE */
  5188. #ifdef RLOGCODE
  5189.                     if (TELOPT_ME(TELOPT_NAWS))
  5190.                       rlog_naws();
  5191. #endif /* RLOGCODE */
  5192. #ifdef SSHBUILTIN
  5193.                     if (TELOPT_ME(TELOPT_NAWS))
  5194.                       ssh_snaws();
  5195. #endif /* SSHBUILTIN */
  5196.               } else {
  5197.                   tt_szchng[VTERM] = 1;
  5198.                   tt_rows[VTERM]++;
  5199.                   VscrnInit(VTERM);     /* Height set here */
  5200. #ifdef TNCODE
  5201.                   if (TELOPT_ME(TELOPT_NAWS))
  5202.                     tn_snaws();
  5203. #endif /* TNCODE */
  5204. #ifdef RLOGCODE
  5205.                   if (TELOPT_ME(TELOPT_NAWS))
  5206.                     rlog_naws();
  5207. #endif /* RLOGCODE */
  5208. #ifdef SSHBUILTIN
  5209.                   if (TELOPT_ME(TELOPT_NAWS))
  5210.                     ssh_snaws();
  5211. #endif /* SSHBUILTIN */
  5212.               }
  5213.           }
  5214.           return(1);
  5215.       }
  5216. #endif /* OS2 */
  5217.  
  5218. #ifdef NT
  5219.       case XYTATTBUG:
  5220.         if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5221.         if ((x = cmcfm()) < 0) return(x);
  5222.         tt_attr_bug = y;
  5223.         return(1);
  5224. #endif /* NT */
  5225.  
  5226. #ifdef OS2
  5227.       case XYTSGRC:
  5228.         if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5229.         if ((x = cmcfm()) < 0) return(x);
  5230.         sgrcolors = y;
  5231.         return(1);
  5232.  
  5233.       case XYTSEND:
  5234.           if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5235.           if ((x = cmcfm()) < 0) return(x);
  5236.           tt_senddata = y;
  5237.           return(1);
  5238.  
  5239.       case XYTSEOB:
  5240.           if ((y = cmkey(ttyseobtab,2,"","us_cr",xxstring)) < 0) return(y);
  5241.           if ((x = cmcfm()) < 0) return(x);
  5242.           wy_blockend = y;
  5243.           return(1);
  5244.  
  5245.       case XYTURLHI: {
  5246.           int done = 0, attr = VT_CHAR_ATTR_NORMAL;
  5247.  
  5248.           if ((x = cmkey(onoff,2,"","on",xxstring)) < 0)
  5249.             return(x);
  5250.           if (x) {
  5251.               z = 0;
  5252.               while (!done) {
  5253.                   if ((y = cmkey(ttyprotab,nprotect,"",
  5254.                                  z?"done":"reverse",xxstring)) < 0)
  5255.                     return(y);
  5256.                   switch (y) {
  5257.                     case TTATTDONE:
  5258.                       done = TRUE;
  5259.                       break;
  5260.                     case TTATTBLI:
  5261.                       attr |= VT_CHAR_ATTR_BLINK;
  5262.                       break;
  5263.                     case TTATTREV:
  5264.                       attr |= VT_CHAR_ATTR_REVERSE;
  5265.                       break;
  5266.                     case TTATTITA:
  5267.                       attr |= VT_CHAR_ATTR_ITALIC;
  5268.                       break;
  5269.                     case TTATTUND:
  5270.                       attr |= VT_CHAR_ATTR_UNDERLINE;
  5271.                       break;
  5272.                     case TTATTBLD:
  5273.                       attr |= VT_CHAR_ATTR_BOLD;
  5274.                       break;
  5275.                     case TTATTDIM:
  5276.                       attr |= VT_CHAR_ATTR_DIM;
  5277.                       break;
  5278.                     case TTATTINV:
  5279.                       attr |= VT_CHAR_ATTR_INVISIBLE;
  5280.                       break;
  5281.                     case TTATTNOR:
  5282.                       break;
  5283.                   }
  5284.                   z = 1;                /* One attribute has been chosen */
  5285.               }
  5286.           }
  5287.           if ((z = cmcfm()) < 0) return(z);
  5288.           seturlhl(x);
  5289.           if (x)
  5290.             tt_url_hilite_attr = attr;
  5291.           return(1);
  5292.       }
  5293.       case XYTATTR:
  5294.         if ((x = cmkey(ttyattrtab,nattrib,"","underline",xxstring)) < 0)
  5295.           return(x);
  5296.         switch (x) {
  5297.           case TTATTBLI:
  5298.             if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5299.             if ((x = cmcfm()) < 0) return(x);
  5300.             trueblink = y;
  5301. #ifndef KUI
  5302.             if ( !trueblink && trueunderline ) {
  5303.                 trueunderline = 0;
  5304.                 printf("Warning: Underline being simulated by color.\n");
  5305.             }
  5306.  
  5307. #endif /* KUI */
  5308.             break;
  5309.  
  5310.           case TTATTDIM:
  5311.             if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5312.             if ((x = cmcfm()) < 0) return(x);
  5313.             truedim = y;
  5314.             break;
  5315.  
  5316.           case TTATTREV:
  5317.             if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5318.             if ((x = cmcfm()) < 0) return(x);
  5319.             truereverse = y;
  5320.             break;
  5321.  
  5322.           case TTATTUND:
  5323.             if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5324.             if ((x = cmcfm()) < 0) return(x);
  5325.             trueunderline = y;
  5326. #ifndef KUI
  5327.             if (!trueblink && trueunderline) {
  5328.                 trueblink = 1;
  5329.                 printf("Warning: True blink mode is active.\n");
  5330.             }
  5331. #endif /* KUI */
  5332.             break;
  5333.  
  5334.           case TTATTITA:
  5335.               if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5336.               if ((x = cmcfm()) < 0) return(x);
  5337.               trueitalic = y;
  5338.             break;
  5339.  
  5340.           case TTATTPRO: {      /* Set default Protected Character attribute */
  5341.               extern vtattrib WPattrib;    /* current WP Mode Attrib */
  5342.               extern vtattrib defWPattrib; /* default WP Mode Attrib */
  5343.               vtattrib wpa = {0,0,0,0,0,1,0,0,0,0,0};   /* Protected */
  5344.               int done = 0;
  5345.  
  5346.               x = 0;
  5347.               while (!done) {
  5348.                   if ((y = cmkey(ttyprotab,nprotect,"",
  5349.                                  x?"done":"dim",xxstring)) < 0)
  5350.                     return(y);
  5351.                   switch (y) {
  5352.                     case TTATTNOR:
  5353.                       break;
  5354.                     case TTATTBLI:      /* Blinking doesn't work */
  5355.                       wpa.blinking = TRUE;
  5356.                       break;
  5357.                     case TTATTREV:
  5358.                       wpa.reversed = TRUE;
  5359.                       break;
  5360.                     case TTATTITA:
  5361.                       wpa.italic = TRUE;
  5362.                       break;
  5363.                     case TTATTUND:
  5364.                       wpa.underlined = TRUE;
  5365.                       break;
  5366.                     case TTATTBLD:
  5367.                       wpa.bold = TRUE;
  5368.                       break;
  5369.                     case TTATTDIM:
  5370.                       wpa.dim = TRUE;
  5371.                       break;
  5372.                     case TTATTINV:
  5373.                       wpa.invisible = TRUE ;
  5374.                       break;
  5375.                     case TTATTDONE:
  5376.                       done = TRUE;
  5377.                       break;
  5378.                   }
  5379.                   x = 1;                /* One attribute has been chosen */
  5380.               }
  5381.               if ((x = cmcfm()) < 0) return(x);
  5382.               WPattrib = defWPattrib = wpa;
  5383.               break;
  5384.           }
  5385.         }
  5386.         return(1);
  5387.  
  5388.       case XYTKEY: {                    /* SET TERMINAL KEY */
  5389.           int t, x, y;
  5390.           int clear = 0, deflt = 0;
  5391.           int confirmed = 0;
  5392.           int flag = 0;
  5393.           int kc = -1;                  /* Key code */
  5394.           int litstr = 0;               /* Literal String? */
  5395.           char *s = NULL;               /* Key binding */
  5396. #ifndef NOKVERBS
  5397.           char *p = NULL;               /* Worker */
  5398. #endif /* NOKVERBS */
  5399.           con_event defevt;
  5400.           extern int os2gks;
  5401.           extern int mskkeys;
  5402.           extern int initvik;
  5403.           struct FDB kw,sw,nu,cm;
  5404.  
  5405.           defevt.type = error;
  5406.  
  5407.           if ((t = cmkey(ttkeytab,nttkey,"","",xxstring)) < 0)
  5408.             return(t);
  5409.           cmfdbi(&nu,                   /* First FDB - command switches */
  5410.                  _CMNUM,                /* fcode */
  5411.                  "/literal, keycode, or action",
  5412.                  "",                    /* default */
  5413.                  "",                    /* addtl string data */
  5414.                  10,                    /* addtl numeric data 1: radix */
  5415.                  0,                     /* addtl numeric data 2: 0 */
  5416.                  xxstring,              /* Processing function */
  5417.                  NULL,                  /* Keyword table */
  5418.                  &sw                    /* Pointer to next FDB */
  5419.                  );                     /*  */
  5420.           cmfdbi(&sw,                   /* Second FDB - switches */
  5421.                  _CMKEY,                /* fcode */
  5422.                  "",
  5423.                  "",                    /* default */
  5424.                  "",                    /* addtl string data */
  5425.                  nstrmswitab,           /* addtl numeric data 1: tbl size */
  5426.                  4,                     /* addtl numeric data 2: 4 = cmswi */
  5427.                  xxstring,              /* Processing function */
  5428.                  strmswitab,            /* Keyword table */
  5429.                  &kw                    /* Pointer to next FDB */
  5430.                  );
  5431.           cmfdbi(&kw,                   /* Third FDB - command switches */
  5432.                  _CMKEY,                /* fcode */
  5433.                  "/literal, keycode, or action",
  5434.                  "",                    /* default */
  5435.                  "",                    /* addtl string data */
  5436.                  nstrmkeytab,           /* addtl numeric data 1: tbl size */
  5437.                  0,                     /* addtl numeric data 2 */
  5438.                  xxstring,              /* Processing function */
  5439.                  strmkeytab,            /* Keyword table */
  5440.                  &cm                    /* Pointer to next FDB */
  5441.                  );
  5442.           cmfdbi(&cm,                   /* Final FDB - Confirmation */
  5443.                  _CMCFM,                /* fcode */
  5444.                  "",
  5445.                  "",                    /* default */
  5446.                  "",                    /* addtl string data */
  5447.                  0,                     /* addtl numeric data 1: tbl size */
  5448.                  0,                     /* addtl numeric data 2: 4 = cmswi */
  5449.                  xxstring,              /* Processing function */
  5450.                  NULL,                  /* Keyword table */
  5451.                  NULL                   /* Pointer to next FDB */
  5452.                  );
  5453.           while (kc < 0) {
  5454.               x = cmfdb(&nu);           /* Parse something */
  5455.               if (x < 0)
  5456.                 return(x);
  5457.  
  5458.               switch (cmresult.fcode) {
  5459.                 case _CMCFM:
  5460.                   printf(" Press key to be defined: ");
  5461.                   conbin((char)escape); /* Put terminal in binary mode */
  5462.                   os2gks = 0;           /* Turn off Kverb preprocessing */
  5463.                   kc = congks(0);       /* Get character or scan code */
  5464.                   os2gks = 1;           /* Turn on Kverb preprocessing */
  5465.                   concb((char)escape);  /* Restore terminal to cbreak mode */
  5466.                   if (kc < 0) {         /* Check for error */
  5467.                       printf("?Error reading key\n");
  5468.                       return(0);
  5469.                   }
  5470.                   shokeycode(kc,t);     /* Show current definition */
  5471.                   flag = 1;             /* Remember it's a multiline command */
  5472.                   break;
  5473.                 case _CMNUM:
  5474.                   kc = cmresult.nresult;
  5475.                   break;
  5476.                 case _CMKEY:
  5477.                   if (cmresult.fdbaddr == &sw) { /* Switch */
  5478.                       if (cmresult.nresult == 0)
  5479.                         litstr = 1;
  5480.                   } else if (cmresult.fdbaddr == &kw) { /* Keyword */
  5481.                       if (cmresult.nresult == 0)
  5482.                         clear = 1;
  5483.                       else
  5484.                         deflt = 1;
  5485.                       if ((x = cmcfm()) < 0)
  5486.                         return(x);
  5487.                       if (clear)
  5488.                         clearkeymap(t);
  5489.                       else if (deflt)
  5490.                         defaultkeymap(t);
  5491.                       initvik = 1;
  5492.                       return(1);
  5493.                   }
  5494.               }
  5495.           }
  5496.  
  5497.     /* Normal SET TERMINAL KEY <terminal> <scancode> <value> command... */
  5498.  
  5499.           if (mskkeys)
  5500.             kc = msktock(kc);
  5501.  
  5502.           if (kc < 0 || kc >= KMSIZE) {
  5503.               printf("?key code must be between 0 and %d\n", KMSIZE - 1);
  5504.               return(-9);
  5505.           }
  5506.           if (kc == escape) {
  5507.               printf("Sorry, %d is the CONNECT-mode escape character\n",kc);
  5508.               return(-9);
  5509.           }
  5510.           wideresult = -1;
  5511.           if (flag) {
  5512.               cmsavp(psave,PROMPTL);
  5513.               cmsetp(" Enter new definition: ");
  5514.               cmini(ckxech);
  5515.           }
  5516.         def_again:
  5517.           if (flag) prompt(NULL);
  5518.           if ((y = cmtxt("key definition,\n\
  5519.  or Ctrl-C to cancel this command,\n\
  5520.  or Enter to restore default definition",
  5521.                          "",&s,NULL)) < 0) {
  5522.               if (flag)                 /* Handle parse errors */
  5523.                 goto def_again;
  5524.               else
  5525.                 return(y);
  5526.           }
  5527.           s = brstrip(s);
  5528. #ifndef NOKVERBS
  5529.           p = s;                        /* Save this place */
  5530. #endif /* NOKVERBS */
  5531. /*
  5532.   If the definition included any \Kverbs, quote the backslash so the \Kverb
  5533.   will still be in the definition when the key is pressed.  We don't do this
  5534.   in zzstring(), because \Kverbs are valid only in this context and nowhere
  5535.   else.
  5536.  
  5537.   We use this code active for all versions that support SET KEY, even if they
  5538.   don't support \Kverbs, because otherwise \K would behave differently for
  5539.   different versions.
  5540. */
  5541.           for (x = 0, y = 0; s[x]; x++, y++) { /* Convert \K to \\K */
  5542.               if ((x > 0) &&
  5543.                   (s[x] == 'K' || s[x] == 'k')
  5544.                   ) {                   /* Have K */
  5545.  
  5546.                   if ((x == 1 && s[x-1] == CMDQ) ||
  5547.                       (x > 1 && s[x-1] == CMDQ && s[x-2] != CMDQ)) {
  5548.                       line[y++] = CMDQ; /* Make it \\K */
  5549.                   }
  5550.                   if (x > 1 && s[x-1] == '{' && s[x-2] == CMDQ) {
  5551.                       line[y-1] = CMDQ; /* Have \{K */
  5552.                       line[y++] = '{';  /* Make it \\{K */
  5553.                   }
  5554.               }
  5555.               line[y] = s[x];
  5556.           }
  5557.           line[y++] = NUL;              /* Terminate */
  5558.           s = line + y + 1;             /* Point to after it */
  5559.           x = LINBUFSIZ - (int) strlen(line) - 1; /* Get remaining space */
  5560.           if ((x < (LINBUFSIZ / 2)) ||
  5561.               (zzstring(line, &s, &x) < 0)) { /* Expand variables, etc. */
  5562.               printf("?Key definition too long\n");
  5563.               if (flag) cmsetp(psave);
  5564.               return(-9);
  5565.           }
  5566.           s = line + y + 1;             /* Point to result. */
  5567.  
  5568. #ifndef NOKVERBS
  5569. /*
  5570.   Special case: see if the definition starts with a \Kverb.
  5571.   If it does, point to it with p, otherwise set p to NULL.
  5572. */
  5573.           p = s;
  5574.           if (*p++ == CMDQ) {
  5575.               if (*p == '{') p++;
  5576.               p = (*p == 'k' || *p == 'K') ? p + 1 : NULL;
  5577.           }
  5578. #endif /* NOKVERBS */
  5579.  
  5580.           switch (strlen(s)) {          /* Action depends on length */
  5581.             case 0:                     /* Clear individual key def */
  5582.               deletekeymap(t,kc);
  5583.               break;
  5584.             case 1:
  5585.               if (!litstr) {
  5586.                   defevt.type = key;    /* Single character */
  5587.                   defevt.key.scancode = *s;
  5588.                   break;
  5589.               }
  5590.             default:                    /* Character string */
  5591. #ifndef NOKVERBS
  5592.               if (p) {
  5593.                   y = xlookup(kverbs,p,nkverbs,&x); /* Look it up */
  5594.                   /* Need exact match */
  5595.                   debug(F101,"set key kverb lookup",0,y);
  5596.                   if (y > -1) {
  5597.                       defevt.type = kverb;
  5598.                       defevt.kverb.id = y;
  5599.                       break;
  5600.                   }
  5601.               }
  5602. #endif /* NOKVERBS */
  5603.               if (litstr) {
  5604.                   defevt.type = literal;
  5605.                   defevt.literal.string = (char *) malloc(strlen(s)+1);
  5606.                   if (defevt.literal.string)
  5607.                     strcpy(defevt.literal.string, s); /* safe */
  5608.               } else {
  5609.                   defevt.type = macro;
  5610.                   defevt.macro.string = (char *) malloc(strlen(s)+1);
  5611.                   if (defevt.macro.string)
  5612.                     strcpy(defevt.macro.string, s); /* safe */
  5613.               }
  5614.               break;
  5615.           }
  5616.           insertkeymap(t, kc, defevt);
  5617.           if (flag)
  5618.             cmsetp(psave);
  5619.           initvik = 1;                  /* Update VIK table */
  5620.           return(1);
  5621.       }
  5622.  
  5623. #ifdef PCTERM
  5624.       case XYTPCTERM:                   /* PCTERM Keyboard Mode */
  5625.         if ((x = seton(&tt_pcterm)) < 0) return(x);
  5626.         return(success = 1);
  5627. #endif /* PCTERM */
  5628. #endif /* OS2 */
  5629.  
  5630. #ifdef CK_TRIGGER
  5631.       case XYTRIGGER:
  5632.         if ((y = cmtxt("String to trigger automatic return to command mode",
  5633.                        "",&s,xxstring)) < 0)
  5634.           return(y);
  5635.         makelist(s,tt_trigger,TRIGGERS);
  5636.         return(1);
  5637. #endif /* CK_TRIGGER */
  5638.  
  5639. #ifdef OS2
  5640.       case XYTSAC:
  5641.         if ((y = cmnum("ASCII value to use for spacing attributes",
  5642.                        "32",10,&x,xxstring)) < 0)
  5643.           return(y);
  5644.         if ((y = cmcfm()) < 0) return(y);
  5645.         tt_sac = x;
  5646.         return(success = 1);
  5647.  
  5648.       case XYTKBDGL: {      /* SET TERM KBD-FOLLOWS-GL/GR */
  5649.           extern int tt_kb_glgr;        /* from ckoco3.c */
  5650.           if ((x = seton(&tt_kb_glgr)) < 0)
  5651.               return(x);
  5652.           return(success = 1);
  5653.       }
  5654. #ifndef NOCSETS
  5655.       case XYTVTLNG:        /* SET TERM DEC-LANGUAGE */
  5656.         if ((y = cmkey(vtlangtab,nvtlangtab,"VT language",
  5657.                        IS97801(tt_type_mode)?"german":"north-american",
  5658.                        xxstring)) < 0)
  5659.           return(y);
  5660.         if ((x = cmcfm()) < 0) return(x);
  5661.  
  5662.         /* A real VT terminal would use the language to set the   */
  5663.         /* default keyboard language for both 8-bit multinational */
  5664.         /* and 7-bit national modes.  For 8-bit mode it would     */
  5665.         /* set the terminal character-set to the ISO set if it    */
  5666.         /* is not already set.                                    */
  5667.         /* Latin-1 can be replaced by DEC Multinational           */
  5668.         switch (y) {
  5669.           case VTL_NORTH_AM:  /* North American */
  5670.             /* Multinational: Latin-1   */
  5671.             /* National:      US_ASCII  */
  5672.             dec_lang = y;
  5673.             dec_nrc = TX_ASCII;
  5674.             dec_kbd = TX_8859_1;
  5675.             break;
  5676.           case VTL_BRITISH :
  5677.             /* Multinational: Latin-1   */
  5678.             /* National:      UK_ASCII  */
  5679.             dec_lang = y;
  5680.             dec_nrc = TX_BRITISH;
  5681.             dec_kbd = TX_8859_1;
  5682.             break;
  5683.           case VTL_FRENCH  :
  5684.           case VTL_BELGIAN :
  5685.           case VTL_CANADIAN:
  5686.             /* Multinational: Latin-1   */
  5687.             /* National:      FR_ASCII  */
  5688.             dec_lang = y;
  5689.             dec_nrc = TX_FRENCH;
  5690.             dec_kbd = TX_8859_1;
  5691.             break;
  5692.           case VTL_FR_CAN  :
  5693.             /* Multinational: Latin-1   */
  5694.             /* National:      FC_ASCII  */
  5695.             dec_lang = y;
  5696.             dec_nrc = TX_CN_FRENCH;
  5697.             dec_kbd = TX_8859_1;
  5698.             break;
  5699.           case VTL_DANISH  :
  5700.           case VTL_NORWEGIA:
  5701.             /* Multinational: Latin-1   */
  5702.             /* National:      NO_ASCII  */
  5703.             dec_lang = y;
  5704.             dec_nrc = TX_NORWEGIAN;
  5705.             dec_kbd = TX_8859_1;
  5706.             break;
  5707.           case VTL_FINNISH :
  5708.             /* Multinational: Latin-1   */
  5709.             /* National:      FI_ASCII  */
  5710.             dec_lang = y;
  5711.             dec_nrc = TX_FINNISH;
  5712.             dec_kbd = TX_8859_1;
  5713.             break;
  5714.           case VTL_GERMAN  :
  5715.             /* Multinational: Latin-1   */
  5716.             /* National:      GR_ASCII  */
  5717.             dec_lang = y;
  5718.             dec_nrc = TX_GERMAN;
  5719.             dec_kbd = TX_8859_1;
  5720.             break;
  5721.           case VTL_DUTCH   :
  5722.             /* Multinational: Latin-1   */
  5723.             /* National:      DU_ASCII  */
  5724.             dec_lang = y;
  5725.             dec_nrc = TX_DUTCH;
  5726.             dec_kbd = TX_8859_1;
  5727.             break;
  5728.           case VTL_ITALIAN :
  5729.             /* Multinational: Latin-1   */
  5730.             /* National:      IT_ASCII  */
  5731.             dec_lang = y;
  5732.             dec_nrc = TX_ITALIAN;
  5733.             dec_kbd = TX_8859_1;
  5734.             break;
  5735.           case VTL_SW_FR   :
  5736.           case VTL_SW_GR   :
  5737.             /* Multinational: Latin-1   */
  5738.             /* National:      CH_ASCII  */
  5739.             dec_lang = y;
  5740.             dec_nrc = TX_SWISS;
  5741.             dec_kbd = TX_8859_1;
  5742.             break;
  5743.           case VTL_SWEDISH :
  5744.             /* Multinational: Latin-1   */
  5745.             /* National:      SW_ASCII  */
  5746.             dec_lang = y;
  5747.             dec_nrc = TX_SWEDISH;
  5748.             dec_kbd = TX_8859_1;
  5749.             break;
  5750.           case VTL_SPANISH :
  5751.             /* Multinational: Latin-1   */
  5752.             /* National:      SP_ASCII  */
  5753.             dec_lang = y;
  5754.             dec_nrc = TX_SPANISH;
  5755.             dec_kbd = TX_8859_1;
  5756.             break;
  5757.           case VTL_PORTUGES:
  5758.             /* Multinational: Latin-1   */
  5759.             /* National:      Portugese ASCII  */
  5760.             dec_lang = y;
  5761.             dec_nrc = TX_PORTUGUESE;
  5762.             dec_kbd = TX_8859_1;
  5763.             break;
  5764.           case VTL_HEBREW  :
  5765.             /* Multinational: Latin-Hebrew / DEC-Hebrew  */
  5766.             /* National:      DEC 7-bit Hebrew  */
  5767.             dec_lang = y;
  5768.             dec_nrc = TX_HE7;
  5769.             dec_kbd = TX_8859_8;
  5770.             break;
  5771.           case VTL_GREEK   :
  5772.             /* Multinational: Latin-Greek / DEC-Greek   */
  5773.             /* National:      DEC Greek NRC             */
  5774.             /* is ELOT927 equivalent to DEC Greek????   */
  5775.             dec_lang = y;
  5776.             dec_nrc = TX_ELOT927;
  5777.             dec_kbd = TX_8859_7;
  5778.             break;
  5779. #ifdef COMMENT
  5780.           case VTL_TURK_Q  :
  5781.           case VTL_TURK_F  :
  5782.             /* Multinational: Latin-Turkish / DEC-Turkish   */
  5783.             /* National:      DEC 7-bit Turkish             */
  5784.             break;
  5785. #endif /* COMMENT */
  5786.           case VTL_HUNGARIA:
  5787.             /* Multinational: Latin-2   */
  5788.             /* National:      no national mode  */
  5789.             dec_lang = y;
  5790.             dec_nrc = TX_HUNGARIAN;
  5791.             dec_kbd = TX_8859_2;
  5792.             break;
  5793.           case VTL_SLOVAK  :
  5794.           case VTL_CZECH   :
  5795.           case VTL_POLISH  :
  5796.           case VTL_ROMANIAN:
  5797.             /* Multinational: Latin-2   */
  5798.             /* National:      no national mode  */
  5799.             dec_lang = y;
  5800.             dec_nrc = TX_ASCII;
  5801.             dec_kbd = TX_8859_2;
  5802.             break;
  5803.           case VTL_RUSSIAN :
  5804.             /* Multinational: Latin-Cyrillic / KOI-8   */
  5805.             /* National:      DEC Russian NRC  */
  5806.             dec_lang = y;
  5807.             dec_nrc = TX_KOI7;
  5808.             dec_kbd = TX_8859_5;
  5809.             break;
  5810.           case VTL_LATIN_AM:
  5811.             /* Multinational: not listed in table   */
  5812.             /* National:      not listed in table  */
  5813.             dec_lang = y;
  5814.             dec_nrc = TX_ASCII;
  5815.             dec_kbd = TX_8859_1;
  5816.             break;
  5817. #ifdef COMMENT
  5818.           case VTL_SCS     :
  5819.             /* Multinational: Latin-2   */
  5820.             /* National:      SCS NRC   */
  5821.             break;
  5822. #endif /* COMMENT */
  5823.           default:
  5824.             return(success = 0);
  5825.         }
  5826.         if (IS97801(tt_type_mode)) {
  5827.             SNI_bitmode(cmask == 0377 ? 8 : 7);
  5828.         }
  5829.         return(success = 1);
  5830. #endif /* NOCSETS */
  5831.  
  5832.       case XYTVTNRC: {                  /* SET TERM DEC-NRC-MODE */
  5833.           extern int decnrcm_usr, decnrcm;        /* from ckoco3.c */
  5834.           if ((x = seton(&decnrcm_usr)) < 0)
  5835.             return(x);
  5836.           decnrcm = decnrcm_usr;
  5837.           return(success = 1);
  5838.       }
  5839.       case XYTSNIPM: {                  /* SET TERM SNI-PAGEMODE */
  5840.           extern int sni_pagemode, sni_pagemode_usr;
  5841.           if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5842.           if ((x = cmcfm()) < 0) return(x);
  5843.           sni_pagemode_usr = sni_pagemode = y;
  5844.           return(success = 1);
  5845.       }
  5846.       case XYTSNISM: {                  /* SET TERM SNI-SCROLLMODE */
  5847.           extern int sni_scroll_mode, sni_scroll_mode_usr;
  5848.           if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5849.           if ((x = cmcfm()) < 0) return(x);
  5850.           sni_scroll_mode_usr = sni_scroll_mode = y;
  5851.           return(success = 1);
  5852.       }
  5853.       case XYTSNICC: {  /* SET TERM SNI-CH.CODE */
  5854.           extern int sni_chcode_usr;
  5855.           if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
  5856.           if ((x = cmcfm()) < 0) return(x);
  5857.           sni_chcode_usr = y;
  5858.           SNI_chcode(y);
  5859.           return(success = 1);
  5860.       }
  5861.       case XYTSNIFV: {  /* SET TERM SNI-FIRMWARE-VERSIONS */
  5862.           extern CHAR sni_kbd_firmware[], sni_term_firmware[];
  5863.           CHAR kbd[7],term[7];
  5864.  
  5865.           if ((x = cmfld("Keyboard Firmware Version",sni_kbd_firmware,
  5866.                          &s, xxstring)) < 0)
  5867.             return(x);
  5868.           if ((int)strlen(s) != 6) {
  5869.               printf("?Sorry - the firmware version must be 6 digits long\n");
  5870.               return(-9);
  5871.           }
  5872.           for (i = 0; i < 6; i++) {
  5873.               if (!isdigit(s[i])) {
  5874.    printf("?Sorry - the firmware version can only contain digits [0-9]\n");
  5875.                   return(-9);
  5876.               }
  5877.           }
  5878.           ckstrncpy(kbd,s,7);
  5879.  
  5880.           if ((x = cmfld("Terminal Firmware Version",sni_term_firmware,
  5881.                          &s, xxstring)) < 0)
  5882.             return(x);
  5883.           if ((int)strlen(s) != 6) {
  5884.               printf("?Sorry - the firmware version must be 6 digits long\n");
  5885.               return(-9);
  5886.           }
  5887.           for (i = 0; i < 6; i++) {
  5888.               if (!isdigit(s[i])) {
  5889.    printf("?Sorry - the firmware version can only contain digits [0-9]\n");
  5890.                    return(-9);
  5891.               }
  5892.           }
  5893.           ckstrncpy(term,s,7);
  5894.           if ((x = cmcfm()) < 0) return(x);
  5895.  
  5896.           ckstrncpy(sni_kbd_firmware,kbd,7);
  5897.           ckstrncpy(sni_term_firmware,term,7);
  5898.           return(success = 1);
  5899.     }
  5900.  
  5901.     case XYTLSP: {              /* SET TERM LINE-SPACING */
  5902.         if ((x = cmfld("Line Spacing","1",&s, xxstring)) < 0)
  5903.           return(x);
  5904.         if (isfloat(s,0) < 1) {        /* (sets floatval) */
  5905.             printf("?Integer or floating-point number required\n");
  5906.             return(-9);
  5907.         }
  5908.         if (floatval < 1.0 || floatval > 3.0) {
  5909.             printf("?Value must within the range 1.0 and 3.0 (inclusive)\n");
  5910.             return(-9);
  5911.         }
  5912.         if ((x = cmcfm()) < 0) return(x);
  5913. #ifdef KUI
  5914.         tt_linespacing[VCMD] = tt_linespacing[VTERM] = floatval;
  5915.         return(success = 1);
  5916. #else /* KUI */
  5917.         printf("?Sorry, Line-spacing is only supported in K95G.EXE.\n");
  5918.         return(success = 0);
  5919. #endif /* KUI */
  5920.     }
  5921. #endif /* OS2 */
  5922.  
  5923.       default:                          /* Shouldn't get here. */
  5924.         return(-2);
  5925.     }
  5926. #endif /* MAC */
  5927. #ifdef COMMENT
  5928.     /*
  5929.       This was supposed to shut up picky compilers but instead it makes
  5930.       most compilers complain about "statement not reached".
  5931.     */
  5932.     return(-2);
  5933. #endif /* COMMENT */
  5934. #ifdef OS2
  5935.     return(-2);
  5936. #endif /* OS2 */
  5937. }
  5938.  
  5939. #ifdef OS2
  5940. int
  5941. settitle(void) {
  5942.     extern char usertitle[];
  5943.     if ((y = cmtxt("title text","",&s,xxstring)) < 0)
  5944.       return(y);
  5945. #ifdef IKSD
  5946.     if (inserver) {
  5947.         printf("?Sorry, command disabled.\r\n");
  5948.         return(success = 0);
  5949.     }
  5950. #endif /* IKSD */
  5951.     s = brstrip(s);
  5952.     ckstrncpy(usertitle,s,64);
  5953.     os2settitle("",1);
  5954.     return(1);
  5955. }
  5956.  
  5957. static struct keytab dialertab[] = {    /* K95 Dialer types */
  5958.     "backspace",        0, 0,
  5959.     "enter",            1, 0
  5960. };
  5961. static int ndialer = 2;
  5962.  
  5963. int
  5964. setdialer(void) {
  5965.     int t, x, y;
  5966.     int clear = 0, deflt = 0;
  5967.     int kc;                             /* Key code */
  5968.     char *s = NULL;                     /* Key binding */
  5969. #ifndef NOKVERBS
  5970.     char *p = NULL;                     /* Worker */
  5971. #endif /* NOKVERBS */
  5972.     con_event defevt;
  5973.     extern int os2gks;
  5974.     extern int mskkeys;
  5975.     extern int initvik;
  5976.  
  5977.     defevt.type = error;
  5978.  
  5979.     if (( x = cmkey(dialertab, ndialer,
  5980.                     "Kermit-95 dialer work-arounds",
  5981.                     "", xxstring)) < 0 )
  5982.       return(x);
  5983.     switch (x) {
  5984.       case 0:                           /* Backspace */
  5985.         kc = 264;
  5986.         break;
  5987.       case 1:                           /* Enter */
  5988.         kc = 269;
  5989.         break;
  5990.       default:
  5991.         printf("Illegal value in setdialer()\n");
  5992.         return(-9);
  5993.     }
  5994.     if ((y = cmtxt("Key definition","",&s,xxstring)) < 0)
  5995.       return(y);
  5996.  
  5997. #ifdef IKSD
  5998.     if (inserver) {
  5999.         printf("?Sorry, command disabled.\r\n");
  6000.         return(success = 0);
  6001.     }
  6002. #endif /* IKSD */
  6003.     s = brstrip(s);
  6004. #ifndef NOKVERBS
  6005.     p = s;                              /* Save this place */
  6006. #endif /* NOKVERBS */
  6007. /*
  6008.   If the definition included any \Kverbs, quote the backslash so the \Kverb
  6009.   will still be in the definition when the key is pressed.  We don't do this
  6010.   in zzstring(), because \Kverbs are valid only in this context and nowhere
  6011.   else.
  6012.  
  6013.   We use this code active for all versions that support SET KEY, even if they
  6014.   don't support \Kverbs, because otherwise \K would behave differently for
  6015.   different versions.
  6016. */
  6017.     for (x = 0, y = 0; s[x]; x++, y++) { /* Convert \K to \\K */
  6018.         if ((x > 0) &&
  6019.             (s[x] == 'K' || s[x] == 'k')
  6020.             ) {                         /* Have K */
  6021.  
  6022.             if ((x == 1 && s[x-1] == CMDQ) ||
  6023.                 (x > 1 && s[x-1] == CMDQ && s[x-2] != CMDQ)) {
  6024.                 line[y++] = CMDQ;       /* Make it \\K */
  6025.             }
  6026.             if (x > 1 && s[x-1] == '{' && s[x-2] == CMDQ) {
  6027.                 line[y-1] = CMDQ;       /* Have \{K */
  6028.                 line[y++] = '{';        /* Make it \\{K */
  6029.             }
  6030.         }
  6031.         line[y] = s[x];
  6032.     }
  6033.     line[y++] = NUL;                    /* Terminate */
  6034.     s = line + y + 1;                   /* Point to after it */
  6035.     x = LINBUFSIZ - (int) strlen(line) - 1; /* Calculate remaining space */
  6036.     if ((x < (LINBUFSIZ / 2)) ||
  6037.         (zzstring(line, &s, &x) < 0)) { /* Expand variables, etc. */
  6038.         printf("?Key definition too long\n");
  6039.         return(-9);
  6040.     }
  6041.     s = line + y + 1;                   /* Point to result. */
  6042.  
  6043. #ifndef NOKVERBS
  6044. /*
  6045.   Special case: see if the definition starts with a \Kverb.
  6046.   If it does, point to it with p, otherwise set p to NULL.
  6047. */
  6048.     p = s;
  6049.     if (*p++ == CMDQ) {
  6050.         if (*p == '{') p++;
  6051.         p = (*p == 'k' || *p == 'K') ? p + 1 : NULL;
  6052.     }
  6053. #endif /* NOKVERBS */
  6054.  
  6055.     /* Clear the definition for SET KEY */
  6056.     if (macrotab[kc]) {                 /* Possibly free old macro from key. */
  6057.         free((char *)macrotab[kc]);
  6058.         macrotab[kc] = NULL;
  6059.     }
  6060.     keymap[kc] = (KEY) kc;
  6061.  
  6062.     /* Now reprogram the default value for all terminal types */
  6063.     /* remember to treat Wyse and Televideo terminals special */
  6064.     /* because of their use of Kverbs for Backspace and Enter */
  6065.     for (t = 0; t <= TT_MAX; t++) {
  6066.         if ( ISDG200(t) && kc == 264) {
  6067.             extern char * udkfkeys[] ;
  6068.             if (kc == 264) {            /* \Kdgbs */
  6069.                 if (udkfkeys[83])
  6070.                   free(udkfkeys[83]);
  6071.                 udkfkeys[83] = strdup(s);
  6072.             }
  6073.         } else if (ISWYSE(t) || ISTVI(t)) {
  6074.             extern char * udkfkeys[] ;
  6075.             if (kc == 264) {            /* \Kwybs or \Ktvibs */
  6076.                 if (udkfkeys[32])
  6077.                   free(udkfkeys[32]);
  6078.                 udkfkeys[32] = strdup(s);
  6079.             }
  6080.             if (kc == 269) {            /* \Kwyenter and \Kwyreturn */
  6081.                 if (udkfkeys[39])       /* \Ktvienter and \Ktvireturn */
  6082.                   free(udkfkeys[39]);
  6083.                 udkfkeys[39] = strdup(s);
  6084.                 if (udkfkeys[49])
  6085.                   free(udkfkeys[49]);
  6086.                 udkfkeys[49] = strdup(s);
  6087.             }
  6088.         } else {
  6089.             switch (strlen(s)) {        /* Action depends on length */
  6090.               case 0:                   /* Clear individual key def */
  6091.                 deletekeymap(t,kc);
  6092.                 break;
  6093.               case 1:
  6094.                 defevt.type = key;      /* Single character */
  6095.                 defevt.key.scancode = *s;
  6096.                 break;
  6097.               default:                  /* Character string */
  6098. #ifndef NOKVERBS
  6099.                 if (p) {
  6100.                     y = xlookup(kverbs,p,nkverbs,&x); /* Look it up */
  6101.                     /* Exact match req'd */
  6102.                     debug(F101,"set key kverb lookup",0,y);
  6103.                     if (y > -1) {
  6104.                         defevt.type = kverb;
  6105.                         defevt.kverb.id = y;
  6106.                         break;
  6107.                     }
  6108.                 }
  6109. #endif /* NOKVERBS */
  6110.                 defevt.type = macro;
  6111.                 defevt.macro.string = (char *) malloc(strlen(s)+1);
  6112.                 if (defevt.macro.string)
  6113.                   strcpy(defevt.macro.string, s); /* safe */
  6114.                 break;
  6115.             }
  6116.             insertkeymap( t, kc, defevt ) ;
  6117.             initvik = 1;                /* Update VIK table */
  6118.         }
  6119.     }
  6120.     return(1);
  6121. }
  6122. #endif /* OS2 */
  6123.  
  6124. #ifdef NT
  6125. int
  6126. setwin95( void ) {
  6127.     int x, y, z;
  6128.  
  6129.     if (( y = cmkey(win95tab, nwin95,
  6130.                     "Windows 95 specific work-arounds",
  6131.                     "keyboard-translation",
  6132.                     xxstring)) < 0 )
  6133.         return (y);
  6134.     switch (y) {
  6135.       case XYWPOPUP:
  6136.         if ((y = cmkey(onoff,2,"popups are used to prompt the user for data",
  6137.                        "on",xxstring)) < 0)
  6138.           return(y);
  6139.         if ((x = cmcfm()) < 0) return(x);
  6140.         win95_popup = y;
  6141.         return(1);
  6142.  
  6143.       case XYW8_3:
  6144.         if ((y = cmkey(onoff,2,"8.3 FAT file names","off",xxstring)) < 0)
  6145.           return(y);
  6146.         if ((x = cmcfm()) < 0) return(x);
  6147.         win95_8_3 = y;
  6148.         return(1);
  6149.  
  6150.       case XYWSELECT:
  6151.         if ((y = cmkey(onoff,2,"\"select()\" fails on write","off",
  6152.              xxstring)) < 0)
  6153.           return(y);
  6154.         if ((x = cmcfm()) < 0) return(x);
  6155.         win95selectbug = y;
  6156.         return(1);
  6157.  
  6158.       case XYWAGR:
  6159.         if ((y = cmkey(onoff,2,"Right-Alt is Alt-Gr","off",xxstring)) < 0)
  6160.           return(y);
  6161.         if ((x = cmcfm()) < 0) return(x);
  6162.         win95altgr = y;
  6163.         return(1);
  6164.  
  6165.       case XYWOIO:
  6166.         if ((y = cmkey(onoff,2,"Use Overlapped I/O","on",xxstring)) < 0)
  6167.           return(y);
  6168.         if (y) {
  6169.             if ((x = cmnum("Maximum number of outstanding I/O requests",
  6170.                            "10",10,&z,xxstring)) < 0)
  6171.               return(x);
  6172.             if (z < 1 || z > 7) {
  6173.                 printf(
  6174. "?Maximum outstanding I/O requests must be between 1 and 7.\n");
  6175.                 return(-9);
  6176.             }
  6177.         } else
  6178.           z = 1;
  6179.         if ((x = cmcfm()) < 0) return(x);
  6180.         owwait = !y;
  6181.         maxow = maxow_usr = z;
  6182.         return(1);
  6183.  
  6184.       case XYWKEY:
  6185. #ifndef COMMENT
  6186.         printf("\n?\"Keyboard-Translation\" is no longer required.\n");
  6187.         return(-9);
  6188. #else /* COMMENT */
  6189.         if (( z = cmkey(tcstab, ntcs,
  6190.                         "Keyboard Character Set",
  6191.                         "latin1-iso",
  6192.                         xxstring)) < 0)
  6193.           return (z);
  6194.         if ((x = cmcfm()) < 0)
  6195.           return(x);
  6196.  
  6197.         win95kcsi = z;
  6198.         win95kl2 = (win95kcsi == TC_2LATIN);
  6199.  
  6200.         if (win95kcsi == TC_TRANSP) {
  6201.             win95kcs = NULL;
  6202.         } else {
  6203. #ifdef UNICODE
  6204.             win95kcs = xlr[win95kcsi][tx2fc(tcsl)];
  6205. #else /* UNICODE */
  6206.             win95kcs = xlr[win95kcsi][tcsl];
  6207. #endif /* UNICODE */
  6208.         }
  6209.         return(1);
  6210. #endif /* COMMENT */
  6211.  
  6212.       case XYWLUC:
  6213.         if ((y = cmkey(onoff,2,"Unicode-to-Lucida-Console substitutions",
  6214.                        "on",xxstring)) < 0)
  6215.           return(y);
  6216.         if ((x = cmcfm()) < 0) return(x);
  6217.         win95lucida = y;
  6218.         return(1);
  6219.  
  6220.       case XYWHSL:
  6221.     if ((y = cmkey(onoff,2,"Horizontal Scan Line substitutions",
  6222.                "on",xxstring)) < 0)
  6223.       return(y);
  6224.     if ((x = cmcfm()) < 0) return(x);
  6225.     win95hsl = y;
  6226.     return(1);
  6227.  
  6228.       default:
  6229.         printf("Illegal value in setwin95()\n");
  6230.         return(-9);
  6231.     }
  6232. }
  6233. #endif /* NT */
  6234.  
  6235. #ifdef OS2
  6236. int
  6237. setprty (
  6238. #ifdef CK_ANSIC
  6239.     void
  6240. #endif /* CK_ANSIC */
  6241. /* setprty */ ) {
  6242.     int x, y, z;
  6243.  
  6244.     if (( y = cmkey(prtytab, nprty,
  6245.                     "priority level of terminal and communication threads",
  6246.                     "foreground-server",
  6247.                     xxstring)) < 0 )
  6248.       return (y);
  6249.  
  6250.     if ((x = cmcfm()) < 0)
  6251.       return (x);
  6252. #ifdef IKSD
  6253.     if (inserver &&
  6254. #ifdef IKSDCONF
  6255.          iksdcf
  6256. #else
  6257.          1
  6258. #endif /* IKSDCONF */
  6259.     ) {
  6260.         if ((y = cmcfm()) < 0) return(y);
  6261.         printf("?Sorry, command disabled.\r\n");
  6262.         return(success = 0);
  6263.     }
  6264. #endif /* IKSD */
  6265.     priority = y;
  6266.     return(TRUE);
  6267. }
  6268. #endif /* OS2 */
  6269.  
  6270. int
  6271. setbell() {
  6272.     int y, x;
  6273. #ifdef OS2
  6274.     int z;
  6275. #endif /* OS2 */
  6276.  
  6277.     if ((y = cmkey(beltab,nbeltab,
  6278. #ifdef OS2
  6279.         "how console and terminal bells should\nbe generated", "audible",
  6280. #else
  6281.         "Whether Kermit should ring the terminal bell (beep)", "on",
  6282. #endif /* OS2 */
  6283.                    xxstring)) < 0)
  6284.           return(y);
  6285.  
  6286. #ifdef IKSD
  6287.     if (inserver) {
  6288.         if ((y = cmcfm()) < 0) return(y);
  6289.         printf("?Sorry, command disabled.\r\n");
  6290.         return(success = 0);
  6291.     }
  6292. #endif /* IKSD */
  6293.  
  6294.     switch (y) {                        /* SET BELL */
  6295.       case XYB_NONE:
  6296. #ifdef OS2
  6297.       case XYB_VIS:
  6298. #endif /* OS2 */
  6299.         if ((x = cmcfm()) < 0)
  6300.           return(x);
  6301. #ifdef OS2
  6302.         tt_bell = y;
  6303. #else
  6304.         tt_bell = 0;
  6305. #endif /* OS2 */
  6306.         break;
  6307.  
  6308.       case XYB_AUD:
  6309. #ifdef OS2
  6310.         if ((x = cmkey(audibletab, naudibletab,
  6311.                "how audible console and terminal\nbells should be generated",
  6312.                        "beep",xxstring))<0)
  6313.           return(x);
  6314.         if ((z = cmcfm()) < 0)
  6315.           return(z);
  6316.         tt_bell = y | x;
  6317. #else
  6318.         /* This lets C-Kermit accept but ignore trailing K95 keywords */
  6319.         if ((x = cmtxt("Confirm with carriage return","",&s,xxstring)) < 0)
  6320.           return(x);
  6321.         tt_bell = 1;
  6322. #endif /* OS2 */
  6323.         break;
  6324.     }
  6325.     return(1);
  6326. }
  6327.  
  6328. #ifdef OS2MOUSE
  6329. int
  6330. setmou(
  6331. #ifdef CK_ANSIC
  6332.        void
  6333. #endif /* CK_ANSIC */
  6334.  /* setmou */ ) {
  6335.     extern int initvik;
  6336.     int button = 0, event = 0;
  6337.     char * p;
  6338.  
  6339.     if ((y = cmkey(mousetab,nmtab,"","",xxstring)) < 0)
  6340.       return(y);
  6341.  
  6342. #ifdef IKSD
  6343.     if (inserver) {
  6344.         if ((y = cmcfm()) < 0) return(y);
  6345.         printf("?Sorry, command disabled.\r\n");
  6346.         return(success = 0);
  6347.     }
  6348. #endif /* IKSD */
  6349.  
  6350.     if (y == XYM_ON) {                  /* MOUSE ACTIVATION */
  6351.         int old_mou = tt_mouse;
  6352.         if ((x = seton(&tt_mouse)) < 0)
  6353.             return(x);
  6354.         if (tt_mouse != old_mou)
  6355.           if (tt_mouse)
  6356.             os2_mouseon();
  6357.           else
  6358.             os2_mouseoff();
  6359.         return(1);
  6360.     }
  6361.  
  6362.     if (y == XYM_DEBUG) {               /* MOUSE DEBUG */
  6363.         extern int MouseDebug;
  6364.         if ((x = seton(&MouseDebug)) < 0)
  6365.             return(x);
  6366.         return(1);
  6367.     }
  6368.  
  6369.     if (y == XYM_CLEAR) {               /* Reset Mouse Defaults */
  6370.         if ((x = cmcfm()) < 0) return(x);
  6371.         mousemapinit(-1,-1);
  6372.         initvik = 1;                    /* Update VIK Table */
  6373.         return 1;
  6374.     }
  6375.     if (y != XYM_BUTTON) {              /* Shouldn't happen. */
  6376.         printf("Internal parsing error\n");
  6377.         return(-9);
  6378.     }
  6379.  
  6380.     /* MOUSE EVENT ... */
  6381.  
  6382.     if ((button = cmkey(mousebuttontab,nmbtab,
  6383.                         "Button number","1",
  6384.                         xxstring)) < 0)
  6385.       return(button);
  6386.  
  6387.     if ((y =  cmkey(mousemodtab,nmmtab,
  6388.                     "Keyboard modifier","none",
  6389.                     xxstring)) < 0)
  6390.       return(y);
  6391.  
  6392.     event |= y;                         /* OR in the bits */
  6393.  
  6394.     if ((y =  cmkey(mclicktab,nmctab,"","click",xxstring)) < 0)
  6395.       return(y);
  6396.  
  6397.     /* Two bits are assigned, if neither are set then it is button one */
  6398.  
  6399.     event |= y;                 /* OR in the bit */
  6400.  
  6401.     wideresult = -1;
  6402.  
  6403.     if ((y = cmtxt("definition,\n\
  6404. or Ctrl-C to cancel this command,\n\
  6405. or Enter to restore default definition",
  6406.                    "",&s,NULL)) < 0) {
  6407.         return(y);
  6408.     }
  6409.     s = brstrip(s);
  6410.     p = s;                              /* Save this place */
  6411. /*
  6412.   If the definition included any \Kverbs, quote the backslash so the \Kverb
  6413.   will still be in the definition when the key is pressed.  We don't do this
  6414.   in zzstring(), because \Kverbs are valid only in this context and nowhere
  6415.   else.  This code copied from SET KEY, q.v. for addt'l commentary.
  6416. */
  6417.     for (x = 0, y = 0; s[x]; x++, y++) { /* Convert \K to \\K */
  6418.         if ((x > 0) &&
  6419.             (s[x] == 'K' || s[x] == 'k')
  6420.             ) {                         /* Have K */
  6421.  
  6422.             if ((x == 1 && s[x-1] == CMDQ) ||
  6423.                 (x > 1 && s[x-1] == CMDQ && s[x-2] != CMDQ)) {
  6424.                 line[y++] = CMDQ;       /* Make it \\K */
  6425.             }
  6426.             if (x > 1 && s[x-1] == '{' && s[x-2] == CMDQ) {
  6427.                 line[y-1] = CMDQ;       /* Have \{K */
  6428.                 line[y++] = '{';        /* Make it \\{K */
  6429.             }
  6430.         }
  6431.         line[y] = s[x];
  6432.     }
  6433.     line[y++] = NUL;                    /* Terminate */
  6434.     s = line + y + 1;                   /* Point to after it */
  6435.     x = LINBUFSIZ - (int) strlen(line) - 1; /* Calculate remaining space */
  6436.     if ((x < (LINBUFSIZ / 2)) ||
  6437.         (zzstring(line, &s, &x) < 0)) { /* Expand variables, etc. */
  6438.         printf("?Key definition too long\n");
  6439.         return(-9);
  6440.     }
  6441.     s = line + y + 1;                   /* Point to result. */
  6442.  
  6443. #ifndef NOKVERBS
  6444. /*
  6445.   Special case: see if the definition starts with a \Kverb.
  6446.   If it does, point to it with p, otherwise set p to NULL.
  6447. */
  6448.     p = s;
  6449.     if (*p++ == CMDQ) {
  6450.         if (*p == '{') p++;
  6451.         p = (*p == 'k' || *p == 'K') ? p + 1 : NULL;
  6452.     }
  6453. #else
  6454.     p = NULL;
  6455. #endif /* NOKVERBS */
  6456.  
  6457.     /* free the old definition if necessary */
  6458.     if (mousemap[button][event].type == macro) {
  6459.         free( mousemap[button][event].macro.string);
  6460.         mousemap[button][event].macro.string = NULL;
  6461.     }
  6462.     switch (strlen(s)) {                /* Action depends on length */
  6463.       case 0:                           /* Reset to default binding */
  6464.         mousemapinit( button, event );
  6465.         break;
  6466.       case 1:                           /* Single character */
  6467.             mousemap[button][event].type = key;
  6468.         mousemap[button][event].key.scancode = *s;
  6469.         break;
  6470.       default:                          /* Character string */
  6471. #ifndef NOKVERBS
  6472.         if (p) {
  6473.             y = xlookup(kverbs,p,nkverbs,&x); /* Look it up */
  6474.             debug(F101,"set mouse kverb lookup",0,y); /* need exact match */
  6475.             if (y > -1) {
  6476.             /* Assign the kverb to the event */
  6477.             mousemap[button][event].type = kverb;
  6478.             mousemap[button][event].kverb.id = F_KVERB | y;
  6479.             break;
  6480.             }
  6481.         }
  6482. #endif /* NOKVERBS */
  6483.  
  6484.        /* Otherwise, it's a macro, so assign the macro to the event */
  6485.        mousemap[button][event].type = macro;
  6486.        mousemap[button][event].macro.string = (MACRO) malloc(strlen(s)+1);
  6487.        if (mousemap[button][event].macro.string)
  6488.          strcpy((char *) mousemap[button][event].macro.string, s); /* safe */
  6489.         break;
  6490.     }
  6491.     initvik = 1;                        /* Update VIK Table */
  6492.     if ( (button == XYM_B3) && (mousebuttoncount() < 3) && !quiet )
  6493.     {
  6494.         printf("?Warning: this machine does not have a three button mouse.\n");
  6495.         return(0);
  6496.     }
  6497.     return(1);
  6498. }
  6499. #endif /* OS2MOUSE */
  6500. #endif /* NOLOCAL */
  6501.  
  6502. #ifndef NOXFER
  6503. int                                     /* SET SEND/RECEIVE */
  6504. setsr(xx, rmsflg) int xx; int rmsflg; {
  6505.     if (xx == XYRECV)
  6506.       ckstrncpy(line,"Parameter for inbound packets",LINBUFSIZ);
  6507.     else
  6508.       ckstrncpy(line,"Parameter for outbound packets",LINBUFSIZ);
  6509.  
  6510.     if (rmsflg) {
  6511.         if ((y = cmkey(rsrtab,nrsrtab,line,"",xxstring)) < 0) {
  6512.             if (y == -3) {
  6513.                 printf("?Remote receive parameter required\n");
  6514.                 return(-9);
  6515.             } else return(y);
  6516.         }
  6517.     } else {
  6518.         if ((y = cmkey(srtab,nsrtab,line,"",xxstring)) < 0) return(y);
  6519.     }
  6520.     switch (y) {
  6521.       case XYQCTL:                      /* CONTROL-PREFIX */
  6522.         if ((x = cmnum("ASCII value of control prefix","",10,&y,xxstring)) < 0)
  6523.           return(x);
  6524.         if ((x = cmcfm()) < 0) return(x);
  6525.         if ((y > 32 && y < 63) || (y > 95 && y < 127)) {
  6526.             if (xx == XYRECV)
  6527.               ctlq = (CHAR) y;          /* RECEIVE prefix, use with caution! */
  6528.             else
  6529.               myctlq = (CHAR) y;        /* SEND prefix, OK to change */
  6530.             return(success = 1);
  6531.         } else {
  6532.             printf("?Illegal value for prefix character\n");
  6533.             return(-9);
  6534.         }
  6535.  
  6536.       case XYEOL:
  6537.         if ((y = setcc("13",&z)) < 0)
  6538.             return(y);
  6539.         if (z > 31) {
  6540.             printf("Sorry, the legal values are 0-31\n");
  6541.             return(-9);
  6542.         }
  6543.         if (xx == XYRECV)
  6544.           eol = (CHAR) z;
  6545.         else
  6546.           seol = (CHAR) z;
  6547.         return(success = y);
  6548.  
  6549.       case XYLEN:
  6550.         y = cmnum("Maximum number of characters in a packet","90",10,&x,
  6551.                   xxstring);
  6552.         if (xx == XYRECV) {             /* Receive... */
  6553.             if ((y = setnum(&z,x,y,maxrps)) < 0)
  6554.               return(y);
  6555.             if (protocol != PROTO_K) {
  6556.                 printf("?Sorry, this command does not apply to %s protocol.\n",
  6557.                        ptab[protocol].p_name
  6558.                        );
  6559.                 printf("Use SET SEND PACKET-LENGTH for XYZMODEM\n");
  6560.                 return(-9);
  6561.             }
  6562.             if (z < 10) {
  6563.                 printf("Sorry, 10 is the minimum\n");
  6564.                 return(-9);
  6565.             }
  6566.             if (rmsflg) {
  6567.                 sstate = setgen('S', "401", ckitoa(z), "");
  6568.                 return((int) sstate);
  6569.             } else {
  6570.                 if (protocol == PROTO_K) {
  6571.                     if (z > MAXRP) z = MAXRP;
  6572.                     y = adjpkl(z,wslotr,bigrbsiz);
  6573.                     if (y != z) {
  6574.                         urpsiz = y;
  6575.                         if (!xcmdsrc)
  6576.                           if (msgflg) printf(
  6577. " Adjusting receive packet-length to %d for %d window slots\n",
  6578.                                              y, wslotr);
  6579.                     }
  6580.                     urpsiz = y;
  6581.                     ptab[protocol].rpktlen = urpsiz;
  6582.                     rpsiz =  (y > 94) ? 94 : y;
  6583.                 } else {
  6584. #ifdef CK_XYZ
  6585.                     if ((protocol == PROTO_X || protocol == PROTO_XC) &&
  6586.                          z != 128 && z != 1024) {
  6587.                         printf("Sorry, bad packet length for XMODEM.\n");
  6588.                         printf("Please use 128 or 1024.\n");
  6589.                         return(-9);
  6590.                     }
  6591. #endif /* CK_XYZ */
  6592.                     urpsiz = rpsiz = z;
  6593.                 }
  6594.             }
  6595.         } else {                        /* Send... */
  6596.             if ((y = setnum(&z,x,y,maxsps)) < 0)
  6597.               return(y);
  6598.             if (z < 10) {
  6599.                 printf("Sorry, 10 is the minimum\n");
  6600.                 return(-9);
  6601.             }
  6602.             if (protocol == PROTO_K) {
  6603.                 if (z > MAXSP) z = MAXSP;
  6604.                 spsiz = z;              /* Set it */
  6605.                 y = adjpkl(spsiz,wslotr,bigsbsiz);
  6606.                 if (y != spsiz && !xcmdsrc)
  6607.                   if (msgflg)
  6608.                     printf("Adjusting packet size to %d for %d window slots\n",
  6609.                            y,wslotr);
  6610.             } else
  6611.               y = z;
  6612. #ifdef CK_XYZ
  6613.             if ((protocol == PROTO_X || protocol == PROTO_XC) &&
  6614.                  z != 128 && z != 1024) {
  6615.                 printf("Sorry, bad packet length for XMODEM.\n");
  6616.                 printf("Please use 128 or 1024.\n");
  6617.                 return(-9);
  6618.             }
  6619. #endif /* CK_XYZ */
  6620.             spsiz = spmax = spsizr = y; /* Set it and flag that it was set */
  6621.             spsizf = 1;                 /* to allow overriding Send-Init. */
  6622.             ptab[protocol].spktflg = spsizf;
  6623.             ptab[protocol].spktlen = spsiz;
  6624.         }
  6625.         if (pflag && protocol == PROTO_K && !xcmdsrc) {
  6626.             if (z > 94 && !reliable && msgflg) {
  6627.                 /* printf("Extended-length packets requested.\n"); */
  6628.                 if (bctr < 2 && z > 200) printf("\
  6629. Remember to SET BLOCK 2 or 3 for long packets.\n");
  6630.             }
  6631.             if (speed <= 0L) speed = ttgspd();
  6632. #ifdef COMMENT
  6633. /*
  6634.   Kermit does this now itself.
  6635. */
  6636.             if (speed <= 0L && z > 200 && msgflg) {
  6637.                 printf("\
  6638. Make sure your timeout interval is long enough for %d-byte packets.\n",z);
  6639.             }
  6640. #endif /* COMMENT */
  6641.         }
  6642.         return(success = y);
  6643.  
  6644.       case XYMARK:
  6645. #ifdef DOOMSDAY
  6646. /*
  6647.   Printable start-of-packet works for UNIX and VMS only!
  6648. */
  6649.         x_ifnum = 1;
  6650.         y = cmnum("Code for packet-start character","1",10,&x,xxstring);
  6651.         x_ifnum = 0;
  6652.         if ((y = setnum(&z,x,y,126)) < 0) return(y);
  6653. #else
  6654.         if ((y = setcc("1",&z)) < 0)
  6655.             return(y);
  6656. #endif /* DOOMSDAY */
  6657.         if (xx == XYRECV)
  6658.           stchr = (CHAR) z;
  6659.         else {
  6660.             mystch = (CHAR) z;
  6661. #ifdef IKS_OPTION
  6662.             /* If IKS negotiation in use   */
  6663.             if (TELOPT_U(TELOPT_KERMIT) || TELOPT_ME(TELOPT_KERMIT))
  6664.               tn_siks(KERMIT_SOP);      /* Report change to other side */
  6665. #endif /* IKS_OPTION */
  6666.         }
  6667.         return(success = y);
  6668.  
  6669.       case XYNPAD:                      /* PADDING */
  6670.         y = cmnum("How many padding characters for inbound packets","0",10,&x,
  6671.                   xxstring);
  6672.         if ((y = setnum(&z,x,y,94)) < 0) return(y);
  6673.         if (xx == XYRECV)
  6674.           mypadn = (CHAR) z;
  6675.         else
  6676.           npad = (CHAR) z;
  6677.         return(success = y);
  6678.  
  6679.       case XYPADC:                      /* PAD-CHARACTER */
  6680.         if ((y = setcc("0",&z)) < 0) return(y);
  6681.         if (xx == XYRECV) mypadc = z; else padch = z;
  6682.         return(success = y);
  6683.  
  6684.       case XYTIMO:                      /* TIMEOUT */
  6685.         if (xx == XYRECV) {
  6686.             y = cmnum("Packet timeout interval",ckitoa(URTIME),10,&x,xxstring);
  6687.             if ((y = setnum(&z,x,y,94)) < 0) return(y);
  6688.  
  6689.             if (rmsflg) {               /* REMOTE SET RECEIVE TIMEOUT */
  6690.                 sstate = setgen('S', "402", ckitoa(z), "");
  6691.                 return((int) sstate);
  6692.             } else {                    /* SET RECEIVE TIMEOUT */
  6693.                 pkttim = z;             /*   Value to put in my negotiation */
  6694.             }                           /*   packet for other Kermit to use */
  6695.  
  6696.         } else {                        /* SET SEND TIMEOUT */
  6697. #ifdef CK_TIMERS
  6698.             extern int rttflg, mintime, maxtime;
  6699.             int tmin = 0, tmax = 0;
  6700. #endif /* CK_TIMERS */
  6701.             y = cmnum("Packet timeout interval",ckitoa(DMYTIM),10,&x,xxstring);
  6702.             if (y == -3) {              /* They cancelled a previous */
  6703.                 x = DMYTIM;             /* SET SEND command, so restore */
  6704.                 timef = 0;              /* and turn off the override flag */
  6705.                 y = cmcfm();
  6706.             }
  6707. #ifdef CK_TIMERS
  6708.             if (y < 0) return(y);
  6709.             if (x < 0) {
  6710.                 printf("?Out of range - %d\n",x);
  6711.                 return(-9);
  6712.             }
  6713.             if ((z = cmkey(timotab,2,"","dynamic",xxstring)) < 0) return(z);
  6714.             if (z) {
  6715.                 if ((y = cmnum("Minimum timeout to allow",
  6716.                                "1",10,&tmin,xxstring)) < 0)
  6717.                   return(y);
  6718.                 if (tmin < 1) {
  6719.                     printf("?Out of range - %d\n",tmin);
  6720.                     return(-9);
  6721.                 }
  6722.                 if ((y = cmnum("Maximum timeout to allow",
  6723.                                "0",10,&tmax,xxstring)) < 0)
  6724.                   return(y);
  6725.                 /* 0 means let Kermit choose, < 0 means no maximum */
  6726.             }
  6727.             if ((y = cmcfm()) < 0)
  6728.               return(y);
  6729.             rttflg = z;                 /* Round-trip timer flag */
  6730.             z = x;
  6731. #else
  6732.             if ((y = setnum(&z,x,y,94)) < 0)
  6733.               return(y);
  6734. #endif /* CK_TIMERS */
  6735.             timef = 1;                  /* Turn on the override flag */
  6736.             timint = rtimo = z;         /* Override value for me to use */
  6737. #ifdef CK_TIMERS
  6738.             if (rttflg) {               /* Lower and upper bounds */
  6739.                 mintime = tmin;
  6740.                 maxtime = tmax;
  6741.             }
  6742. #endif /* CK_TIMERS */
  6743.         }
  6744.         return(success = 1);
  6745.  
  6746.       case XYFPATH:                     /* PATHNAMES */
  6747.         if (xx == XYRECV) {
  6748.             y = cmkey(rpathtab,nrpathtab,"","auto",xxstring);
  6749.         } else {
  6750.             y = cmkey(pathtab,npathtab,"","off",xxstring);
  6751.         }
  6752.         if (y < 0) return(y);
  6753.  
  6754.         if ((x = cmcfm()) < 0) return(x);
  6755.         if (xx == XYRECV) {             /* SET RECEIVE PATHNAMES */
  6756.             fnrpath = y;
  6757.             ptab[protocol].fnrp = fnrpath;
  6758.         } else {                        /* SET SEND PATHNAMES */
  6759.             fnspath = y;
  6760.             ptab[protocol].fnsp = fnspath;
  6761.         }
  6762.         return(success = 1);            /* Note: 0 = ON, 1 = OFF */
  6763.         /* In other words, ON = leave pathnames ON, OFF = take them off. */
  6764.  
  6765.       case XYPAUS:                      /* SET SEND/RECEIVE PAUSE */
  6766.         y = cmnum("Milliseconds to pause between packets","0",10,&x,xxstring);
  6767.         if ((y = setnum(&z,x,y,15000)) < 0)
  6768.           return(y);
  6769.         pktpaus = z;
  6770.         return(success = 1);
  6771.  
  6772. #ifdef CKXXCHAR                         /* SET SEND/RECEIVE IGNORE/DOUBLE */
  6773.       case XYIGN:
  6774.       case XYDBL: {
  6775.           int i, zz;
  6776.           short *p;
  6777.           extern short dblt[];
  6778.           extern int dblflag, ignflag;
  6779.  
  6780.           /* Make space for a temporary copy of the ignore/double table */
  6781.  
  6782.           zz = y;
  6783. #ifdef COMMENT
  6784.           if (zz == XYIGN && xx == XYSEND) {
  6785.               blah blah who cares
  6786.           }
  6787.           if (zz == XYDBL && xx == XYRECV) {
  6788.               blah blah
  6789.           }
  6790. #endif /* COMMENT */
  6791.           p = (short *)malloc(256 * sizeof(short));
  6792.           if (!p) {
  6793.               printf("?Internal error - malloc failure\n");
  6794.               return(-9);
  6795.           }
  6796.           for (i = 0; i < 256; i++) p[i] = dblt[i]; /* Copy current table */
  6797.  
  6798.           while (1) {                   /* Collect a list of numbers */
  6799. #ifndef NOSPL
  6800.               x_ifnum = 1;              /* Turn off complaints from eval() */
  6801. #endif /* NOSPL */
  6802.               if ((x = cmnum(zz == XYDBL ?
  6803.                              "Character to double" :
  6804.                              "Character to ignore",
  6805.                              "",10,&y,xxstring
  6806.                              )) < 0) {
  6807. #ifndef NOSPL
  6808.                   x_ifnum = 0;
  6809. #endif /* NOSPL */
  6810.                   if (x == -3)          /* Done */
  6811.                     break;
  6812.                   if (x == -2) {
  6813.                       if (p) { free(p); p = NULL; }
  6814.                       debug(F110,"SET S/R DOUBLE/IGNORE atmbuf",atmbuf,0);
  6815.                       if (!ckstrcmp(atmbuf,"none",4,0) ||
  6816.                           !ckstrcmp(atmbuf,"non",3,0) ||
  6817.                           !ckstrcmp(atmbuf,"no",2,0) ||
  6818.                           !ckstrcmp(atmbuf,"n",1,0)) {
  6819.                           if ((x = cmcfm()) < 0) /* Get confirmation */
  6820.                             return(x);
  6821.                           for (y = 0; y < 256; y++)
  6822.                             dblt[y] &= (zz == XYDBL) ? 1 : 2;
  6823.                           if (zz == XYDBL) dblflag = 0;
  6824.                           if (zz == XYIGN) ignflag = 0;
  6825.                           return(success = 1);
  6826.                       } else {
  6827.                           printf(
  6828.                             "?Please specify a number or the word NONE\n");
  6829.                           return(-9);
  6830.                       }
  6831.                   } else {
  6832.                       free(p);
  6833.                       p = NULL;
  6834.                       return(x);
  6835.                   }
  6836.               }
  6837. #ifndef NOSPL
  6838.               x_ifnum = 0;
  6839. #endif /* NOSPL */
  6840.               if (y < 0 || y > 255) {
  6841.                   printf("?Please enter a character code in range 0-255\n");
  6842.                   free(p);
  6843.                   p = NULL;
  6844.                   return(-9);
  6845.               }
  6846.               p[y] |= (zz == XYDBL) ? 2 : 1;
  6847.               if (zz == XYDBL) dblflag = 1;
  6848.               if (zz == XYIGN) ignflag = 1;
  6849.           } /* End of while loop */
  6850.  
  6851.           if ((x = cmcfm()) < 0) return(x);
  6852. /*
  6853.   Get here only if they have made no mistakes.  Copy temporary table back to
  6854.   permanent one, then free temporary table and return successfully.
  6855. */
  6856.           if (p) {
  6857.               for (i = 0; i < 256; i++) dblt[i] = p[i];
  6858.               free(p);
  6859.               p = NULL;
  6860.           }
  6861.           return(success = 1);
  6862.       }
  6863. #endif /* CKXXCHAR */
  6864.  
  6865. #ifdef PIPESEND
  6866.       case XYFLTR: {                    /* SET { SEND, RECEIVE } FILTER */
  6867.           if ((y = cmtxt((xx == XYSEND) ?
  6868.                 "Filter program for sending files -\n\
  6869.  use \\v(filename) to substitute filename" :
  6870.                 "Filter program for receiving files -\n\
  6871.  use \\v(filename) to substitute filename",
  6872.                          "",&s,NULL)) < 0)
  6873.             return(y);
  6874.           if (!*s) {                    /* Removing a filter... */
  6875.               if (xx == XYSEND && sndfilter) {
  6876.                   makestr(&g_sfilter,NULL);
  6877.                   makestr(&sndfilter,NULL);
  6878.               } else if (rcvfilter) {
  6879.                   makestr(&g_rfilter,NULL);
  6880.                   makestr(&rcvfilter,NULL);
  6881.               }
  6882.               return(success = 1);
  6883.           }                             /* Adding a filter... */
  6884.           s = brstrip(s);               /* Strip any braces */
  6885.           y = strlen(s);
  6886.           if (xx == XYSEND) {           /* For SEND filter... */
  6887.               for (x = 0; x < y; x++) { /* make sure they included "\v(...)" */
  6888.                   if (s[x] != '\\') continue;
  6889.                   if (s[x+1] == 'v') break;
  6890.               }
  6891.               if (x == y) {
  6892.                   printf(
  6893.               "?Filter must contain a replacement variable for filename.\n"
  6894.                          );
  6895.                   return(-9);
  6896.               }
  6897.           }
  6898.           if (xx == XYSEND) {
  6899.               makestr(&sndfilter,s);
  6900.               makestr(&g_sfilter,s);
  6901.           } else {
  6902.               makestr(&rcvfilter,s);
  6903.               makestr(&g_rfilter,s);
  6904.           }
  6905.           return(success = 1);
  6906.       }
  6907. #endif /* PIPESEND */
  6908.  
  6909.       case XYINIL:
  6910.         y = cmnum("Max length for protocol init string","-1",10,&x,xxstring);
  6911.         if ((y = setnum(&z,x,y,-1)) < 0)
  6912.           return(y);
  6913.         if (xx == XYSEND)
  6914.           sprmlen = z;
  6915.         else
  6916.           rprmlen = z;
  6917.         return(success = 1);
  6918.  
  6919.       case 993: {
  6920.           extern int sendipkts;
  6921.           if (xx == XYSEND) {
  6922.               if ((x = seton(&sendipkts)) < 0)
  6923.                 return(x);
  6924.           }
  6925.           return(1);
  6926.       }
  6927. #ifdef CK_PERMS
  6928.       case 994:
  6929.     switch(xx) {
  6930.       case XYSEND:
  6931.         if ((x = seton(&atlpro)) < 0) return(x);
  6932.         atgpro = atlpro;
  6933.         return(1);
  6934.       case XYRECV:
  6935.         if ((x = seton(&atlpri)) < 0) return(x);
  6936.         atgpri = atlpri;
  6937.         return(1);
  6938.       default:
  6939.         return(-2);
  6940.     }
  6941. #endif /* CK_PERMS */
  6942.  
  6943. #ifndef NOCSETS
  6944.       case XYCSET: {                    /* CHARACTER-SET-SELECTION */
  6945.           extern struct keytab xfrmtab[];
  6946.           extern int r_cset, s_cset;
  6947.           if ((y = cmkey(xfrmtab,2,"","automatic",xxstring)) < 0)
  6948.             return(y);
  6949.           if ((x = cmcfm()) < 0)
  6950.             return(x);
  6951.           if (xx == XYSEND)
  6952.             s_cset = y;
  6953.           else
  6954.             r_cset = y;
  6955.           return(success = 1);
  6956.       }
  6957. #endif /* NOCSETS */
  6958.  
  6959.       case XYBUP:
  6960.         if ((y = cmkey(onoff,2,"","on",xxstring)) < 0)
  6961.           return(y);
  6962.         if ((x = cmcfm()) < 0) return(x);
  6963.         if (xx == XYSEND) {
  6964.             extern int skipbup;
  6965.             skipbup = (y == 0) ? 1 : 0;
  6966.             return(success = 1);
  6967.         } else {
  6968.             printf(
  6969. "?Please use SET FILE COLLISION to choose the desired action\n");
  6970.             return(-9);
  6971.         }
  6972.  
  6973.       case XYMOVE:
  6974. #ifdef COMMENT
  6975.         y = cmdir("Directory to move file(s) to after successful transfer",
  6976.                   "",&s,xxstring);
  6977. #else
  6978.         y = cmtxt("Directory to move file(s) to after successful transfer",
  6979.           "",&s,xxstring);
  6980. #endif /* COMMENT */
  6981.  
  6982.         if (y < 0 && y != -3)
  6983.           return(y);
  6984.         ckstrncpy(line,s,LINBUFSIZ);
  6985.         s = brstrip(line);
  6986.  
  6987. #ifdef COMMENT
  6988.     /* Only needed for cmdir() */
  6989.         if ((x = cmcfm()) < 0)
  6990.           return(x);
  6991. #endif /* COMMENT */
  6992.     
  6993.     /* Check directory existence if absolute */
  6994.     /* THIS MEANS IT CAN'T INCLUDE ANY DEFERRED VARIABLES! */
  6995.     if (s) if (*s) {
  6996.         if (isabsolute(s) && !isdir(s)) {
  6997.         printf("?Directory does not exist - %s\n",s);
  6998.         return(-9);
  6999.         }
  7000.     }
  7001.         if (xx == XYSEND) {
  7002.             if (*s) {
  7003. #ifdef COMMENT
  7004.         /* Allow it to be relative */
  7005.                 zfnqfp(s,LINBUFSIZ,line);
  7006. #endif /* COMMENT */
  7007.                 makestr(&snd_move,line);
  7008.                 makestr(&g_snd_move,line);
  7009.             } else {
  7010.                 makestr(&snd_move,NULL);
  7011.                 makestr(&g_snd_move,NULL);
  7012.             }
  7013.         } else {
  7014.             if (*s) {
  7015. #ifdef COMMENT
  7016.         /* Allow it to be relative */
  7017.                 zfnqfp(s,LINBUFSIZ,line);
  7018. #endif /* COMMENT */
  7019.                 makestr(&rcv_move,line);
  7020.                 makestr(&g_rcv_move,line);
  7021.             } else {
  7022.                 makestr(&rcv_move,NULL);
  7023.                 makestr(&g_rcv_move,NULL);
  7024.             }
  7025.         }
  7026.         return(success = 1);
  7027.  
  7028.       case XYRENAME:
  7029.         y = cmtxt("Template to rename file(s) to after successful transfer",
  7030.                   "",&s,NULL);        /* NOTE: no xxstring */
  7031.         if (y < 0 && y != -3)        /* Evaluation is deferred */
  7032.           return(y);
  7033.         ckstrncpy(line,s,LINBUFSIZ);
  7034.         s = brstrip(line);
  7035.         if ((x = cmcfm()) < 0)
  7036.           return(x);
  7037.         if (xx == XYSEND) {
  7038.             if (*s) {
  7039.                 makestr(&snd_rename,s);
  7040.                 makestr(&g_snd_rename,s);
  7041.             } else {
  7042.                 makestr(&snd_rename,NULL);
  7043.                 makestr(&g_snd_rename,NULL);
  7044.             }
  7045.         } else {
  7046.             if (*s) {
  7047.                 makestr(&rcv_rename,s);
  7048.                 makestr(&g_rcv_rename,s);
  7049.             } else {
  7050.                 makestr(&rcv_rename,NULL);
  7051.                 makestr(&g_rcv_rename,NULL);
  7052.             }
  7053.         }
  7054.         return(success = 1);
  7055.  
  7056. #ifdef VMS
  7057.       case 887:                /* VERSION-NUMBERS */
  7058.         if (xx == XYSEND) {
  7059.             extern int vmssversions;
  7060.             return(seton(&vmssversions));
  7061.         } else {
  7062.             extern int vmsrversions;
  7063.             return(seton(&vmsrversions));
  7064.         }
  7065. #endif /* VMS */
  7066.  
  7067.       default:
  7068.         return(-2);
  7069.     }                                   /* End of SET SEND/RECEIVE... */
  7070. }
  7071. #endif /* NOXFER */
  7072.  
  7073. #ifndef NOXMIT
  7074. int
  7075. setxmit() {
  7076.     if ((y = cmkey(xmitab,nxmit,"","",xxstring)) < 0) return(y);
  7077.     switch (y) {
  7078.       case XMITE:                       /* EOF */
  7079.         y = cmtxt("Characters to send at end of file,\n\
  7080.  Use backslash codes for control characters","",&s,xxstring);
  7081.         if (y < 0) return(y);
  7082.         if ((int)strlen(s) > XMBUFL) {
  7083.             printf("?Too many characters, %d maximum\n",XMBUFL);
  7084.             return(-2);
  7085.         }
  7086.         ckstrncpy(xmitbuf,s,XMBUFL);
  7087.         return(success = 1);
  7088.  
  7089.       case XMITF:                       /* Fill */
  7090.         y = cmnum("Numeric code for blank-line fill character","0",10,&x,
  7091.                   xxstring);
  7092.         if ((y = setnum(&z,x,y,127)) < 0) return(y);
  7093.         xmitf = z;
  7094.         return(success = 1);
  7095.       case XMITL:                       /* Linefeed */
  7096.         return(seton(&xmitl));
  7097.       case XMITS:                       /* Locking-Shift */
  7098.         return(seton(&xmits));
  7099.       case XMITP:                       /* Prompt */
  7100.         y = cmnum("Numeric code for host's prompt character, 0 for none",
  7101.                   "10",10,&x,xxstring);
  7102.         if ((y = setnum(&z,x,y,127)) < 0) return(y);
  7103.         xmitp = z;
  7104.         return(success = 1);
  7105.       case XMITX:                       /* Echo */
  7106.         return(seton(&xmitx));
  7107.       case XMITW:                       /* Pause */
  7108.         y = cmnum("Number of milliseconds to pause between binary characters\n\
  7109. or text lines during transmission","0",10,&x,xxstring);
  7110.         if ((y = setnum(&z,x,y,1000)) < 0) return(y);
  7111.         xmitw = z;
  7112.         return(success = 1);
  7113.       case XMITT:                       /* Timeout */
  7114.         y = cmnum("Seconds to wait for each character to echo",
  7115.                   "1",10,&x,xxstring);
  7116.         if ((y = setnum(&z,x,y,1000)) < 0) return(y);
  7117.         xmitt = z;
  7118.         return(success = 1);
  7119.       default:
  7120.         return(-2);
  7121.     }
  7122. }
  7123. #endif /* NOXMIT */
  7124.  
  7125. #ifndef NOXFER
  7126. /*  D O R M T  --  Do a remote command  */
  7127.  
  7128. VOID
  7129. rmsg() {
  7130.     if (pflag && !quiet && fdispla != XYFD_N)
  7131.       printf(
  7132. #ifdef CK_NEED_SIG
  7133.        " Type your escape character, %s, followed by X or E to cancel.\n",
  7134.        dbchr(escape)
  7135. #else
  7136.        " Press the X or E key to cancel.\n"
  7137. #endif /* CK_NEED_SIG */
  7138.       );
  7139. }
  7140.  
  7141. static int xzcmd = 0;                   /* Global copy of REMOTE cmd index */
  7142.  
  7143. /*  R E M C F M  --  Confirm a REMOTE command  */
  7144. /*
  7145.   Like cmcfm(), but allows for a redirection indicator on the end,
  7146.   like "> filename" or "| command".  Returns what cmcfm() would have
  7147.   returned: -1 if reparse needed, etc etc blah blah.  On success,
  7148.   returns 1 with:
  7149.  
  7150.     char * remdest containing the name of the file or command.
  7151.     int remfile set to 1 if there is to be any redirection.
  7152.     int remappd set to 1 if output file is to be appended to.
  7153.     int rempipe set to 1 if remdest is a command, 0 if it is a file.
  7154. */
  7155. static int
  7156. remcfm() {
  7157.     int x;
  7158.     char *s;
  7159.     char c;
  7160.  
  7161.     remfile = 0;
  7162.     rempipe = 0;
  7163.     remappd = 0;
  7164.  
  7165.     if ((x = cmtxt(
  7166.              "> filename, | command,\n\
  7167. or type carriage return to confirm the command",
  7168.                    "",&s,xxstring)) < 0)
  7169.       return(x);
  7170.     if (remdest) {
  7171.         free(remdest);
  7172.         remdest = NULL;
  7173.     }
  7174.     debug(F101,"remcfm local","",local);
  7175.     debug(F110,"remcfm s",s,0);
  7176.     debug(F101,"remcfm cmd","",xzcmd);
  7177. /* 
  7178.   This check was added in C-Kermit 6.0 or 7.0 but it turns out to be
  7179.   unhelpful in the situation where the remote is running a script that sends
  7180.   REMOTE commands to the local workstation.  What happens is, the local
  7181.   server executes the command and sends the result back as screen text, which
  7182.   is indicated by using an X packet instead of an F packet as the file
  7183.   header.  There are two parts to this: executing the command under control
  7184.   of the remote Kermit, which is desirable (and in fact some big applications
  7185.   depend on it, and therefore never installed any new C-Kermit versions after
  7186.   5A), and displaying the result.  Commenting out the check allows the
  7187.   command to be executed, but the result is still sent back to the remote in
  7188.   a file transfer, where it vanishes into the ether.  Actually it's on the
  7189.   communication connection, mixed in with the packets.  Pretty amazing that
  7190.   the file transfer still works, right?
  7191. */
  7192. #ifdef COMMENT
  7193.     if (!*s) {                          /* No redirection indicator */
  7194.         if (!local &&
  7195.             (xzcmd == XZDIR || xzcmd == XZTYP ||
  7196.              xzcmd == XZXIT || xzcmd == XZSPA ||
  7197.              xzcmd == XZHLP || xzcmd == XZPWD ||
  7198.              xzcmd == XZLGI || xzcmd == XZLGO ||
  7199.              xzcmd == XZWHO || xzcmd == XZHOS)) {
  7200.             printf("?\"%s\" has no effect in remote mode\n",cmdbuf);
  7201.             return(-9);
  7202.         } else
  7203.           return(1);
  7204.     }
  7205. #endif    /* COMMENT */
  7206.     c = *s;                             /* We have something */
  7207.     if (c != '>' && c != '|') {         /* Is it > or | ? */
  7208.         printf("?Not confirmed\n");     /* No */
  7209.         return(-9);
  7210.     }
  7211.     s++;                                /* See what follows */
  7212.     if (c == '>' && *s == '>') {        /* Allow for ">>" too */
  7213.         s++;
  7214.         remappd = 1;                    /* Append to output file */
  7215.     }
  7216.     while (*s == SP || *s == HT) s++;   /* Strip intervening whitespace */
  7217.     if (!*s) {
  7218.         printf("?%s missing\n", c == '>' ? "Filename" : "Command");
  7219.         return(-9);
  7220.     }
  7221.     if (c == '>' && zchko(s) < 0) {     /* Check accessibility */
  7222.         printf("?Access denied - %s\n", s);
  7223.         return(-9);
  7224.     }
  7225.     remfile = 1;                        /* Set global results */
  7226.     rempipe = (c == '|');
  7227.     if (rempipe
  7228. #ifndef NOPUSH
  7229.         && nopush
  7230. #endif /* NOPUSH */
  7231.         ) {
  7232.         printf("?Sorry, access to external commands is disabled.\n");
  7233.         return(-9);
  7234.     }
  7235.     makestr(&remdest,s);
  7236. #ifndef NODEBUG
  7237.     if (deblog) {
  7238.         debug(F101,"remcfm remfile","",remfile);
  7239.         debug(F101,"remcfm remappd","",remappd);
  7240.         debug(F101,"remcfm rempipe","",rempipe);
  7241.         debug(F110,"remcfm remdest",remdest, 0);
  7242.     }
  7243. #endif /* NODEBUG */
  7244.     return(1);
  7245. }
  7246.  
  7247. /*  R E M T X T  --  Like remcfm()...  */
  7248. /*
  7249.    ... but for REMOTE commands that end with cmtxt().
  7250.    Here we must decipher braces to discover whether the trailing
  7251.    redirection indicator is intended for local use, or to be sent out
  7252.    to the server, as in:
  7253.  
  7254.      remote host blah blah > file                 This end
  7255.      remote host { blah blah } > file             This end
  7256.      remote host { blah blah > file }             That end
  7257.      remote host { blah blah > file } > file      Both ends
  7258.  
  7259.    Pipes too:
  7260.  
  7261.      remote host blah blah | cmd                  This end
  7262.      remote host { blah blah } | cmd              This end
  7263.      remote host { blah blah | cmd }              That end
  7264.      remote host { blah blah | cmd } | cmd        Both ends
  7265.  
  7266.    Or both:
  7267.  
  7268.      remote host blah blah | cmd > file           This end, etc etc...
  7269.  
  7270.    Note: this really only makes sense for REMOTE HOST, but why be picky?
  7271.    Call after calling cmtxt(), with pointer to string that cmtxt() parsed,
  7272.    as in "remtxt(&s);".
  7273.  
  7274.    Returns:
  7275.     1 on success with braces & redirection things removed & pointer updated,
  7276.    -9 on failure (bad indirection), after printing error message.
  7277. */
  7278. int
  7279. remtxt(p) char ** p; {
  7280.     int i, x, bpos, ppos;
  7281.     char c, *s, *q;
  7282.  
  7283.     remfile = 0;                        /* Initialize global results */
  7284.     rempipe = 0;
  7285.     remappd = 0;
  7286.     if (remdest) {
  7287.         free(remdest);
  7288.         remdest = NULL;
  7289.     }
  7290.     s = *p;
  7291.     if (!s)                             /* No redirection indicator */
  7292.       s = "";
  7293. #ifdef COMMENT
  7294.     if (!*s) {                          /* Ditto */
  7295.         if (!local &&
  7296.             (xzcmd == XZDIR || xzcmd == XZTYP ||
  7297.              xzcmd == XZXIT || xzcmd == XZSPA ||
  7298.              xzcmd == XZHLP || xzcmd == XZPWD ||
  7299.              xzcmd == XZLGI || xzcmd == XZLGO ||
  7300.              xzcmd == XZWHO || xzcmd == XZHOS)) {
  7301.             printf("?\"%s\" has no effect in remote mode\n",cmdbuf);
  7302.             if (hints) {
  7303.                 printf("Hint: Try again with an output redirector.\n");
  7304.             }
  7305.             return(-9);
  7306.         } else
  7307.           return(1);
  7308.     }
  7309. #endif    /* COMMENT */
  7310.     bpos = -1;                          /* Position of > (bracket) */
  7311.     ppos = -1;                          /* Position of | (pipe) */
  7312.     x = strlen(s);                      /* Length of cmtxt() string */
  7313.  
  7314.     for (i = x-1; i >= 0; i--) {        /* Search right to left. */
  7315.         c = s[i];
  7316.         if (c == '}')                   /* Break on first right brace */
  7317.           break;                        /* Don't look at contents of braces */
  7318.         else if (c == '>')              /* Record position of > */
  7319.           bpos = i;
  7320.         else if (c == '|')              /* and of | */
  7321.           ppos = i;
  7322.     }
  7323.     if (bpos < 0 && ppos < 0) {         /* No redirectors. */
  7324. #ifdef COMMENT
  7325.         if (!local &&
  7326.             (xzcmd == XZDIR || xzcmd == XZTYP ||
  7327.              xzcmd == XZXIT || xzcmd == XZSPA ||
  7328.              xzcmd == XZHLP || xzcmd == XZPWD ||
  7329.              xzcmd == XZLGI || xzcmd == XZLGO ||
  7330.              xzcmd == XZWHO || xzcmd == XZHOS)) {
  7331.             printf("?\"%s\" has no effect in remote mode\n",cmdbuf);
  7332.             if (hints) {
  7333.                 printf("Hint: Try again with an output redirector.\n");
  7334.             }
  7335.             return(-9);
  7336.         }
  7337. #endif    /* COMMENT */
  7338.         s = brstrip(s);                 /* Remove outer braces if any. */
  7339.         *p = s;                         /* Point to result */
  7340.         return(1);                      /* and return. */
  7341.     }
  7342.     remfile = 1;                        /* It's | or > */
  7343.     i = -1;                             /* Get leftmost symbol */
  7344.     if (bpos > -1)                      /* Bracket */
  7345.       i = bpos;
  7346.     if (ppos > -1 && (ppos < bpos || bpos < 0)) { /* or pipe */
  7347.         i = ppos;
  7348.         rempipe = 1;
  7349.     }
  7350.     if (rempipe
  7351. #ifndef NOPUSH
  7352.         && nopush
  7353. #endif /* NOPUSH */
  7354.         ) {
  7355.         printf("?Sorry, access to external commands is disabled.\n");
  7356.         return(-9);
  7357.     }
  7358.     c = s[i];                           /* Copy of symbol */
  7359.  
  7360.     if (c == '>' && s[i+1] == '>')      /* ">>" for append? */
  7361.       remappd = 1;                     /* It's not just a flag it's a number */
  7362.  
  7363.     q = s + i + 1 + remappd;            /* Point past symbol in string */
  7364.     while (*q == SP || *q == HT) q++;   /* and any intervening whitespace */
  7365.     if (!*q) {
  7366.         printf("?%s missing\n", c == '>' ? "Filename" : "Command");
  7367.         return(-9);
  7368.     }
  7369.     if (c == '>' && zchko(q) < 0) {     /* (Doesn't work for | cmd > file) */
  7370.         printf("?Access denied - %s\n", q);
  7371.         return(-9);
  7372.     }
  7373.     makestr(&remdest,q);                /* Create the destination string */
  7374.     q = s + i - 1;                      /* Point before symbol */
  7375.     while (q > s && (*q == SP || *q == HT)) /* Strip trailing whitespace */
  7376.       q--;
  7377.     *(q+1) = NUL;                       /* Terminate the string. */
  7378.     s = brstrip(s);                     /* Remove any braces */
  7379.     *p = s;                             /* Set return value */
  7380.  
  7381. #ifndef NODEBUG
  7382.     if (deblog) {
  7383.         debug(F101,"remtxt remfile","",remfile);
  7384.         debug(F101,"remtxt remappd","",remappd);
  7385.         debug(F101,"remtxt rempipe","",rempipe);
  7386.         debug(F110,"remtxt remdest",remdest, 0);
  7387.         debug(F110,"remtxt command",s,0);
  7388.     }
  7389. #endif /* NODEBUG */
  7390.  
  7391.     return(1);
  7392. }
  7393.  
  7394. int
  7395. plogin(xx) int xx; {
  7396.     char *p1 = NULL, *p2 = NULL, *p3 = NULL;
  7397.     int psaved = 0, rc = 0;
  7398. #ifdef CK_RECALL
  7399.     extern int on_recall;               /* around Password prompting */
  7400. #endif /* CK_RECALL */
  7401.     debug(F101,"plogin local","",local);
  7402.  
  7403.     if (!local || (network && ttchk() < 0)) {
  7404.         printf("?No connection\n");
  7405.         return(-9);
  7406.     }
  7407.     if ((x = cmfld("User ID","",&s,xxstring)) < 0) { /* Get User ID */
  7408.         if (x != -3) return(x);
  7409.     }
  7410.     y = strlen(s);
  7411.     if (y > 0) {
  7412.         if ((p1 = malloc(y + 1)) == NULL) {
  7413.             printf("?Internal error: malloc\n");
  7414.             rc = -9;
  7415.             goto XZXLGI;
  7416.         } else
  7417.           strcpy(p1,s);                 /* safe */
  7418.         if ((rc = cmfld("Password","",&s,xxstring)) < 0)
  7419.           if (rc != -3) goto XZXLGI;
  7420.         y = strlen(s);
  7421.         if (y > 0) {
  7422.             if ((p2 = malloc(y + 1)) == NULL) {
  7423.                 printf("?Internal error: malloc\n");
  7424.                 rc = -9;
  7425.                 goto XZXLGI;
  7426.             } else
  7427.               strcpy(p2,s);             /* safe */
  7428.             if ((rc = cmfld("Account","",&s,xxstring)) < 0)
  7429.               if (rc != -3) goto XZXLGI;
  7430.             y = strlen(s);
  7431.             if (y > 0) {
  7432.                 if ((p3 = malloc(y + 1)) == NULL) {
  7433.                     printf("?Internal error: malloc\n");
  7434.                     rc = -9;
  7435.                     goto XZXLGI;
  7436.                 } else
  7437.                   strcpy(p3,s);         /* safe */
  7438.             }
  7439.         }
  7440.     }
  7441.     if ((rc = remtxt(&s)) < 0)          /* Confirm & handle redirectors */
  7442.       goto XZXLGI;
  7443.  
  7444.     if (!p1) {                          /* No Userid specified... */
  7445.         debok = 0;                      /* Don't log this */
  7446.         /* Prompt for username, password, and account */
  7447. #ifdef CK_RECALL
  7448.         on_recall = 0;
  7449. #endif /* CK_RECALL */
  7450.         cmsavp(psave,PROMPTL);          /* Save old prompt */
  7451.         psaved = 1;
  7452.         debug(F110,"REMOTE LOGIN saved",psave,0);
  7453.  
  7454.         cmsetp("Username: ");           /* Make new prompt */
  7455.         concb((char)escape);            /* Put console in cbreak mode */
  7456.         cmini(1);
  7457.         prompt(xxstring);
  7458.         rc = -9;
  7459.         for (x = -1; x < 0; ) {         /* Prompt till they answer */
  7460.             cmres();                    /* Reset the parser */
  7461.             x = cmtxt("","",&s,NULL);   /* Get a literal line of text */
  7462.         }
  7463.         y = strlen(s);
  7464.         if (y < 1) {
  7465.             printf("?Canceled\n");
  7466.             goto XZXLGI;
  7467.         }
  7468.         if ((p1 = malloc(y + 1)) == NULL) {
  7469.             printf("?Internal error: malloc\n");
  7470.             goto XZXLGI;
  7471.         } else
  7472.           strcpy(p1,s);                 /* safe */
  7473.  
  7474.         cmsetp("Password: ");           /* Make new prompt */
  7475.         concb((char)escape);            /* Put console in cbreak mode */
  7476.         cmini(0);                       /* No echo */
  7477.         prompt(xxstring);
  7478.         debok = 0;
  7479.         for (x = -1; x < 0 && x != -3; ) { /* Get answer */
  7480.             cmres();                    /* Reset the parser */
  7481.             x = cmtxt("","",&s,NULL);   /* Get literal line of text */
  7482.         }
  7483.         if ((p2 = malloc((int)strlen(s) + 1)) == NULL) {
  7484.             printf("?Internal error: malloc\n");
  7485.             goto XZXLGI;
  7486.         } else
  7487.           strcpy(p2,s);                 /* safe */
  7488.         printf("\r\n");
  7489.         if ((rc = cmcfm()) < 0)
  7490.           goto XZXLGI;
  7491.     }
  7492.     sstate = setgen('I',p1,p2,p3);      /* Get here with at least user ID */
  7493.     rc = 0;
  7494.  
  7495.   XZXLGI:                               /* Common exit point */
  7496.     if (psaved)
  7497.       cmsetp(psave);                    /* Restore original prompt */
  7498.     if (p3) { free(p3); p3 = NULL; }    /* Free malloc'd storage */
  7499.     if (p2) { free(p2); p2 = NULL; }
  7500.     if (p1) { free(p1); p1 = NULL; }
  7501.     if (rc > -1) {
  7502.         if (local && rc > -1)           /* If local, flush tty input buffer */
  7503.           ttflui();
  7504.     }
  7505.     return(rc);
  7506. }
  7507.  
  7508. #ifdef OS2
  7509. #ifndef NOLOCAL
  7510. int
  7511. dormt(xx) int xx; {
  7512.     int rc = 0;
  7513.     extern int term_io;
  7514.     int term_io_sav = term_io;
  7515. #ifdef NEWFTP
  7516.     extern int ftpget, ftpisopen();
  7517.     if ((ftpget == 1) || ((ftpget == 2) && ftpisopen()))
  7518.       return(doftprmt(xx,0));
  7519. #endif /* NEWFTP */
  7520.     term_io = 0;
  7521.     rc = xxdormt(xx);
  7522.     term_io = term_io_sav;
  7523.     return rc;
  7524. }
  7525.  
  7526.  
  7527. int
  7528. xxdormt(xx) int xx;
  7529. #else /* NOLOCAL */
  7530. int
  7531. dormt(xx) int xx;
  7532. #endif /* NOLOCAL */
  7533. #else /* OS2 */
  7534. int
  7535. dormt(xx) int xx;
  7536. #endif /* OS2 */
  7537. {                                       /* REMOTE commands */
  7538.     int x, y, retcode;
  7539.     char *s, sbuf[50], *s2;
  7540.  
  7541. #ifdef NEWFTP
  7542.     extern int ftpget, ftpisopen();
  7543.     if ((ftpget == 1) || ((ftpget == 2) && ftpisopen()))
  7544.       return(doftprmt(xx,0));
  7545. #endif /* NEWFTP */
  7546.  
  7547.     remfile = 0;                        /* Clear these */
  7548.     rempipe = 0;
  7549.     remappd = 0;
  7550.  
  7551.     if (xx < 0) return(xx);             /* REMOTE what? */
  7552.  
  7553.     xzcmd = xx;                         /* Make global copy of arg */
  7554.  
  7555.     if (xx == XZSET) {                  /* REMOTE SET */
  7556.         if ((y = cmkey(rmstab,nrms,"","",xxstring)) < 0) {
  7557.             if (y == -3) {
  7558.                 printf("?Parameter name required\n");
  7559.                 return(-9);
  7560.             } else return(y);
  7561.         }
  7562.         return(doprm(y,1));
  7563.     }
  7564.  
  7565.     switch (xx) {                       /* Others... */
  7566.  
  7567.       case XZCDU:
  7568.         if ((x = cmcfm()) < 0) return(x);
  7569.         printf("?Sorry, REMOTE CDUP not supported yet\n");
  7570.         return(-9);
  7571.  
  7572.       case XZCWD:                       /* CWD (CD) */
  7573.         if ((x = cmtxt("Remote directory name","",&s,xxstring)) < 0)
  7574.           return(x);
  7575.         if ((x = remtxt(&s)) < 0)
  7576.           return(x);
  7577.         debug(F111,"XZCWD: ",s,x);
  7578.         *sbuf = NUL;
  7579.         s2 = sbuf;
  7580. /*
  7581.   The following is commented out because since the disappearance of the
  7582.   DECSYSTEM-20 from the planet, no known computer requires a password for
  7583.   changing directory.
  7584. */
  7585. #ifdef DIRPWDPR
  7586.         if (*s != NUL) {                /* If directory name given, */
  7587.                                         /* get password on separate line. */
  7588.             if (tlevel > -1) {          /* From take file... */
  7589.  
  7590.                 if (fgets(sbuf,50,tfile[tlevel]) == NULL)
  7591.                   fatal("take file ends prematurely in 'remote cwd'");
  7592.                 debug(F110," pswd from take file",s2,0);
  7593.                 for (x = (int)strlen(sbuf);
  7594.                      x > 0 && (sbuf[x-1] == NL || sbuf[x-1] == CR);
  7595.                      x--)
  7596.                   sbuf[x-1] = '\0';
  7597.  
  7598.             } else {                    /* From terminal... */
  7599.  
  7600.                 printf(" Password: ");  /* get a password */
  7601. #ifdef IKSD
  7602.                 if (!local && inserver) {
  7603.                     x = coninc(0);
  7604.                 } else
  7605. #endif /* IKSD */
  7606. #ifdef OS2
  7607.                   x = is_a_tty(0) ? coninc(0) : /* with no echo ... */
  7608.                     getchar();
  7609. #else /* OS2 */
  7610.                 x = getchar();
  7611. #endif /* OS2 */
  7612.                 while ((x != NL) && (x != CR)) {
  7613.                     if ((x &= 0177) == '?') {
  7614.                         printf("? Password of remote directory\n Password: ");
  7615.                         s2 = sbuf;
  7616.                         *sbuf = NUL;
  7617.                     } else if (x == ESC) /* Mini command line editor... */
  7618.                       bleep(BP_WARN);
  7619.                     else if (x == BS || x == 0177)
  7620.                       s2--;
  7621.                     else if (x == 025) {        /* Ctrl-U */
  7622.                         s2 = sbuf;
  7623.                         *sbuf = NUL;
  7624.                     } else
  7625.                       *s2++ = x;
  7626.  
  7627.                     /* Get the next character */
  7628. #ifdef IKSD
  7629.                     if (!local && inserver) {
  7630.                         x = coninc(0);
  7631.                     } else
  7632. #endif /* IKSD */
  7633. #ifdef OS2
  7634.                     x = is_a_tty(0) ? coninc(0) : /* with no echo ... */
  7635.                       getchar();
  7636. #else /* OS2 */
  7637.                     x = getchar();
  7638. #endif /* OS2 */
  7639.                 }
  7640.                 *s2 = NUL;
  7641.                 putchar('\n');
  7642.             }
  7643.             s2 = sbuf;
  7644.         } else s2 = "";
  7645. #endif /* DIRPWDPR */
  7646.  
  7647.         debug(F110," password",s2,0);
  7648.     rcdactive = 1;
  7649.         sstate = setgen('C',s,s2,"");
  7650.         retcode = 0;
  7651.         break;
  7652.  
  7653.       case XZDEL:                               /* Delete */
  7654.         if ((x = cmtxt("Name of remote file(s) to delete",
  7655.                        "",&s,xxstring)) < 0) {
  7656.             if (x == -3) {
  7657.                 printf("?Name of remote file(s) required\n");
  7658.                 return(-9);
  7659.             } else return(x);
  7660.         }
  7661.         if ((x = remtxt(&s)) < 0)
  7662.           return(x);
  7663.         if (local) ttflui();            /* If local, flush tty input buffer */
  7664.         retcode = sstate = rfilop(s,'E');
  7665.         break;
  7666.  
  7667.       case XZDIR:                       /* Directory */
  7668.         if ((x = cmtxt("Remote directory or file specification","",&s,
  7669.                        xxstring)) < 0)
  7670.           return(x);
  7671.         if ((x = remtxt(&s)) < 0)
  7672.           return(x);
  7673.         if (local) ttflui();            /* If local, flush tty input buffer */
  7674.         rmsg();
  7675.         retcode = sstate = setgen('D',s,"","");
  7676.         break;
  7677.  
  7678.       case XZHLP:                       /* Help */
  7679.         if ((x = remcfm()) < 0) return(x);
  7680.         sstate = setgen('H',"","","");
  7681.         retcode = 0;
  7682.         break;
  7683.  
  7684.       case XZHOS:                       /* Host */
  7685.         if ((x = cmtxt("Command for remote system","",&s,xxstring)) < 0)
  7686.           return(x);
  7687.         if ((x = remtxt(&s)) < 0)
  7688.           return(x);
  7689.         if ((y = (int)strlen(s)) < 1)
  7690.           return(x);
  7691.         ckstrncpy(line,s,LINBUFSIZ);
  7692.         cmarg = line;
  7693.         rmsg();
  7694.         retcode = sstate = 'c';
  7695.         break;
  7696.  
  7697. #ifndef NOFRILLS
  7698.       case XZKER:
  7699.         if ((x = cmtxt("Command for remote Kermit","",&s,xxstring)) < 0)
  7700.           return(x);
  7701.         if ((x = remtxt(&s)) < 0)
  7702.           return(x);
  7703.         if ((int)strlen(s) < 1)  {
  7704.             if (x == -3) {
  7705.                 printf("?Remote Kermit command required\n");
  7706.                 return(-9);
  7707.             } else return(x);
  7708.         }
  7709.         ckstrncpy(line,s,LINBUFSIZ);
  7710.         cmarg = line;
  7711.         retcode = sstate = 'k';
  7712.         rmsg();
  7713.         break;
  7714.  
  7715.       case XZLGI:                       /* Login */
  7716.     rcdactive = 1;            /* Suppress "Logged in" msg if quiet */
  7717.         return(plogin(XXREM));
  7718.  
  7719.       case XZLGO: {                     /* Logout */
  7720.           extern int bye_active;
  7721.           if ((x = remcfm()) < 0) return(x);
  7722.           sstate = setgen('I',"","","");
  7723.           retcode = 0;
  7724.           bye_active = 1;               /* Close connection when done */
  7725.           break;
  7726.       }
  7727.  
  7728.       case XZPRI:                       /* Print */
  7729.         if (!atdiso || !atcapr) {       /* Disposition attribute off? */
  7730.             printf("?Disposition Attribute is Off\n");
  7731.             return(-2);
  7732.         }
  7733.         cmarg = "";
  7734.         cmarg2 = "";
  7735.         if ((x = cmifi("Local file(s) to print on remote printer","",&s,&y,
  7736.                        xxstring)) < 0) {
  7737.             if (x == -3) {
  7738.                 printf("?Name of local file(s) required\n");
  7739.                 return(-9);
  7740.             }
  7741.             return(x);
  7742.         }
  7743.         ckstrncpy(line,s,LINBUFSIZ);    /* Make a safe copy of filename */
  7744.         *optbuf = NUL;                  /* Wipe out any old options */
  7745.         if ((x = cmtxt("Options for remote print command","",&s,xxstring)) < 0)
  7746.           return(x);
  7747.         if ((x = remtxt(&s)) < 0)
  7748.           return(x);
  7749.         if ((int)strlen(optbuf) > 94) { /* Make sure this is legal */
  7750.             printf("?Option string too long\n");
  7751.             return(-9);
  7752.         }
  7753.         ckstrncpy(optbuf,s,OPTBUFLEN);  /* Make a safe copy of options */
  7754.         nfils = -1;                     /* Expand file list internally */
  7755.         cmarg = line;                   /* Point to file list. */
  7756.         rprintf = 1;                    /* REMOTE PRINT modifier for SEND */
  7757.         sstate = 's';                   /* Set start state to SEND */
  7758.         if (local) displa = 1;
  7759.         retcode = 0;
  7760.         break;
  7761. #endif /* NOFRILLS */
  7762.  
  7763.       case XZSPA:                       /* Space */
  7764.         if ((x = cmtxt("Confirm, or remote directory name",
  7765.                        "",&s,xxstring)) < 0)
  7766.           return(x);
  7767.         if ((x = remtxt(&s)) < 0)
  7768.           return(x);
  7769.         retcode = sstate = setgen('U',s,"","");
  7770.         break;
  7771.  
  7772.       case XZMSG:                       /* Message */
  7773.         if ((x = cmtxt("Short text message for server","",&s,xxstring)) < 0)
  7774.           return(x);
  7775.         if ((x = remtxt(&s)) < 0)
  7776.           return(x);
  7777.         retcode = sstate = setgen('M',s,"","");
  7778.         break;
  7779.  
  7780. #ifndef NOFRILLS
  7781.       case XZTYP:                       /* Type */
  7782.         if ((x = cmtxt("Remote file specification","",&s,xxstring)) < 0)
  7783.           return(x);
  7784.         if ((int)strlen(s) < 1) {
  7785.             printf("?Remote filename required\n");
  7786.             return(-9);
  7787.         }
  7788.         if ((x = remtxt(&s)) < 0)
  7789.           return(x);
  7790.         rmsg();
  7791.         retcode = sstate = rfilop(s,'T');
  7792.         break;
  7793. #endif /* NOFRILLS */
  7794.  
  7795. #ifndef NOFRILLS
  7796.       case XZWHO:
  7797.         if ((x = cmtxt("Remote user name, or carriage return",
  7798.                        "",&s,xxstring)) < 0)
  7799.           return(x);
  7800.         if ((x = remtxt(&s)) < 0)
  7801.           return(x);
  7802.         retcode = sstate = setgen('W',s,"","");
  7803.         break;
  7804. #endif /* NOFRILLS */
  7805.  
  7806.       case XZPWD:                       /* PWD */
  7807.         if ((x = remcfm()) < 0) return(x);
  7808.         sstate = setgen('A',"","","");
  7809.         retcode = 0;
  7810.         break;
  7811.  
  7812. #ifndef NOSPL
  7813.       case XZQUE: {                     /* Query */
  7814.           char buf[2];
  7815.           extern char querybuf[], * qbufp;
  7816.           extern int qbufn;
  7817.           if ((y = cmkey(vartyp,nvartyp,"","",xxstring)) < 0)
  7818.             return(y);
  7819.           if ((x = cmtxt(y == 'F' ? "Remote function invocation" :
  7820.                          ('K' ? "Remote variable name or function":
  7821.                          "Remote variable name"),
  7822.                          "",
  7823.                          &s,
  7824.                          (y == 'K') ? xxstring : NULL
  7825.                          )) < 0)        /* Don't evaluate */
  7826.             return(x);
  7827.           if ((x = remtxt(&s)) < 0)
  7828.             return(x);
  7829.           query = 1;                    /* QUERY is active */
  7830.           qbufp = querybuf;             /* Initialize query response buffer */
  7831.           qbufn = 0;
  7832.           querybuf[0] = NUL;
  7833.           buf[0] = (char) (y & 127);
  7834.           buf[1] = NUL;
  7835.           retcode = sstate = setgen('V',"Q",(char *)buf,s);
  7836.           break;
  7837.       }
  7838.  
  7839.       case XZASG: {                     /* Assign */
  7840.           char buf[VNAML];
  7841.           if ((y = cmfld("Remote variable name","",&s,NULL)) < 0) /* No eval */
  7842.             return(y);
  7843.           if ((int)strlen(s) >= VNAML) {
  7844.               printf("?Too long\n");
  7845.               return(-9);
  7846.           }
  7847.           ckstrncpy(buf,s,VNAML);
  7848.           if ((x = cmtxt("Assignment for remote variable",
  7849.                    "",&s,xxstring)) < 0) /* Evaluate this one */
  7850.             return(x);
  7851.           if ((x = remtxt(&s)) < 0)
  7852.             return(x);
  7853. #ifdef COMMENT
  7854. /*
  7855.   Server commands can't be long packets.  In principle there's no reason
  7856.   why they shouldn't be, except that we don't know at this point if the
  7857.   server is capable of accepting long packets because we haven't started
  7858.   the protocol yet.  In practice, allowing a long packet here breaks a lot
  7859.   of assumptions, causes buffer overruns and crashes, etc.  To be fixed
  7860.   later.  (But since this is commented out, evidently I fixed it later...)
  7861. */
  7862.           if ((int)strlen(s) > 85) {    /* Allow for encoding expansion */
  7863.               printf("?Sorry, value is too long - 85 characters max\n");
  7864.               return(-9);
  7865.           }
  7866. #endif /* COMMENT */
  7867.           retcode = sstate = setgen('V',"S",(char *)buf,s);
  7868.           break;
  7869.       }
  7870. #endif /* NOSPL */
  7871.  
  7872.       case XZCPY: {                     /* COPY */
  7873.           char buf[TMPBUFSIZ];
  7874.           buf[TMPBUFSIZ-1] = '\0';
  7875.           if ((x = cmfld("Name of remote file to copy","",&s,xxstring)) < 0) {
  7876.               if (x == -3) {
  7877.                   printf("?Name of remote file required\n");
  7878.                   return(-9);
  7879.               }
  7880.               else
  7881.                 return(x);
  7882.           }
  7883.           ckstrncpy(buf,s,TMPBUFSIZ);
  7884.           if ((x = cmfld("Name of remote destination file or directory",
  7885.                          "",&s, xxstring)) < 0) {
  7886.               if (x == -3) {
  7887.                   printf("?Name of remote file or directory required\n");
  7888.                   return(-9);
  7889.               } else return(x);
  7890.           }
  7891.           ckstrncpy(tmpbuf,s,TMPBUFSIZ);
  7892.           if ((x = remcfm()) < 0)
  7893.             return(x);
  7894.           if (local) ttflui();          /* If local, flush tty input buffer */
  7895.           retcode = sstate = setgen('K',buf,tmpbuf,"");
  7896.           break;
  7897.       }
  7898.       case XZREN: {                     /* Rename */
  7899.           char buf[TMPBUFSIZ];
  7900.           buf[TMPBUFSIZ-1] = '\0';
  7901.           if ((x = cmfld("Name of remote file to rename",
  7902.                          "",&s,xxstring)) < 0) {
  7903.               if (x == -3) {
  7904.                   printf("?Name of remote file required\n");
  7905.                   return(-9);
  7906.               } else return(x);
  7907.           }
  7908.           ckstrncpy(buf,s,TMPBUFSIZ);
  7909.           if ((x = cmfld("New name of remote file","",&s, xxstring)) < 0) {
  7910.               if (x == -3) {
  7911.                   printf("?Name of remote file required\n");
  7912.                   return(-9);
  7913.               } else return(x);
  7914.           }
  7915.           ckstrncpy(tmpbuf,s,TMPBUFSIZ);
  7916.           if ((x = remcfm()) < 0)
  7917.             return(x);
  7918.           if (local) ttflui();          /* If local, flush device buffer */
  7919.           retcode = sstate = setgen('R',buf,tmpbuf,"");
  7920.           break;
  7921.       }
  7922.       case XZMKD:                       /* mkdir */
  7923.       case XZRMD:                       /* rmdir */
  7924.         if ((x = cmtxt((xx == XZMKD) ?
  7925.                        "Name of remote directory to create" :
  7926.                        "Name of remote directory to delete",
  7927.                        "",
  7928.                        &s,
  7929.                        xxstring
  7930.                        )) < 0) {
  7931.             if (x == -3) {
  7932.                 printf("?Name required\n");
  7933.                 return(-9);
  7934.             } else return(x);
  7935.         }
  7936.         if ((x = remtxt(&s)) < 0)
  7937.           return(x);
  7938.         if (local) ttflui();            /* If local, flush tty input buffer */
  7939.         retcode = sstate = rfilop(s, (char)(xx == XZMKD ? 'm' : 'd'));
  7940.         break;
  7941.  
  7942.       case XZXIT:                       /* Exit */
  7943.         if ((x = remcfm()) < 0) return(x);
  7944.         sstate = setgen('X',"","","");
  7945.         retcode = 0;
  7946.         break;
  7947.  
  7948.       default:
  7949.         if ((x = remcfm()) < 0) return(x);
  7950.         printf("?Not implemented - %s\n",cmdbuf);
  7951.         return(-2);
  7952.     }
  7953.     if (local && retcode > -1)          /* If local, flush tty input buffer */
  7954.       ttflui();
  7955.     return(retcode);
  7956. }
  7957.  
  7958.  
  7959. /*  R F I L O P  --  Remote File Operation  */
  7960.  
  7961. CHAR
  7962. #ifdef CK_ANSIC
  7963. rfilop(char * s, char t)
  7964. #else
  7965. rfilop(s,t) char *s, t;
  7966. #endif /* CK_ANSIC */
  7967. /* rfilop */ {
  7968.     if (*s == NUL) {
  7969.         printf("?File specification required\n");
  7970.         return((CHAR) 0);
  7971.     }
  7972.     debug(F111,"rfilop",s,t);
  7973.     return(setgen(t,s,"",""));
  7974. }
  7975. #endif /* NOXFER */
  7976.  
  7977. #ifdef ANYX25
  7978. int
  7979. setx25() {
  7980.     if ((y = cmkey(x25tab,nx25,"X.25 call options","",xxstring)) < 0)
  7981.       return(y);
  7982.     switch (y) {
  7983.       case XYUDAT:
  7984.         if ((z = cmkey(onoff,2,"X.25 call user data","",xxstring))
  7985.             < 0) return(z);
  7986.         if (z == 0) {
  7987.             if ((z = cmcfm()) < 0) return(z);
  7988.             cudata = 0;             /* disable call user data */
  7989.             return (success = 1);
  7990.         }
  7991.         if ((x = cmtxt("X.25 call user data string","",&s,xxstring)) < 0)
  7992.           return(x);
  7993.         if ((int)strlen(s) == 0) {
  7994.             return (-3);
  7995.         } else if ((int)strlen(s) > MAXCUDATA) {
  7996.             printf("?The length must be > 0 and <= %d\n",MAXCUDATA);
  7997.             return(-2);
  7998.         }
  7999.         if ((y = cmcfm()) < 0) return(y);
  8000.         ckstrncpy(udata,s,MAXCUDATA);
  8001.         cudata = 1;                     /* X.25 call user data specified */
  8002.         return (success = 1);
  8003.       case XYCLOS:
  8004.         if ((z = cmkey(onoff,2,"X.25 closed user group call","",xxstring))
  8005.             < 0) return(z);
  8006.         if (z == 0) {
  8007.             if ((z = cmcfm()) < 0) return(z);
  8008.             closgr = -1;                /* disable closed user group */
  8009.             return (success = 1);
  8010.         }
  8011.         if ((y = cmnum("0 <= cug index >= 99","",10,&x,xxstring)) < 0)
  8012.           return(y);
  8013.         if (x < 0 || x > 99) {
  8014.             printf("?The choices are 0 <= cug index >= 99\n");
  8015.             return(-2);
  8016.         }
  8017.         if ((y = cmcfm()) < 0) return(y);
  8018.         closgr = x;                     /* closed user group selected */
  8019.         return (success = 1);
  8020.  
  8021.       case XYREVC:
  8022.         if((z = cmkey(onoff,2,"X.25 reverse charge call","",xxstring)) < 0)
  8023.           return(z);
  8024.         if ((x = cmcfm()) < 0) return(x);
  8025.         revcall = z;
  8026.         return (success = 1);
  8027.     }
  8028. }
  8029.  
  8030. #ifndef IBMX25
  8031. int
  8032. setpadp() {
  8033.     if ((y = cmkey(padx3tab,npadx3,"PAD X.3 parameter name","",xxstring)) < 0)
  8034.       return(y);
  8035.     x = y;
  8036.     switch (x) {
  8037.       case PAD_BREAK_CHARACTER:
  8038.         if ((y = cmnum("PAD break character value","",10,&z,xxstring)) < 0)
  8039.           return(y);
  8040.         if ((y = cmcfm()) < 0) return(y);
  8041.         break;
  8042.       case PAD_ESCAPE:
  8043.         if ((y = cmnum("PAD escape","",10,&z,xxstring)) < 0) return(y);
  8044.         if (z != 0 && z != 1) {
  8045.             printf("?The choices are 0 or 1\n");
  8046.             return(-2);
  8047.         }
  8048.         if ((y = cmcfm()) < 0) return(y);
  8049.         break;
  8050.       case PAD_ECHO:
  8051.         if ((y = cmnum("PAD echo","",10,&z,xxstring)) < 0) return(y);
  8052.         if (z != 0 && z != 1) {
  8053.             printf("?The choices are 0 or 1\n");
  8054.             return(-2);
  8055.         }
  8056.         if ((y = cmcfm()) < 0) return(y);
  8057.         break;
  8058.       case PAD_DATA_FORWARD_CHAR:
  8059.         if ((y = cmnum("PAD data forward char","",10,&z,xxstring)) < 0)
  8060.           return(y);
  8061.         if (z != 0 && z != 2) {
  8062.             printf("?The choices are 0 or 2\n");
  8063.             return(-2);
  8064.         }
  8065.         if ((y = cmcfm()) < 0) return(y);
  8066.         break;
  8067.       case PAD_DATA_FORWARD_TIMEOUT:
  8068.         if ((y = cmnum("PAD data forward timeout","",10,&z,xxstring)) < 0)
  8069.             return(y);
  8070.         if (z < 0 || z > 255) {
  8071.             printf("?The choices are 0 or 1 <= timeout <= 255\n");
  8072.             return(-2);
  8073.         }
  8074.         if ((y = cmcfm()) < 0) return(y);
  8075.         break;
  8076.       case PAD_FLOW_CONTROL_BY_PAD:
  8077.         if ((y = cmnum("PAD pad flow control","",10,&z,xxstring)) < 0)
  8078.           return(y);
  8079.         if (z != 0 && z != 1) {
  8080.             printf("?The choices are 0 or 1\n");
  8081.             return(-2);
  8082.         }
  8083.         if ((y = cmcfm()) < 0) return(y);
  8084.         break;
  8085.       case PAD_SUPPRESSION_OF_SIGNALS:
  8086.         if ((y = cmnum("PAD service","",10,&z,xxstring)) < 0) return(y);
  8087.         if (z != 0 && z != 1) {
  8088.             printf("?The choices are 0 or 1\n");
  8089.             return(-2);
  8090.         }
  8091.         if ((y = cmcfm()) < 0) return(y);
  8092.         break;
  8093.  
  8094.       case PAD_BREAK_ACTION:
  8095.         if ((y = cmnum("PAD break action","",10,&z,xxstring)) < 0) return(y);
  8096.         if (z != 0 && z != 1 && z != 2 && z != 5 && z != 8 && z != 21) {
  8097.             printf("?The choices are 0, 1, 2, 5, 8 or 21\n");
  8098.             return(-2);
  8099.         }
  8100.         if ((y = cmcfm()) < 0) return(y);
  8101.         break;
  8102.  
  8103.       case PAD_SUPPRESSION_OF_DATA:
  8104.         if ((y = cmnum("PAD data delivery","",10,&z,xxstring)) < 0) return(y);
  8105.         if (z != 0 && z != 1) {
  8106.             printf("?The choices are 0 or 1\n");
  8107.             return(-2);
  8108.         }
  8109.         if ((y = cmcfm()) < 0) return(y);
  8110.         break;
  8111.  
  8112.       case PAD_PADDING_AFTER_CR:
  8113.         if ((y = cmnum("PAD crpad","",10,&z,xxstring)) < 0) return(y);
  8114.         if (z < 0 || z > 7) {
  8115.             printf("?The choices are 0 or 1 <= crpad <= 7\n");
  8116.             return(-2);
  8117.         }
  8118.         if ((y = cmcfm()) < 0) return(y);
  8119.         break;
  8120.  
  8121.       case PAD_LINE_FOLDING:
  8122.         if ((y = cmnum("PAD linefold","",10,&z,xxstring)) < 0) return(y);
  8123.         if (z < 0 || z > 255) {
  8124.             printf("?The choices are 0 or 1 <= linefold <= 255\n");
  8125.             return(-2);
  8126.         }
  8127.         if ((y = cmcfm()) < 0) return(y);
  8128.         break;
  8129.  
  8130.       case PAD_LINE_SPEED:
  8131.         if ((y = cmnum("PAD baudrate","",10,&z,xxstring)) < 0) return(y);
  8132.         if (z < 0 || z > 18) {
  8133.             printf("?The choices are 0 <= baudrate <= 18\n");
  8134.             return(-2);
  8135.         }
  8136.         if ((y = cmcfm()) < 0) return(y);
  8137.         break;
  8138.  
  8139.       case PAD_FLOW_CONTROL_BY_USER:
  8140.         if ((y = cmnum("PAD terminal flow control","",10,&z,xxstring)) < 0)
  8141.             return(y);
  8142.         if (z != 0 && z != 1) {
  8143.             printf("?The choices are 0 or 1\n");
  8144.             return(-2);
  8145.         }
  8146.         if ((y = cmcfm()) < 0) return(y);
  8147.         break;
  8148.  
  8149.       case PAD_LF_AFTER_CR:
  8150.         if ((y = cmnum("PAD crpad","",10,&z,xxstring)) < 0) return(y);
  8151.         if (z < 0 || z == 3 || z > 7) {
  8152.             printf("?The choices are 0, 1, 2, 4, 5, 6 or 7\n");
  8153.             return(-2);
  8154.         }
  8155.         if ((y = cmcfm()) < 0) return(y);
  8156.         break;
  8157.  
  8158.       case PAD_PADDING_AFTER_LF:
  8159.         if ((y = cmnum("PAD lfpad","",10,&z,xxstring)) < 0) return(y);
  8160.         if (z < 0 || z > 7) {
  8161.             printf("?The choices are 0 or 1 <= lfpad <= 7\n");
  8162.             return(-2);
  8163.         }
  8164.         if ((y = cmcfm()) < 0) return(y);
  8165.         break;
  8166.  
  8167.       case PAD_EDITING:
  8168.         if ((y = cmnum("PAD edit control","",10,&z,xxstring)) < 0) return(y);
  8169.         if (z != 0 && z != 1) {
  8170.             printf("?The choices are 0 or 1\n");
  8171.             return(-2);
  8172.         }
  8173.         if ((y = cmcfm()) < 0) return(y);
  8174.         break;
  8175.  
  8176.       case PAD_CHAR_DELETE_CHAR:
  8177.         if ((y = cmnum("PAD char delete char","",10,&z,xxstring)) < 0)
  8178.             return(y);
  8179.         if (z < 0 || z > 127) {
  8180.             printf("?The choices are 0 or 1 <= chardelete <= 127\n");
  8181.             return(-2);
  8182.         }
  8183.         if ((y = cmcfm()) < 0) return(y);
  8184.         break;
  8185.  
  8186.       case PAD_BUFFER_DELETE_CHAR:
  8187.         if ((y = cmnum("PAD buffer delete char","",10,&z,xxstring)) < 0)
  8188.             return(y);
  8189.         if (z < 0 || z > 127) {
  8190.             printf("?The choices are 0 or 1 <= bufferdelete <= 127\n");
  8191.             return(-2);
  8192.         }
  8193.         if ((y = cmcfm()) < 0) return(y);
  8194.         break;
  8195.  
  8196.       case PAD_BUFFER_DISPLAY_CHAR:
  8197.         if ((y = cmnum("PAD display line char","",10,&z,xxstring)) < 0)
  8198.             return(y);
  8199.         if (z < 0 || z > 127) {
  8200.             printf("?The choices are 0 or 1 <= displayline <= 127\n");
  8201.             return(-2);
  8202.         }
  8203.         if ((y = cmcfm()) < 0) return(y);
  8204.         break;
  8205.     }
  8206.     padparms[x] = z;
  8207.     return(success = 1);
  8208. }
  8209. #endif /* IBMX25 */
  8210. #endif /* ANYX25 */
  8211.  
  8212. #ifndef NOXFER
  8213. int
  8214. setat(rmsflg) int rmsflg; {
  8215.     int xx;
  8216.     if ((y = cmkey(attrtab,natr,"File Attribute packets","",xxstring)) < 0)
  8217.       return(y);
  8218.     if (y == AT_XALL) {                 /* ATTRIBUTES ALL ON or ALL OFF */
  8219.         if ((z = seton(&xx)) < 0) return(z);
  8220.         if (rmsflg) {
  8221.             printf("Sorry, command not available\n");
  8222.             return(-9);
  8223.         } else {
  8224.             atenci = xx;                /* Encoding in */
  8225.             atenco = xx;                /* Encoding out */
  8226.             atdati = xx;                /* Date in */
  8227.             atdato = xx;                /* Date out */
  8228.             atdisi = xx;                /* Disposition in/out */
  8229.             atdiso = xx;
  8230.             atleni = xx;                /* Length in/out (both kinds) */
  8231.             atleno = xx;
  8232.             atblki = xx;                /* Blocksize in/out */
  8233.             atblko = xx;
  8234.             attypi = xx;                /* File type in/out */
  8235.             attypo = xx;
  8236.             atsidi = xx;                /* System ID in/out */
  8237.             atsido = xx;
  8238.             atsysi = xx;                /* System-dependent params in/out */
  8239.             atsyso = xx;
  8240. #ifdef CK_PERMS                         /* Protection */
  8241.             atlpri = xx;                /* Local in */
  8242.             atlpro = xx;                /* Local out */
  8243.             atgpri = xx;                /* Generic in */
  8244.             atgpro = xx;                /* Generic out */
  8245. #endif /* CK_PERMS */
  8246. #ifdef STRATUS
  8247.             atfrmi = xx;                /* Format in/out */
  8248.             atfrmo = xx;
  8249.             atcrei = xx;                /* Creator id in/out */
  8250.             atcreo = xx;
  8251.             atacti = xx;                /* Account in/out */
  8252.             atacto = xx;
  8253. #endif /* STRATUS */
  8254.         }
  8255.         return(z);
  8256.     } else if (y == AT_ALLY || y == AT_ALLN) { /* ATTRIBUTES ON or OFF */
  8257.         if ((x = cmcfm()) < 0) return(x);
  8258.         atcapr = (y == AT_ALLY) ? 1 : 0;
  8259.         if (rmsflg) {
  8260.             sstate = setgen('S', "132", atcapr ? "1" : "0", "");
  8261.             return((int) sstate);
  8262.         } else return(success = 1);
  8263.     }
  8264.     /* Otherwise, it's an individual attribute that wants turning off/on */
  8265.  
  8266.     if ((z = cmkey(onoff,2,"","",xxstring)) < 0) return(z);
  8267.     if ((x = cmcfm()) < 0) return(x);
  8268.  
  8269. /* There are better ways to do this... */
  8270. /* The real problem is that we're not separating the in and out cases */
  8271. /* and so we have to arbitrarily pick the "in" case, i.e tell the remote */
  8272. /* server to ignore incoming attributes of the specified type, rather */
  8273. /* than telling it not to send them.  The protocol does not (yet) define */
  8274. /* codes for "in-and-out-at-the-same-time". */
  8275.  
  8276.     switch (y) {
  8277. #ifdef CK_PERMS
  8278. /* We're lumping local and generic protection together for now... */
  8279.       case AT_LPRO:
  8280.       case AT_GPRO:
  8281.         if (rmsflg) {
  8282.             sstate = setgen('S', "143", z ? "1" : "0", "");
  8283.             return((int) sstate);
  8284.         }
  8285.         atlpri = atlpro = atgpri = atgpro = z; break;
  8286. #endif /* CK_PERMS */
  8287.       case AT_DISP:
  8288.         if (rmsflg) {
  8289.             sstate = setgen('S', "142", z ? "1" : "0", "");
  8290.             return((int) sstate);
  8291.         }
  8292.         atdisi = atdiso = z; break;
  8293.       case AT_ENCO:
  8294.         if (rmsflg) {
  8295.             sstate = setgen('S', "141", z ? "1" : "0", "");
  8296.             return((int) sstate);
  8297.         }
  8298.         atenci = atenco = z; break;
  8299.       case AT_DATE:
  8300.         if (rmsflg) {
  8301.             sstate = setgen('S', "135", z ? "1" : "0", "");
  8302.             return((int) sstate);
  8303.         }
  8304.         atdati = atdato = z; break;
  8305.       case AT_LENB:
  8306.       case AT_LENK:
  8307.         if (rmsflg) {
  8308.             sstate = setgen('S', "133", z ? "1" : "0", "");
  8309.             return((int) sstate);
  8310.         }
  8311.         atleni = atleno = z; break;
  8312.       case AT_BLKS:
  8313.         if (rmsflg) {
  8314.             sstate = setgen('S', "139", z ? "1" : "0", "");
  8315.             return((int) sstate);
  8316.         }
  8317.         atblki = atblko = z; break;
  8318.       case AT_FTYP:
  8319.         if (rmsflg) {
  8320.             sstate = setgen('S', "134", z ? "1" : "0", "");
  8321.             return((int) sstate);
  8322.         }
  8323.         attypi = attypo = z; break;
  8324. #ifdef STRATUS
  8325.       case AT_CREA:
  8326.         if (rmsflg) {
  8327.             sstate = setgen('S', "136", z ? "1" : "0", "");
  8328.             return((int) sstate);
  8329.         }
  8330.         atcrei = atcreo = z; break;
  8331.       case AT_ACCT:
  8332.         if (rmsflg) {
  8333.             sstate = setgen('S', "137", z ? "1" : "0", "");
  8334.             return((int) sstate);
  8335.         }
  8336.         atacti = atacto = z; break;
  8337. #endif /* STRATUS */
  8338.       case AT_SYSI:
  8339.         if (rmsflg) {
  8340.             sstate = setgen('S', "145", z ? "1" : "0", "");
  8341.             return((int) sstate);
  8342.         }
  8343.         atsidi = atsido = z; break;
  8344.       case AT_RECF:
  8345.         if (rmsflg) {
  8346.             sstate = setgen('S', "146", z ? "1" : "0", "");
  8347.             return((int) sstate);
  8348.         }
  8349.         atfrmi = atfrmo = z; break;
  8350.       case AT_SYSP:
  8351.         if (rmsflg) {
  8352.             sstate = setgen('S', "147", z ? "1" : "0", "");
  8353.             return((int) sstate);
  8354.         }
  8355.         atsysi = atsyso = z; break;
  8356.       default:
  8357.         printf("?Not available\n");
  8358.         return(-2);
  8359.     }
  8360.     return(1);
  8361. }
  8362. #endif /* NOXFER */
  8363.  
  8364. #ifndef NOSPL
  8365. int
  8366. setinp() {
  8367.     if ((y = cmkey(inptab,ninp,"","",xxstring)) < 0) return(y);
  8368.     switch (y) {
  8369. #ifdef OS2
  8370.       case IN_PAC:                      /* SET INPUT PACING */
  8371.         z = cmnum("milliseconds","0",10,&x,xxstring);
  8372.         return(setnum(&tt_inpacing,x,z,1000));
  8373.       case IN_TRM:                      /* SET INPUT TERMINAL */
  8374.         return(seton(&interm));
  8375. #endif /* OS2 */
  8376.       case IN_DEF:                      /* SET INPUT DEFAULT-TIMEOUT */
  8377.         z = cmnum("Positive number","",10,&x,xxstring);
  8378.         return(setnum(&indef,x,z,94));
  8379. #ifdef CKFLOAT
  8380.       case IN_SCA:                      /* SET INPUT SCALE-FACTOR */
  8381.     if ((x = cmfld("Number such as 2 or 0.5","1.0",&s, xxstring)) < 0)
  8382.       return(x);
  8383.         if (isfloat(s,0)) {        /* A floating-point number? */
  8384.             extern char * inpscale;
  8385.         inscale = floatval;        /* Yes, get its value */
  8386.         makestr(&inpscale,s);    /* Save it as \v(inscale) */
  8387.         return(success = 1);
  8388.     } else {
  8389.         return(-2);
  8390.     }
  8391. #endif    /* CKFLOAT */
  8392.       case IN_TIM:                      /* SET INPUT TIMEOUT-ACTION */
  8393.         if ((z = cmkey(intimt,2,"","",xxstring)) < 0) return(z);
  8394.         if ((x = cmcfm()) < 0) return(x);
  8395.         intime[cmdlvl] = z;
  8396.         return(success = 1);
  8397.       case IN_CAS:                      /* SET INPUT CASE */
  8398.         if ((z = cmkey(incast,2,"","",xxstring)) < 0) return(z);
  8399.         if ((x = cmcfm()) < 0) return(x);
  8400.         inpcas[cmdlvl] = z;
  8401.         return(success = 1);
  8402.       case IN_ECH:                      /* SET INPUT ECHO */
  8403.         return(seton(&inecho));
  8404.       case IN_SIL:                      /* SET INPUT SILENCE */
  8405.         z = cmnum("Seconds of inactivity before INPUT fails","",10,&x,
  8406.                   xxstring);
  8407.         return(setnum(&insilence,x,z,-1));
  8408.  
  8409.       case IN_BUF:                      /* SET INPUT BUFFER-SIZE */
  8410.         if ((z = cmnum("Number of bytes in INPUT buffer",
  8411.                        ckitoa(INPBUFSIZ),10,&x, xxstring)) < 0)
  8412.           return(z);
  8413.         if ((y = cmcfm()) < 0) return(y);
  8414.         inbufsize = 0;
  8415.         if (inpbuf) {
  8416.             free(inpbuf);
  8417.             inpbuf = NULL;
  8418.             inpbp = NULL;
  8419.         }
  8420.         if (!(s = (char *)malloc(x + 1)))
  8421.           return(0);
  8422.         inpbuf = s;
  8423.         inpbp = s;
  8424.         inbufsize = x;
  8425.         for (x = 0; x <= inbufsize; x++)
  8426.           inpbuf[x] = NUL;
  8427.         return(success = 1);
  8428.  
  8429. #ifdef CK_AUTODL
  8430.       case IN_ADL:                      /* AUTODOWNLOAD */
  8431.         return(seton(&inautodl));
  8432. #endif /* CK_AUTODL */
  8433.  
  8434.       case IN_CAN:                      /* SET INPUT INTERRUPTS */
  8435.         return(seton(&inintr));
  8436.     }
  8437.     return(0);
  8438. }
  8439. #endif /* NOSPL */
  8440.  
  8441. #ifdef NETCONN
  8442. VOID
  8443. ndreset() {
  8444. #ifndef NODIAL                          /* This depends on DIAL... */
  8445.     int i=0, j=0;
  8446.     if (!ndinited)                      /* Don't free garbage... */
  8447.       return;
  8448.     for (i = 0; i < nhcount; i++) {     /* Clean out previous list */
  8449.         if (nh_p[i])
  8450.           free(nh_p[i]);
  8451.         nh_p[i] = NULL;
  8452.         if (nh_p2[i])
  8453.           free(nh_p2[i]);
  8454.         nh_p2[i] = NULL;
  8455.         for (j = 0; j < 4; j++) {
  8456.             if (nh_px[j][i])
  8457.               free(nh_px[j][i]);
  8458.             nh_px[j][i] = NULL;
  8459.         }
  8460.     }
  8461. #endif /* NODIAL */
  8462. }
  8463.  
  8464. VOID
  8465. ndinit() {                              /* Net directory pointers */
  8466. #ifndef NODIAL                          /* This depends on DIAL... */
  8467.     int i, j;
  8468.     if (ndinited++)                     /* Don't do this more than once. */
  8469.       return;
  8470.     for (i = 0; i < MAXDDIR; i++) {     /* Init all pointers to NULL */
  8471.         netdir[i] = NULL;
  8472.     }
  8473.     for (i = 0; i < MAXDNUMS; i++) {
  8474.         nh_p[i] = NULL;
  8475.         nh_p2[i] = NULL;
  8476.         for (j = 0; j < 4; j++)
  8477.           nh_px[j][i] = NULL;
  8478.     }
  8479. #endif /* NODIAL */
  8480. }
  8481.  
  8482. #ifndef NODIAL
  8483. #ifdef NETCONN
  8484. VOID                                    /* Get net defaults from environment */
  8485. getnetenv() {
  8486.     char *p = NULL;
  8487.  
  8488.     makestr(&p,getenv("K_NET_DIRECTORY")); /* Dialing directories */
  8489.     if (p) {
  8490.         int i;
  8491.         xwords(p,MAXDDIR,netdir,0);
  8492.         for (i = 0; i < MAXDDIR; i++) { /* Fill in any gaps... */
  8493.             if (!netdir[i+1])
  8494.               break;
  8495.             else
  8496.               netdir[i] = netdir[i+1];
  8497.             debug(F111,"netdir[i]",netdir[i],i);
  8498.         }
  8499.         nnetdir = i;
  8500.     }
  8501. }
  8502. #endif /* NETCONN */
  8503. #endif /* NODIAL */
  8504.  
  8505. int
  8506. #ifdef CK_ANSIC
  8507. lunet(char *s)                          /* s = name to look up   */
  8508. #else
  8509. lunet(s) char *s;
  8510. #endif /* CK_ANSIC */
  8511. /* lunet */ {
  8512. #ifndef NODIAL                          /* This depends on DIAL... */
  8513.     int n, n1, t, dd = 0;
  8514.     int ambiguous = 0;
  8515.     FILE * f;
  8516.     char *line = NULL;
  8517.     extern int dialdpy;
  8518.     int netdpy = dialdpy;
  8519.     char *info[8];
  8520.  
  8521.     nhcount = 0;                        /* Set this before returning */
  8522.  
  8523.     if (!s || nnetdir < 1)              /* Validate arguments */
  8524.       return(-1);
  8525.  
  8526.     if (isdigit(*s) || *s == '*' || *s == '.')
  8527.       return(0);
  8528.  
  8529.     if ((n1 = (int) strlen(s)) < 1)     /* Length of string to look up */
  8530.       return(-1);
  8531.  
  8532.     if (!(line = malloc(1024)))         /* Allocate input buffer */
  8533.       return(-1);
  8534.  
  8535.   lu_again:
  8536.     f = NULL;                           /* Network directory file descriptor */
  8537.     t = nhcount = 0;                    /* Match count */
  8538.     dd = 0;                             /* Directory counter */
  8539.  
  8540.     dirline = 0;
  8541.     while (1) {                         /* We make one pass */
  8542.         if (!f) {                       /* Directory not open */
  8543.             if (dd >= nnetdir)          /* No directories left? */
  8544.               break;                    /* Done. */
  8545.             if ((f = fopen(netdir[dd],"r")) == NULL) { /* Open it */
  8546.                 perror(netdir[dd]);     /* Can't, print message saying why */
  8547.                 dd++;
  8548.                 continue;               /* But go on to next one. */
  8549.             }
  8550.             if (netdpy)
  8551.               printf("Opening %s...\n",netdir[dd]);
  8552.             dd++;
  8553.         }
  8554.         line[0] = NUL;
  8555.         if (getnct(line,1023,f,1) < 0) { /* Read a line */
  8556.             if (f) {                    /* f can be clobbered! */
  8557.                 fclose(f);              /* Close the file */
  8558.                 f = NULL;               /* Indicate next one needs opening */
  8559.             }
  8560.             continue;
  8561.         }
  8562.         if (!line[0])                   /* Empty line */
  8563.           continue;
  8564.  
  8565.         xwords(line,7,info,0);          /* Parse it */
  8566.  
  8567.         if (!info[1] || !info[2] || !info[3]) /* Required fields */
  8568.           continue;
  8569.         if (*info[1] == ';')            /* Full-line comment */
  8570.           continue;
  8571.         if ((n = (int) strlen(info[1])) < 1) /* Length of name-tag */
  8572.           continue;
  8573.         if (n < n1)                     /* Search name is longer */
  8574.           continue;                     /* Can't possibly match */
  8575.         if (ambiguous && n != n1)
  8576.           continue;
  8577.         if (ckstrcmp(s,info[1],n1,0))   /* Compare using length of */
  8578.           continue;                     /* search string s. */
  8579.  
  8580.         /* Have a match */
  8581.  
  8582.         makestr(&(nh_p[nhcount]), info[3]);    /* address */
  8583.         makestr(&(nh_p2[nhcount]),info[2]);    /* net type */
  8584.         makestr(&(nh_px[0][nhcount]),info[4]); /* net-specific stuff... */
  8585.         makestr(&(nh_px[1][nhcount]),info[5]);
  8586.         makestr(&(nh_px[2][nhcount]),info[6]);
  8587.         makestr(&(nh_px[3][nhcount]),info[7]);
  8588.  
  8589.         nhcount++;                      /* Count this match */
  8590.         if (nhcount > MAXDNUMS) {       /* Watch out for too many */
  8591.             printf("Warning: %d matches found, %d max\n",
  8592.                    nhcount,
  8593.                    MAXDNUMS
  8594.                    );
  8595.             nhcount = MAXDNUMS;
  8596.             break;
  8597.         }
  8598.         if (nhcount == 1) {             /* First one - save entry name */
  8599.             if (n_name) {               /* Free the one from before if any */
  8600.                 free(n_name);
  8601.                 n_name = NULL;
  8602.             }
  8603.             if (!(n_name = (char *)malloc(n + 1))) { /* Allocate new storage */
  8604.                 printf("?memory allocation error - lunet:3\n");
  8605.                 if (line) {
  8606.                     free(line);
  8607.                     line = NULL;
  8608.                 }
  8609.                 nhcount = 0;
  8610.                 return(-1);
  8611.             }
  8612.             t = n;                      /* Remember its length */
  8613.             strcpy(n_name,info[1]);     /* safe */
  8614.         } else {                        /* Second or subsequent one */
  8615.             if ((int) strlen(info[1]) == t) /* Lengths compare */
  8616.               if (!ckstrcmp(n_name,info[1],t,0)) /* Caseless compare OK */
  8617.                 continue;
  8618.  
  8619.             /* Name given by user matches entries with different names */
  8620.  
  8621.             if (ambiguous)              /* Been here before */
  8622.               break;
  8623.  
  8624.             ambiguous = 1;              /* Now an exact match is required */
  8625.             ndreset();                  /* Clear out previous list */
  8626.             goto lu_again;              /* Do it all over again. */
  8627.         }
  8628.     }
  8629.     if (line) {
  8630.         free(line);
  8631.         line = NULL;
  8632.     }
  8633.     if (nhcount == 0 && ambiguous)
  8634.       printf("?\"%s\" - ambiguous in network directory\n",s);
  8635. #else
  8636.     nhcount = 0;
  8637. #endif /* NODIAL */
  8638.     return(nhcount);
  8639. }
  8640. #endif /* NETCONN */
  8641.  
  8642. #ifndef NOLOCAL
  8643. /*  C L S C O N N X  --  Close connection  */
  8644.  
  8645. int
  8646. clsconnx(ask) int ask; {
  8647.     int x, rc = 0;
  8648. #ifdef NEWFTP
  8649.     extern int ftpget, ftpisopen();
  8650.     if ((ftpget == 1) || ((ftpget == 2) && !local && ftpisopen()))
  8651.       return(success = ftpbye());
  8652. #endif /* NEWFTP */
  8653.     debug(F101,"clsconnx local","",local);
  8654.     if (local) {
  8655.         x = ask ? hupok(1) : 1;         /* Make sure it's OK to close */
  8656.         if (!x) {
  8657.             rc = -1;
  8658.             debug(F101,"clsconnx hupok says no","",rc);
  8659.             return(rc);
  8660.         }
  8661.         ttflui();                       /* Clear away buffered up junk */
  8662. #ifndef NODIAL
  8663. #ifdef OS2ONLY
  8664. /* Don't hangup a line that is shared with the SLIP or PPP driver */
  8665.         if (!ttslip && !ttppp)
  8666. #endif /* OS2ONLY */
  8667.           mdmhup();
  8668. #endif /* NODIAL */
  8669.         if (network && msgflg)
  8670.           printf(" Closing connection\n");
  8671.         ttclos(0);                      /* Close old connection, if any */
  8672.         rc = 1;
  8673.         {
  8674.             extern int wasclosed, whyclosed;
  8675.             if (wasclosed) {
  8676.                 whyclosed = WC_CLOS;
  8677. #ifndef NOSPL
  8678.                 if (nmac) {             /* Any macros defined? */
  8679.                     int k;              /* Yes */
  8680.                     /* printf("ON_CLOSE CLSCONNX\n"); */
  8681.                     wasclosed = 0;
  8682.                     k = mlook(mactab,"on_close",nmac);  /* Look this up */
  8683.                     if (k >= 0) {                       /* If found, */
  8684.                         if (dodo(k,ckitoa(whyclosed),0) > -1) /* set it up, */
  8685.                           parser(1);                    /* and execute it */
  8686.                     }
  8687.                 }
  8688. #endif /* NOSPL */
  8689.                 whyclosed = WC_REMO;
  8690.                 wasclosed = 0;
  8691.             }
  8692.         }
  8693.     }
  8694. #ifdef VMS                              /* Or maybe #ifndef UNIX? */
  8695.     else {                              /* Need to do this in VMS to */
  8696.         ttclos(0);                      /* free the tty channel number */
  8697.         rc = 1;                         /* obtained in ttopen() or else */
  8698.     }                                   /* subsequent ttopen's won't work */
  8699. #endif /* VMS */
  8700.     dologend();
  8701.     haveline = 0;
  8702.     if (mdmtyp < 0) {                   /* Switching from net to async? */
  8703.         if (mdmsav > -1)                /* Restore modem type from last */
  8704.           mdmtyp = mdmsav;              /* SET MODEM command, if any. */
  8705.         else
  8706.           mdmtyp = 0;
  8707.         mdmsav = -1;
  8708.     }
  8709.     if (network)
  8710.       network = 0;
  8711. #ifdef NETCONN
  8712.     if (oldplex > -1) {                 /* Restore previous duplex setting. */
  8713.         duplex = oldplex;
  8714.         oldplex = -1;
  8715.     }
  8716. #endif /* NETCONN */
  8717. #ifndef MAC
  8718.     ckstrncpy(ttname,dftty,TTNAMLEN);   /* Restore default communication */
  8719. #endif /* MAC */
  8720.     local = dfloc;                      /* device and local/remote status */
  8721.     if (local) {
  8722.         cxtype = CXT_DIRECT;            /* Something reasonable */
  8723.         speed = ttgspd();               /* Get the current speed */
  8724.     } else {
  8725.         cxtype = CXT_REMOTE;
  8726.         speed = -1L;
  8727.     }
  8728. #ifndef NOXFER
  8729.     if (xreliable > -1 && !setreliable) {
  8730.         reliable = xreliable;
  8731.         debug(F101,"clsconnx reliable A","",reliable);
  8732.     } else if (!setreliable) {
  8733.         reliable = SET_AUTO;
  8734.         debug(F101,"clsconnx reliable B","",reliable);
  8735.     }
  8736. #endif /* NOXFER */
  8737.     setflow();                          /* Revert flow control */
  8738.     return(rc);
  8739. }
  8740.  
  8741. int
  8742. clskconnx(x) int x; {                   /* Close Kermit connection only */
  8743.     int t, rc;                          /* (not FTP) */
  8744. #ifdef NEWFTP
  8745.     extern int ftpget;
  8746.     t = ftpget;
  8747.     ftpget = 0;
  8748. #endif /* NEWFTP */
  8749.     rc = clsconnx(x);
  8750. #ifdef NEWFTP
  8751.     ftpget = t;
  8752. #endif /* NEWFTP */
  8753.     return(rc);
  8754. }
  8755.  
  8756. /* May 2002: setlin() decomposition starts here ... */
  8757.  
  8758. #ifdef OS2
  8759. #define SRVBUFSIZ PIPENAML
  8760. #else /* OS2 */
  8761. #define SRVBUFSIZ 63
  8762. #endif /* OS2 */
  8763. #define HOSTNAMLEN 15*65
  8764.  
  8765. int netsave = -1;
  8766. static char * tmpstring = NULL;
  8767. static char * tmpusrid = NULL;
  8768.  
  8769. #ifdef SSHCMD
  8770. char * sshcmd = NULL;
  8771. char * defsshcmd = "ssh -e none";
  8772. #else
  8773. #ifdef SSHBUILTIN
  8774. char * sshrcmd = NULL;
  8775. char * sshtmpcmd = NULL;
  8776. #endif /* SSHBUILTIN */
  8777. #endif /* SSHCMD */
  8778.  
  8779. /* c x _ f a i l  --  Common error exit routine for cx_net, cx_line */
  8780.  
  8781. int
  8782. cx_fail(msg, text) int msg; char * text; {
  8783.     makestr(&slmsg,text);        /* For the record (or GUI) */
  8784.     if (msg)                /* Not GUI, not quiet, etc */
  8785.       printf("?%s\n",text);        /* Print error message */
  8786.     slrestor();                /* Restore LINE/HOST to known state */
  8787.     return(msg ? -9 : (success = 0));    /* Return appropriate code */
  8788. }
  8789.  
  8790. #ifdef NETCONN
  8791. /* c x _ n e t  --  Make a network connection */
  8792.  
  8793. /*
  8794.   Call with:
  8795.     net      = network type
  8796.     protocol = protocol type
  8797.     host     = string pointer to host name.
  8798.     svc      = string pointer to service or port on host.
  8799.     username = username for connection
  8800.     password = password for connection
  8801.     command  = command to execute
  8802.     param1   = Telnet: Authentication type
  8803.                SSH:    Version
  8804.     param2   = Telnet: Encryption type
  8805.                SSH:    Command as Subsystem
  8806.     param3   = Telnet: 1 to wait for negotiations, 0 otherwise
  8807.                SSH:    X11 Forwarding
  8808.     cx       = 1 to automatically enter Connect mode, 0 otherwise.
  8809.     sx       = 1 to automatically enter Server mode, 0 otherwise.
  8810.     flag     = if no host name given, 1 = close current connection, 0 = resume
  8811.     gui      = 1 if called from GUI dialog, 0 otherwise.
  8812.   Returns:
  8813.     1 on success
  8814.     0 on failure and no message printed, slmsg set to failure message.
  8815.    -9 on failure and message printed, ditto.
  8816. */
  8817. int
  8818. #ifdef CK_ANSIC
  8819. cx_net( int net, int protocol, char * xhost, char * svc, 
  8820.         char * username, char * password, char * command,
  8821.         int param1, int param2, int param3, int cx, int sx, int flag, int gui)
  8822. #else /* CK_ANSIC */
  8823. cx_net(net, protocol, xhost, svc,
  8824.        username, password, command,
  8825.        param1, param2, param3, cx, sx, flag, gui)
  8826.     char * xhost, * svc, * username, *password, *command; 
  8827.     int net, protocol, cx, sx, flag, param1, param2, param3, gui; 
  8828. #endif /* CK_ANSIC */
  8829. /* cx_net */ {
  8830.  
  8831.     int i, n, x, msg;
  8832.     int _local = -1;
  8833.  
  8834.     extern char pwbuf[], * g_pswd;
  8835.     extern int pwflg, pwcrypt, g_pflg, g_pcpt, nolocal;
  8836.  
  8837.     char srvbuf[SRVBUFSIZ+1];        /* Service */
  8838.     char hostbuf[HOSTNAMLEN];        /* Host buffer to manipulate */
  8839.     char hostname[HOSTNAMLEN];        /* Copy of host parameter */
  8840.     char * host = hostbuf;        /* Pointer to copy of host param */
  8841.  
  8842.     if (!xhost) xhost = "";        /* Watch out for null pointers */
  8843.     if (!svc) svc = "";
  8844.     ckstrncpy(host,xhost,HOSTNAMLEN);    /* Avoid buffer confusion */
  8845.  
  8846.     debug(F110,"cx_net host",host,0);
  8847.     debug(F111,"cx_net service",svc,SRVBUFSIZ);
  8848.     debug(F101,"cx_net network type","",net);
  8849.  
  8850.     msg = (gui == 0) && msgflg;        /* Whether to print messages */
  8851.  
  8852. #ifndef NODIAL
  8853.     debug(F101,"cx_net nnetdir","",nnetdir);
  8854.     x = 0;                /* Look up in network directory */
  8855.     if (*host == '=') {            /* If number starts with = sign */
  8856.     host++;                /* strip it */
  8857.     while (*host == SP) host++;    /* and any leading spaces */
  8858.     debug(F110,"cx_net host 2",host,0);
  8859.     nhcount = 0;
  8860.     } else if (*host) {            /* We want to look it up. */
  8861.     if (nnetdir > 0)        /* If there is a directory... */
  8862.       x = lunet(host);        /* (sets nhcount) */
  8863.     else                /* otherwise */
  8864.       nhcount = 0;            /* we didn't find any there */
  8865.     if (x < 0)            /* Internal error? */
  8866.       return(cx_fail(msg,"Network directory lookup error"));
  8867.     debug(F111,"cx_net lunet nhcount",host,nhcount);
  8868.     }
  8869. #endif /* NODIAL */
  8870.  
  8871.     /* New connection wanted.  Make a copy of the host name/address... */
  8872.  
  8873.     if (clskconnx(1) < 0)        /* Close current Kermit connection */
  8874.       return(cx_fail(msg,"Error closing previous connection"));
  8875.  
  8876.     if (*host) {            /* They gave a hostname */
  8877.     _local = 1;            /* Network connection always local */
  8878.     if (mdmsav < 0)
  8879.       mdmsav = mdmtyp;        /* Remember old modem type */
  8880.     mdmtyp = -net;            /* Special code for network */
  8881.     } else {                /* They just said "set host" */
  8882.     host = dftty;            /* So go back to normal */
  8883.     _local = dfloc;            /* default tty, location, */
  8884.     if (flag) {            /* Close current connection */
  8885.         setflow();            /* Maybe change flow control */
  8886.         haveline = 1;        /* (* is this right? *) */
  8887.         dologend();
  8888. #ifndef NODIAL
  8889.         dialsta = DIA_UNK;
  8890. #endif /* NODIAL */
  8891. #ifdef LOCUS
  8892.         if (autolocus) {
  8893.         setlocus(1,1);
  8894.         }
  8895. #endif /* LOCUS */
  8896.             /* XXX - Is this right? */
  8897.         /* Should we be returning without doing anything ? */
  8898.         /* Yes it's right -- we closed the old connection just above. */
  8899.         return(success = 1);        
  8900.     }
  8901.     }
  8902.     success = 0;
  8903.     if (host != line)                   /* line[] is a global */
  8904.       ckstrncpy(line,host,LINBUFSIZ);
  8905.     ckstrncpy(hostname,host,HOSTNAMLEN);
  8906.     ckstrncpy(srvbuf,svc,SRVBUFSIZ+1);
  8907.  
  8908. #ifndef NODIAL
  8909.     if ((nhcount > 1) && msg) {
  8910.     int k;
  8911.     printf("%d entr%s found for \"%s\"%s\n",
  8912.            nhcount,
  8913.            (nhcount == 1) ? "y" : "ies",
  8914.            s,
  8915.            (nhcount > 0) ? ":" : "."
  8916.            );
  8917.     for (i = 0; i < nhcount; i++) {
  8918.         printf("%3d. %-12s => %-9s %s",
  8919.                i+1,n_name,nh_p2[i],nh_p[i]);
  8920.         for (k = 0; k < 4; k++) { /* Also list net-specific items */
  8921.         if (nh_px[k][i])      /* free format... */
  8922.           printf(" %s",nh_px[k][i]);
  8923.         else
  8924.           break;
  8925.         }
  8926.         printf("\n");
  8927.     }
  8928.     }
  8929.     if (nhcount == 0)
  8930.       n = 1;
  8931.     else
  8932.       n = nhcount;
  8933. #else
  8934.     n = 1;
  8935.     nhcount = 0;
  8936. #endif /* NODIAL */
  8937.  
  8938.     for (i = 0; i < n; i++) {        /* Loop for each entry found */
  8939.     debug(F101,"cx_net loop i","",i);
  8940. #ifndef NODIAL
  8941.     if (nhcount > 0) {        /* If we found at least one entry... */
  8942.         ckstrncpy(line,nh_p[i],LINBUFSIZ); /* Copy current entry */
  8943.         if (lookup(netcmd,nh_p2[i],nnets,&x) > -1) { /* Net type */
  8944.         int xx;
  8945.         xx = netcmd[x].kwval;
  8946.         /* User specified SSH so don't let net directory override */
  8947.         if (net != NET_SSH || xx != NET_TCPB) {
  8948.             net = xx;
  8949.             mdmtyp  = 0 - net;
  8950.         }
  8951.         } else {
  8952.         makestr(&slmsg,"Network type not supported");
  8953.         if (msg)
  8954.           printf("Error - network type \"%s\" not supported\n",
  8955.              nh_p2[i]
  8956.                  );
  8957.         continue;
  8958.         }
  8959.         switch (net) {        /* Net-specific directory things */
  8960. #ifdef SSHBUILTIN
  8961.           case NET_SSH:        /* SSH */
  8962.                 /* Any SSH specific network directory stuff? */
  8963.                 break;                  /* NET_SSH */
  8964. #endif /* SSHBUILTIN */
  8965.  
  8966.           case NET_TCPB: {        /* TCP/IP TELNET,RLOGIN,... */
  8967. #ifdef TCPSOCKET
  8968.           char *q;
  8969.           int flag = 0;
  8970.  
  8971.           /* Extract ":service", if any, from host string */
  8972.           debug(F110,"cx_net service 1",line,0);
  8973.           for (q = line; (*q != '\0') && (*q != ':'); q++)
  8974.             ;
  8975.           if (*q == ':') { *q++ = NUL; flag = 1; }
  8976.           debug(F111,"cx_net service 2",line,flag);
  8977.  
  8978.           /* Get service, if any, from directory entry */
  8979.  
  8980.           if (!*srvbuf) {
  8981.               if (nh_px[0][i]) {
  8982.               ckstrncpy(srvbuf,nh_px[0][i],SRVBUFSIZ);
  8983.               debug(F110,"cx_net service 3",srvbuf,0);
  8984.               }
  8985.               if (flag) {
  8986.               ckstrncpy(srvbuf,q,SRVBUFSIZ);
  8987.               debug(F110,"cx_net service 4",srvbuf,0);
  8988.               }
  8989.           }
  8990.           ckstrncpy(hostname,line,HOSTNAMLEN);
  8991.  
  8992.           /* If we have a service, append to host name/address */
  8993.           if (*srvbuf) {
  8994.               ckstrncat(line, ":", LINBUFSIZ);
  8995.               ckstrncat(line, srvbuf, LINBUFSIZ);
  8996.               debug(F110,"cx_net service 5",line,0);
  8997.           }
  8998. #ifdef RLOGCODE
  8999.           /* If no service given but command was RLOGIN */
  9000.           else if (ttnproto == NP_RLOGIN) { /* add this... */
  9001.               ckstrncat(line, ":login",LINBUFSIZ);
  9002.               debug(F110,"cx_net service 6",line,0);
  9003.           }
  9004. #ifdef CK_AUTHENTICATION
  9005. #ifdef CK_KERBEROS
  9006.           else if (ttnproto == NP_K4LOGIN ||
  9007.                ttnproto == NP_K5LOGIN) { /* add this... */
  9008.               ckstrncat(line, ":klogin",LINBUFSIZ);
  9009.               debug(F110,"cx_net service 7",line,0);
  9010.           }
  9011.           else if (ttnproto == NP_EK4LOGIN ||
  9012.                ttnproto == NP_EK5LOGIN) { /* add this... */
  9013.               ckstrncat(line, ":eklogin",LINBUFSIZ);
  9014.               debug(F110,"cx_net service 8",line,0);
  9015.           }
  9016. #endif /* CK_KERBEROS */
  9017. #endif /* CK_AUTHENTICATION */
  9018. #endif /* RLOGCODE */
  9019.           else {        /* Otherwise, add ":telnet". */
  9020.               ckstrncat(line, ":telnet", LINBUFSIZ);
  9021.               debug(F110,"cx_net service 9",line,0);
  9022.           }
  9023.           if (username) {    /* This is a parameter... */
  9024.               ckstrncpy(uidbuf,username,UIDBUFLEN);
  9025.               uidflag = 1;
  9026.           }
  9027.           /* Fifth field, if any, is user ID (for rlogin) */
  9028.  
  9029.           if (nh_px[1][i] && !uidflag)
  9030.             ckstrncpy(uidbuf,username,UIDBUFLEN);
  9031. #ifdef RLOGCODE
  9032.           if (IS_RLOGIN() && !uidbuf[0])
  9033.             return(cx_fail(msg,"Username required"));
  9034. #endif /* RLOGCODE */
  9035. #endif /* TCPSOCKET */
  9036.           break;
  9037.           }
  9038.           case NET_PIPE:        /* Pipe */
  9039. #ifdef NPIPE
  9040.         if (!pipename[0]) { /* User didn't give a pipename */
  9041.             if (nh_px[0][i]) { /* But directory entry has one */
  9042.             if (strcmp(pipename,"\\pipe\\")) {
  9043.                 ckstrncpy(pipename,"\\pipe\\",LINBUFSIZ);
  9044.                 ckstrncat(srvbuf,nh_px[0][i],PIPENAML-6);
  9045.             } else {
  9046.                 ckstrncpy(pipename,nh_px[0][i],PIPENAML);
  9047.             }
  9048.             debug(F110,"cx_net pipeneme",pipename,0);
  9049.             }
  9050.         }
  9051. #endif /* NPIPE */
  9052.         break;
  9053.  
  9054.           case NET_SLAT:            /* LAT / CTERM */
  9055. #ifdef SUPERLAT
  9056.         if (!slat_pwd[0]) { /* User didn't give a password */
  9057.             if (nh_px[0][i]) { /* But directory entry has one */
  9058.             ckstrncpy(slat_pwd,nh_px[0][i],18);
  9059.             debug(F110,"cx_net SuperLAT password",slat_pwd,0);
  9060.             }
  9061.         }
  9062. #endif /* SUPERLAT */
  9063.         break;
  9064.  
  9065.           case NET_SX25:        /* X.25 keyword parameters */
  9066.           case NET_IX25:
  9067.           case NET_VX25: {
  9068. #ifdef ANYX25
  9069.           int k;            /* Cycle through the four fields */
  9070.           for (k = 0; k < 4; k++) {
  9071.               if (!nh_px[k][i]) /* Bail out if none left */
  9072.             break;
  9073.               if (!ckstrcmp(nh_px[k][i],"cug=",4,0)) {
  9074.               closgr = atoi(nh_px[k][i]+4);
  9075.               debug(F101,"X25 CUG","",closgr);
  9076.               } else if (!ckstrcmp(nh_px[k][i],"cud=",4,0)) {
  9077.               cudata = 1;
  9078.               ckstrncpy(udata,nh_px[k][i]+4,MAXCUDATA);
  9079.               debug(F110,"X25 CUD",cudata,0);
  9080.               } else if (!ckstrcmp(nh_px[k][i],"rev=",4,0)) {
  9081.               revcall = !ckstrcmp(nh_px[k][i]+4,"=on",3,0);
  9082.               debug(F101,"X25 REV","",revcall);
  9083. #ifndef IBMX25
  9084.               } else if (!ckstrcmp(nh_px[k][i],"pad=",4,0)) {
  9085.               int x3par, x3val;
  9086.               char *s1, *s2;
  9087.               s1 = s2 = nh_px[k][i]+4; /* PAD parameters */
  9088.               while (*s2) {            /* Pick them apart */
  9089.                   if (*s2 == ':') {
  9090.                   *s2 = NUL;
  9091.                   x3par = atoi(s1);
  9092.                   s1 = ++s2;
  9093.                   continue;
  9094.                   } else if (*s2 == ',') {
  9095.                   *s2 = NUL;
  9096.                   x3val = atoi(s1);
  9097.                   s1 = ++s2;
  9098.                   debug(F111,"X25 PAD",x3par,x3val);
  9099.                   if (x3par > -1 &&
  9100.                       x3par <= MAXPADPARMS)
  9101.                     padparms[x3par] = x3val;
  9102.                   continue;
  9103.                   } else
  9104.                 s2++;
  9105.               }
  9106. #endif /* IBMX25 */
  9107.               }
  9108.           }
  9109. #endif /* ANYX25 */
  9110.           break;
  9111.           }
  9112.           default:            /* Nothing special for other nets */
  9113.         break;
  9114.         }
  9115.     } else
  9116. #endif /* NODIAL */
  9117.     {                /* No directory entries found. */
  9118.         ckstrncpy(line,hostname,LINBUFSIZ); /* Put this back... */
  9119.         /* If the user gave a TCP service */
  9120.         if (net == NET_TCPB || net == NET_SSH)
  9121.           if (*srvbuf) {        /* Append it to host name/address */
  9122.           ckstrncat(line, ":", LINBUFSIZ);
  9123.           ckstrncat(line, srvbuf,LINBUFSIZ);
  9124.           }
  9125.     }
  9126.     /*
  9127.        Get here with host name/address and all net-specific
  9128.        parameters set, ready to open the connection.
  9129.     */
  9130.     mdmtyp = -net;            /* This should have been done */
  9131.                     /* already but just in case ... */
  9132.  
  9133.     debug(F110,"cx_net net line[] before ttopen",line,0);
  9134.     debug(F101,"cx_net net mdmtyp before ttopen","",mdmtyp);
  9135.     debug(F101,"cx_net net ttnproto","",ttnproto);
  9136.  
  9137. #ifdef SSHBUILTIN
  9138.         if (net == NET_SSH) {
  9139.             makestr(&ssh_hst,hostname);        /* Stash everything */
  9140.             if (username) {
  9141.                 if (!sl_uid_saved) {
  9142.                     ckstrncpy(sl_uidbuf,uidbuf,UIDBUFLEN);
  9143.                     sl_uid_saved = 1;
  9144.                 }
  9145.                 ckstrncpy(uidbuf,username,UIDBUFLEN);
  9146.             }
  9147.             if (srvbuf[0]) {
  9148.                 makestr(&ssh_prt,srvbuf);
  9149.             } else
  9150.                 makestr(&ssh_prt,NULL);
  9151.  
  9152.             if (command) {
  9153.                 makestr(&ssh_cmd,brstrip(command));
  9154.                 ssh_cas = param2;
  9155.             } else
  9156.                 makestr(&ssh_cmd,NULL);
  9157.  
  9158.             if (param1 > -1) {
  9159. #ifndef SSHTEST
  9160.                 if (!sl_ssh_ver_saved) {
  9161.                     sl_ssh_ver = ssh_ver;
  9162.                     sl_ssh_ver_saved = 1;
  9163.                 }
  9164. #endif /* SSHTEST */
  9165.                 ssh_ver = param1;
  9166.             }
  9167.             if (param3 > -1) {
  9168. #ifndef SSHTEST
  9169.                 if (!sl_ssh_xfw_saved) {
  9170.                     sl_ssh_xfw = ssh_xfw;
  9171.                     sl_ssh_xfw_saved = 1;
  9172.                 }
  9173. #endif /* SSHTEST */
  9174.                 ssh_xfw = param3;
  9175.             }
  9176.         } else                          /* NET_SSH */
  9177. #endif /* SSHBUILTIN */
  9178. #ifdef TCPSOCKET
  9179.       if (net == NET_TCPB) {
  9180.             switch (protocol) {
  9181. #ifdef CK_SSL
  9182. #ifdef COMMENT
  9183. /*
  9184.   Jeff's version from 30 Dec 2006 - doesn't work - SSL/TLS_RAW still
  9185.   start Telnet negotions if a 0xff byte comes in.
  9186. */
  9187.           case NP_SSL_RAW:
  9188.                 ttnproto = NP_SSL_RAW;
  9189.         debug(F101,"NP_SSL_RAW ttnproto","",ttnproto);
  9190.                 ssl_only_flag = 1;
  9191.                 tls_only_flag = 0;
  9192.                 break;
  9193.  
  9194.           case NP_TLS_RAW:
  9195.           ttnproto = NP_TLS_RAW;
  9196.           debug(F101,"NP_TLS_RAW ttnproto","",ttnproto);
  9197.           ssl_only_flag = 0;
  9198.           tls_only_flag = 1;
  9199.           break;
  9200.  
  9201.           case NP_SSL:
  9202.                 ttnproto = NP_SSL;
  9203.         debug(F101,"NP_SSL ttnproto","",ttnproto);
  9204.                 ssl_only_flag = 1;
  9205.                 tls_only_flag = 0;
  9206.                 break;
  9207.  
  9208.           case NP_TLS:
  9209.                 ttnproto = NP_TLS;
  9210.         debug(F101,"NP_TLS ttnproto","",ttnproto);
  9211.                 ssl_only_flag = 0;
  9212.                 tls_only_flag = 1;
  9213.                 break;
  9214.  
  9215.           case NP_SSL_TELNET:
  9216.                 ttnproto = NP_TELNET;
  9217.         debug(F101,"NP_SSL_TELNET ttnproto","",ttnproto);
  9218.                 ssl_only_flag = 1;
  9219.                 tls_only_flag = 0;
  9220.                 break;
  9221.  
  9222.           case NP_TLS_TELNET:
  9223.                 ttnproto = NP_TELNET;
  9224.         debug(F101,"NP_TLS_TELNET ttnproto","",ttnproto);
  9225.                 ssl_only_flag = 0;
  9226.                 tls_only_flag = 1;
  9227.                 break;
  9228. #else
  9229. /* fdc version of 4 Dec 2006 works OK */
  9230.           case NP_SSL_RAW:
  9231.           case NP_SSL:
  9232.         ssl_raw_flag = (protocol == NP_SSL_RAW) ? 1 : 0;
  9233.                 ttnproto = protocol;
  9234.         debug(F101,protocol==NP_SSL ?
  9235.               "NP_SSL ttnproto" :
  9236.               "NP_SSL_RAW ttnproto",
  9237.               "",ttnproto);
  9238.                 ssl_only_flag = 1;
  9239.                 tls_only_flag = 0;
  9240.                 break;
  9241.  
  9242.           case NP_TLS:
  9243.           case NP_TLS_RAW:
  9244.         tls_raw_flag = (protocol == NP_SSL_RAW) ? 1 : 0;
  9245.                 ttnproto = protocol;
  9246.         debug(F101,protocol==NP_TLS ?
  9247.               "NP_TLS ttnproto" :
  9248.               "NP_TLS_RAW ttnproto",
  9249.               "",ttnproto);
  9250.                 ssl_only_flag = 0;
  9251.                 tls_only_flag = 1;
  9252.                 break;
  9253.  
  9254.           case NP_SSL_TELNET:
  9255.         ssl_raw_flag = 0;
  9256.                 ttnproto = NP_TELNET;
  9257.         debug(F101,"NP_SSL_TELNET ttnproto","",ttnproto);
  9258.                 ssl_only_flag = 1;
  9259.                 tls_only_flag = 0;
  9260.                 break;
  9261.  
  9262.           case NP_TLS_TELNET:
  9263.         tls_raw_flag = 0;
  9264.                 ttnproto = NP_TELNET;
  9265.         debug(F101,"NP_TLS_TELNET ttnproto","",ttnproto);
  9266.                 ssl_only_flag = 0;
  9267.                 tls_only_flag = 1;
  9268.                 break;
  9269. #endif    /* COMMENT */
  9270. #endif /* CK_SSL */
  9271.  
  9272.           case NP_NONE:
  9273.           case NP_TCPRAW:
  9274.           case NP_RLOGIN:
  9275.           case NP_K4LOGIN:
  9276.           case NP_K5LOGIN:
  9277.           case NP_EK4LOGIN:
  9278.           case NP_EK5LOGIN:
  9279.           case NP_TELNET:
  9280.           case NP_KERMIT:
  9281.           default:
  9282.                 ttnproto = protocol;
  9283. #ifdef CK_SSL
  9284. #ifdef COMMENT
  9285.         /* Jeff version from 30 Dec 2006 */
  9286.                 ssl_only_flag = 0;
  9287.                 tls_only_flag = 0;
  9288. #else
  9289.         /* fdc version from 4 Dec 2006 */
  9290.         ssl_raw_flag = 0;
  9291.         tls_raw_flag = 0;
  9292.                 ssl_only_flag = 0;
  9293.                 tls_only_flag = 0;
  9294. #endif    /* COMMENT */
  9295. #endif /* CK_SSL */
  9296.                 break;
  9297.             }
  9298. #ifdef CK_AUTHENTICATION
  9299.             if ((ttnproto == NP_TELNET || ttnproto == NP_KERMIT) &&
  9300.         param1 > -1) {
  9301.         if (!sl_auth_saved) {
  9302.         int x;
  9303.         for (x = 0; x < AUTHTYPLSTSZ; x++)
  9304.           sl_auth_type_user[x] = auth_type_user[x];
  9305.         sl_auth_saved = 1;
  9306.         }
  9307.         if (!sl_topt_a_s_saved) {
  9308.         sl_topt_a_su = TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION);
  9309.         sl_topt_a_s_saved = 1;
  9310.         }
  9311.         if (!sl_topt_a_c_saved) {
  9312.         sl_topt_a_cm = TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION);
  9313.         sl_topt_a_c_saved = 1;
  9314.         }
  9315.         switch (param1) {
  9316.           case AUTHTYPE_AUTO:
  9317.         auth_type_user[0] = AUTHTYPE_AUTO;
  9318.         TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_RQ;
  9319.         TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_RQ;
  9320.         break;
  9321.           case AUTHTYPE_NULL:
  9322.         auth_type_user[0] = AUTHTYPE_NULL;
  9323.         TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_RF;
  9324.         TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_RF;
  9325.         break;
  9326. #ifdef CK_SRP
  9327.           case AUTHTYPE_SRP:
  9328.         auth_type_user[0] = AUTHTYPE_SRP;
  9329.         auth_type_user[1] = AUTHTYPE_NULL;
  9330.         TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
  9331.         TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
  9332.         break;
  9333. #endif /* CK_SRP */
  9334. #ifdef CK_SSL
  9335.           case AUTHTYPE_SSL:
  9336.         auth_type_user[0] = AUTHTYPE_SSL;
  9337.         auth_type_user[1] = AUTHTYPE_NULL;
  9338.         TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
  9339.         TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
  9340.         break;
  9341. #endif /* CK_SSL */
  9342. #ifdef NT
  9343.           case AUTHTYPE_NTLM:
  9344.         auth_type_user[0] = AUTHTYPE_NTLM;
  9345.         auth_type_user[1] = AUTHTYPE_NULL;
  9346.         TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
  9347.         TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
  9348.         break;
  9349. #endif /* NT */
  9350. #ifdef CK_KERBEROS
  9351.           case AUTHTYPE_KERBEROS_V4:
  9352.         auth_type_user[0] = AUTHTYPE_KERBEROS_V4;
  9353.         auth_type_user[1] = AUTHTYPE_NULL;
  9354.         TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
  9355.         TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
  9356.         break;
  9357.  
  9358.           case AUTHTYPE_KERBEROS_V5:
  9359.         auth_type_user[0] = AUTHTYPE_KERBEROS_V5;
  9360.         auth_type_user[1] = AUTHTYPE_NULL;
  9361.         TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
  9362.         TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = TN_NG_MU;
  9363.         break;
  9364. #endif /* CK_KERBEROS */
  9365.         }
  9366.     }
  9367.     /*
  9368.        If the user requires a particular type of Kerberos connection,
  9369.        make sure we have a valid TGT.
  9370.     */
  9371.     makestr(&slmsg,"Authentication failure");
  9372.     if ((ttnproto == NP_TELNET || ttnproto == NP_KERMIT) &&
  9373.         (line[0] == '*' &&
  9374.          TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) == TN_NG_MU ||
  9375.          line[0] != '*' &&
  9376.          TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) == TN_NG_MU)
  9377.         ) {
  9378. #ifdef CK_KERBEROS
  9379.         if ( auth_type_user[0] == AUTHTYPE_KERBEROS_V4 ) {
  9380.         extern int krb4_autoget;
  9381.         if (!ck_krb4_is_installed())
  9382.           return(cx_fail(msg,
  9383.           "Required authentication method (Kerberos 4) is not installed"));
  9384. #ifdef COMMENT
  9385.         /* This code results in false failures when using */
  9386.         /* kerberos to machines in realms other than the  */
  9387.         /* default since we don't know the realm of the   */
  9388.         /* other machine until perform the reverse DNS    */
  9389.         /* lookup.                                        */
  9390.         else if (line[0] != '*' && !ck_krb4_is_tgt_valid() &&
  9391.                (!krb4_autoget ||
  9392.                 krb4_autoget && !ck_krb4_autoget_TGT(NULL))) {
  9393.             return(cx_fail(msg,
  9394.                "Kerberos 4: Ticket Getting Ticket not valid"));
  9395.         }
  9396. #endif /* COMMENT */
  9397.         } else if (auth_type_user[0] == AUTHTYPE_KERBEROS_V5) {
  9398.         extern int krb5_autoget;
  9399.         if (!ck_krb5_is_installed()) {
  9400.             return(cx_fail(msg,
  9401.        "Required authentication method (Kerberos 5) is not installed"));
  9402.         }
  9403. #ifdef COMMENT
  9404.         /* This code results in false failures when using */
  9405.         /* kerberos to machines in realms other than the  */
  9406.         /* default since we don't know the realm of the   */
  9407.         /* other machine until perform the reverse DNS    */
  9408.         /* lookup.                                        */
  9409.         else if (line[0] != '*' && !ck_krb5_is_tgt_valid() &&
  9410.                (!krb5_autoget ||
  9411.                 krb5_autoget && !ck_krb5_autoget_TGT(NULL))) {
  9412.             return(cx_fail(msg,
  9413.              "Kerberos 5: Ticket Getting Ticket not valid."));
  9414.         }
  9415. #endif /* COMMENT */
  9416.         }
  9417. #endif /* CK_KERBEROS */
  9418. #ifdef NT
  9419.         if (auth_type_user[0] == AUTHTYPE_NTLM) {
  9420.         if (!ck_ntlm_is_installed()) {
  9421.             return(cx_fail(msg,
  9422.            "Required authentication method (NTLM) is not installed"));
  9423.         } else if (line[0] != '*' && !ck_ntlm_is_valid(0)) {
  9424.             return(cx_fail(msg,"NTLM: Credentials are unavailable."));
  9425.         }
  9426.         }
  9427. #endif /* NT */
  9428. #ifdef CK_SSL
  9429.         if (auth_type_user[0] == AUTHTYPE_SSL) {
  9430.         if (!ck_ssleay_is_installed()) {
  9431.             return(cx_fail(msg,
  9432.              "Required authentication method (SSL) is not installed"));
  9433.         }
  9434.         }
  9435. #endif /* CK_SSL */
  9436. #ifdef CK_SRP
  9437.         if (auth_type_user[0] == AUTHTYPE_SRP) {
  9438.         if (!ck_srp_is_installed()) {
  9439.             return(cx_fail(msg,
  9440.              "Required authentication method (SRP) is not installed"));
  9441.         }
  9442.         }
  9443. #endif /* CK_SRP */
  9444.     }
  9445. #endif /* CK_AUTHENTICATION */
  9446. #ifdef CK_ENCRYPTION
  9447.     if ((ttnproto == NP_TELNET || ttnproto == NP_KERMIT) &&
  9448.          param2 > -1) {
  9449.         if (!sl_cx_saved) {
  9450.         sl_cx_type = cx_type;
  9451.         sl_cx_saved = 1;
  9452.         }
  9453.         if (!sl_topt_e_s_saved) {
  9454.         sl_topt_e_su = TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION);
  9455.         sl_topt_e_sm = TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION);
  9456.         sl_topt_e_s_saved = 1;
  9457.         }
  9458.         if (!sl_topt_e_c_saved) {
  9459.         sl_topt_e_cu = TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION);
  9460.         sl_topt_e_cm = TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION);
  9461.         sl_topt_e_c_saved = 1;
  9462.         }
  9463.         cx_type = param2;
  9464.         if (cx_type == CX_AUTO) {
  9465.         TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
  9466.         TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
  9467.         TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
  9468.         TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RQ;
  9469.         } else if (cx_type == CX_NONE) {
  9470.         TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  9471.         TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  9472.         TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  9473.         TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_RF;
  9474.         } else {
  9475.         TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION) = TN_NG_MU;
  9476.         TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_MU;
  9477.         TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION) = TN_NG_MU;
  9478.         TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) = TN_NG_MU;
  9479.         }
  9480.     }
  9481.     if (ttnproto == NP_EK4LOGIN || ttnproto == NP_EK5LOGIN ||
  9482.         (ttnproto == NP_TELNET || ttnproto == NP_KERMIT) &&
  9483.         ((line[0] == '*' &&
  9484.           TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION) == TN_NG_MU &&
  9485.           TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) == TN_NG_MU) ||
  9486.          (line[0] != '*' &&
  9487.           TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION) == TN_NG_MU &&
  9488.           TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) == TN_NG_MU))
  9489.         ) {
  9490.         if (!ck_crypt_is_installed()) {
  9491.         return(cx_fail(msg,
  9492.           "Required Encryption methods are not installed"));
  9493.         }
  9494.     }
  9495. #endif /* CK_ENCRYPTION */
  9496. #ifdef RLOGCODE
  9497. #ifdef CK_KERBEROS
  9498. #ifdef KRB4
  9499.     if (ttnproto == NP_K4LOGIN || ttnproto == NP_EK4LOGIN) {
  9500.         extern int krb4_autoget;
  9501.         char tgt[256];
  9502.         char * realm;
  9503.  
  9504.         /* We don't have the full hostname at yet so  */
  9505.         /* we do a DNS lookup before calling ttopen() */ 
  9506.  
  9507.         realm = ck_krb4_realmofhost(ckgetfqhostname(hostname));
  9508.         ckmakmsg(tgt,256,"krbtgt.",realm,"@",realm);
  9509.         if (!ck_krb4_is_installed()) {
  9510.         return(cx_fail(msg,
  9511.          "Required authentication method (Kerberos 4) is not installed"
  9512.                    ));
  9513.         } else {
  9514.         if ((ck_krb4_tkt_isvalid(tgt) <= 0) &&
  9515.             (!krb4_autoget ||
  9516.              krb4_autoget && !ck_krb4_autoget_TGT(realm))) {
  9517.             return(cx_fail(msg,
  9518.                "Kerberos 4: Ticket Getting Ticket not valid"));
  9519.         }
  9520.         }
  9521.     }
  9522. #endif /* KRB4 */
  9523. #ifdef KRB5
  9524.     if (ttnproto == NP_K5LOGIN || ttnproto == NP_EK5LOGIN ||
  9525.         ttnproto == NP_K5U2U)
  9526.     {
  9527.         extern int krb5_autoget;
  9528.         char tgt[256];
  9529.         char * realm;
  9530.  
  9531.         /* Must get full hostname before calling ttopen() */
  9532.  
  9533.         realm = ck_krb5_realmofhost(ckgetfqhostname(hostname));
  9534.         ckmakmsg(tgt,256,"krbtgt/",realm,"@",realm);
  9535.  
  9536.         if (!ck_krb5_is_installed()) {
  9537.         return(cx_fail(msg,
  9538.                  "Required authentication method (Kerberos 5) not installed"));
  9539.         } else if (!((ck_krb5_tkt_isvalid(NULL,tgt) > 0) ||
  9540.               ck_krb5_is_tgt_valid()) &&
  9541.                (!krb5_autoget ||
  9542.             krb5_autoget && !ck_krb5_autoget_TGT(realm))) {
  9543.         return(cx_fail(msg,
  9544.                "Kerberos 5: Ticket Getting Ticket not valid."));
  9545.         }
  9546.     }
  9547. #endif /* KRB5 */
  9548. #endif /* CK_KERBEROS */
  9549. #endif /* RLOGCODE */
  9550.  
  9551. #ifndef NOSPL
  9552. #ifdef RLOGCODE
  9553.     if (username) {
  9554.         if (!sl_uid_saved) {
  9555.         ckstrncpy(sl_uidbuf,uidbuf,UIDBUFLEN);
  9556.         sl_uid_saved = 1;
  9557.         }
  9558.         ckstrncpy(uidbuf,username,UIDBUFLEN);
  9559.         uidflag = 1;
  9560.     }
  9561. #endif /* RLOGCODE */
  9562. #ifdef TNCODE
  9563.     if (!sl_tn_saved) {
  9564.         sl_tn_wait = tn_wait_flg;
  9565.         sl_tn_saved = 1;
  9566.     }
  9567.     tn_wait_flg = param3;
  9568. #endif /* TNCODE */
  9569. #endif /* NOSPL */
  9570.     } /* if (net == NET_TCPB) */
  9571. #endif /* TCPSOCKET */
  9572.  
  9573. #ifndef NOSPL
  9574. #ifdef CK_SECURITY
  9575.     if (password) {
  9576.         if (password[0]) {
  9577.         ckstrncpy(pwbuf,password,PWBUFL+1);
  9578.         pwflg = 1;
  9579.         pwcrypt = 0;
  9580.         } else
  9581.         pwflg = 0;
  9582.     }
  9583. #endif /* CK_SECURITY */
  9584. #endif /* NOSPL */
  9585.  
  9586.     /* Try to open - network */
  9587.     ckstrncpy(ttname,line,TTNAMLEN);
  9588.     y = ttopen(line, &_local, mdmtyp, 0 );
  9589.  
  9590. #ifndef NOHTTP
  9591.     /*  If the connection failed and we are using an HTTP Proxy
  9592.      *  and the reason for the failure was an authentication
  9593.      *  error, then we need to give the user to ability to
  9594.      *  enter a username and password, just like a browser.
  9595.      *
  9596.      *  I tried to do all of this within the netopen() call
  9597.      *  but it is much too much work.
  9598.      */
  9599.     while (y < 0 && tcp_http_proxy != NULL ) {
  9600.  
  9601.         if (tcp_http_proxy_errno == 401 ||
  9602.         tcp_http_proxy_errno == 407 ) {
  9603.         char uid[UIDBUFLEN];
  9604.         char pwd[256];
  9605.                 struct txtbox tb[2];
  9606.                 int ok;
  9607.  
  9608.                 tb[0].t_buf = uid;
  9609.                 tb[0].t_len = UIDBUFLEN;
  9610.                 tb[0].t_lbl = "Proxy Userid: ";
  9611.                 tb[0].t_dflt = NULL;
  9612.                 tb[0].t_echo = 1;
  9613.                 tb[1].t_buf = pwd;
  9614.                 tb[1].t_len = 256;
  9615.                 tb[1].t_lbl = "Proxy Passphrase: ";
  9616.                 tb[1].t_dflt = NULL;
  9617.                 tb[1].t_echo = 2;
  9618.  
  9619.                 ok = uq_mtxt("Proxy Server Authentication Required\n",
  9620.                               NULL, 2, tb);
  9621.  
  9622.         if (ok && uid[0]) {
  9623.             char * proxy_user, * proxy_pwd;
  9624.  
  9625.             proxy_user = tcp_http_proxy_user;
  9626.             proxy_pwd  = tcp_http_proxy_pwd;
  9627.  
  9628.             tcp_http_proxy_user = uid;
  9629.             tcp_http_proxy_pwd = pwd;
  9630.  
  9631.             ckstrncpy(ttname,line,TTNAMLEN);
  9632.             y = ttopen(line, &_local, mdmtyp, 0);
  9633.             memset(pwd,0,sizeof(pwd));
  9634.             tcp_http_proxy_user = proxy_user;
  9635.             tcp_http_proxy_pwd = proxy_pwd;
  9636.         } else
  9637.           break;
  9638.         } else
  9639.           break;
  9640.     }
  9641. #endif /* NOHTTP */
  9642.     if (y < 0) {
  9643.         slrestor();
  9644.         makestr(&slmsg,"Network connection failure");
  9645. #ifdef VMS
  9646.         if (msg && hints && !xcmdsrc && IS_RLOGIN()) {
  9647.         makestr(&slmsg,"RLOGIN failure");
  9648.         if  (socket_errno == EACCES) {
  9649.             printf("*************************\n");
  9650.             printf(
  9651.        "Hint: RLOGIN requires privileges to open an outbound port.\n");
  9652.             printf(
  9653.             "(Use SET HINTS OFF to suppress future hints.)\n");
  9654.             printf("*************************\n");
  9655.         }
  9656.         }
  9657. #else  /* Not VMS... */
  9658.         if (errno) {
  9659.         int x;
  9660.         debug(F111,"set host line, errno","",errno);
  9661.         makestr(&slmsg,ck_errstr());
  9662.         if (msg) {
  9663. #ifdef OS2
  9664.             printf("Can't connect to %s\n",line);
  9665. #else /* OS2 */
  9666. #ifdef UNIX
  9667.             if (hints && !xcmdsrc && IS_RLOGIN()) {
  9668.             makestr(&slmsg,"RLOGIN failure");
  9669.             printf("*************************\n");
  9670.             printf(
  9671.      "Hint: RLOGIN requires privileges to open an outbound port.\n");
  9672.             printf(
  9673.      "(Use SET HINTS OFF to suppress future hints.)\n");
  9674.             printf("*************************\n");
  9675.             }
  9676. #endif /* UNIX */
  9677. #endif /* OS2 */
  9678.         } else printf("Can't connect to %s\n",line);
  9679.         } else
  9680. #endif /* VMS */
  9681.           if (msg) printf("Can't open connection to %s\n",line);
  9682.         continue;
  9683.     } else {
  9684.         success = 1;
  9685. #ifndef NODIAL
  9686.         dialsta = DIA_UNK;
  9687. #endif /* NODIAL */
  9688.         switch (net) {
  9689.           case NET_TCPA:
  9690.           case NET_TCPB:
  9691.         cxtype = CXT_TCPIP;
  9692. #ifdef COMMENT
  9693. /* This works but it messes up interactive anonymous login */
  9694. #ifndef NOXFER
  9695. #ifdef IKS_OPTION
  9696.         /* If we have connected to an Internet Kermit service */
  9697.         /* and a /USER: switch was given, then log in. */
  9698.  
  9699.         if (TELOPT_U(TELOPT_KERMIT) || TELOPT_ME(TELOPT_KERMIT)) {
  9700.             debug(F111,"cx_net IKSD /USER:",uidbuf,haveuser);
  9701.             if (haveuser /* && cx == 0 */ ) { /* /USER: given */
  9702.             char * psw = pwbuf; /* Do we have a password? */
  9703.             if (!*psw) {        /* No... */
  9704.                 if (!strcmp(uidbuf,"anonymous") ||
  9705.                 !strcmp(uidbuf,"ftp")) {
  9706.                 extern char myhost[];
  9707.                 char * u = (char *)sl_uidbuf;
  9708.                 char * h = (char *)myhost;
  9709.                 if (!*u) u = "nobody";
  9710.                 if (!*h) h = "nowhere";
  9711.                 ckmakmsg(tmpbuf,TMPBUFSIZ,u,"@",h,NULL);
  9712.                 psw = tmpbuf;
  9713.                 debug(F110,"cx_net IKSD anon",psw,0);
  9714.                 } else {
  9715.                 readpass(" Password: ",pwbuf,PWBUFL);
  9716.                 }
  9717.             }
  9718.             sstate = setgen('I',uidbuf,psw,"");
  9719.             }
  9720.         }
  9721. #endif /* IKS_OPTION */
  9722. #endif /* NOXFER */
  9723. #endif /* COMMENT */
  9724.         break;
  9725.           case NET_SSH:
  9726.         cxtype = CXT_SSH;
  9727.         duplex = 0;         /* Remote echo */
  9728.         break;
  9729.           case NET_SLAT:
  9730.         cxtype = CXT_LAT;
  9731.         break;
  9732.           case NET_SX25:
  9733.           case NET_IX25:
  9734.           case NET_HX25:
  9735.           case NET_VX25:
  9736.         cxtype = CXT_X25;
  9737.         break;
  9738.           case NET_BIOS:
  9739.         cxtype = CXT_NETBIOS;
  9740.         break;
  9741.           case NET_FILE:
  9742.           case NET_PIPE:
  9743.           case NET_CMD:
  9744.           case NET_DLL:
  9745.           case NET_PTY:
  9746.         cxtype = CXT_PIPE;
  9747.         break;
  9748.           default:
  9749.         cxtype = CXT_PIPE;
  9750.         break;
  9751.         }
  9752.         break;
  9753.     }
  9754.     } /* for-loop */
  9755.     s = line;
  9756.  
  9757.     debug(F101,"cx_net post ttopen success","",success);
  9758.     if (!success) {
  9759.         local = dfloc;                  /* Go back to normal */
  9760. #ifndef MAC
  9761.         ckstrncpy(ttname,dftty,TTNAMLEN); /* Restore default tty name */
  9762. #endif /* MAC */
  9763.         speed = ttgspd();
  9764.         network = 0;                    /* No network connection active */
  9765.         haveline = 0;
  9766.         if (mdmtyp < 0) {               /* Switching from net to async? */
  9767.             if (mdmsav > -1)            /* Restore modem type from last */
  9768.               mdmtyp = mdmsav;          /* SET MODEM command, if any. */
  9769.             else
  9770.               mdmtyp = 0;
  9771.             mdmsav = -1;
  9772.         }
  9773.         return(0);                      /* Return failure */
  9774.     }
  9775.     if (_local > -1) local = _local;    /* Opened ok, set local/remote. */
  9776.     makestr(&slmsg,NULL);
  9777.     network = (mdmtyp < 0);             /* Remember connection type. */
  9778.     ckstrncpy(ttname,s,TTNAMLEN);       /* Copy name into real place. */
  9779.     debug(F110,"cx_net ok",ttname,0);
  9780.     debug(F101,"cx_net network","",network);
  9781. #ifndef NOXFER
  9782.     if ((reliable != SET_OFF || !setreliable)) /* Assume not reliable. */
  9783.       reliable = SET_OFF;
  9784. #endif /* NOXFER */
  9785.     if (!network || istncomport())    
  9786.       speed = ttgspd();                 /* Get the current speed. */
  9787.     debug(F101,"cx_net local","",local);
  9788.     if (network) {
  9789.         debug(F101,"cx_net net","",net);
  9790. #ifndef NOXFER
  9791.         /* Force prefixing of 255 on TCP/IP connections... */
  9792.         if (net == NET_TCPB
  9793. #ifdef SSHBUILTIN
  9794.              || net == NET_SSH
  9795. #endif /* SSHBUILTIN */
  9796.              ) {
  9797.             debug(F101,"cx_net reliable A","",reliable);
  9798. #ifdef CK_SPEED
  9799.             ctlp[(unsigned)255] = 1;
  9800. #endif /* CK_SPEED */
  9801.             if ((reliable != SET_OFF || !setreliable)) {
  9802. #ifdef TN_COMPORT
  9803.                 if (istncomport()) {    /* Telnet communication port */
  9804.                     reliable = SET_OFF; /* Transport is not reliable */
  9805.                     debug(F101,"cx_net reliable istncomport()","",1);
  9806.                 } else {
  9807.                     reliable = SET_ON;  /* Transport is reliable end to end */
  9808.                     debug(F101,"cx_net reliable istncomport()","",0);
  9809.                 }
  9810. #else
  9811.                 reliable = SET_ON;      /* Transport is reliable end to end */
  9812. #endif /* ifdef TN_COMPORT */
  9813.             }
  9814.             debug(F101,"cx_net reliable B","",reliable);
  9815.         } else if (net == NET_SX25 ||
  9816.                    net == NET_VX25 ||
  9817.                    net == NET_IX25 ||
  9818.                    net == NET_HX25) {
  9819.             duplex = 1;                 /* Local echo for X.25 */
  9820.             if (reliable != SET_OFF || !setreliable)
  9821.               reliable = SET_ON;        /* Transport is reliable end to end */
  9822.         }
  9823. #endif /* NOXFER */
  9824.     }
  9825. #ifndef NOXFER
  9826.     debug(F101,"cx_net reliable","",reliable);
  9827. #endif /* NOXFER */
  9828. #ifdef OS2
  9829.     if (mdmtyp <= 0)                    /* Network or Direct Connection */
  9830.       DialerSend(OPT_KERMIT_CONNECT, 0);
  9831. #endif /* OS2 */
  9832.  
  9833.   xcx_net:
  9834.  
  9835.     setflow();                          /* Set appropriate flow control */
  9836.  
  9837.     haveline = 1;
  9838. #ifdef CKLOGDIAL
  9839.     dolognet();
  9840. #endif /* CKLOGDIAL */
  9841.  
  9842. #ifndef NOSPL
  9843.     if (local) {
  9844.         if (nmac) {                     /* Any macros defined? */
  9845.             int k;                      /* Yes */
  9846.             k = mlook(mactab,"on_open",nmac);   /* Look this up */
  9847.             if (k >= 0) {                       /* If found, */
  9848.                 if (dodo(k,ttname,0) > -1)      /* set it up, */
  9849.                   parser(1);                    /* and execute it */
  9850.             }
  9851.         }
  9852.     }
  9853. #endif /* NOSPL */
  9854.  
  9855.     if (local && (cx || sx)) {          /* /CONNECT or /SERVER switch given */
  9856.         if (cx) {                       /* /CONNECT */
  9857.         if (!gui) {
  9858.         /* Command was confirmed so we can pre-pop command level.  */
  9859.         /* This is so CONNECT module won't think we're executing a */
  9860.         /* script if CONNECT was the final command in the script.  */
  9861.         if (cmdlvl > 0)
  9862.           prepop();
  9863.         }
  9864. #ifndef NODIAL
  9865.             dialsta = DIA_UNK;
  9866. #endif /* NODIAL */
  9867. #ifdef LOCUS
  9868.             if (autolocus) {
  9869.         setlocus(1,1);
  9870.             }
  9871. #endif /* LOCUS */
  9872.             success = doconect(0, cmdlvl == 0 ? 1 : 0);
  9873.             if (ttchk() < 0)
  9874.               dologend();
  9875.         debug(F101,"cx_net post doconect success","",success);
  9876.             return(success);
  9877. #ifndef NOXFER
  9878.         } else if (sx) {                /* /SERVER */
  9879.             sstate = 'x';
  9880. #ifdef MAC
  9881.             what = W_RECV;
  9882.             scrcreate();
  9883. #endif /* MAC */
  9884.             if (local) displa = 1;
  9885. #ifdef AMIGA
  9886.             reqoff();                   /* No DOS requestors while server */
  9887. #endif /* AMIGA */
  9888. #endif /* NOXFER */
  9889.         }
  9890.     }
  9891. #ifndef NODIAL
  9892.     dialsta = DIA_UNK;
  9893. #endif /* NODIAL */
  9894. #ifdef LOCUS
  9895.     if (autolocus) {
  9896.         setlocus(1,1);
  9897.     }
  9898. #endif /* LOCUS */
  9899.     return(success = 1);
  9900. }
  9901. #endif /* NETCONN */
  9902.  
  9903. /* c x _ s e r i a l  --  Make a serial connection */
  9904.  
  9905. /*
  9906.   Call with:
  9907.     device  = string pointer to device name.
  9908.     cx      = 1 to automatically enter Connect mode, 0 otherwise.
  9909.     sx      = 1 to automatically enter Server mode, 0 otherwise.
  9910.     shr     = 1 if device should be opened in shareable mode, 0 otherwise.
  9911.     flag    = if no dev name given: 1 = close current connection, 0 = resume.
  9912.     gui     = 1 if called from GUI dialog, 0 otherwise.
  9913.   Returns:
  9914.     1 on success
  9915.     0 on failure and no message printed, slmsg set to failure message.
  9916.    -9 on failure and message printed, ditto.
  9917. */
  9918.  
  9919. /* these are bit flags */
  9920. #define CX_TAPI 1
  9921. #define CX_PPP  2
  9922. #define CX_SLIP 4
  9923.  
  9924. int
  9925. #ifdef CK_ANSIC
  9926. cx_serial(char *device, 
  9927.           int cx, int sx, int shr, int flag, int gui, int special)
  9928. #else /* CK_ANSIC */
  9929. cx_serial(device, cx, sx, shr, flag, gui, special)
  9930.     char * device; int cx, sx, shr, flag, gui, special; 
  9931. #endif /* CK_ANSIC */
  9932. /* cx_serial */ {
  9933.     int i, n, x, y, msg;
  9934.     int _local = -1;
  9935.     char *s;
  9936.  
  9937.     debug(F110,"cx_serial device",device,0);
  9938.     s = device;
  9939.     msg = (gui == 0) && msgflg;        /* Whether to print messages */
  9940.     success = 0;
  9941.  
  9942. #ifndef NODIAL
  9943.     dialsta = DIA_UNK;
  9944. #endif /* NODIAL */
  9945.     debug(F101,"cx_serial mdmtyp","",mdmtyp);
  9946.     if (clskconnx(1) < 0)        /* Close the Kermit connection */
  9947.       return(success = 0);
  9948.     if (*s) {                /* They gave a device name */
  9949.     _local = -1;            /* Let ttopen decide about it */
  9950.     } else {                /* They just said "set line" */
  9951.     s = dftty;            /* so go back to normal tty */
  9952.     _local = dfloc;            /* and mode. */
  9953.     }
  9954. #ifdef VMS
  9955.     {
  9956.     extern int ok_to_share;
  9957.     ok_to_share = shr;
  9958.     }
  9959. #endif /* VMS */
  9960.  
  9961. #ifdef OS2                              /* Must wait until after ttclos() */
  9962. #ifdef NT                               /* to change these settings       */
  9963. #ifdef CK_TAPI
  9964.     tttapi = special & CX_TAPI;
  9965. #endif /* CK_TAPI */
  9966. #else
  9967.     ttslip = special & CX_SLIP;
  9968.     ttppp  = special & CX_PPP;
  9969. #endif /* NT */
  9970.     ttshare = shr;            /* Shareable device ? */
  9971.     debug(F110,"OS2 SET PORT final s",s,"");
  9972. #endif /* OS2 */
  9973.  
  9974.     /* Open the new line */        
  9975.  
  9976.     ckstrncpy(ttname,s,TTNAMLEN);
  9977.     if ((y = ttopen(s,&_local,mdmtyp,cdtimo)) > -1) {
  9978.     cxtype = (mdmtyp > 0) ? CXT_MODEM : CXT_DIRECT;
  9979. #ifndef NODIAL
  9980.     dialsta = DIA_UNK;
  9981. #ifdef CK_TAPI
  9982.     /* if the line is a tapi device, then we need to auto-execute */
  9983.     /* SET MODEM TYPE TAPI - which we do the equivalent of here.  */
  9984.     if (tttapi) {
  9985.         extern int usermdm;
  9986.         usermdm = 0;
  9987.         initmdm(38);        /* From ckudia.c n_TAPI == 38 */
  9988.     }
  9989. #endif /* CK_TAPI */
  9990. #endif /* NODIAL */
  9991.     success = 1;
  9992.     } else {                /* Failed */
  9993. #ifdef OS2ONLY
  9994.     if (!strcmp(s,dftty))   /* Do not generate an error with dftty */
  9995.       ;
  9996.     else if (y == -6 && ttslip) {
  9997.         makestr(&slmsg,"Can't access SLIP driver");
  9998.         if (msg) printf("?%s\n",slmsg);
  9999.     } else if (y == -6 && ttppp) {
  10000.         makestr(&slmsg,"Can't access PPP driver");
  10001.         if (msg) printf("?%s\n",slmsg);
  10002.     } else
  10003. #endif /* OS2ONLY */
  10004.       if (y == -2) {
  10005.           makestr(&slmsg,"Timed out - no carrier");
  10006.           if (msg) {
  10007.           printf("?%s\n",slmsg);
  10008.           if (hints) {
  10009.               printf("\n*************************\n");
  10010.               printf(
  10011.                "HINT (Use SET HINTS OFF to suppress future hints):\n");
  10012.               printf(
  10013.               "Try SET CARRIER OFF and SET LINE again, or else\n");
  10014.               printf("SET MODEM, SET LINE, and then DIAL.\n");
  10015.               printf("*************************\n\n");
  10016.           }
  10017.           }
  10018.       } else if (y == -3) {
  10019.           makestr(&slmsg,"Access to lock denied");
  10020.           if (msg) {
  10021. #ifdef UNIX
  10022.           printf(
  10023.            "Sorry, write access to UUCP lockfile directory denied.\n");
  10024. #ifndef NOHINTS
  10025.           if (hints) {
  10026.               printf("\n*************************\n");
  10027.               printf(
  10028.                "HINT (Use SET HINTS OFF to suppress future hints):\n");
  10029.               printf(
  10030.       "Please read the installation instructions file, %sckuins.txt,\n",
  10031.                          k_info_dir ? k_info_dir : ""
  10032.                              );
  10033.               printf(
  10034.       "or the UNIX appendix of the manual, \"Using C-Kermit\"\n"
  10035.                              );
  10036.               printf(
  10037.           "or visit http://www.columbia.edu/kermit/ckuins.html \n"
  10038.                              );
  10039.               printf("*************************\n\n");
  10040.           }
  10041. #endif /* NOHINTS */
  10042. #else
  10043.           printf("Sorry, access to lock denied: %s\n",s);
  10044. #endif /* UNIX */
  10045.           }
  10046.       } else if (y == -4) {
  10047.           makestr(&slmsg,"Access to device denied");
  10048.           if (msg) {
  10049.           printf("Sorry, access to device denied: %s\n",s);
  10050. #ifdef UNIX
  10051. #ifndef NOHINTS
  10052.           if (hints) {
  10053.               printf("\n*************************\n");
  10054.               printf(
  10055.               "HINT (Use SET HINTS OFF to suppress future hints):\n");
  10056.               printf(
  10057.         "Please read the installation instructions file, %sckuins.txt,\n",
  10058.                              k_info_dir ? k_info_dir : ""
  10059.                              );
  10060.               printf(
  10061.         "or the UNIX appendix of the manual, \"Using C-Kermit\".\n"
  10062.                              );
  10063.               printf("*************************\n\n");
  10064.           }
  10065. #endif /* NOHINTS */
  10066. #endif /* UNIX */
  10067.           }
  10068.       } else if (y == -5) {
  10069.           makestr(&slmsg,"Device is in use or unavailable");
  10070.           if (msg)
  10071. #ifdef VMS
  10072.         printf(
  10073.           "Sorry, device is in use or otherwise unavailable: %s\n",s);
  10074. #else
  10075.           printf("Sorry, device is in use: %s\n",s);
  10076. #endif /* VMS */
  10077.       } else {            /* Other error. */
  10078.           makestr(&slmsg,"Device open failed");
  10079.           if (
  10080. #ifdef VMS
  10081.           1
  10082. #else
  10083.           errno
  10084. #endif /* VMS */
  10085.           ) {
  10086.           int x;        /* Find a safe, long buffer */
  10087.           makestr(&slmsg,ck_errstr());
  10088. #ifndef VMS
  10089.           debug(F111,"cx_serial serial errno",slmsg,errno);
  10090. #endif /* VMS */
  10091.           if (msg)
  10092.             printf("Connection to %s failed: %s\n",s,slmsg);
  10093.           } else if (msg)
  10094.         printf("Sorry, can't open connection: %s\n",s);
  10095.       }
  10096.     }
  10097.     network = 0;            /* No network connection active */
  10098.     speed = ttgspd();
  10099.     if (!success) {
  10100.         local = dfloc;                  /* Go back to normal */
  10101. #ifndef MAC
  10102.         ckstrncpy(ttname,dftty,TTNAMLEN); /* Restore default tty name */
  10103. #endif /* MAC */
  10104.         haveline = 0;
  10105.         if (mdmtyp < 0) {               /* Switching from net to async? */
  10106.             if (mdmsav > -1)            /* Restore modem type from last */
  10107.               mdmtyp = mdmsav;          /* SET MODEM command, if any. */
  10108.             else
  10109.               mdmtyp = 0;
  10110.             mdmsav = -1;
  10111.         }
  10112.         return(msg ? -9 : 0);        /* Return failure */
  10113.     }
  10114.     if (_local > -1)
  10115.       local = _local;            /* Opened ok, set local/remote. */
  10116.     makestr(&slmsg,NULL);        /* Erase SET LINE message */
  10117.     ckstrncpy(ttname,s,TTNAMLEN);       /* Copy name into real place. */
  10118.     debug(F110,"cx_serial ok",ttname,0);
  10119. #ifndef NOXFER
  10120.     if ((reliable != SET_OFF || !setreliable)) /* Assume not reliable. */
  10121.       reliable = SET_OFF;
  10122. #endif /* NOXFER */
  10123.  
  10124.   xcx_serial:
  10125.     setflow();                          /* Set appropriate flow control */
  10126.     haveline = 1;
  10127. #ifdef CKLOGDIAL
  10128.       dologline();
  10129. #endif /* CKLOGDIAL */
  10130.  
  10131. #ifndef NOSPL
  10132.     if (local) {
  10133.         if (nmac) {                     /* Any macros defined? */
  10134.             int k;                      /* Yes */
  10135.             k = mlook(mactab,"on_open",nmac);   /* Look this up */
  10136.             if (k >= 0) {                       /* If found, */
  10137.                 if (dodo(k,ttname,0) > -1)      /* set it up, */
  10138.                   parser(1);                    /* and execute it */
  10139.             }
  10140.         }
  10141.     }
  10142. #endif /* NOSPL */
  10143.  
  10144.     if (local && (cx || sx)) {          /* /CONNECT or /SERVER switch given */
  10145.         extern int carrier;
  10146.         if (carrier != CAR_OFF) {    /* Looking for carrier? */
  10147.             /* Open() turns on DTR -- wait up to a second for CD to come up */
  10148.             int i, x;
  10149.             for (i = 0; i < 10; i++) {  /* WAIT 1 CD... */
  10150.                 x = ttgmdm();
  10151.                 if (x < 0 || x & BM_DCD)
  10152.                   break;
  10153.                 msleep(100);
  10154.             }
  10155.         }
  10156.         if (cx) {                       /* /CONNECT */
  10157.             /* Command was confirmed so we can pre-pop command level. */
  10158.             /* This is so CONNECT module won't think we're executing a */
  10159.             /* script if CONNECT was the final command in the script. */
  10160.  
  10161.             if (cmdlvl > 0)
  10162.               prepop();
  10163. #ifndef NODIAL
  10164.             dialsta = DIA_UNK;
  10165. #endif /* NODIAL */
  10166. #ifdef LOCUS
  10167.             if (autolocus) {
  10168.                 setlocus(1,1);
  10169.             }
  10170. #endif /* LOCUS */
  10171.             success = doconect(0, cmdlvl == 0 ? 1 : 0);
  10172.             if (ttchk() < 0)
  10173.               dologend();
  10174.             return(success);
  10175. #ifndef NOXFER
  10176.         } else if (sx) {                /* /SERVER */
  10177.             sstate = 'x';
  10178. #ifdef MAC
  10179.             what = W_RECV;
  10180.             scrcreate();
  10181. #endif /* MAC */
  10182.             if (local) displa = 1;
  10183. #ifdef AMIGA
  10184.             reqoff();                   /* No DOS requestors while server */
  10185. #endif /* AMIGA */
  10186. #endif /* NOXFER */
  10187.         }
  10188.     }
  10189. #ifndef NODIAL
  10190.     dialsta = DIA_UNK;
  10191. #endif /* NODIAL */
  10192. #ifdef LOCUS
  10193.     if (autolocus) {
  10194.         setlocus(1,1);
  10195.     }
  10196. #endif /* LOCUS */
  10197.     return(success = 1);
  10198. }
  10199.  
  10200.  
  10201. /* S E T L I N -- parse name of and then open communication device. */
  10202. /*
  10203.   Call with:
  10204.     xx == XYLINE for a serial (tty) line, XYHOST for a network host,
  10205.     zz == 0 means if user doesn't give a device name, continue current
  10206.             active connection (if any);
  10207.     zz != 0 means if user doesn't give a device name, then close the
  10208.             current connection and restore the default communication device.
  10209.     fc == 0 to just make the connection, 1 to also CONNECT (e.g. "telnet").
  10210. */
  10211. int
  10212. setlin(xx, zz, fc) 
  10213.     int xx, zz, fc; 
  10214. {
  10215.     extern char pwbuf[], * g_pswd;
  10216.     extern int pwflg, pwcrypt, g_pflg, g_pcpt, nolocal;
  10217.     int wait;
  10218.     /* int tn_wait_sv; */
  10219.     int mynet;
  10220.     int _local = -1;
  10221.     int c, i, haveswitch = 0;
  10222.     int haveuser = 0;
  10223.     int getval = 0;
  10224.     int wild = 0;                       /* Filespec has wildcards */
  10225.     int cx = 0;                         /* Connect after */
  10226.     int sx = 0;                         /* Become server after */
  10227.     int a_type = -1;                    /* Authentication type */
  10228.     int e_type = -1;                    /* Telnet /ENCRYPT type */
  10229. #ifdef CK_ENCRYPTION
  10230.     int encrypt = 0;                    /* Encrypted? */
  10231. #endif /* CK_ENCRYPTION */
  10232.     int shr = 0;                        /* Share serial device */
  10233.     int confirmed = 0;                  /* Command has been entered */
  10234.     struct FDB sw, tx, nx;
  10235. #ifdef OS2
  10236.     struct FDB fl;
  10237. #endif /* OS2 */
  10238.  
  10239.     char * ss;
  10240. #ifdef TCPSOCKET
  10241.     int rawflg = 0;
  10242. #endif /* TCPSOCKET */
  10243.  
  10244.     char srvbuf[SRVBUFSIZ+1];
  10245.  
  10246. #ifdef OS2
  10247. #ifdef NT
  10248.     int xxtapi = 0;
  10249. #else
  10250.     int xxslip = 0, xxppp = 0;
  10251. #endif /* NT */
  10252. #endif /* OS2 */
  10253.  
  10254.     int dossh = 0;
  10255.  
  10256.     debug(F101,"setlin fc","",fc);
  10257.     debug(F101,"setlin zz","",zz);
  10258.     debug(F101,"setlin xx","",xx);
  10259.  
  10260. #ifdef SSHCMD
  10261.     if (xx == XXSSH) {                  /* SSH becomes PTY SSH ... */
  10262.         dossh = 1;
  10263.         xx = XYHOST;
  10264.     } else if (!ckstrcmp("ssh ",line,4,0)) { /* 2010/03/01 */
  10265.         dossh = 1;
  10266.         xx = XYHOST;
  10267.     }
  10268.     debug(F101,"setlin dossh","",dossh);
  10269. #endif /* SSHCMD */
  10270.  
  10271. #ifdef TNCODE
  10272.     /* tn_wait_sv = tn_wait_flg; */
  10273.     wait = tn_wait_flg;
  10274. #else
  10275.     /* tn_wait_sv = 0; */
  10276.     wait = 0;
  10277. #endif /* TNCODE */
  10278.  
  10279.     mynet = nettype;
  10280.  
  10281.     if (nolocal) {
  10282.         makestr(&slmsg,"Making connections is disabled");
  10283.         printf("?Sorry, making connections is disabled\n");
  10284.         return(-9);
  10285.     }
  10286.     if (netsave > -1)
  10287.       nettype = netsave;
  10288.  
  10289.     if (fc != 0 || zz == 0)             /* Preset /CONNECT switch */
  10290.       cx = 1;
  10291.  
  10292.     debug(F101,"setlin cx","",cx);
  10293.  
  10294.     *srvbuf = NUL;
  10295.  
  10296.     line[0] = NUL;
  10297.     s = line;
  10298.  
  10299. #ifdef NETCONN
  10300. #ifdef CK_SECURITY
  10301.     if (tmpstring)
  10302.         makestr(&tmpstring,NULL);
  10303. #endif /* CK_SECURITY */
  10304.     if (tmpusrid)
  10305.         makestr(&tmpusrid,NULL);
  10306. #endif /* NETCONN */
  10307.  
  10308.     autoflow = 1;                       /* Enable automatic flow setting */
  10309.  
  10310.     if (xx == XYHOST) {                 /* SET HOST <hostname> */
  10311. #ifndef NETCONN
  10312.         makestr(&slmsg,"Network connections not supported");
  10313.         printf("?%s\n",slmsg);
  10314.         return(-9);
  10315. #else /* NETCONN */
  10316. #ifndef NOPUSH
  10317.         if ((mynet == NET_CMD || mynet == NET_PTY || dossh) && nopush) {
  10318.             makestr(&slmsg,"Access to external commands is disabled");
  10319.             printf("?Sorry, access to external commands is disabled\n");
  10320.             return(-9);
  10321.         }
  10322. #endif /* NOPUSH */
  10323.  
  10324. #ifdef SSHCMD
  10325.         if (dossh) {                    /* SSH connection via pty */
  10326.             int k;
  10327.         extern int ttyfd;        /* 2010/03/01 */
  10328.             k = ckstrncpy(line, sshcmd ? sshcmd : defsshcmd, LINBUFSIZ);
  10329.             debug(F111,"setlin sshcmd 1",line,k);
  10330.             if ((x = cmtxt("Optional switches and hostname","",&s,xxstring))<0)
  10331.               return(x);
  10332.  
  10333.             /* 2010-03-30 */
  10334.         if (!*s && ttyfd < 0 && !ckstrcmp("ssh ",ttname,4,0)) { 
  10335.         x = ckstrncpy(line,ttname,LINBUFSIZ);
  10336.         } else {
  10337.         if (!*s) {
  10338.             printf("?SSH to where?\n");
  10339.             return(-9);
  10340.         }
  10341.         if (k < LINBUFSIZ) {
  10342.             line[k++] = SP;
  10343.             line[k] = NUL;
  10344.             debug(F111,"setlin sshcmd 2",line,k);
  10345.         } if (k < LINBUFSIZ) {
  10346.             ckstrncpy(&line[k],s,LINBUFSIZ-k);
  10347.             debug(F111,"setlin sshcmd 3",line,k);
  10348.         } else {
  10349.             printf("?Too long\n");
  10350.             return(-9);
  10351.         }
  10352.         }
  10353.         x = cx_net( NET_PTY,                /* network type */
  10354.                         0,                      /* protocol (not used) */
  10355.                         line,                   /* host */
  10356.                         NULL,                   /* service (not used) */
  10357.                         NULL,                   /* username (not used) */
  10358.                         NULL,                   /* password (not used) */
  10359.                         NULL,                   /* command (not used) */
  10360.                         -1,-1,-1,               /* params 1-3 (not used) */
  10361.                         1,                      /* connect immediately */
  10362.                         sx,                     /* server? */
  10363.                         zz,                     /* close current? */
  10364.                         0);                     /* not gui */
  10365.         debug(F111,"setlin cx_net",line,x);
  10366.         return(x);
  10367.         }
  10368. #endif /* SSHCMD */
  10369.  
  10370. /*
  10371.   Here we parse optional switches and then the hostname or whatever,
  10372.   which depends on the network type.  The tricky part is, the network type
  10373.   can be set by a switch.
  10374. */
  10375. #ifndef NOSPL
  10376.         makestr(&g_pswd,pwbuf);         /* Save global pwbuf */
  10377.         g_pflg = pwflg;                 /* and flag */
  10378.         g_pcpt = pwcrypt;
  10379. #endif /* NOSPL */
  10380.  
  10381.         confirmed = 0;
  10382.         haveswitch = 0;
  10383. #ifdef NETFILE
  10384.         if (mynet != NET_FILE) {
  10385. #endif /* NETFILE */
  10386.             ss = (mynet == NET_CMD || mynet == NET_PTY) ?
  10387.               "Command, or switch" :
  10388.                 (mynet == NET_TCPA || mynet == NET_TCPB
  10389.                   || mynet == NET_SSH) ?
  10390.                   "Hostname, ip-address, or switch" :
  10391.                     "Host or switch";
  10392.             if (fc) {
  10393.                 if (mynet == NET_TCPB &&
  10394.                     (ttnproto == NP_TELNET || ttnproto == NP_KERMIT)) {
  10395.                     if (nshteltab) {
  10396.                         haveswitch++;
  10397.                         cmfdbi(&sw,_CMKEY,ss,"","",nshteltab,4,xxstring,
  10398.                              shteltab,&nx);
  10399.                     }
  10400.                 }
  10401. #ifdef RLOGCODE
  10402.                 else if (mynet == NET_TCPB && ttnproto == NP_RLOGIN) {
  10403.                     if (nshrlgtab) {
  10404.                         haveswitch++;
  10405.                         cmfdbi(&sw,_CMKEY,ss,"","",nshrlgtab,4,xxstring,
  10406.                                shrlgtab,&nx);
  10407.                     }
  10408.                 }
  10409. #endif /* RLOGCODE */
  10410.             } else {
  10411.                 haveswitch++;
  10412.                 cmfdbi(&sw,_CMKEY,ss,"","",nshtab,4,xxstring,shtab,&nx);
  10413.             }
  10414. #ifdef NETFILE
  10415.         }
  10416. #endif /* NETFILE */
  10417.         if (mynet == NET_TCPB || mynet == NET_SLAT ||
  10418.         mynet == NET_SSH  || mynet == NET_DEC) {
  10419.             cmfdbi(&nx,_CMFLD,"Host","","",0,0,xxstring,NULL,NULL);
  10420. #ifdef NETFILE
  10421.         } else if (mynet == NET_FILE) {
  10422.             cmfdbi(&nx,_CMIFI,"Filename","","",0,0,xxstring,NULL,NULL);
  10423. #endif /* NETFILE */
  10424. #ifdef PTYORPIPE
  10425.         } else if (mynet == NET_CMD || mynet == NET_PTY) {
  10426.             cmfdbi(&nx,_CMTXT,"Command","","",0,0,xxstring,NULL,NULL);
  10427. #endif /* PTYORPIPE */
  10428.         } else {
  10429.             cmfdbi(&nx,_CMTXT,"Host","","",0,0,xxstring,NULL,NULL);
  10430.         }
  10431.         while (1) {
  10432.             x = cmfdb(haveswitch ? &sw : &nx);
  10433.             debug(F101,"setlin cmfdb","",x);
  10434.             if (x < 0)
  10435.               if (x != -3)
  10436.                 return(x);
  10437.             if (x == -3) {
  10438.                 if ((x = cmcfm()) < 0) {
  10439.                     return(x);
  10440.                 } else {
  10441.                     confirmed = 1;
  10442.                     break;
  10443.                 }
  10444.             }
  10445.             if (cmresult.fcode != _CMKEY) {    /* Not a switch */
  10446.                 ckstrncpy(line,cmresult.sresult,LINBUFSIZ); /* Save the data */
  10447.                 s = line;                      /* that was parsed... */
  10448.                 if (cmresult.fcode == _CMIFI) {
  10449.                     wild = cmresult.nresult;
  10450.                 } else if (cmresult.fcode == _CMTXT) {
  10451.                     confirmed = 1;
  10452.                 }
  10453.                 break;                  /* and break out of this loop */
  10454.             }
  10455.             c = cmgbrk();               /* Have switch - get break character */
  10456.             getval = (c == ':' || c == '='); /* Must parse an agument? */
  10457.             if (getval && !(cmresult.kflags & CM_ARG)) {
  10458.                 printf("?This switch does not take arguments\n");
  10459.                 return(-9);
  10460.             }
  10461.             if (!getval && (cmgkwflgs() & CM_ARG)) {
  10462.                 printf("?This switch requires an argument\n");
  10463.                 return(-9);
  10464.             }
  10465.             switch (cmresult.nresult) { /* It's a switch.. */
  10466.               case SL_CNX:              /* /CONNECT */
  10467.                 cx = 1;
  10468.                 sx = 0;
  10469.                 break;
  10470.               case SL_SRV:              /* /SERVER */
  10471.                 cx = 0;
  10472.                 sx = 1;
  10473.                 break;
  10474. #ifdef NETCMD
  10475.               case SL_CMD:              /* /COMMAND */
  10476.                 netsave = mynet;
  10477.                 mynet = NET_CMD;
  10478.                 break;
  10479. #endif /* NETCMD */
  10480. #ifdef NETPTY
  10481.               case SL_PTY:              /* /PTY */
  10482.                 netsave = mynet;
  10483.                 mynet = NET_PTY;
  10484.                 break;
  10485. #endif /* NETPTY */
  10486.               case SL_NET:              /* /NETWORK-TYPE */
  10487.                 if ((x = cmkey(netcmd,nnets,"","",xxstring)) < 0)
  10488.                   return(x);
  10489.                 mynet = x;
  10490.                 break;
  10491.  
  10492. #ifdef CK_SECURITY
  10493.               case SL_PSW:              /* /PASSWORD: */
  10494.                 if (!getval)
  10495.                   break;
  10496.                 debok = 0;
  10497.                 if ((x = cmfld("Password","",&s,xxstring)) < 0) {
  10498.                     if (x == -3) {
  10499.                         makestr(&tmpstring,"");
  10500.                     } else {
  10501.                         return(x);
  10502.                     }
  10503.                 } else {
  10504.                     s = brstrip(s);
  10505.                     if ((x = (int)strlen(s)) > PWBUFL) {
  10506.                         makestr(&slmsg,"Internal error");
  10507.                         printf("?Sorry, too long - max = %d\n",PWBUFL);
  10508.                         return(-9);
  10509.                     }
  10510.                     makestr(&tmpstring,s);
  10511.                 }
  10512.                 break;
  10513. #endif /* CK_SECURITY */
  10514.  
  10515.               case SL_UID:              /* /USERID: */
  10516.                 if (!getval)
  10517.                   break;
  10518.                 if ((x = cmfld("Userid","",&s,xxstring)) < 0) {
  10519.                     if (x == -3) {
  10520.                         makestr(&tmpusrid,"");
  10521.                     } else {
  10522.                         return(x);
  10523.                     }
  10524.                 } else {
  10525.                     s = brstrip(s);
  10526.                     if ((x = (int)strlen(s)) > 63) {
  10527.                         makestr(&slmsg,"Internal error");
  10528.                         printf("?Sorry, too long - max = %d\n",63);
  10529.                         return(-9);
  10530.                     }
  10531.                     makestr(&tmpusrid,s);
  10532.                     haveuser = 1;
  10533.                 }
  10534.                 break;
  10535.  
  10536. #ifdef CK_AUTHENTICATION
  10537. #ifdef CK_SRP
  10538.               case SL_SRP:
  10539.                 a_type = AUTHTYPE_SRP;
  10540.                 break;
  10541. #endif /* CK_SRP */
  10542. #ifdef CK_SSL
  10543.               case SL_SSL:
  10544.                 a_type = AUTHTYPE_SSL;
  10545.                 break;
  10546. #endif /* CK_SSL */
  10547. #ifdef NT
  10548.               case SL_NTLM:
  10549.                 a_type = AUTHTYPE_NTLM;
  10550.                 break;
  10551. #endif /* NT */
  10552. #ifdef CK_KERBEROS
  10553.               case SL_KRB4:
  10554.                 a_type = AUTHTYPE_KERBEROS_V4;
  10555.                 if (ttnproto == NP_RLOGIN)
  10556.                   ttnproto =
  10557. #ifdef CK_ENCRYPTION
  10558.                     encrypt ? NP_EK4LOGIN :
  10559. #endif /* CK_ENCRYPTION */
  10560.                       NP_K4LOGIN;
  10561.                 else if (ttnproto == NP_K5LOGIN)
  10562.                   ttnproto = NP_K4LOGIN;
  10563. #ifdef CK_ENCRYPTION
  10564.                 else if (ttnproto == NP_EK5LOGIN)
  10565.                   ttnproto = NP_EK4LOGIN;
  10566. #endif /* CK_ENCRYPTION */
  10567.                 break;
  10568.               case SL_KRB5:
  10569.                 a_type = AUTHTYPE_KERBEROS_V5;
  10570.                 if (ttnproto == NP_RLOGIN)
  10571.                   ttnproto =
  10572. #ifdef CK_ENCRYPTION
  10573.                     encrypt ? NP_EK5LOGIN :
  10574. #endif /* CK_ENCRYPTION */
  10575.                       NP_K5LOGIN;
  10576.                 else if (ttnproto == NP_K4LOGIN)
  10577.                   ttnproto = NP_K5LOGIN;
  10578. #ifdef CK_ENCRYPTION
  10579.                 else if (ttnproto == NP_EK4LOGIN)
  10580.                   ttnproto = NP_EK5LOGIN;
  10581. #endif /* CK_ENCRYPTION */
  10582.                 break;
  10583. #endif /* CK_KERBEROS */
  10584.               case SL_AUTH: {
  10585.                   extern struct keytab autyptab[];
  10586.                   extern int nautyp;
  10587.                   if ((x = cmkey(autyptab,nautyp,"type of authentication",
  10588.                                  "automatic",xxstring)) < 0)
  10589.                     return(x);
  10590.                   a_type = x;
  10591.                   break;
  10592.               }
  10593. #endif /* CK_AUTHENTICATION */
  10594. #ifdef CK_ENCRYPTION
  10595.               case SL_ENC:
  10596.                 switch (ttnproto) {
  10597.                   case NP_K4LOGIN:
  10598.                     ttnproto = NP_EK4LOGIN;
  10599.                     encrypt = 1;
  10600.                     break;
  10601.                   case NP_K5LOGIN:
  10602.                     ttnproto = NP_EK5LOGIN;
  10603.                     encrypt = 1;
  10604.                     break;
  10605.                   case NP_KERMIT:
  10606.                   case NP_TELNET: {
  10607.                       static struct keytab * tnetbl = NULL;
  10608.                       static int ntnetbl = 0;
  10609.                       x = ck_get_crypt_table(&tnetbl,&ntnetbl);
  10610.                       debug(F101,"ck_get_crypt_table x","",x);
  10611.                       debug(F101,"ck_get_crypt_table n","",ntnetbl);
  10612.                       if (x < 1 || !tnetbl || ntnetbl < 1) /* Didn't get it */
  10613.                         x = 0;
  10614.                       if (!x) {
  10615.                           makestr(&slmsg,"Internal error");
  10616.                           printf("?Oops, types not loaded\n");
  10617.                           return(-9);
  10618.                       }
  10619.                       if ((x = cmkey(tnetbl,ntnetbl,"type of encryption",
  10620.                                      "automatic",xxstring)) < 0)
  10621.                         return(x);
  10622.                       e_type = x;
  10623.                       break;
  10624.                   }
  10625.                 }
  10626.                 break;
  10627. #endif /* CK_ENCRYPTION */
  10628.               case SL_WAIT:
  10629.                 wait = 1;
  10630.                 break;
  10631.               case SL_NOWAIT:
  10632.                 wait = 0;
  10633.                 break;
  10634.             }
  10635.         }
  10636.  
  10637. #ifdef NETFILE
  10638.         if (mynet == NET_FILE) {        /* Parsed by cmifi() */
  10639.         if ((x = cmcfm()) < 0)    /* Needs confirmation */
  10640.           return(x);
  10641.         x = cx_net(mynet,        /* nettype */
  10642.                0,        /* protocol (not used) */
  10643.                line,        /* host */
  10644.                "",        /* port */
  10645.                NULL,        /* alternate username */
  10646.                NULL,        /* password */
  10647.                NULL,        /* command to execute */
  10648.                0,        /* param1 */
  10649.                0,        /* param2 */
  10650.                0,        /* param3 */
  10651.                cx,        /* enter CONNECT mode */
  10652.                sx,        /* enter SERVER mode */
  10653.                zz,        /* close connection if open */
  10654.                0        /* gui */
  10655.                );
  10656.         }
  10657. #endif /* NETFILE */
  10658.  
  10659. #ifdef NETCMD
  10660.         if (mynet == NET_CMD || mynet == NET_PTY) {
  10661.             char *p = NULL;
  10662.             if (!confirmed) {
  10663.                 if ((x = cmtxt("Rest of command","",&s,xxstring)) < 0)
  10664.                   return(x);
  10665.                 if (*s) {
  10666.                     ckstrncat(line," ",LINBUFSIZ);
  10667.                     ckstrncat(line,s,LINBUFSIZ);
  10668.                 }
  10669.                 s = line;
  10670.             }
  10671.             /* s == line - so we must protect the line buffer */
  10672.             s = brstrip(s);
  10673.             makestr(&p,s);
  10674.             ckstrncpy(line,p,LINBUFSIZ);
  10675.             makestr(&p,NULL);
  10676.  
  10677.             x = cx_net( mynet,                  /* nettype */
  10678.                         0,                      /* protocol (not used) */
  10679.                         line,                   /* host */
  10680.                         "",                     /* port */
  10681.                         NULL,                   /* alternate username */
  10682.                         NULL,                   /* password */
  10683.                         NULL,                   /* command to execute */
  10684.                         0,                      /* param1 */
  10685.                         0,                      /* param2 */
  10686.                         0,                      /* param3 */
  10687.                         cx,                     /* enter CONNECT mode */
  10688.                         sx,                     /* enter SERVER mode */
  10689.                         zz,                     /* close connection if open */
  10690.                         0                       /* gui */
  10691.                         );
  10692.         }
  10693. #endif /* NETCMD */
  10694.  
  10695. #ifdef NPIPE                            /* Named pipe */
  10696.         if (mynet == NET_PIPE) {        /* Needs backslash twiddling */
  10697.             if (line[0]) {
  10698.                 if (strcmp(line,"*")) {    /* If remote, begin with */
  10699.                     char * p = NULL;
  10700.                     makestr(&p,line);      
  10701.                     ckstrncpy(line,"\\\\",LINBUFSIZ); /* server name */
  10702.                     ckstrncat(line,p,LINBUFSIZ);
  10703.                     makestr(&p,NULL);      
  10704.                 } else {
  10705.                     line[0]='\0';
  10706.                 }
  10707.                 ckstrncat(line,"\\pipe\\", LINBUFSIZ); /* Make pipe name */
  10708.                 ckstrncat(line,pipename, LINBUFSIZ); /* Add name of pipe */
  10709.  
  10710.                 x = cx_net(mynet,    /* nettype */
  10711.                0,        /* protocol (not used) */
  10712.                line,    /* host */
  10713.                "",        /* port */
  10714.                NULL,    /* alternate username */
  10715.                NULL,    /* password */
  10716.                NULL,    /* command to execute */
  10717.                0,        /* param1 */
  10718.                0,        /* param2 */
  10719.                0,        /* param3 */
  10720.                cx,        /* enter CONNECT mode */
  10721.                sx,        /* enter SERVER mode */
  10722.                zz,        /* close connection if open */
  10723.                0        /* gui */
  10724.                );
  10725.             }
  10726.         }
  10727. #endif /* NPIPE */
  10728.  
  10729. #ifdef SUPERLAT
  10730.         if (mynet == NET_SLAT) {        /* Needs password, etc. */
  10731.             slat_pwd[0] = NUL;          /* Erase any previous password */
  10732.             debok = 0;
  10733.             if (*line) {        /* If they gave a host name... */
  10734.                 if ((x = cmfld(
  10735.                      "password,\n or carriage return if no password required",
  10736.                                "",
  10737.                                &s,
  10738.                                xxstring
  10739.                                )) < 0 && x != -3)
  10740.                   return(x);
  10741.                 ckstrncpy(slat_pwd,s,18); /* Set the password, if any */
  10742.             }
  10743.             if ((x = cmcfm()) < 0) return(x); /* Confirm the command */
  10744.  
  10745.             x = cx_net(mynet,        /* nettype */
  10746.                        0,        /* protocol (not used) */
  10747.                        line,        /* host */
  10748.                        "",        /* port */
  10749.                        NULL,        /* alternate username */
  10750.                        NULL,        /* password */
  10751.                        NULL,        /* command to execute */
  10752.                        0,        /* param1 */
  10753.                        0,        /* param2 */
  10754.                        0,        /* param3 */
  10755.                        cx,        /* enter CONNECT mode */
  10756.                        sx,        /* enter SERVER mode */
  10757.                        zz,        /* close connection if open */
  10758.                        0        /* gui */
  10759.                        );
  10760.         }
  10761. #endif /* SUPERLAT */
  10762.  
  10763. #ifdef DECNET
  10764.         if (mynet == NET_DEC) {  
  10765.             if (!line[0]) {                   /* If they gave a host name... */
  10766.                 printf("?hostname required\n");
  10767.                 return(-3);
  10768.             }
  10769.             if ((x = cmcfm()) < 0) return(x); /* Confirm the command */
  10770.  
  10771.             x = cx_net(mynet,        /* nettype */
  10772.                        0,        /* protocol (not used) */
  10773.                        line,        /* host */
  10774.                        "",        /* port */
  10775.                        NULL,        /* alternate username */
  10776.                        NULL,        /* password */
  10777.                        NULL,        /* command to execute */
  10778.                        0,        /* param1 */
  10779.                        0,        /* param2 */
  10780.                        0,        /* param3 */
  10781.                        cx,        /* enter CONNECT mode */
  10782.                        sx,        /* enter SERVER mode */
  10783.                        zz,        /* close connection if open */
  10784.                        0        /* gui */
  10785.                        );
  10786.         }
  10787. #endif /* DECNET */
  10788.  
  10789. #ifdef SSHBUILTIN
  10790.         if (mynet == NET_SSH) {        /* SSH connection */
  10791.             int k, havehost = 0, trips = 0;
  10792.             int    tmpver = -1, tmpxfw = -1, tmpssh_cas;
  10793. #ifndef SSHTEST
  10794.             extern int sl_ssh_xfw, sl_ssh_xfw_saved;
  10795.             extern int sl_ssh_ver, sl_ssh_ver_saved;
  10796. #endif /* SSHTEST */
  10797.             extern struct keytab sshopnsw[];
  10798.             extern int nsshopnsw;
  10799.             extern char *ssh_tmpcmd, *ssh_tmpport;
  10800.             struct FDB sw, kw, fl;
  10801.  
  10802.             debug(F110,"setlin SSH service 0",srvbuf,0);
  10803.             debug(F110,"setlin SSH host s 2",s,0);
  10804.             if (*s) {           /* If they gave a host name... */
  10805.                 debug(F110,"setlin SSH host s 1",s,0);
  10806.                 if (*s == '*') {
  10807.                     makestr(&slmsg,"Incoming connections not supported");
  10808.                     printf(
  10809.      "?Sorry, incoming connections not supported for SSH.\n"
  10810.                            );
  10811.                     return(-9);
  10812.                 }
  10813.                 ckstrncpy(line,s,LINBUFSIZ);
  10814.             } else {
  10815.                 printf("?hostname required\n");
  10816.                 return(-3);
  10817.             }
  10818.  
  10819.             /* Parse [ port ] [ switches ] */
  10820.             cmfdbi(&kw,                 /* Switches */
  10821.                     _CMKEY,
  10822.                     "Port number or service name,\nor switch",
  10823.                     "",
  10824.                     "",
  10825.                     nsshopnsw,
  10826.                     4,
  10827.                     xxstring,
  10828.                     sshopnsw,
  10829.                     &fl
  10830.                     );
  10831.             cmfdbi(&fl,                 /* Port number or service name */
  10832.                     _CMFLD,
  10833.                     "",
  10834.                     "",
  10835.                     "",
  10836.                     0,
  10837.                     0,
  10838.                     xxstring,
  10839.                     NULL,
  10840.                     NULL
  10841.                     );
  10842.             trips = 0;                  /* Explained below */
  10843.             while (1) {                 /* Parse port and switches */
  10844.                 y = cmfdb(&kw);         /* Get a field */
  10845.                 if (y == -3)            /* User typed CR so quit from loop */
  10846.                     break;
  10847.                 if (y < 0)              /* Other parse error, pass it back */
  10848.                     return(y);
  10849.                 switch (cmresult.fcode) { /* Field or Keyword? */
  10850.                 case _CMFLD:              /* Field */
  10851.                     ckstrncpy(srvbuf,cmresult.sresult,SRVBUFSIZ);
  10852.                     break;
  10853.                 case _CMKEY:            /* Keyword */
  10854.                     switch (cmresult.nresult) { /* Which one? */
  10855.                     case SSHSW_PWD:
  10856.                         if (!cmgbrk()) {
  10857.                             printf("?This switch requires an argument\n");
  10858.                             return(-9);
  10859.                         }
  10860.                         debok = 0;
  10861.                         if ((y = cmfld("Password","",&s,xxstring)) < 0) {
  10862.                             if (y == -3) {
  10863.                                 makestr(&tmpstring,"");
  10864.                             } else {
  10865.                                 return(y);
  10866.                             }
  10867.                         } else {
  10868.                             s = brstrip(s);
  10869.                             if ((y = (int)strlen(s)) > PWBUFL) {
  10870.                                 makestr(&slmsg,"Internal error");
  10871.                                 printf("?Sorry, too long - max = %d\n",PWBUFL);
  10872.                                 return(-9);
  10873.                             }
  10874.                             makestr(&tmpstring,s);
  10875.                         }
  10876.                         break;
  10877.                     case SSHSW_USR:             /* /USER: */
  10878.                         if (!cmgbrk()) {
  10879.                             printf("?This switch requires an argument\n");
  10880.                             return(-9);
  10881.                         }
  10882.                         if ((y = cmfld("Username","",&s,xxstring)) < 0)
  10883.                             return(y);
  10884.                         s = brstrip(s);
  10885.                         makestr(&tmpusrid,s);
  10886.                         break;
  10887.                     case SSHSW_VER:
  10888.                         if ((y = cmnum("Number","",10,&z,xxstring)) < 0)
  10889.                             return(y);
  10890.                         if (z < 1 || z > 2) {
  10891.                             printf("?Out of range: %d\n",z);
  10892.                             return(-9);
  10893.                         }
  10894.                         tmpver = z;
  10895.                         break;
  10896.                     case SSHSW_CMD:
  10897.                     case SSHSW_SUB:
  10898.                         if ((y = cmfld("Text","",&s,xxstring)) < 0)
  10899.                           return(y);
  10900.                         makestr(&ssh_tmpcmd,s);
  10901.                         tmpssh_cas = (cmresult.nresult == SSHSW_SUB);
  10902.                         break;
  10903.                     case SSHSW_X11:
  10904.                         if ((y = cmkey(onoff,2,"","on",xxstring)) < 0)
  10905.                             return(y);
  10906.                         tmpxfw = y;
  10907.                         break;
  10908.                     default:
  10909.                         return(-2);
  10910.                     }
  10911.                 }
  10912.                 if (trips++ == 0) {     /* After first time through */
  10913.                     cmfdbi(&kw,         /* only parse switches, not port. */
  10914.                             _CMKEY,
  10915.                             "Switch",
  10916.                             "",
  10917.                             "",
  10918.                             nsshopnsw,
  10919.                             4,
  10920.                             xxstring,
  10921.                             sshopnsw,
  10922.                             NULL
  10923.                             );
  10924.                 }
  10925.             }
  10926.             if ((y = cmcfm()) < 0)      /* Get confirmation */
  10927.                 return(y);
  10928.  
  10929.             debug(F110,"setlin pre-cx_net line",line,0);
  10930.             debug(F110,"setlin pre-cx_net srvbuf",srvbuf,0);
  10931.             x = cx_net( mynet,                  /* nettype */
  10932.                         0,                      /* protocol (not used) */
  10933.                         line,                   /* host */
  10934.                         srvbuf,                 /* port */
  10935.                         tmpusrid,               /* alternate username */
  10936.                         tmpstring,              /* password */
  10937.                         ssh_tmpcmd,             /* command to execute */
  10938.                         tmpver,                 /* param1 - ssh version */
  10939.                         tmpssh_cas,             /* param2 - ssh cas  */
  10940.                         tmpxfw,                 /* param3 - ssh x11fwd */
  10941.                         cx,                     /* enter CONNECT mode */
  10942.                         sx,                     /* enter SERVER mode */
  10943.                         zz,                     /* close connection if open */
  10944.                         0                       /* gui */
  10945.                         );
  10946.             if (tmpusrid)
  10947.                 makestr(&tmpusrid,NULL);
  10948.             if (ssh_tmpcmd)
  10949.                 makestr(&ssh_tmpcmd,NULL);
  10950.         }
  10951. #endif /* SSHBUILTIN */
  10952.  
  10953. #ifdef TCPSOCKET
  10954.         if (mynet == NET_TCPB) {        /* TCP/IP connection */
  10955.             debug(F110,"setlin service 0",srvbuf,0);
  10956.             debug(F110,"setlin host s 2",s,0);
  10957.             if (*s) {            /* If they gave a host name... */
  10958.                 debug(F110,"setlin host s 1",s,0);
  10959. #ifdef NOLISTEN
  10960.                 if (*s == '*') {
  10961.                     makestr(&slmsg,"Incoming connections not supported");
  10962.                     printf(
  10963.      "?Sorry, incoming connections not supported in this version of Kermit.\n"
  10964.                            );
  10965.                     return(-9);
  10966.                 }
  10967. #endif /* NOLISTEN */
  10968. #ifdef RLOGCODE
  10969.                 /* Allow a username if rlogin is requested */
  10970.                 if (mynet == NET_TCPB &&
  10971.                     (ttnproto == NP_RLOGIN || ttnproto == NP_K5LOGIN ||
  10972.                      ttnproto == NP_EK5LOGIN || ttnproto == NP_K4LOGIN ||
  10973.                      ttnproto == NP_EK4LOGIN
  10974.                     )) {
  10975.                     int y;
  10976.                     uidflag = 0;
  10977.                     /* Check for "host:service" */
  10978.                     for ( ; (*s != '\0') && (*s != ':'); s++) ;
  10979.                     if (*s) {   /* Service, save it */
  10980.                         *s = NUL;
  10981.                         ckstrncpy(srvbuf,++s,SRVBUFSIZ);
  10982.                     } else {            /* No :service, then use default. */
  10983. #ifdef VMS
  10984.                         switch (ttnproto) {
  10985.                           case NP_RLOGIN:
  10986.                             ckstrncpy(srvbuf,"513",SRVBUFSIZ); /* "login" */
  10987.                             break;
  10988.                           case NP_K4LOGIN:
  10989.                           case NP_K5LOGIN:
  10990.                             ckstrncpy(srvbuf,"543",SRVBUFSIZ); /* "klogin" */
  10991.                             break;
  10992.                           case NP_EK4LOGIN:
  10993.                           case NP_EK5LOGIN:
  10994.                             ckstrncpy(srvbuf,"2105",SRVBUFSIZ); /* "eklogin" */
  10995.                             break;
  10996.                         }
  10997. #else /* VMS */
  10998.                         switch (ttnproto) {
  10999.                           case NP_RLOGIN:
  11000.                             ckstrncpy(srvbuf,"login",SRVBUFSIZ);
  11001.                             break;
  11002.                           case NP_K4LOGIN:
  11003.                           case NP_K5LOGIN:
  11004.                             ckstrncpy(srvbuf,"klogin",SRVBUFSIZ);
  11005.                             break;
  11006.                           case NP_EK4LOGIN:
  11007.                           case NP_EK5LOGIN:
  11008.                             ckstrncpy(srvbuf,"eklogin",SRVBUFSIZ);
  11009.                             break;
  11010.                         }
  11011. #endif /* VMS */
  11012.                     }
  11013.                     if (!confirmed) {
  11014.                         y = cmfld("Userid on remote system",
  11015.                                   uidbuf,&s,xxstring);
  11016.                         if (y < 0 && y != -3)
  11017.                           return(y);
  11018.                         if ((int)strlen(s) > 63) {
  11019.                             makestr(&slmsg,"Internal error");
  11020.                             printf("Sorry, too long\n");
  11021.                             return(-9);
  11022.                         }
  11023.                         makestr(&tmpusrid,s);
  11024.                     }
  11025.                 } else {        /* TELNET or SET HOST */
  11026. #endif /* RLOGCODE */
  11027.                     /* Check for "host:service" */
  11028.                     for ( ; (*s != '\0') && (*s != ':'); s++) ;
  11029.                     if (*s) {   /* Service, save it */
  11030.                         *s = NUL;
  11031.                         ckstrncpy(srvbuf,++s,SRVBUFSIZ);
  11032.                     } else if (!confirmed) {
  11033.                         /* No :service, let them type one. */
  11034.                         if (*line != '*') { /* Not incoming */
  11035.                             if (mynet == NET_TCPB && ttnproto == NP_KERMIT) {
  11036.                                 if ((x = cmfld(
  11037.                                                "TCP service name or number",
  11038.                                                "kermit",&s,xxstring)
  11039.                                      ) < 0 && x != -3)
  11040.                                   return(x);
  11041. #ifdef RLOGCODE
  11042.                             } else if (mynet == NET_TCPB &&
  11043.                                        ttnproto == NP_RLOGIN) {
  11044.                                 if ((x = cmfld(
  11045.   "TCP service name or number,\n or carriage return for rlogin (513)",
  11046.                                                "login",&s,xxstring)
  11047.                                      ) < 0 && x != -3)
  11048.                                   return(x);
  11049. #ifdef CK_AUTHENTICATION
  11050. #ifdef CK_KERBEROS
  11051.                             } else if (mynet == NET_TCPB &&
  11052.                                        (ttnproto == NP_K4LOGIN ||
  11053.                                        ttnproto == NP_K5LOGIN)) {
  11054.                                 if ((x = cmfld(
  11055.   "TCP service name or number,\n or carriage return for klogin (543)",
  11056.                                                "klogin",&s,xxstring)
  11057.                                      ) < 0 && x != -3)
  11058.                                   return(x);
  11059.                             } else if (mynet == NET_TCPB &&
  11060.                                        (ttnproto == NP_EK4LOGIN ||
  11061.                                         ttnproto == NP_EK5LOGIN)) {
  11062.                                 if ((x = cmfld(
  11063.   "TCP service name or number,\n or carriage return for eklogin (2105)",
  11064.                                                "eklogin",&s,xxstring)
  11065.                                      ) < 0 && x != -3)
  11066.                                   return(x);
  11067. #endif /* CK_KERBEROS */
  11068. #endif /* CK_AUTHENTICATION */
  11069. #endif /* RLOGCODE */
  11070.                             } else {
  11071.                                 /* Do not set a default value in this call */
  11072.                                 /* If you do then it will prevent entries  */
  11073.                                 /* in the network directory from accessing */
  11074.                                 /* alternate ports.                        */
  11075.  
  11076.                                 if ((x = cmfld(
  11077.                                                "TCP service name or number",
  11078.                                                "",&s,xxstring)
  11079.                                      ) < 0 && x != -3)
  11080.                                   return(x);
  11081.                             }
  11082.                         } else { /* Incoming connection */
  11083.                             if ((x = cmfld("TCP service name or number",
  11084.                                            "",&s,xxstring)
  11085.                                  ) < 0 && x != -3)
  11086.                               return(x);
  11087.                         }
  11088.                         if (*s)         /* If they gave a service, */
  11089.                           ckstrncpy(srvbuf,s,SRVBUFSIZ); /* copy it */
  11090.                         debug(F110,"setlin service 0.5",srvbuf,0);
  11091.                     }
  11092. #ifdef RLOGCODE
  11093.                 }
  11094. #endif /* RLOGCODE */
  11095.                 if (!confirmed) {
  11096.                     char * defproto;
  11097.                     switch (ttnproto) {
  11098.                       case NP_RLOGIN:
  11099.                         defproto = "/rlogin";
  11100.                         break;
  11101.                       case NP_K4LOGIN:
  11102.                         defproto = "/k4login";
  11103.                         break;
  11104.                       case NP_K5LOGIN:
  11105.                         defproto = "/k5login";
  11106.                         break;
  11107.                       case NP_EK4LOGIN:
  11108.                         defproto = "/ek4login";
  11109.                         break;
  11110.                       case NP_EK5LOGIN:
  11111.                         defproto = "/ek5login";
  11112.                         break;
  11113.                       case NP_KERMIT:
  11114.                       case NP_TELNET:
  11115.                         defproto = "/telnet";
  11116.                         break;
  11117.                       default:
  11118.                         defproto = "/default";
  11119.                     }
  11120.                     if ((x = cmkey(tcprawtab,ntcpraw,"Switch",defproto,
  11121.                                    xxstring)) < 0) {
  11122.                         if (x != -3)
  11123.                           return(x);
  11124.                         else if ((x = cmcfm()) < 0)
  11125.                           return(x);
  11126.                     } else {
  11127.                         rawflg = x;
  11128.                         if ((x = cmcfm()) < 0)
  11129.                           return(x);
  11130.                     }
  11131.                 }
  11132.             }
  11133.             debug(F110,"setlin pre-cx_net line",line,0);
  11134.             debug(F110,"setlin pre-cx_net srvbuf",srvbuf,0);
  11135.             x = cx_net( mynet,                  /* nettype */
  11136.                         rawflg                  /* protocol */,
  11137.                         line,                   /* host */
  11138.                         srvbuf,                 /* port */
  11139.                         tmpusrid,               /* alternate username */
  11140.                         tmpstring,              /* password */
  11141.                         NULL,                   /* command to execute */
  11142.                         a_type,                 /* param1 - telnet authtype */
  11143.                         e_type,                 /* param2 - telnet enctype  */
  11144.                         wait,                   /* param3 - telnet wait */
  11145.                         cx,                     /* enter CONNECT mode */
  11146.                         sx,                     /* enter SERVER mode */
  11147.                         zz,                     /* close connection if open */
  11148.                         0                       /* gui */
  11149.                         );
  11150.         }
  11151. #endif /* TCPSOCKET */
  11152.  
  11153. #ifdef CK_SECURITY
  11154.         if (tmpstring)
  11155.             makestr(&tmpstring,NULL);
  11156. #endif /* CK_SECURITY */
  11157.         if (tmpusrid)
  11158.             makestr(&tmpusrid,NULL);
  11159.     debug(F111,"setlin cx_net",line,x);
  11160.     return(x);
  11161. #endif /* NETCONN */
  11162.     }
  11163.  
  11164. /* Serial tty device, possibly modem, connection... */
  11165.  
  11166. #ifdef OS2
  11167. /*
  11168.   User can type:
  11169.     COM1..COM8 = Regular COM port
  11170.     1..8       = Synonym for COM1..COM8, is translated to COM1..COM8
  11171.     _n         = (n is a number) = open file handle
  11172.     string     = any text string = name of some other kind of device,
  11173.                  taken literally, as given.
  11174. */
  11175.     s = "Communication device name";
  11176.  
  11177. #ifdef CK_TAPI
  11178.     if (TAPIAvail)
  11179.       cktapiBuildLineTable(&tapilinetab, &_tapilinetab, &ntapiline);
  11180.     if (!(tapilinetab && _tapilinetab && ntapiline > 0) &&
  11181.     xx == XYTAPI_LIN ) {
  11182.     makestr(&slmsg,"TAPI device not configured");
  11183.     printf("\nNo TAPI Line Devices are configured for this system\n");
  11184.     return(-9);
  11185.     }
  11186.     if (xx == XYTAPI_LIN) {        /* Default (first) TAPI line */
  11187.     s = "tapi";            /* (whatever it is) */
  11188.     } else {                /* Query the user */
  11189. #endif /* CK_TAPI */
  11190.  
  11191. /* Now parse optional switches and then device name */
  11192.  
  11193.     confirmed = 0;
  11194.     cmfdbi(&sw,_CMKEY,"Device name, or switch",
  11195.            "","",npsltab,4,xxstring,psltab,&fl);
  11196.     cmfdbi(&fl,_CMFLD,"",dftty,"",0,0,xxstring,NULL,NULL);
  11197.     while (1) {
  11198.         x = cmfdb(&sw);
  11199.         debug(F101,"setlin cmfdb","",x);
  11200.         if (x < 0)
  11201.           if (x != -3)
  11202.         return(x);
  11203.         if (x == -3) {
  11204.         if ((x = cmcfm()) < 0) {
  11205.             return(x);
  11206.         } else {
  11207.             confirmed = 1;
  11208.             break;
  11209.         }
  11210.         }
  11211.         if (cmresult.fcode == _CMFLD) {
  11212.         s = cmresult.sresult;
  11213.         break;
  11214.         } else if (cmresult.fcode == _CMKEY) {
  11215.         switch (cmresult.nresult) {
  11216.           case SL_CNX:        /* /CONNECT */
  11217.             cx = 1;
  11218.             sx = 0;
  11219.             break;
  11220.           case SL_SRV:        /* /SERVER */
  11221.             cx = 0;
  11222.             sx = 1;
  11223.             break;
  11224.           case SL_SHR:        /* /SHARE */
  11225.             shr = 1;
  11226.             break;
  11227.           case SL_NSH:        /* /NOSHARE */
  11228.             shr = 0;
  11229.             break;
  11230.         }
  11231.         }
  11232.     }
  11233. #ifdef CK_TAPI
  11234.     }
  11235. #endif /* CK_TAPI */
  11236.  
  11237.     debug(F110,"OS2 SET PORT s",s,0);
  11238.     y = lookup(os2devtab,s,nos2dev,&x); /* Look up in keyword table */
  11239.     debug(F101,"OS2 SET PORT x","",x);
  11240.     debug(F101,"OS2 SET PORT y","",y);
  11241.     if ((y > -1) && (x >= 0 && x < 8)) { /* User typed a digit 1..8 */
  11242.     s = os2devtab[x+8].kwd;        /* Substitite its real name */
  11243. #ifdef NT
  11244.     xxtapi = 0;
  11245. #else /* NT */
  11246.     xxslip = xxppp = 0;
  11247. #endif /* NT */
  11248.     debug(F110,"OS2 SET PORT subst s",s,"");
  11249. #ifndef NT
  11250.     } else if ((y >-1) && (x >= 16 && x < 24)) { /* SLIP access */
  11251.     s = os2devtab[x-8].kwd;        /* Substitite its real name */
  11252.     debug(F110,"OS2 SET PORT SLIP subst s",s,"");
  11253.     xxslip = 1;
  11254.     xxppp  = 0;
  11255.     } else if ((y >-1) && (x >= 24 && x < 32)) { /* PPP access */
  11256.     s = os2devtab[x-16].kwd;    /* Substitite its real name */
  11257.     debug(F110,"OS2 SET PORT PPP subst s",s,"");
  11258.     xxppp = 1;
  11259.     xxslip = 0;
  11260.     if ((y = cmkey(os2ppptab,
  11261.                nos2ppp,
  11262.                "PPP driver interface",
  11263.                "ppp0",
  11264.                xxstring)
  11265.          ) < 0)
  11266.       return(y);
  11267.     debug(F101,"OS2 SET PORT PPP INTERFACE y","",y);
  11268.     xxppp = (y % 10) + 1;
  11269. #endif /* NT */
  11270.     } else if (*s == '_') {        /* User used "_" prefix */
  11271.     s++;                /* Remove it */
  11272.     /* Rest must be numeric */
  11273.     debug(F110,"OS2 SET PORT HANDLE _subst s",s,0);
  11274.     if (!rdigits(s)) {
  11275.         makestr(&slmsg,"Invalid file handle");
  11276.         printf("?Invalid format for file handle\n");
  11277.         return(-9);
  11278.     }
  11279. #ifdef NT
  11280.     xxtapi = 0;
  11281. #else /* NT */
  11282.     xxslip = xxppp = 0;
  11283. #endif /* NT */
  11284.     } else {                /* A normal COMx port or a string */
  11285.     s = brstrip(s);            /* Strip braces if any */
  11286. #ifdef NT
  11287. #ifdef CK_TAPI
  11288.     /* Windows TAPI support - Look up in keyword table */
  11289.     if (tapilinetab && _tapilinetab && ntapiline > 0) {
  11290.         if (!ckstrcmp(s,"tapi",4,0)) {
  11291.  
  11292.         /* Find out what the lowest numbered TAPI device is */
  11293.         /* and use it as the default.                       */
  11294.         int j = 9999, k = -1;
  11295.         for (i = 0; i < ntapiline; i++) {
  11296.             if (tapilinetab[i].kwval < j) {
  11297.             j = tapilinetab[i].kwval;
  11298.             k = i;
  11299.             }
  11300.         }
  11301.         if (k >= 0)
  11302.           s = _tapilinetab[k].kwd;
  11303.         else
  11304.           s = "";
  11305.  
  11306.         if ((y = cmkey(_tapilinetab,ntapiline,
  11307.                    "TAPI device name",s,xxstring)) < 0)
  11308.           return(y);
  11309.  
  11310.         xxtapi = 1;
  11311.  
  11312.         /* Get the non Underscored string */
  11313.         for (i = 0; i < ntapiline; i++ ) {
  11314.             if (tapilinetab[i].kwval == y) {
  11315.             s = tapilinetab[i].kwd;
  11316.             break;
  11317.             }
  11318.         }
  11319.         } else
  11320.           xxtapi = 0;
  11321.     }
  11322. #endif /* CK_TAPI */
  11323. #else /* NT */
  11324.     /* not OS/2 SLIP or PPP */
  11325.     xxslip = xxppp = 0;
  11326. #endif /* NT */
  11327.     }
  11328.     ckstrncpy(tmpbuf,s,TMPBUFSIZ);    /* Copy to a safe place */
  11329.     s = tmpbuf;
  11330.     if ((x = cmcfm()) < 0)
  11331.       return(x);
  11332.  
  11333. #else /* !OS2 */
  11334.  
  11335.     cmfdbi(&sw,_CMKEY,"Device name, or switch",
  11336.        "","",npsltab,4,xxstring,psltab,&tx);
  11337.     cmfdbi(&tx,_CMTXT,"",dftty,"",0,0,xxstring,NULL,NULL);
  11338.     while (!confirmed) {
  11339.     x = cmfdb(&sw);
  11340.     debug(F101,"setlin cmfdb","",x);
  11341.     if (x < 0)
  11342.       if (x != -3)
  11343.         return(x);
  11344.     if (x == -3) {
  11345.         if ((x = cmcfm()) < 0) {
  11346.         return(x);
  11347.         } else {
  11348.         confirmed = 1;
  11349.         break;
  11350.         }
  11351.     }
  11352.     switch (cmresult.fcode) {
  11353.       case _CMTXT:
  11354.         ckstrncpy(tmpbuf,cmresult.sresult,TMPBUFSIZ);
  11355.         s = tmpbuf;
  11356.         debug(F110,"setlin CMTXT",tmpbuf,0);
  11357.         confirmed = 1;
  11358.         break;
  11359.       case _CMKEY:            /* Switch */
  11360.         debug(F101,"setlin CMKEY",tmpbuf,cmresult.nresult);
  11361.         switch (cmresult.nresult) {
  11362.           case SL_CNX:        /* /CONNECT */
  11363.         cx = 1;
  11364.         sx = 0;
  11365.         break;
  11366.           case SL_SRV:        /* /SERVER */
  11367.         cx = 0;
  11368.         sx = 1;
  11369.         break;
  11370. #ifdef VMS
  11371.           case SL_SHR:        /* /SHARE */
  11372.         shr = 1;
  11373.         break;
  11374.           case SL_NSH:        /* /NOSHARE */
  11375.         shr = 0;
  11376.         break;
  11377. #endif /* VMS */
  11378.         }
  11379.         continue;
  11380.       default:
  11381.         debug(F101,"setlin bad cmfdb result","",cmresult.fcode);
  11382.         makestr(&slmsg,"Internal error");
  11383.         printf("?Internal parsing error\n");
  11384.         return(-9);
  11385.     }
  11386.     }
  11387. #endif /* OS2 */
  11388.     if (!confirmed)
  11389.       if ((x = cmcfm()) < 0)
  11390.     return(x);
  11391.  
  11392.     debug(F110,"setlin pre-cx_serial s",s,0);
  11393.     debug(F110,"setlin pre-cx_serial line",line,0);
  11394.     x = cx_serial(s,cx,sx,shr,zz,0,
  11395. #ifdef OS2
  11396. #ifdef NT
  11397.                    (xxtapi ? CX_TAPI : 0)
  11398. #else
  11399.                    (xxslip ? CX_SLIP : 0) | (xxppp ? CX_PPP : 0)
  11400. #endif /* NT */
  11401. #else /* OS2 */
  11402.                    0
  11403. #endif /* OS2 */
  11404.                    );
  11405.     debug(F111,"setlin cx_serial",line,x);
  11406.     return(x);
  11407. }
  11408. #endif /* NOLOCAL */
  11409.  
  11410. #ifdef CKCHANNELIO
  11411. /*
  11412.   C-Library based file-i/o package for scripts.  This should be portable to
  11413.   all C-Kermit versions since it uses the same APIs we have always used for
  11414.   processing command files.  The entire channel i/o package is contained
  11415.   herein, apart from some keyword table entries in the main keyword table
  11416.   and the help text in the HELP command module.
  11417.  
  11418.   On platforms like VMS and VOS, this package handles only UNIX-style
  11419.   stream files.  If desired, it can be replaced for those platforms by
  11420.   <#>ifdef'ing out this code and adding the equivalent replacement routines
  11421.   to the ck?fio.c module, e.g. for RMS-based file i/o in ckvfio.c.
  11422. */
  11423. #ifndef NOSTAT
  11424. #ifdef VMS
  11425. /* 2010-03-09 SMS.  VAX C needs help to find "sys".  It's easier not to try. */
  11426. #include <stat.h>
  11427. #else /* def VMS */
  11428. #include <sys/stat.h>
  11429. #endif /* def VMS [else] */
  11430. #endif /* NOSTAT */
  11431.  
  11432. #ifdef NLCHAR
  11433. static int z_lt = 1;                    /* Length of line terminator */
  11434. #else
  11435. static int z_lt = 2;
  11436. #endif /* NLCHAR */
  11437.  
  11438. struct ckz_file {                       /* C-Kermit file struct */
  11439.     FILE * z_fp;                        /* Includes the C-Lib file struct */
  11440.     unsigned int z_flags;               /* Plus C-Kermit mode flags, */
  11441.     CK_OFF_T z_nline;            /* current line number if known, */
  11442.     char z_name[CKMAXPATH+2];           /* and the file's name. */
  11443. };
  11444. static struct ckz_file ** z_file = NULL; /* Array of C-Kermit file structs */
  11445. static int z_inited = 0;                /* Flag for array initialized */
  11446. int z_maxchan = Z_MAXCHAN;              /* Max number of C-Kermit channels */
  11447. int z_openmax = CKMAXOPEN;              /* Max number of open files overall */
  11448. int z_nopen = 0;                        /* How many channels presently open */
  11449. int z_error = 0;                        /* Most recent error */
  11450. int z_filcount = -1;                    /* Most recent FILE COUNT result */
  11451.  
  11452. #define RD_LINE 0                       /* FILE READ options */
  11453. #define RD_CHAR 1
  11454. #define RD_SIZE 2
  11455. #define RD_TRIM 8            /* Like Snobol &TRIM = 1 */
  11456. #define RD_UNTA 9            /* Untabify */
  11457.  
  11458. #define WR_LINE RD_LINE                 /* FILE WRITE options */
  11459. #define WR_CHAR RD_CHAR
  11460. #define WR_SIZE RD_SIZE
  11461. #define WR_STRI 3
  11462. #define WR_LPAD 4
  11463. #define WR_RPAD 5
  11464.  
  11465. #ifdef UNIX
  11466. extern int ckmaxfiles;                  /* Filled in by sysinit(). */
  11467. #endif /* UNIX */
  11468.  
  11469. /* See ckcker.h for error numbers */
  11470. /* See ckcdeb.h for Z_MAXCHAN and CKMAXOPEN definitions */
  11471. /* NOTE: For VMS we might be able to fill in ckmaxfiles */
  11472. /* from FILLM and CHANNELCNT -- find out about these... */
  11473.  
  11474. static char * fopnargs[] = {            /* Mode combinations for fopen() */
  11475. #ifdef COMMENT
  11476.     /* All combinations of rwa */
  11477.     "",  "r",  "w",  "rw",  "a",  "ra",  "wa",  "rwa", /* Text mode */
  11478.     "b", "rb", "wb", "rwb", "ab", "rab", "wab", "rwab" /* Binary mode */
  11479. #else
  11480.     /* Combinations and syntax permitted by C libraries... */
  11481.     "",  "r",  "w",  "r+",  "a",  "",   "a",  "", /* Text mode */
  11482. #ifdef OS2
  11483.     "",  "rb", "wb", "r+b", "ab", "",   "ab", "" /* Binary modes for K95 */
  11484. #else
  11485. #ifdef VMS
  11486.     "",  "rb", "wb", "r+b", "ab", "",   "ab", "" /* Binary modes for VMS */
  11487. #else
  11488.     "",  "r",   "w", "r+",  "a",  "",   "a",  "" /* Binary modes for UNIX */
  11489. #endif /* VMS */
  11490. #endif /* OS2 */
  11491. #endif /* COMMENT */
  11492. };
  11493. static int nfopnargs = sizeof(fopnargs) / sizeof(char *);
  11494.  
  11495. char *                                  /* Error messages */
  11496. ckferror(n) int n; {
  11497.     switch (n) {
  11498.       case FX_NER: return("No error");
  11499.       case FX_SYS: return(ck_errstr());
  11500.       case FX_EOF: return("End of file");
  11501.       case FX_NOP: return("File not open");
  11502.       case FX_CHN: return("Channel out of range");
  11503.       case FX_RNG: return("Parameter out of range");
  11504.       case FX_NMF: return("Too many files open");
  11505.       case FX_FOP: return("Operation conflicts with OPEN mode");
  11506.       case FX_NYI: return("OPEN mode not supported");
  11507.       case FX_BOM: return("Illegal combination of OPEN modes");
  11508.       case FX_ACC: return("Access denied");
  11509.       case FX_FNF: return("File not found");
  11510.       case FX_OFL: return("Buffer overflow");
  11511.       case FX_LNU: return("Current line number unknown");
  11512.       case FX_ROO: return("Off limits");
  11513.       case FX_UNK: return("Operation fails - reason unknown");
  11514.       default: return("Error number out of range");
  11515.     }
  11516. }
  11517.  
  11518. /*
  11519.   Z _ O P E N --  Open a file for the requested type of access.
  11520.  
  11521.   Call with:
  11522.     name:  Name of file to be opened.
  11523.     flags: Any combination of FM_xxx values except FM_EOF (ckcker.h).
  11524.   Returns:
  11525.     >= 0 on success: The assigned channel number
  11526.     <  0 on failure: A negative FX_xxx error code (ckcker.h).
  11527. */
  11528. int
  11529. z_open(name, flags) char * name; int flags; {
  11530.     int i, n;
  11531.     FILE * t;
  11532.     char * mode;
  11533.     debug(F111,"z_open",name,flags);
  11534.     if (!name) name = "";               /* Check name argument */
  11535.     if (!name[0])
  11536.       return(z_error = FX_BFN);
  11537.     if (flags & FM_CMD)                 /* Opening pipes not implemented yet */
  11538.       return(z_error = FX_NYI);         /* (and not portable either) */
  11539.     debug(F101,"z_open nfopnargs","",nfopnargs);
  11540.     if (flags < 0 || flags >= nfopnargs) /* Range check flags */
  11541.       return(z_error = FX_RNG);
  11542.     mode = fopnargs[flags];             /* Get fopen() arg */
  11543.     debug(F111,"z_open fopen args",mode,flags);
  11544.     if (!mode[0])                       /* Check for illegal combinations */
  11545.       return(z_error = FX_BOM);
  11546.     if (!z_inited) {                    /* If file structs not inited */
  11547.         debug(F101,"z_open z_maxchan 1","",z_maxchan);
  11548. #ifdef UNIX
  11549.         debug(F101,"z_open ckmaxfiles","",ckmaxfiles);
  11550.         if (ckmaxfiles > 0) {           /* Set in ck?tio.c: sysinit() */
  11551.             int x;
  11552.             x = ckmaxfiles - ZNFILS - 5;
  11553.             if (x > z_maxchan)          /* sysconf() value greater than */
  11554.               z_maxchan = x;            /* value from header files. */
  11555.             debug(F101,"z_open z_maxchan 2","",z_maxchan);
  11556.         }
  11557. #endif /* UNIX */
  11558.         if (z_maxchan < Z_MINCHAN)      /* Allocate at least this many. */
  11559.           z_maxchan = Z_MINCHAN;
  11560.         debug(F101,"z_open z_maxchan 3","",z_maxchan);
  11561.         /* Note: This could be a pretty big chunk of memory */
  11562.         /* if z_maxchan is a big number.  If this becomes a problem */
  11563.         /* we'll need to malloc and free each element at open/close time */
  11564. #ifdef COMMENT
  11565.     /* May 2006 - it's time - in current Linux this about 3MB */
  11566.         if (!(z_file = (struct ckz_file *)
  11567.               malloc(sizeof(struct ckz_file) * (z_maxchan + 1))))
  11568.           return(z_error = FX_NMF);
  11569.         for (i = 0; i < z_maxchan; i++) {
  11570.             z_file[i].z_fp = NULL;
  11571.             z_file[i].z_flags = 0;
  11572.             z_file[i].z_nline = 0;
  11573.             *(z_file[i].z_name) = '\0';
  11574.         }
  11575. #else
  11576.     /* New economical way, allocate storage for each channel as needed */
  11577.     if (!z_file) {
  11578.         z_file = (struct ckz_file **)malloc((z_maxchan + 1) *
  11579.                         sizeof(struct ckz_file *));
  11580.         if (!z_file)
  11581.           return(z_error = FX_NMF);
  11582.         for (i = 0; i < z_maxchan; i++)
  11583.           z_file[i] = NULL;
  11584.     }
  11585. #endif    /* COMMENT */
  11586.         z_inited = 1;                   /* Remember we initialized */
  11587.     }
  11588.     for (n = -1, i = 0; i < z_maxchan; i++) { /* Find a free channel */
  11589. #ifdef COMMENT
  11590.         if (!z_file[i].z_fp) {
  11591.             n = i;
  11592.             break;
  11593.         }
  11594. #else
  11595.         if (!z_file[i]) {
  11596.         z_file[i] = (struct ckz_file *) malloc(sizeof(struct ckz_file));
  11597.         if (!z_file[i])
  11598.           return(z_error = FX_NMF);
  11599.             n = i;
  11600.             break;
  11601.         }
  11602. #endif    /* COMMENT */
  11603.  
  11604.     }
  11605.     if (n < 0 || n >= z_maxchan)        /* Any free channels? */
  11606.       return(z_error = FX_NMF);         /* No, fail. */
  11607.     errno = 0;
  11608.  
  11609.     z_file[n]->z_flags = 0;        /* In case of failure... */
  11610.     z_file[n]->z_fp = NULL;        /* Set file pointer to NULL */
  11611.  
  11612.     t = fopen(name, mode);              /* Try to open the file. */
  11613.     if (!t) {                           /* Failed... */
  11614.         debug(F111,"z_open error",name,errno);
  11615. #ifdef EMFILE
  11616.         if (errno == EMFILE)
  11617.           return(z_error = FX_NMF);
  11618. #endif /* EMFILE */
  11619.     free(z_file[n]);
  11620.     z_file[n] = NULL;
  11621.         return(z_error = (errno ?  FX_SYS : FX_UNK)); /* Return error code */
  11622.     }
  11623. #ifdef NT
  11624. #ifdef O_SEQUENTIAL
  11625.     if (t)                              /* Caching hint for NT */
  11626.       _setmode(_fileno(t),O_SEQUENTIAL);
  11627. #endif /* O_SEQUENTIAL */
  11628. #endif /* NT */
  11629.     z_nopen++;                          /* Open, count it. */
  11630.     z_file[n]->z_fp = t;        /* Stash the file pointer */
  11631.     z_file[n]->z_flags = flags;        /* and the flags */
  11632.     z_file[n]->z_nline = 0;        /* Current line number is 0 */
  11633.     z_error = 0;
  11634.     zfnqfp(name,CKMAXPATH,z_file[n]->z_name); /* and the file's full name */
  11635.     return(n);                          /* Return the channel number */
  11636. }
  11637.  
  11638. int
  11639. z_close(channel) int channel; {         /* Close file on given channel */
  11640.     int x;
  11641.     FILE * t;
  11642.     if (!z_inited)                      /* Called before any files are open? */
  11643.       return(z_error = FX_NOP);
  11644.     if (channel >= z_maxchan)           /* Channel out of range? */
  11645.       return(z_error = FX_CHN);
  11646.     if (!z_file[channel])
  11647.       return(z_error = FX_NOP);
  11648.     if (!(t = z_file[channel]->z_fp))    /* Channel wasn't open? */
  11649.       return(z_error = FX_NOP);
  11650.     errno = 0;                          /* Set errno 0 to get a good reading */
  11651.     x = fclose(t);                      /* Try to close */
  11652.     if (x == EOF)                       /* On failure */
  11653.       return(z_error = FX_SYS);         /* indicate system error. */
  11654.     z_nopen--;                          /* Closed OK, decrement open count */
  11655.     z_file[channel]->z_fp = NULL;    /* Set file pointer to NULL */
  11656.     z_file[channel]->z_nline = 0;    /* Current line number is 0 */
  11657.     z_file[channel]->z_flags = 0;    /* Set flags to 0 */
  11658.     *(z_file[channel]->z_name) = '\0';    /* Clear name */
  11659.     free(z_file[channel]);
  11660.     z_file[channel] = NULL;
  11661.     return(z_error = 0);
  11662. }
  11663.  
  11664. /*
  11665.   Z _ O U T  --  Output string to channel.
  11666.  
  11667.   Call with:
  11668.     channel:     Channel number to write to.
  11669.     s:           String to write.
  11670.     length > -1: How many characters of s to write.
  11671.     length < 0:  Write entire NUL-terminated string.
  11672.     flags == 0:  Supply line termination.
  11673.     flags >  0:  Don't supply line termination.
  11674.     flags <  0:  Write 'length' NUL characters.
  11675.   Special case:
  11676.     If flags > -1 and s is empty or NULL and length == 1, write 1 NUL.
  11677.   Returns:
  11678.     Number of characters written to channel on success, or
  11679.     negative FX_xxx error code on failure.
  11680. */
  11681. int
  11682. z_out(channel,s,length,flags) int channel, flags, length; char * s; {
  11683.     FILE * t;
  11684.     int x, n;
  11685.     char c = '\0';
  11686.  
  11687.     if (!s) s = "";                     /* Guard against null pointer */
  11688. #ifdef DEBUG
  11689.     if (deblog) {
  11690.         debug(F111,"z_out",s,channel);
  11691.         debug(F101,"z_out length","",length);
  11692.         debug(F101,"z_out flags","",flags);
  11693.     }
  11694. #endif /* DEBUG */
  11695.     if (!z_inited)                      /* File i/o inited? */
  11696.       return(z_error = FX_NOP);
  11697.     if (channel >= z_maxchan)           /* Channel in range? */
  11698.       return(z_error = FX_CHN);
  11699.     if (!z_file[channel])
  11700.       return(z_error = FX_NOP);
  11701.     if (!(t = z_file[channel]->z_fp))    /* File open? */
  11702.       return(z_error = FX_NOP);
  11703.     if (!((z_file[channel]->z_flags) & (FM_WRI|FM_APP))) /* In write mode? */
  11704.       return(z_error = FX_FOP);
  11705.     n = length;                         /* Length of string to write */
  11706.     if (n < 0) {                        /* Negative means get it ourselves */
  11707.         if (flags < 0)                  /* Except when told to write NULs in */
  11708.           return(z_error = FX_RNG);     /* which case args are inconsistent */
  11709.         n = strlen(s);                  /* Get length of string arg */
  11710.     }
  11711.     errno = 0;                          /* Reset errno */
  11712.     debug(F101,"z_out n","",n);
  11713.     if (flags < 0) {                    /* Writing NULs... */
  11714.         int i;
  11715.         for (i = 0; i < n; i++) {
  11716.             x = fwrite(&c,1,1,t);
  11717.             if (x < 1)
  11718.               return(z_error = (errno ? FX_SYS : FX_UNK));
  11719.         }
  11720.         z_file[channel]->z_nline = -1;   /* Current line no longer known */
  11721.         z_error = 0;
  11722.         return(i);
  11723.     } else {                            /* Writing string arg */
  11724.         if (n == 1 && !s[0])            /* Writing one char but it's NUL */
  11725.           x = fwrite(&c,1,1,t);
  11726.         else                            /* Writing non-NUL char or string */
  11727.           x = fwrite(s,1,n,t);
  11728.         debug(F101,"z_out fwrite",ckitoa(x),errno);
  11729.         if (x < n)                      /* Failure to write requested amount */
  11730.           return(z_error = (errno ? FX_SYS : FX_UNK)); /* Return error */
  11731.         if (flags == 0) {               /* If supplying line termination */
  11732.             if (fwrite("\n",1,1,t))     /* do that  */
  11733.               x += z_lt;                /* count the terminator */
  11734.             if (z_file[channel]->z_nline > -1) /* count this line */
  11735.               z_file[channel]->z_nline++;
  11736.         } else {
  11737.             z_file[channel]->z_nline = -1; /* Current line no longer known */
  11738.         }
  11739.     }
  11740.     z_error = 0;
  11741.     return(x);
  11742. }
  11743.  
  11744. #define Z_INBUFLEN 64
  11745.  
  11746. /*
  11747.   Z _ I N  --  Multichannel i/o file input function.
  11748.  
  11749.   Call with:
  11750.     channel number to read from.
  11751.     s = address of destination buffer.
  11752.     buflen = destination buffer length.
  11753.     length = Number of bytes to read, must be < buflen.
  11754.     flags: 0 = read a line; nonzero = read the given number of bytes.
  11755.   Returns:
  11756.     Number of bytes read into buffer or a negative error code.
  11757.     A terminating NUL is deposited after the last byte that was read.
  11758. */
  11759. int
  11760. z_in(channel,s,buflen,length,flags)
  11761.  int channel, buflen, length, flags; char * s;
  11762. /* z_in */ {
  11763.     int i, j, x;
  11764.     FILE * t;
  11765.     char * p;
  11766.  
  11767.     if (!z_inited)                      /* Check everything... */
  11768.       return(z_error = FX_NOP);
  11769.     if (channel >= z_maxchan)
  11770.       return(z_error = FX_CHN);
  11771.     if (!z_file[channel])
  11772.       return(z_error = FX_NOP);
  11773.     if (!(t = z_file[channel]->z_fp))
  11774.       return(z_error = FX_NOP);
  11775.     if (!((z_file[channel]->z_flags) & FM_REA))
  11776.       return(z_error = FX_FOP);
  11777.     if (!s)                             /* Check destination */
  11778.      return(z_error = FX_RNG);
  11779.     s[0] = NUL;
  11780.     if (length == 0)                    /* Read 0 bytes - easy. */
  11781.       return(z_error = 0);
  11782.     debug(F101,"z_in channel","",channel);
  11783.     debug(F101,"z_in buflen","",buflen);
  11784.     debug(F101,"z_in length","",length);
  11785.     debug(F101,"z_in flags","",flags);
  11786.     if (length < 0 || buflen < 0)       /* Check length args */
  11787.       return(z_error = FX_RNG);
  11788.     if (buflen <= length)
  11789.       return(z_error = FX_RNG);
  11790.     errno = 0;                          /* Reset errno */
  11791.     if (flags) {                        /* Read block or byte */
  11792.     int n;                /* 20050912 */
  11793.     n = length;            /* 20050912 */
  11794.     i = 0;                /* 20050912 */
  11795.     while (n > 0) {            /* 20050912 */
  11796.         i = fread(s,1,n,t);        /* 20050912 */
  11797. #ifdef DEBUG
  11798.         if (deblog) {
  11799.         debug(F111,"z_in block",s,i);
  11800.         debug(F101,"z_in block errno","",errno);
  11801.         debug(F101,"z_in block ferror","",ferror(t));
  11802.         debug(F101,"z_in block feof","",feof(t));
  11803.         }
  11804. #endif /* DEBUG */
  11805.         if (i == 0) break;        /* 20050912 */
  11806.         s += i;            /* 20050912 */
  11807.         n -= i;            /* 20050912 */
  11808.     }
  11809.     /* Current line no longer known */
  11810.         z_file[channel]->z_nline = (CK_OFF_T)-1;
  11811.     } else {                            /* Read line */
  11812. #ifndef COMMENT
  11813.         /* This method is used because it's simpler than the others */
  11814.         /* and also marginally faster. */
  11815.         debug(F101,"z_in getc loop","",CKFTELL(t));
  11816.         for (i = 0; i < length; i++) {
  11817.             if ((x = getc(t)) == EOF) {
  11818.                 debug(F101,"z_in getc error","",CKFTELL(t));
  11819.                 s[i] = '\0';
  11820.                 break;
  11821.             }
  11822.             s[i] = x;
  11823.             if (s[i] == '\n') {
  11824.                 s[i] = '\0';
  11825.                 break;
  11826.             }
  11827.         }
  11828.         debug(F111,"z_in line byte loop",ckitoa(errno),i);
  11829.         debug(F111,"z_in line got",s,z_file[channel]->z_nline);
  11830.         if (z_file[channel]->z_nline > -1)
  11831.           z_file[channel]->z_nline++;
  11832. #else
  11833. #ifdef COMMENT2
  11834.         /* Straightforward but strlen() slows it down. */
  11835.         s[0] = '\0';
  11836.         i = 0;
  11837.         if (fgets(s,length,t)) {
  11838.             i = strlen(s);
  11839.             if (i > 0 && s[i-1] == '\n') i--;
  11840.         }
  11841.         debug(F111,"z_in line fgets",ckitoa(errno),i);
  11842.         if (z_file[channel]->z_nline > -1)
  11843.           z_file[channel]->z_nline++;
  11844. #else
  11845.         /* This is a do-it-yourself fgets() with its own readahead and */
  11846.         /* putback.  It's a bit faster than real fgets() but not enough */
  11847.         /* to justify the added complexity or the risk of the ftell() and */
  11848.         /* fseek() calls failing. */
  11849.         int k, flag = 0;
  11850.         CK_OFF_T pos;
  11851.         for (i = 0; !flag && i <= (length - Z_INBUFLEN); i += Z_INBUFLEN) {
  11852.             k = ((length - i) < Z_INBUFLEN) ? length - i : Z_INBUFLEN;
  11853.             if ((x = fread(s+i,1,k,t)) < 1)
  11854.               break;
  11855.             s[i+x] = '\0';
  11856.             for (j = 0; j < x; j++) {
  11857.                 if (s[i+j] == '\n') {
  11858.                     s[i+j] = '\0';
  11859.                     flag ++;
  11860.                     pos = CKFTELL(t);
  11861.                     if (pos > -1) {
  11862.                         pos -= (x - j - 1);
  11863.                         x = CKFSEEK(t, pos, 0);
  11864.                         i += j;
  11865.                         break;
  11866.                     } else
  11867.                       return(z_error = FX_SYS);
  11868.                 }
  11869.             }
  11870.         }
  11871.         if (z_file[channel]->z_nline > -1)
  11872.           z_file[channel]->z_nline++;
  11873.         debug(F111,"z_in line chunk loop",ckitoa(errno),i);
  11874. #endif /* COMMENT2 */
  11875. #endif /* COMMENT */
  11876.     }
  11877.     debug(F111,"z_in i",ckitoa(errno),i);
  11878.     if (i < 0) i = 0;                   /* NUL-terminate result */
  11879.     s[i] = '\0';
  11880.     if (i > 0) {
  11881.         z_error = 0;
  11882.         return(i);
  11883.     }
  11884.     if (i == 0 && feof(t))              /* EOF on reading? */
  11885.       return(z_error = FX_EOF);         /* Return EOF code */
  11886.     return(errno ? (z_error = -1) : i); /* Return length or system error */
  11887. }
  11888.  
  11889. int
  11890. z_flush(channel) int channel; {         /* Flush output channel */
  11891.     FILE * t;
  11892.     int x;
  11893.     if (!z_inited)                      /* Regular checks */
  11894.       return(z_error = FX_NOP);
  11895.     if (channel >= z_maxchan)
  11896.       return(z_error = FX_CHN);
  11897.     if (!z_file[channel])
  11898.       return(z_error = FX_NOP);
  11899.     if (!(t = z_file[channel]->z_fp))
  11900.       return(z_error = FX_NOP);
  11901.     if (!((z_file[channel]->z_flags) & (FM_WRI|FM_APP))) /* Write access? */
  11902.       return(z_error = FX_FOP);
  11903.     errno = 0;                          /* Reset errno */
  11904.     x = fflush(t);                      /* Try to flush */
  11905.     return(x ? (z_error = FX_SYS) : 0); /* Return system error or 0 if OK */
  11906. }
  11907.  
  11908. int
  11909. #ifdef CK_ANSIC
  11910. z_seek(int channel, CK_OFF_T pos)    /* Move file pointer to byte */
  11911. #else
  11912. z_seek(channel,pos) int channel; CK_OFF_T pos; /* (seek to given position) */
  11913. #endif /* CK_ANSIC */
  11914. {
  11915.     int i, x = 0, rc;
  11916.     FILE * t;
  11917.     if (!z_inited)                      /* Check... */
  11918.       return(z_error = FX_NOP);
  11919.     if (channel >= z_maxchan)
  11920.       return(z_error = FX_CHN);
  11921.     if (!z_file[channel])
  11922.       return(z_error = FX_NOP);
  11923.     if (!(t = z_file[channel]->z_fp))
  11924.       return(z_error = FX_NOP);
  11925.     if (pos < 0L) {
  11926.         x = 2;
  11927.         pos = (pos == -2) ? -1L : 0L;
  11928.     }
  11929.     errno = 0;
  11930.     rc = CKFSEEK(t,pos,x);        /* Try to seek */
  11931.     debug(F111,"z_seek",ckitoa(errno),rc);
  11932.     if (rc < 0)                         /* OK? */
  11933.       return(z_error = FX_SYS); /* No. */
  11934.     z_file[channel]->z_nline = ((pos || x) ? -1 : 0);
  11935.     return(z_error = 0);
  11936. }
  11937.  
  11938. int
  11939. #ifdef CK_ANSIC
  11940. z_line(int channel, CK_OFF_T pos)           /* Move file pointer to line */
  11941. #else
  11942. z_line(channel,pos) int channel; CK_OFF_T pos; /* (seek to given position) */
  11943. #endif /* CK_ANSIC */
  11944. {
  11945.     int i, len, x = 0;
  11946.     CK_OFF_T current = (CK_OFF_T)0, prev = (CK_OFF_T)-1, old = (CK_OFF_T)-1;
  11947.     FILE * t;
  11948.     char tmpbuf[256];
  11949.     if (!z_inited)                      /* Check... */
  11950.       return(z_error = FX_NOP);
  11951.     if (channel >= z_maxchan)
  11952.       return(z_error = FX_CHN);
  11953.     if (!z_file[channel])
  11954.       return(z_error = FX_NOP);
  11955.     if (!(t = z_file[channel]->z_fp))
  11956.       return(z_error = FX_NOP);
  11957.     debug(F101,"z_line pos","",pos);
  11958.     if (pos < 0L) {                     /* EOF wanted */
  11959.         CK_OFF_T n;
  11960.         n = z_file[channel]->z_nline;
  11961.         debug(F101,"z_line n","",n);
  11962.         if (n < 0 || pos < 0) {
  11963.             rewind(t);
  11964.             n = 0;
  11965.         }
  11966.         while (1) {                     /* This could take a while... */
  11967.             if ((x = getc(t)) == EOF)
  11968.               break;
  11969.             if (x == '\n') {
  11970.                 n++;
  11971.                 if (pos == -2) {
  11972.                     old = prev;
  11973.                     prev = CKFTELL(t);
  11974.                 }
  11975.             }
  11976.         }
  11977.         debug(F101,"z_line old","",old);
  11978.         debug(F101,"z_line prev","",prev);
  11979.         if (pos == -2) {
  11980.             if ((x = z_seek(channel,old)) < 0)
  11981.               return(z_error = x);
  11982.             else
  11983.               n--;
  11984.         }
  11985.         z_file[channel]->z_nline = n;
  11986.         return(z_error = 0);
  11987.     }
  11988.     if (pos == 0L) {                    /* Rewind wanted */
  11989.         z_file[channel]->z_nline = 0L;
  11990.         rewind(t);
  11991.         debug(F100,"z_line rewind","",0);
  11992.         return(0L);
  11993.     }
  11994.     tmpbuf[255] = NUL;                  /* Make sure buf is NUL terminated */
  11995.     current = z_file[channel]->z_nline;  /* Current line */
  11996.     /*
  11997.       If necessary the following could be optimized, e.g. for positioning
  11998.       to a previous line in a large file without starting over.
  11999.     */
  12000.     if (current < 0 || pos < current) { /* Not known or behind us... */
  12001.         debug(F101,"z_line rewinding","",pos);
  12002.         if ((x = z_seek(channel, 0L)) < 0) /* Rewind */
  12003.           return(z_error = x);
  12004.         if (pos == 0)                   /* If 0th line wanted we're done */
  12005.           return(z_error = 0);
  12006.         current = 0;
  12007.     }
  12008.     while (current < pos) {             /* Search for specified line */
  12009.         if (fgets(tmpbuf,255,t)) {
  12010.             len = strlen(tmpbuf);
  12011.             if (len > 0 && tmpbuf[len-1] == '\n') {
  12012.                 current++;
  12013.                 debug(F111,"z_line read",ckitoa(len),current);
  12014.             } else if (len == 0) {
  12015.                 return(z_error = FX_UNK);
  12016.             }
  12017.         } else {
  12018.             z_file[channel]->z_nline = -1L;
  12019.             debug(F101,"z_line premature EOF","",current);
  12020.             return(z_error = FX_EOF);
  12021.         }
  12022.     }
  12023.     z_file[channel]->z_nline = current;
  12024.     debug(F101,"z_line result","",current);
  12025.     z_error = 0;
  12026.     return(current);
  12027. }
  12028.  
  12029. char *
  12030. z_getname(channel) int channel; {       /* Return name of file on channel */
  12031.     FILE * t;
  12032.     if (!z_inited) {
  12033.         z_error = FX_NOP;
  12034.         return(NULL);
  12035.     }
  12036.     if (channel >= z_maxchan) {
  12037.         z_error = FX_CHN;
  12038.         return(NULL);
  12039.     }
  12040.     if (!z_file[channel]) {
  12041.         z_error = FX_NOP;
  12042.         return(NULL);
  12043.     }
  12044.     if (!(t = z_file[channel]->z_fp)) {
  12045.         z_error = FX_NOP;
  12046.         return(NULL);
  12047.     }
  12048.     return((char *)(z_file[channel]->z_name));
  12049. }
  12050.  
  12051. int
  12052. z_getmode(channel) int channel; {       /* Return OPEN modes of channel */
  12053.     FILE * t;                           /* 0 if file not open */
  12054. #ifndef NOSTAT
  12055. #ifdef NT
  12056.     struct _stat statbuf;
  12057. #else /* NT */
  12058.     struct stat statbuf;
  12059. #endif /* NT */
  12060. #endif /* NOSTAT */
  12061.     int x;
  12062.     if (!z_inited)
  12063.       return(0);
  12064.     if (channel >= z_maxchan)
  12065.       return(z_error = FX_CHN);
  12066.     if (!z_file[channel])
  12067.       return(0);
  12068.     if (!(t = z_file[channel]->z_fp))
  12069.       return(0);
  12070.     x = z_file[channel]->z_flags;
  12071.     if (feof(t)) {                      /* This might not work for */
  12072.         x |= FM_EOF;                    /* output files */
  12073. #ifndef NOSTAT
  12074.     /* But this does if we can use it. */
  12075.     } else if (stat(z_file[channel]->z_name,&statbuf) > -1) {
  12076.         if (CKFTELL(t) == statbuf.st_size)
  12077.           x |= FM_EOF;
  12078. #endif /* NOSTAT */
  12079.     }
  12080.     return(x);
  12081. }
  12082.  
  12083. CK_OFF_T
  12084. z_getpos(channel) int channel; {        /* Get file pointer position */
  12085.     FILE * t;                           /* on this channel */
  12086.     CK_OFF_T x;
  12087.     if (!z_inited)
  12088.       return(z_error = FX_NOP);
  12089.     if (channel >= z_maxchan)
  12090.       return(z_error = FX_CHN);
  12091.     if (!z_file[channel])
  12092.       return(z_error = FX_NOP);
  12093.     if (!(t = z_file[channel]->z_fp))
  12094.       return(z_error = FX_NOP);
  12095.     x = CKFTELL(t);
  12096.     return((x < 0L) ? (z_error = FX_SYS) : x);
  12097. }
  12098.  
  12099. CK_OFF_T
  12100. z_getline(channel) int channel; {       /* Get current line number */
  12101.     FILE * t;                           /* in file on this channel */
  12102.     CK_OFF_T rc;
  12103.     if (!z_inited)
  12104.       return(z_error = FX_NOP);
  12105.     if (channel >= z_maxchan)
  12106.       return(z_error = FX_CHN);
  12107.     if (!z_file[channel])
  12108.       return(z_error = FX_NOP);
  12109.     if (!(t = z_file[channel]->z_fp))
  12110.       return(z_error = FX_NOP);
  12111.     debug(F101,"z_getline","",z_file[channel]->z_nline);
  12112.     rc = z_file[channel]->z_nline;
  12113.     return((rc < 0) ? (z_error = FX_LNU) : rc);
  12114. }
  12115.  
  12116. int
  12117. z_getfnum(channel) int channel; {       /* Get file number / handle */
  12118.     FILE * t;                           /* for file on this channel */
  12119.     if (!z_inited)
  12120.       return(z_error = FX_NOP);
  12121.     if (channel >= z_maxchan)
  12122.       return(z_error = FX_CHN);
  12123.     if (!z_file[channel])
  12124.       return(z_error = FX_NOP);
  12125.     if (!(t = z_file[channel]->z_fp))
  12126.       return(z_error = FX_NOP);
  12127.     z_error = 0;
  12128.     return(fileno(t));
  12129. }
  12130.  
  12131. /*
  12132.   Line-oriented counts and seeks are as dumb as they can be at the moment.
  12133.   Later we can speed them up by building little indexes.
  12134. */
  12135. CK_OFF_T
  12136. z_count(channel, what) int channel, what; { /* Count bytes or lines in file */
  12137.     FILE * t;
  12138.     int i, x;
  12139.     CK_OFF_T pos, count = (CK_OFF_T)0;
  12140.     if (!z_inited)                      /* Check stuff... */
  12141.       return(z_error = FX_NOP);
  12142.     if (channel >= z_maxchan)
  12143.       return(z_error = FX_CHN);
  12144.     if (!z_file[channel])
  12145.       return(z_error = FX_NOP);
  12146.     if (!(t = z_file[channel]->z_fp))
  12147.       return(z_error = FX_NOP);
  12148.     pos = CKFTELL(t);            /* Save current file pointer */
  12149.     errno = 0;
  12150.     z_error = 0;
  12151.     if (what == RD_CHAR) {              /* Size in bytes requested */
  12152. #ifdef COMMENT
  12153.         if (!CKFSEEK(t,0L,2)) {        /* Seek to end */
  12154.             count = CKFTELL(t);        /* Get file pointer */
  12155.             CKFSEEK(t,pos,0);        /* Restore file file pointer */
  12156.             return(count);
  12157.         } else                          /* Fallback in case seek fails */
  12158. #endif    /* COMMENT */
  12159.           return(zgetfs(z_file[channel]->z_name));
  12160.     }
  12161.     rewind(t);                          /* Line count requested - rewind. */
  12162.     while (1) {                         /* Count lines. */
  12163.         if ((x = getc(t)) == EOF)       /* Stupid byte loop */
  12164.           break;                        /* but it works as well as anything */
  12165.         if (x == '\n')                  /* else... */
  12166.           count++;
  12167.     }
  12168.     x = CKFSEEK(t,pos,0);        /* Restore file pointer */
  12169.     return(count);
  12170. }
  12171.  
  12172. /* User interface for generalized channel-oriented file i/o */
  12173.  
  12174. struct keytab fctab[] = {               /* FILE subcommands */
  12175.     { "close",      FIL_CLS, 0 },
  12176.     { "count",      FIL_COU, 0 },
  12177.     { "flush",      FIL_FLU, 0 },
  12178.     { "list",       FIL_LIS, 0 },
  12179.     { "open",       FIL_OPN, 0 },
  12180.     { "read",       FIL_REA, 0 },
  12181.     { "rewind",     FIL_REW, 0 },
  12182.     { "seek",       FIL_SEE, 0 },
  12183.     { "status",     FIL_STA, 0 },
  12184.     { "write",      FIL_WRI, 0 }
  12185. };
  12186. int nfctab = (sizeof (fctab) / sizeof (struct keytab));
  12187.  
  12188. static struct keytab fcswtab[] = {      /* OPEN modes */
  12189.     { "/append",    FM_APP,  0 },
  12190.     { "/binary",    FM_BIN,  0 },
  12191. #ifdef COMMENT
  12192.     { "/command",   FM_CMD,  0 },       /* Not implemented */
  12193. #endif /* COMMENT */
  12194.     { "/read",      FM_REA,  0 },
  12195.     { "/write",     FM_WRI,  0 }
  12196. };
  12197. static int nfcswtab = (sizeof (fcswtab) / sizeof (struct keytab));
  12198.  
  12199. static struct keytab fclkwtab[] = {     /* CLOSE options */
  12200.     { "all",        1,       0 }
  12201. };
  12202.  
  12203. static struct keytab fsekwtab[] = {     /* SEEK symbols */
  12204.     { "eof",        1,       0 },
  12205.     { "last",       2,       0 }
  12206. };
  12207. static int nfsekwtab = (sizeof (fsekwtab) / sizeof (struct keytab));
  12208.  
  12209. #define SEE_LINE  RD_LINE               /* SEEK options */
  12210. #define SEE_CHAR  RD_CHAR
  12211. #define SEE_REL   3
  12212. #define SEE_ABS   4
  12213. #define SEE_FIND  5
  12214.  
  12215. static struct keytab fskswtab[] = {
  12216.     { "/absolute",  SEE_ABS,  0 },
  12217.     { "/byte",      SEE_CHAR, 0 },
  12218.     { "/character", SEE_CHAR, CM_INV },
  12219.     { "/find",      SEE_FIND, CM_ARG },
  12220.     { "/line",      SEE_LINE, 0 },
  12221.     { "/relative",  SEE_REL,  0 }
  12222. };
  12223. static int nfskswtab = (sizeof (fskswtab) / sizeof (struct keytab));
  12224.  
  12225. #define COU_LINE  RD_LINE               /* COUNT options */
  12226. #define COU_CHAR  RD_CHAR
  12227. #define COU_LIS   3
  12228. #define COU_NOL   4
  12229.  
  12230. static struct keytab fcoswtab[] = {
  12231.     { "/bytes",     COU_CHAR, 0      },
  12232.     { "/characters",COU_CHAR, CM_INV },
  12233.     { "/lines",     COU_LINE, 0      },
  12234.     { "/list",      COU_LIS,  0      },
  12235.     { "/nolist",    COU_NOL,  0      },
  12236.     { "/quiet",     COU_NOL,  CM_INV }
  12237. };
  12238. static int nfcoswtab = (sizeof (fcoswtab) / sizeof (struct keytab));
  12239.  
  12240. static struct keytab frdtab[] = {       /* READ types */
  12241.     { "/block",     RD_SIZE, CM_INV|CM_ARG },
  12242.     { "/byte",      RD_CHAR, CM_INV },
  12243.     { "/character", RD_CHAR, 0      },
  12244.     { "/line",      RD_LINE, 0      },
  12245.     { "/size",      RD_SIZE, CM_ARG },
  12246.     { "/trim",      RD_TRIM, 0      },
  12247.     { "/untabify",  RD_UNTA, 0      }
  12248. };
  12249. static int nfrdtab = (sizeof (frdtab) / sizeof (struct keytab));
  12250.  
  12251. static struct keytab fwrtab[] = {       /* WRITE types */
  12252.     { "/block",     WR_SIZE, CM_INV|CM_ARG },
  12253.     { "/byte",      WR_CHAR, CM_INV },
  12254.     { "/character", WR_CHAR, 0      },
  12255.     { "/line",      WR_LINE, 0      },
  12256.     { "/lpad",      WR_LPAD, CM_ARG },
  12257.     { "/rpad",      WR_RPAD, CM_ARG },
  12258.     { "/size",      WR_SIZE, CM_ARG },
  12259.     { "/string",    WR_STRI, 0      }
  12260. };
  12261. static int nfwrtab = (sizeof (fwrtab) / sizeof (struct keytab));
  12262.  
  12263. static char blanks[] = "\040\040\040\040"; /* Some blanks for formatting */
  12264. static char * seek_target = NULL;
  12265.  
  12266. int
  12267. dofile(op) int op; {                    /* Do the FILE command */
  12268.     char vnambuf[VNAML];                /* Buffer for variable names */
  12269.     char *vnp = NULL;                   /* Pointer to same */
  12270.     char zfilnam[CKMAXPATH+2];
  12271.     char * p, * m;
  12272.     struct FDB fl, sw, nu;
  12273.     CK_OFF_T z;
  12274.     int rsize, filmode = 0, relative = -1, eofflg = 0;
  12275.     int rc, x, y, cx, n, getval, dummy, confirmed, listing = -1;
  12276.     int charflag = 0, sizeflag = 0;
  12277.     int pad = 32, wr_lpad = 0, wr_rpad = 0, rd_trim = 0, rd_untab = 0;
  12278.  
  12279.     makestr(&seek_target,NULL);
  12280.  
  12281.     if (op == XXFILE) {                 /* FILE command was given */
  12282.         /* Get subcommand */
  12283.         if ((cx = cmkey(fctab,nfctab,"Operation","",xxstring)) < 0) {
  12284.             if (cx == -3) {
  12285.                 printf("?File operation required\n");
  12286.                 x = -9;
  12287.             }
  12288.             return(cx);
  12289.         }
  12290.     } else {                            /* Shorthand command was given */
  12291.         switch (op) {
  12292.           case XXF_CL: cx = FIL_CLS; break; /* FCLOSE */
  12293.           case XXF_FL: cx = FIL_FLU; break; /* FFLUSH */
  12294.           case XXF_LI: cx = FIL_LIS; break; /* FLIST */
  12295.           case XXF_OP: cx = FIL_OPN; break; /* etc... */
  12296.           case XXF_RE: cx = FIL_REA; break;
  12297.           case XXF_RW: cx = FIL_REW; break;
  12298.           case XXF_SE: cx = FIL_SEE; break;
  12299.           case XXF_ST: cx = FIL_STA; break;
  12300.           case XXF_WR: cx = FIL_WRI; break;
  12301.           case XXF_CO: cx = FIL_COU; break;
  12302.           default: return(-2);
  12303.         }
  12304.     }
  12305.     switch (cx) {                       /* Do requested subcommand */
  12306.       case FIL_OPN:                     /* OPEN */
  12307.         cmfdbi(&sw,                     /* Switches */
  12308.                _CMKEY,                  /* fcode */
  12309.                "Variable or switch",    /* hlpmsg */
  12310.                "",                      /* default */
  12311.                "",                      /* addtl string data */
  12312.                nfcswtab,                /* addtl numeric data 1: tbl size */
  12313.                4,                       /* addtl numeric data 2: 4 = cmswi */
  12314.                xxstring,                /* Processing function */
  12315.                fcswtab,                 /* Keyword table */
  12316.                &fl                      /* Pointer to next FDB */
  12317.                );
  12318.         cmfdbi(&fl,                     /* Anything that doesn't match */
  12319.                _CMFLD,                  /* fcode */
  12320.                "Variable",              /* hlpmsg */
  12321.                "",
  12322.                "",
  12323.                0,
  12324.                0,
  12325.                NULL,
  12326.                NULL,
  12327.                NULL
  12328.                );
  12329.         while (1) {
  12330.             x = cmfdb(&sw);             /* Parse something */
  12331.             if (x < 0) {
  12332.                 if (x == -3) {
  12333.                     printf("?Variable name and file name required\n");
  12334.                     x = -9;
  12335.                 }
  12336.                 return(x);
  12337.             }
  12338.             if (cmresult.fcode == _CMFLD)
  12339.               break;
  12340.             else if (cmresult.fcode == _CMKEY) {
  12341.                 char c;
  12342.                 c = cmgbrk();
  12343.                 if ((getval =
  12344.                      (c == ':' || c == '=')) && !(cmgkwflgs() & CM_ARG)) {
  12345.                     printf("?This switch does not take an argument\n");
  12346.                     return(-9);
  12347.                 }
  12348. #ifdef COMMENT
  12349.                 /* Uncomment if we add any switches here that take args */
  12350.                 if (!getval && (cmgkwflgs() & CM_ARG)) {
  12351.                     printf("?This switch requires an argument\n");
  12352.                     return(-9);         /* (none do...) */
  12353.                 }
  12354. #endif /* COMMENT */
  12355.                 filmode |= cmresult.nresult; /* OR in the file mode */
  12356.             } else
  12357.               return(-2);
  12358.         }
  12359.         /* Not a switch - get the string */
  12360.         ckstrncpy(vnambuf,cmresult.sresult,VNAML);
  12361.         if (!vnambuf[0] || chknum(vnambuf)) { /* (if there is one...) */
  12362.             printf("?Variable name required\n");
  12363.             return(-9);
  12364.         }
  12365.         vnp = vnambuf;                  /* Check variable-name syntax */
  12366.         if (vnambuf[0] == CMDQ &&
  12367.             (vnambuf[1] == '%' || vnambuf[1] == '&'))
  12368.           vnp++;
  12369.         y = 0;
  12370.         if (*vnp == '%' || *vnp == '&') {
  12371.             if ((y = parsevar(vnp,&x,&dummy)) < 0) {
  12372.                 printf("?Syntax error in variable name\n");
  12373.                 return(-9);
  12374.             }
  12375.         }
  12376.     /* Assign a negative channel number in case we fail */
  12377.     addmac(vnambuf,"-1");
  12378.  
  12379.         if (!(filmode & FM_RWA))        /* If no access mode specified */
  12380.           filmode |= FM_REA;            /* default to /READ. */
  12381.  
  12382.         y = 0;                          /* Now parse the filename */
  12383.         if ((filmode & FM_RWA) == FM_WRI) {
  12384.         x = cmofi("Name of new file","",&s,xxstring);
  12385.     } else if ((filmode & FM_RWA) == FM_REA) {
  12386.         x = cmifi("Name of existing file","",&s,&y,xxstring);
  12387.     } else {
  12388.             x = cmiofi("Filename","",&s,&y,xxstring);
  12389.             debug(F111,"fopen /append x",s,x);
  12390.     }
  12391.         if (x < 0) {
  12392.             if (x == -3) {
  12393.                 printf("?Filename required\n");
  12394.                 x = -9;
  12395.             }
  12396.             return(x);
  12397.         }
  12398.         if (y) {                        /* No wildcards */
  12399.             printf("?Wildcards not allowed here\n");
  12400.             return(-9);
  12401.         }
  12402.         if (filmode & (FM_APP|FM_WRI)) { /* Check output access */
  12403. #ifndef VMS
  12404.             if (zchko(s) < 0) {          /* and set error code if denied */
  12405.                 z_error = FX_ACC;
  12406.                 printf("?Write access denied - \"%s\"\n",s);
  12407.                 return(-9);
  12408.             }
  12409. #endif /* VMS */
  12410.         }
  12411.         ckstrncpy(zfilnam,s,CKMAXPATH); /* Is OK - make safe copy */
  12412.         if ((x = cmcfm()) < 0)          /* Get confirmation of command */
  12413.           return(x);
  12414.         if ((n = z_open(zfilnam,filmode)) < 0) {
  12415.             printf("?OPEN failed - %s: %s\n",zfilnam,ckferror(n));
  12416.             return(-9);
  12417.         }
  12418.         addmac(vnambuf,ckitoa(n));      /* Assign channel number to variable */
  12419.         return(success = 1);
  12420.  
  12421.       case FIL_REW:                     /* REWIND */
  12422.         if ((x = cmnum("Channel number","",10,&n, xxstring)) < 0) {
  12423.             if (x == -3) {
  12424.                 printf("?Channel number required\n");
  12425.                 x = -9;
  12426.             }
  12427.             return(x);
  12428.         }
  12429.         if ((x = cmcfm()) < 0)
  12430.           return(x);
  12431.     if (n == -9) return(success = 0);
  12432.     if (n == -8) return(success = 1);
  12433.  
  12434.         if ((rc = z_seek(n,0L)) < 0) {
  12435.             printf("?REWIND failed - Channel %d: %s\n",n,ckferror(rc));
  12436.             return(-9);
  12437.         }
  12438.         return(success = 1);
  12439.  
  12440.       case FIL_CLS:                     /* CLOSE */
  12441. #ifdef COMMENT                /* fdc 20100804 - bad idea */
  12442.          {
  12443.         int i, j, k;        /* Supply default if only one open */
  12444.         s = "";
  12445.         for (k = 0, j = 0, i = 0; i < z_maxchan; i++) {
  12446.         if (z_file)
  12447.           if (z_file[i])
  12448.             if (z_file[i]->z_fp) { k++; j = i; }
  12449.         }
  12450.         if (k == 1) s = ckitoa(j);
  12451.      }
  12452. #endif    /* COMMENT */
  12453.           cmfdbi(&nu,                   /* Second FDB - channel number */
  12454.                  _CMNUM,                /* fcode */
  12455.                  "Channel number or ALL", /* Help message */
  12456.                  s,            /* default */
  12457.                  "",                    /* addtl string data */
  12458.                  10,                    /* addtl numeric data 1: radix */
  12459.                  0,                     /* addtl numeric data 2: 0 */
  12460.                  xxstring,              /* Processing function */
  12461.                  NULL,                  /* Keyword table */
  12462.                  &sw            /* Pointer to next FDB */
  12463.                  );                     /* Pointer to next FDB */
  12464.      cmfdbi(&sw,            /* First FDB - command switches */
  12465.                  _CMKEY,                /* fcode */
  12466.                  "",            /* help message */
  12467.          "",            /* Default */
  12468.          "",            /* No addtl string data */
  12469.                  1,                     /* addtl numeric data 1: tbl size */
  12470.                  0,                     /* addtl numeric data 2: 4 = cmswi */
  12471.                  xxstring,              /* Processing function */
  12472.                  fclkwtab,              /* Keyword table */
  12473.          NULL            /* Last in chain */
  12474.                  );
  12475.         x = cmfdb(&nu);                 /* Parse something */
  12476.         if (x < 0) {
  12477.             if (x == -3) {
  12478.                 printf("?Channel number or ALL required\n");
  12479.                 x = -9;
  12480.             }
  12481.             return(x);
  12482.         }
  12483.         if (cmresult.fcode == _CMNUM)
  12484.           n = cmresult.nresult;
  12485.         else if (cmresult.fcode == _CMKEY)
  12486.           n = -1;
  12487.         if ((x = cmcfm()) < 0)
  12488.           return(x);
  12489.     if (n == -9) return(success = 0);
  12490.     if (n == -8) return(success = 1);
  12491.  
  12492.         rc = 1;
  12493.         if (n < 0) {
  12494.             int count = 0;
  12495.             int i;
  12496.             for (i = 0; i < z_maxchan; i++) {
  12497.                 x = z_close(i);
  12498.                 if (x == FX_SYS) {
  12499.                     printf("?CLOSE failed - Channel %d: %s\n",n,ckferror(x));
  12500.                     rc = 0;
  12501.                 } else if (x > -1)
  12502.                   count++;
  12503.             }
  12504.             debug(F101,"FILE CLOSE ALL","",count);
  12505.         } else if ((x = z_close(n)) < 0) {
  12506.             printf("?CLOSE failed - Channel %d: %s\n",n,ckferror(x));
  12507.             return(-9);
  12508.         }
  12509.         return(success = rc);
  12510.  
  12511.       case FIL_REA:                     /* READ */
  12512.       case FIL_WRI:                     /* WRITE */
  12513.         rsize = 0;
  12514.         cmfdbi(&sw,                     /* Switches */
  12515.                _CMKEY,                  /* fcode */
  12516.                "Channel or switch",     /* hlpmsg */
  12517.                "",                      /* default */
  12518.                "",                      /* addtl string data */
  12519.                (cx == FIL_REA) ? nfrdtab : nfwrtab,
  12520.                4,                       /* addtl numeric data 2: 4 = cmswi */
  12521.                xxstring,                /* Processing function */
  12522.                (cx == FIL_REA) ? frdtab : fwrtab, /* Keyword table */
  12523.                &nu                      /* Pointer to next FDB */
  12524.                );
  12525.         cmfdbi(&nu,                     /* Channel number */
  12526.                _CMNUM,                  /* fcode */
  12527.                "Channel",
  12528.                "",                      /* default */
  12529.                "",                      /* addtl string data */
  12530.                10,                      /* addtl numeric data 1: radix */
  12531.                0,                       /* addtl numeric data 2: 0 */
  12532.                xxstring,                /* Processing function */
  12533.                NULL,                    /* Keyword table */
  12534.                NULL                     /* Pointer to next FDB */
  12535.                );
  12536.         do {
  12537.             x = cmfdb(&sw);             /* Parse something */
  12538.             if (x < 0) {
  12539.                 if (x == -3) {
  12540.                     printf("?Channel number required\n");
  12541.                     x = -9;
  12542.                 }
  12543.                 return(x);
  12544.             }
  12545.             if (cmresult.fcode == _CMNUM) /* Channel number */
  12546.               break;
  12547.             else if (cmresult.fcode == _CMKEY) { /* Switch */
  12548.                 char c;
  12549.                 c = cmgbrk();
  12550.                 if ((getval =
  12551.                      (c == ':' || c == '=')) && !(cmgkwflgs() & CM_ARG)) {
  12552.                     printf("?This switch does not take an argument\n");
  12553.                     return(-9);
  12554.                 }
  12555.                 if (!getval && (cmgkwflgs() & CM_ARG)) {
  12556.                     printf("?This switch requires an argument\n");
  12557.                     return(-9);
  12558.                 }
  12559.                 switch (cmresult.nresult) {
  12560.                   case WR_LINE:
  12561.                     charflag = 0;
  12562.                     sizeflag = 0;
  12563.                     rsize = 0;
  12564.                     break;
  12565.                   case WR_CHAR:
  12566.                     rsize = 1;
  12567.                     charflag = 1;
  12568.                     sizeflag = 1;
  12569.                     break;
  12570.                   case WR_SIZE:
  12571.                     if ((x = cmnum("Bytes","",10,&rsize, xxstring)) < 0) {
  12572.                         if (x == -3) {
  12573.                             printf("?Number required\n");
  12574.                             x = -9;
  12575.                         }
  12576.                         return(x);
  12577.                     }
  12578.             if (rsize > LINBUFSIZ) {
  12579.             printf("?Maximum FREAD/FWRITE size is %d\n",LINBUFSIZ);
  12580.             rsize = 0;
  12581.             return(-9);
  12582.             }
  12583.                     charflag = 0;
  12584.                     sizeflag = 1;
  12585.                     break;
  12586.                   case WR_STRI:
  12587.                     rsize = 1;
  12588.                     charflag = 0;
  12589.                     sizeflag = 0;
  12590.                     break;
  12591.                   case WR_LPAD:
  12592.                   case WR_RPAD:
  12593.                     if ((x = cmnum("Numeric ASCII character value",
  12594.                                    "32",10,&pad, xxstring)) < 0)
  12595.                       return(x);
  12596.                     if (cmresult.nresult == WR_LPAD)
  12597.                       wr_lpad = 1;
  12598.                     else
  12599.                       wr_rpad = 1;
  12600.                     break;
  12601.           case RD_TRIM:
  12602.             rd_trim = 1;
  12603.             break;
  12604.           case RD_UNTA:
  12605.             rd_untab = 1;
  12606.             break;
  12607.                 }
  12608.                 debug(F101,"FILE READ rsize 2","",rsize);
  12609.             } else
  12610.               return(-2);
  12611.         } while
  12612.           (cmresult.fcode == _CMKEY);
  12613.  
  12614.         n = cmresult.nresult;           /* Channel */
  12615.         debug(F101,"FILE READ/WRITE channel","",n);
  12616.  
  12617.         if (cx == FIL_WRI) {            /* WRITE */
  12618.             int len = 0;
  12619.             if ((x = cmtxt("Text","",&s,xxstring)) < 0)
  12620.               return(x);
  12621.         if (n == -9) return(success = 0);
  12622.         if (n == -8) return(success = 1);
  12623.  
  12624.             ckstrncpy(line,s,LINBUFSIZ); /* Make a safe copy */
  12625.             s = line;
  12626.             s = brstrip(s);             /* Strip braces */
  12627.             if (charflag) {             /* Write one char */
  12628.                 len = 1;                /* So length = 1 */
  12629.                 rsize = 1;              /* Don't supply terminator */
  12630.             } else if (!sizeflag) {     /* Write a string */
  12631.                 len = -1;               /* So length is unspecified */
  12632.             } else {                    /* Write a block of given size */
  12633.                 int i, k, xx;
  12634.                 if (rsize > TMPBUFSIZ) {
  12635.                     z_error = FX_OFL;
  12636.                     printf("?Buffer overflow\n");
  12637.                     return(-9);
  12638.                 }
  12639.                 len = rsize;            /* rsize is really length */
  12640.                 rsize = 1;              /* Don't supply a terminator */
  12641.                 xx = strlen(s);         /* Size of given string */
  12642.                 if (xx >= len) {        /* Bigger or equal */
  12643.                     s[len] = NUL;
  12644.                 } else if (wr_lpad) {   /* Smaller, left-padding requested */
  12645.                     for (i = 0; i < len - xx; i++) /* Must make a copy */
  12646.                       tmpbuf[i] = pad;
  12647.                     ckstrncpy(tmpbuf+i,s,TMPBUFSIZ-i);
  12648.                     tmpbuf[len] = NUL;
  12649.                     s = tmpbuf;         /* Redirect write source */
  12650.                 } else if (wr_rpad) {   /* Smaller with right-padding */
  12651.                     for (i = xx; i < len; i++)
  12652.                       s[i] = pad;
  12653.                     s[len] = NUL;
  12654.                 }
  12655.             }
  12656.             if ((rc = z_out(n,s,len,rsize)) < 0) { /* Try to write */
  12657.                 printf("?Channel %d WRITE error: %s\n",n,ckferror(rc));
  12658.                 return(-9);
  12659.             }
  12660.         } else {                        /* FIL_REA READ */
  12661.             confirmed = 0;
  12662.             vnambuf[0] = NUL;
  12663.             x = cmfld("Variable name","",&s,NULL);
  12664.             debug(F111,"FILE READ cmfld",s,x);
  12665.             if (x < 0) {
  12666.                 if (x == -3 || !*s) {
  12667.                     if ((x = cmcfm()) < 0)
  12668.                       return(x);
  12669.                     else
  12670.                       confirmed++;
  12671.                 } else
  12672.                   return(x);
  12673.             }
  12674.             ckstrncpy(vnambuf,s,VNAML);
  12675.             debug(F111,"FILE READ vnambuf",vnambuf,confirmed);
  12676.             if (vnambuf[0]) {           /* Variable name given, check it */
  12677.                 if (!confirmed) {
  12678.                     x = cmcfm();
  12679.                     if (x < 0)
  12680.                       return(x);
  12681.                     else
  12682.                       confirmed++;
  12683.                 }
  12684.                 vnp = vnambuf;
  12685.                 if (vnambuf[0] == CMDQ &&
  12686.                     (vnambuf[1] == '%' || vnambuf[1] == '&'))
  12687.                   vnp++;
  12688.                 y = 0;
  12689.                 if (*vnp == '%' || *vnp == '&') {
  12690.                     if ((y = parsevar(vnp,&x,&dummy)) < 0) {
  12691.                         printf("?Syntax error in variable name\n");
  12692.                         return(-9);
  12693.                     }
  12694.                 }
  12695.             }
  12696.             debug(F111,"FILE READ variable",vnambuf,confirmed);
  12697.  
  12698.             if (!confirmed)
  12699.               if ((x = cmcfm()) < 0)
  12700.                 return(x);
  12701.  
  12702.         if (n == -9) return(success = 0);
  12703.         if (n == -8) return(success = 1);
  12704.  
  12705.             line[0] = NUL;              /* Clear destination buffer */
  12706. #ifdef COMMENT
  12707.             if (rsize >= LINBUFSIZ)     /* Don't overrun it */
  12708.               rsize = LINBUFSIZ - 1;
  12709. #endif    /* COMMENT */
  12710.  
  12711.             if (rsize == 0) {        /* Read a line */
  12712.         rc = z_in(n,line,LINBUFSIZ,LINBUFSIZ-1,0);
  12713.             } else {
  12714.         rc = z_in(n,line,LINBUFSIZ,rsize,1); /* Read a block */
  12715.         }
  12716.             if (rc < 0) {               /* Error... */
  12717.                 debug(F101,"FILE READ error","",rc);
  12718.                 debug(F101,"FILE READ errno","",errno);
  12719.                 if (rc == FX_EOF) {     /* EOF - fail but no error message */
  12720.                     return(success = 0);
  12721.                 } else {                /* Other error - fail and print msg */
  12722.                     printf("?READ error: %s\n",ckferror(rc));
  12723.                     return(-9);
  12724.                 }
  12725.             }
  12726.         if (rsize == 0) {        /* FREAD /LINE postprocessing */
  12727.         if (rd_trim) {        /* Trim */
  12728.             int i, k;
  12729.             k = strlen(line);
  12730.             if (k > 0) {
  12731.             for (i = k-1; i > 0; i--) {
  12732.                 if (line[i] == SP || line[i] == '\t')
  12733.                   line[i] = NUL;
  12734.                 else
  12735.                   break;
  12736.             }
  12737.             }
  12738.         }
  12739.         if (rd_untab) {        /* Untabify */
  12740.             if (untabify(line,tmpbuf,TMPBUFSIZ) > -1)
  12741.               ckstrncpy(line,tmpbuf,LINBUFSIZ);
  12742.         }
  12743.         }
  12744.             debug(F110,"FILE READ data",line,0);
  12745.             if (vnambuf[0])             /* Read OK - If variable name given */
  12746.               addmac(vnambuf,line);     /* Assign result to variable */
  12747.             else                        /* otherwise */
  12748.               printf("%s\n",line);      /* just print it */
  12749.         }
  12750.         return(success = 1);
  12751.  
  12752.       case FIL_SEE:                     /* SEEK */
  12753.       case FIL_COU:                     /* COUNT */
  12754.         rsize = RD_CHAR;                /* Defaults to /BYTE */
  12755.         cmfdbi(&sw,                     /* Switches */
  12756.                _CMKEY,                  /* fcode */
  12757.                "Channel or switch",     /* hlpmsg */
  12758.                "",                      /* default */
  12759.                "",                      /* addtl string data */
  12760.                ((cx == FIL_SEE) ? nfskswtab : nfcoswtab),
  12761.                4,                       /* addtl numeric data 2: 4 = cmswi */
  12762.                xxstring,                /* Processing function */
  12763.                ((cx == FIL_SEE) ? fskswtab : fcoswtab),
  12764.                &nu                      /* Pointer to next FDB */
  12765.                );
  12766.         cmfdbi(&nu,                     /* Channel number */
  12767.                _CMNUM,                  /* fcode */
  12768.                "Channel",
  12769.                "",                      /* default */
  12770.                "",                      /* addtl string data */
  12771.                10,                      /* addtl numeric data 1: radix */
  12772.                0,                       /* addtl numeric data 2: 0 */
  12773.                xxstring,                /* Processing function */
  12774.                NULL,                    /* Keyword table */
  12775.                NULL                     /* Pointer to next FDB */
  12776.                );
  12777.         do {
  12778.             x = cmfdb(&sw);             /* Parse something */
  12779.             if (x < 0) {
  12780.                 if (x == -3) {
  12781.                     printf("?Channel number required\n");
  12782.                     x = -9;
  12783.                 }
  12784.                 return(x);
  12785.             }
  12786.             if (cmresult.fcode == _CMNUM) /* Channel number */
  12787.               break;
  12788.             else if (cmresult.fcode == _CMKEY) { /* Switch */
  12789.                 char c;
  12790.                 c = cmgbrk();
  12791.                 if ((getval =
  12792.                      (c == ':' || c == '=')) && !(cmgkwflgs() & CM_ARG)) {
  12793.                     printf("?This switch does not take an argument\n");
  12794.                     return(-9);
  12795.                 }
  12796.                 if (cx == FIL_SEE) {
  12797.                     switch (cmresult.nresult) {
  12798.                       case SEE_REL: relative = 1; break;
  12799.                       case SEE_ABS: relative = 0; break;
  12800.               case SEE_FIND: {
  12801.               if (getval) {
  12802.                   y = cmfld("string or pattern","",&s,xxstring);
  12803.                   if (y < 0)
  12804.                 return(y);
  12805.                   makestr(&seek_target,brstrip(s));
  12806.                   break;
  12807.               }
  12808.               }
  12809.                       default: rsize = cmresult.nresult;
  12810.                     }
  12811.                 } else if (cx == FIL_COU) {
  12812.                     switch (cmresult.nresult) {
  12813.                       case COU_LIS: listing = 1; break;
  12814.                       case COU_NOL: listing = 0; break;
  12815.                       default: rsize = cmresult.nresult;
  12816.                     }
  12817.                 }
  12818.             }
  12819.         } while
  12820.           (cmresult.fcode == _CMKEY);
  12821.  
  12822.         n = cmresult.nresult;           /* Channel */
  12823.         debug(F101,"FILE SEEK/COUNT channel","",n);
  12824.         if (cx == FIL_COU) {
  12825.             if ((x = cmcfm()) < 0)
  12826.               return(x);
  12827.         if (n == -9) return(success = 0);
  12828.         if (n == -8) return(success = 1);
  12829.  
  12830.             z_filcount = z_count(n,rsize);
  12831.             if (z_filcount < 0) {
  12832.                 rc = z_filcount;
  12833.                 printf("?COUNT error: %s\n",ckferror(rc));
  12834.                 return(-9);
  12835.             }
  12836.             if (listing < 0)
  12837.               listing = !xcmdsrc;
  12838.             if (listing)
  12839.               printf(" %ld %s%s\n",
  12840.                      z_filcount,
  12841.                      ((rsize == RD_CHAR) ? "byte" : "line"),
  12842.                      ((z_filcount == 1L) ? "" : "s")
  12843.                      );
  12844.             return(success = (z_filcount > -1) ? 1 : 0);
  12845.         }
  12846.     m = (rsize == RD_CHAR) ?
  12847.         "Number of bytes;\n or keyword" :
  12848.         "Number of lines;\n or keyword";
  12849.         cmfdbi(&sw,                     /* SEEK symbolic targets (EOF) */
  12850.                _CMKEY,                  /* fcode */
  12851.                m,
  12852.                "",
  12853.                "",                      /* addtl string data */
  12854.                nfsekwtab,               /* addtl numeric data 1: table size */
  12855.                0,                       /* addtl numeric data 2: 4 = cmswi */
  12856.                xxstring,                /* Processing function */
  12857.                fsekwtab,                /* Keyword table */
  12858.                &nu                      /* Pointer to next FDB */
  12859.                );
  12860.         cmfdbi(&nu,                     /* Byte or line number */
  12861.                _CMNUW,                  /* fcode */
  12862.                "",
  12863.                "",                      /* default */
  12864.                "",                      /* addtl string data */
  12865.                10,                      /* addtl numeric data 1: radix */
  12866.                0,                       /* addtl numeric data 2: 0 */
  12867.                xxstring,                /* Processing function */
  12868.                NULL,                    /* Keyword table */
  12869.                NULL                     /* Pointer to next FDB */
  12870.                );
  12871.         x = cmfdb(&sw);                 /* Parse something */
  12872.         if (x < 0) {
  12873.             if (x == -3) {
  12874.                 printf("?Channel number or EOF required\n");
  12875.                 x = -9;
  12876.             }
  12877.             return(x);
  12878.         }
  12879.         if (cmresult.fcode == _CMNUW) {
  12880.             z = cmresult.wresult;
  12881.             debug(F110,"FILE SEEK atmbuf",atmbuf,0);
  12882.             if (relative < 0) {
  12883.                 if (cx == FIL_SEE && (atmbuf[0] == '+' || atmbuf[0] == '-'))
  12884.                   relative = 1;
  12885.                 else
  12886.                   relative = 0;
  12887.             }
  12888.         } else if (cmresult.fcode == _CMKEY) {
  12889.             eofflg = cmresult.nresult;
  12890.             relative = 0;
  12891.             y = 0 - eofflg;
  12892.         }
  12893.         if ((x = cmcfm()) < 0)
  12894.           return(x);
  12895.     if (n == -9) return(success = 0);
  12896.     if (n == -8) return(success = 1);
  12897.         y = 1;                          /* Recycle this */
  12898.         z_flush(n);
  12899.         debug(F101,"FILE SEEK relative","",relative);
  12900.         debug(F101,"FILE SEEK rsize","",rsize);
  12901.  
  12902.         if (rsize == RD_CHAR) {         /* Seek to byte position */
  12903.             if (relative > 0) {
  12904.                 CK_OFF_T pos;
  12905.                 pos = z_getpos(n);
  12906.                 if (pos < (CK_OFF_T)0) {
  12907.                     rc = pos;
  12908.                     printf("?Relative SEEK failed: %s\n",ckferror(rc));
  12909.                     return(-9);
  12910.                 }
  12911.                 z += pos;
  12912.             } else {
  12913.                 if (z < 0 && !eofflg) { /* Negative arg but not relative */
  12914.                     y = 0;              /* Remember this was bad */
  12915.                     z = 0;              /* but substitute 0 */
  12916.                 }
  12917.             }
  12918.             debug(F101,"FILE SEEK /CHAR z","",z);
  12919.             if (z < 0 && !eofflg) {
  12920.                 z_error = FX_RNG;
  12921.                 return(success = 0);
  12922.             }
  12923.             if ((rc = z_seek(n,z)) < 0) {
  12924.                 if (rc == FX_EOF) return(success = 0);
  12925.                 printf("?SEEK /BYTE failed - Channel %d: %s\n",n,ckferror(rc));
  12926.                 return(-9);
  12927.             }
  12928.         } else {                        /* Seek to line */
  12929.             if (relative > 0) {
  12930.                 CK_OFF_T pos;
  12931.                 pos = z_getline(n);
  12932.                 debug(F101,"FILE SEEK /LINE pos","",pos);
  12933.                 if (pos < 0) {
  12934.                     rc = pos;
  12935.                     printf("?Relative SEEK failed: %s\n",ckferror(rc));
  12936.                     return(-9);
  12937.                 }
  12938.                 z += pos;
  12939.             }
  12940.             debug(F101,"FILE SEEK /LINE z","",z);
  12941.             debug(F101,"FILE SEEK /LINE eofflg","",eofflg);
  12942.             if (z < 0 && !eofflg) {
  12943.                 z_error = FX_RNG;
  12944.                 return(success = 0);
  12945.             }
  12946.             if ((rc = z_line(n,z)) < 0) {
  12947.                 if (rc == FX_EOF) return(success = 0);
  12948.                 printf("?SEEK /LINE failed - Channel %d: %s\n",n,ckferror(rc));
  12949.                 return(-9);
  12950.             }
  12951.         }
  12952.     /*
  12953.       Now, having sought to the desired starting spot, if a /FIND:
  12954.       target was specified, look for it now.
  12955.     */
  12956.     if (seek_target) {
  12957.         int flag = 0, ispat = 0, matchresult = 0;
  12958.         while (!flag) {
  12959.         y = z_in(n,line,LINBUFSIZ,LINBUFSIZ-1,0);
  12960.         if (y < 0) {
  12961.             y = 0;
  12962.             break;
  12963.         }
  12964.         if (ispattern(seek_target)) {
  12965.             matchresult = ckmatch(seek_target,line,inpcas[cmdlvl],1+4);
  12966.         } else {
  12967.             /* This is faster */
  12968.             matchresult = ckindex(seek_target,line,0,0,inpcas[cmdlvl]);
  12969.         }
  12970.         if (matchresult) {
  12971.             flag = 1;
  12972.             break;
  12973.         }
  12974.         }
  12975.         if (flag) {
  12976.         debug(F111,"FSEEK HAVE MATCH",seek_target,z_getline(n));
  12977.         /* Back up to beginning of line where target found */
  12978.         if ((y = z_line(n,z_getline(n)-1)) < 0) {
  12979.             if (rc == FX_EOF) return(success = 0);
  12980.             printf("?SEEK /LINE failed - Channel %d: %s\n",
  12981.                n,ckferror(rc));
  12982.             return(-9);
  12983.         }
  12984.         debug(F101,"FSEEK LINE","",y);
  12985.         }
  12986.     }
  12987.         return(success = (y < 0) ? 0 : 1);
  12988.  
  12989.       case FIL_LIS: {                   /* LIST open files */
  12990. #ifdef CK_TTGWSIZ
  12991.           extern int cmd_rows, cmd_cols;
  12992. #endif /* CK_TTGWSIZ */
  12993.           extern int xaskmore;
  12994.           int i, x, n = 0, paging = 0;
  12995.           char * s;
  12996.  
  12997.           if ((x = cmcfm()) < 0)
  12998.             return(x);
  12999.  
  13000. #ifdef CK_TTGWSIZ
  13001.           if (cmd_rows > 0 && cmd_cols > 0)
  13002. #endif /* CK_TTGWSIZ */
  13003.             paging = xaskmore;
  13004.  
  13005.           printf("System open file limit:%5d\n", z_openmax);
  13006.           printf("Maximum for FILE OPEN: %5d\n", z_maxchan);
  13007.           printf("Files currently open:  %5d\n\n", z_nopen);
  13008.           n = 4;
  13009.           for (i = 0; i < z_maxchan; i++) {
  13010.               s = z_getname(i);         /* Got one? */
  13011.               if (s) {                  /* Yes */
  13012.                   char m[8];
  13013.                   m[0] = NUL;
  13014.                   printf("%2d. %s",i,s); /* Print name */
  13015.                   n++;                   /* Count it */
  13016.                   x = z_getmode(i);      /* Get modes & print them */
  13017.                   if (x > 0) {
  13018.                       if (x & FM_REA) ckstrncat(m,"R",8);
  13019.                       if (x & FM_WRI) ckstrncat(m,"W",8);
  13020.                       if (x & FM_APP) ckstrncat(m,"A",8);
  13021.                       if (x & FM_BIN) ckstrncat(m,"B",8);
  13022.                       if (m[0])
  13023.                         printf(" (%s)",m);
  13024.                       if (x & FM_EOF)
  13025.                         printf(" [EOF]");
  13026.                       else        /* And file position too */
  13027.                         printf(" %s",ckfstoa(z_getpos(i)));
  13028.                   }
  13029.                   printf("\n");
  13030. #ifdef CK_TTGWSIZ
  13031.                   if (paging > 0) {     /* Pause at end of screen */
  13032.                       if (n > cmd_rows - 3) {
  13033.                           if (!askmore())
  13034.                             break;
  13035.                           else
  13036.                             n = 0;
  13037.                       }
  13038.                   }
  13039. #endif /* CK_TTGWSIZ */
  13040.               }
  13041.           }
  13042.           return(success = 1);
  13043.       }
  13044.  
  13045.       case FIL_FLU:                     /* FLUSH */
  13046.         if ((x = cmnum("Channel number","",10,&n, xxstring)) < 0) {
  13047.             if (x == -3) {
  13048.                 printf("?Channel number required\n");
  13049.                 x = -9;
  13050.             }
  13051.             return(x);
  13052.         }
  13053.         if ((x = cmcfm()) < 0)
  13054.           return(x);
  13055.     if (n == -9) return(success = 0);
  13056.     if (n == -8) return(success = 1);
  13057.         if ((rc = z_flush(n)) < 0) {
  13058.             printf("?FLUSH failed - Channel %d: %s\n",n,ckferror(rc));
  13059.             return(-9);
  13060.         }
  13061.         return(success = 1);
  13062.  
  13063.       case FIL_STA:                     /* STATUS */
  13064.     {
  13065.         int i, j, k;        /* Supply default if only one open */
  13066.         s = "";
  13067.         for (k = 0, j = 0, i = 0; i < z_maxchan; i++) {
  13068.         if (z_file)
  13069.           if (z_file[i])
  13070.             if (z_file[i]->z_fp) { k++; j = i; }
  13071.         }
  13072.         if (k == 1) s = ckitoa(j);
  13073.     }
  13074.         if ((x = cmnum("Channel number",s,10,&n, xxstring)) < 0) {
  13075.             if (x == -3) {
  13076.         if (z_nopen > 1) {
  13077.             printf("?%d files open - please supply channel number\n",
  13078.                z_nopen);
  13079.             return(-9);
  13080.         }
  13081.             } else
  13082.           return(x);
  13083.         }
  13084.         if ((y = cmcfm()) < 0)
  13085.           return(y);
  13086.     if ((!z_file || z_nopen == 0) && x == -3) {
  13087.         printf("No files open\n");
  13088.         return(success = 1);
  13089.     }
  13090.         p = blanks + 3;                 /* Tricky formatting... */
  13091.         if (n < 1000) p--;
  13092.         if (n < 100) p--;
  13093.         if (n < 10) p--;
  13094.         if ((rc = z_getmode(n)) < 0) {
  13095.             printf("Channel %d:%s%s\n",n,p,ckferror(rc));
  13096.             return(success = 0);
  13097.         } else if (!rc) {
  13098.             printf("Channel %d:%sNot open\n",n,p);
  13099.             return(success = 0);
  13100.         } else {
  13101.             CK_OFF_T xx;
  13102.             s = z_getname(n);
  13103.             if (!s) s = "(name unknown)";
  13104.             printf("Channel %d:%sOpen\n",n,p);
  13105.             printf(" File:        %s\n Modes:      ",s);
  13106.             if (rc & FM_REA) printf(" /READ");
  13107.             if (rc & FM_WRI) printf(" /WRITE");
  13108.             if (rc & FM_APP) printf(" /APPEND");
  13109.             if (rc & FM_BIN) printf(" /BINARY");
  13110.             if (rc & FM_CMD) printf(" /COMMAND");
  13111.             if (rc & FM_EOF) printf(" [EOF]");
  13112.             printf("\n Size:        %s\n",ckfstoa(z_count(n,RD_CHAR)));
  13113.             printf(" At byte:     %s\n",ckfstoa(z_getpos(n)));
  13114.             xx = z_getline(n);
  13115.             if (xx > (CK_OFF_T)-1)
  13116.               printf(" At line:     %s\n",ckfstoa(xx));
  13117.             return(success = 1);
  13118.         }
  13119.       default:
  13120.         return(-2);
  13121.     }
  13122. }
  13123. #endif /* CKCHANNELIO */
  13124.  
  13125. #ifndef NOSETKEY
  13126. /* Save Key maps and in OS/2 Mouse maps */
  13127. int
  13128. savkeys(name,disp) char * name; int disp; {
  13129.     char *tp;
  13130.     static struct filinfo xx;
  13131.     int savfil, i, j, k;
  13132.     char buf[1024];
  13133.  
  13134.     zclose(ZMFILE);
  13135.  
  13136.     if (disp) {
  13137.         xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0;
  13138.         xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = "";
  13139.         xx.lblopts = 0;
  13140.         savfil = zopeno(ZMFILE,name,NULL,&xx);
  13141.     } else savfil = zopeno(ZMFILE,name,NULL,NULL);
  13142.  
  13143.     if (savfil) {
  13144. #ifdef OS2
  13145.         ztime(&tp);
  13146.         zsout(ZMFILE, "; Kermit 95 SAVE KEYMAP file: ");
  13147.         zsoutl(ZMFILE,tp);
  13148.         if (mskkeys) {
  13149.             zsoutl(ZMFILE,
  13150.          "if eq \"\\v(program)\" \"C-Kermit\" set mskermit keycodes on");
  13151.         } else {
  13152.             zsoutl(ZMFILE,
  13153.          "if NOT eq \"\\v(program)\" \"C-Kermit\" stop 1 C-Kermit required.");
  13154.             zsoutl(ZMFILE,"set mskermit keycodes off");
  13155.         }
  13156.         zsoutl(ZMFILE,"");
  13157. #else /* OS2 */
  13158.         ztime(&tp);
  13159.         zsout(ZMFILE, "; C-Kermit SAVE KEYMAP file: ");
  13160.         zsoutl(ZMFILE,tp);
  13161. #endif /* OS2 */
  13162.  
  13163.         zsoutl(ZMFILE,"; Clear previous keyboard mappings ");
  13164.         zsoutl(ZMFILE,"set key clear");
  13165. #ifdef OS2
  13166.         for (k = 0; k < nttkey; k++) {
  13167.             if (!ttkeytab[k].flgs) {
  13168.                 ckmakmsg(buf,1024,
  13169.                          "set terminal key ",
  13170.                          ttkeytab[k].kwd,
  13171.                          " clear",
  13172.                          NULL
  13173.                          );
  13174.                 zsoutl(ZMFILE,buf);
  13175.             }
  13176.         }
  13177. #endif /* OS2 */
  13178.         zsoutl(ZMFILE,"");
  13179.  
  13180.         for (i = 0; i < KMSIZE; i++) {
  13181.             if (macrotab[i]) {
  13182.                 int len = strlen((char *)macrotab[i]);
  13183. #ifdef OS2
  13184.                 ckmakmsg(buf,
  13185.                          1024,
  13186.                          "set key \\",
  13187.                          ckitoa(mskkeys ? cktomsk(i) : i),
  13188.                          " ",
  13189.                          NULL
  13190.                          );
  13191. #else /* OS2 */
  13192.                 ckmakmsg(buf,
  13193.                          1024,
  13194.                          "set key \\",
  13195.                          ckitoa(i),
  13196.                          NULL,NULL
  13197.                          );
  13198. #endif /* OS2 */
  13199.                 zsout(ZMFILE,buf);
  13200.  
  13201.                 for (j = 0; j < len; j++) {
  13202.                     char ch = macrotab[i][j];
  13203.                     if (ch <= SP || ch >= DEL ||
  13204.                          ch == '-' || ch == ',' ||
  13205.                          ch == '{' || ch == '}' ||
  13206.                          ch == ';' || ch == '?' ||
  13207.                          ch == '.' || ch == '\'' ||
  13208.                          ch == '\\' || ch == '/' ||
  13209.                          ch == '#') {
  13210.                         ckmakmsg(buf,1024,"\\{",ckitoa((int)ch),"}",NULL);
  13211.                         zsout(ZMFILE,buf);
  13212.                     } else {
  13213.                         ckmakmsg(buf,1024,ckctoa((char)ch),NULL,NULL,NULL);
  13214.                         zsout(ZMFILE,buf);
  13215.                     }
  13216.                 }
  13217. #ifdef OS2
  13218.                 ckmakmsg(buf,1024,"\t; ",keyname(i),NULL,NULL);
  13219.                 zsoutl(ZMFILE,buf);
  13220. #else
  13221.                 zsoutl(ZMFILE,"");
  13222. #endif /* OS2 */
  13223.             } else if ( keymap[i] != i ) {
  13224. #ifndef NOKVERBS
  13225.                 if (IS_KVERB(keymap[i])) {
  13226.                     for (j = 0; j < nkverbs; j++)
  13227.                       if (kverbs[j].kwval == (keymap[i] & ~F_KVERB))
  13228.                         break;
  13229.                     if (j != nkverbs) {
  13230. #ifdef OS2
  13231. #ifdef COMMENT
  13232.                         sprintf(buf, "set key \\%d \\K%s\t; %s",
  13233.                                 mskkeys ? cktomsk(i) : i,
  13234.                                 kverbs[j].kwd, keyname(i)
  13235.                                 );
  13236. #else
  13237.                         ckmakxmsg(buf,  /* 12 string args */
  13238.                                   1024,
  13239.                                   "set key \\",
  13240.                                   ckitoa(mskkeys ? cktomsk(i) : i),
  13241.                                   " \\K",
  13242.                                   kverbs[j].kwd,
  13243.                                   "\t; ",
  13244.                                   keyname(i),
  13245.                                   NULL, NULL, NULL, NULL, NULL, NULL);
  13246. #endif /* COMMENT */
  13247.                         zsoutl(ZMFILE,buf);
  13248. #else
  13249. #ifdef COMMENT
  13250.                         sprintf(buf, "set key \\%d \\K%s", i, kverbs[j].kwd);
  13251. #else
  13252.                         ckmakmsg(buf,1024,
  13253.                                  "set key \\",
  13254.                                  ckitoa(i),
  13255.                                  " \\K",
  13256.                                  kverbs[j].kwd
  13257.                                  );
  13258. #endif /* COMMENT */
  13259.                         zsoutl(ZMFILE,buf);
  13260. #endif
  13261.                     }
  13262.                 } else
  13263. #endif /* NOKVERBS */
  13264.                   {
  13265. #ifdef OS2
  13266. #ifdef COMMENT
  13267.                       sprintf(buf, "set key \\%d \\{%d}\t; %s",
  13268.                               mskkeys ? cktomsk(i) : i,
  13269.                               keymap[i],
  13270.                               keyname(i)
  13271.                               );
  13272. #else
  13273.                       ckmakxmsg(buf,    /* 8 string args */
  13274.                                 1024,
  13275.                                 "set key \\",
  13276.                                 ckitoa(mskkeys ? cktomsk(i) : i),
  13277.                                 " \\{",
  13278.                                 ckitoa(keymap[i]),
  13279.                                 "}\t; ",
  13280.                                 keyname(i),
  13281.                                 NULL,NULL,NULL,NULL,NULL,NULL);
  13282. #endif /* COMMENT */
  13283.                       zsoutl(ZMFILE,buf);
  13284. #else
  13285. #ifdef COMMENT
  13286.                       sprintf(buf, "set key \\%d \\{%d}", i, keymap[i]);
  13287. #else
  13288.                       ckmakxmsg(buf,1024,
  13289.                                "set key \\",
  13290.                                ckitoa(i),
  13291.                                " \\{",
  13292.                                ckitoa(keymap[i]),
  13293.                                "}",
  13294.                                NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  13295. #endif /* COMMENT */
  13296.                       zsoutl(ZMFILE,buf);
  13297. #endif /* OS2 */
  13298.                   }
  13299.             }
  13300.         }
  13301. #ifdef OS2
  13302.         /* OS/2 also has the SET TERMINAL KEY <termtype> defines */
  13303.         for (k = 0; k < nttkey; k++) {
  13304.             extern struct keynode * ttkeymap[];
  13305.             struct keynode * pnode = NULL;
  13306.  
  13307.             if (ttkeytab[k].flgs)       /* Don't process CM_INV or CM_ABR */
  13308.               continue;
  13309.  
  13310.             zsoutl(ZMFILE,"");
  13311.             ckmakmsg(buf,1024,"; SET TERMINAL KEY ",ttkeytab[k].kwd,NULL,NULL);
  13312.             zsoutl(ZMFILE,buf);
  13313.  
  13314.             for (pnode = ttkeymap[ttkeytab[k].kwval];
  13315.                  pnode;
  13316.                  pnode = pnode->next
  13317.                  ) {
  13318.                 switch (pnode->def.type) {
  13319.                   case key:
  13320. #ifdef COMMENT
  13321.                     sprintf(buf, "set terminal key %s \\%d \\{%d}\t; %s",
  13322.                             ttkeytab[k].kwd,
  13323.                             mskkeys ? cktomsk(pnode->key) : pnode->key,
  13324.                             pnode->def.key.scancode,
  13325.                             keyname(pnode->key)
  13326.                             );
  13327. #else
  13328.                     ckmakxmsg(buf,
  13329.                               1024,
  13330.                               "set terminal key ",
  13331.                               ttkeytab[k].kwd,
  13332.                               " \\",
  13333.                               ckitoa(mskkeys ?
  13334.                                      cktomsk(pnode->key) :
  13335.                                      pnode->key),
  13336.                               " \\{",
  13337.                               ckitoa(pnode->def.key.scancode),
  13338.                               "}\t; ",
  13339.                               keyname(pnode->key),
  13340.                               NULL,NULL,NULL,NULL
  13341.                               );
  13342. #endif /* COMMENT */
  13343.                     zsoutl(ZMFILE,buf);
  13344.                     break;
  13345.                   case kverb:
  13346.                     for (j = 0; j < nkverbs; j++)
  13347.                       if (kverbs[j].kwval == (pnode->def.kverb.id & ~F_KVERB))
  13348.                         break;
  13349.                     if (j != nkverbs) {
  13350. #ifdef COMMENT
  13351.                         sprintf(buf, "set terminal key %s \\%d \\K%s\t; %s",
  13352.                                 ttkeytab[k].kwd,
  13353.                                 mskkeys ? cktomsk(pnode->key) : pnode->key,
  13354.                                 kverbs[j].kwd, keyname(pnode->key)
  13355.                                 );
  13356. #else
  13357.                         ckmakxmsg(buf,
  13358.                                   1024,
  13359.                                   "set terminal key ",
  13360.                                   ttkeytab[k].kwd,
  13361.                                   " \\",
  13362.                                   ckitoa(mskkeys ?
  13363.                                          cktomsk(pnode->key) :
  13364.                                          pnode->key),
  13365.                                   " \\K",
  13366.                                   kverbs[j].kwd,
  13367.                                   "\t; ",
  13368.                                   keyname(pnode->key),
  13369.                                   NULL,NULL,NULL,NULL
  13370.                                   );
  13371. #endif /* COMMENT */
  13372.                         zsoutl(ZMFILE,buf);
  13373.                     }
  13374.                     break;
  13375.                   case macro: {
  13376.                       int len = strlen((char *)pnode->def.macro.string);
  13377. #ifdef COMMENT
  13378.                       sprintf(buf,"set terminal key %s \\%d ",
  13379.                               ttkeytab[k].kwd,
  13380.                               mskkeys ? cktomsk(pnode->key) : pnode->key);
  13381. #else
  13382.                       ckmakxmsg(buf,
  13383.                                1024,
  13384.                                "set terminal key ",
  13385.                                ttkeytab[k].kwd,
  13386.                                " \\",
  13387.                                ckitoa(mskkeys ?
  13388.                                       cktomsk(pnode->key) :
  13389.                                       pnode->key),
  13390.                                " ",
  13391.                                NULL,NULL,NULL,NULL,NULL,NULL,NULL
  13392.                               );
  13393. #endif /* COMMENT */
  13394.                       zsout(ZMFILE,buf);
  13395.  
  13396.                       for (j = 0; j < len; j++) {
  13397.                           char ch = pnode->def.macro.string[j];
  13398.                           if (ch <= SP || ch >= DEL ||
  13399.                                ch == '-' || ch == ',' ||
  13400.                                ch == '{' || ch == '}' ||
  13401.                                ch == ';' || ch == '?' ||
  13402.                                ch == '.' || ch == '\'' ||
  13403.                                ch == '\\' || ch == '/' ||
  13404.                                ch == '#') {
  13405.                               ckmakmsg(buf,1024,
  13406.                                        "\\{",ckitoa((int)ch),"}",NULL);
  13407.                               zsout(ZMFILE,buf);
  13408.                           } else {
  13409.                               ckmakmsg(buf,1024,
  13410.                                        ckctoa((char)ch),NULL,NULL,NULL);
  13411.                               zsout(ZMFILE,buf);
  13412.                           }
  13413.                       }
  13414.                       ckmakmsg(buf,1024,"\t; ",keyname(pnode->key),NULL,NULL);
  13415.                       zsoutl(ZMFILE,buf);
  13416.                       break;
  13417.                   }
  13418.                   case literal: {
  13419.                       int len = strlen((char *)pnode->def.literal.string);
  13420. #ifdef COMMENT
  13421.                       sprintf(buf,"set terminal key %s /literal \\%d ",
  13422.                               ttkeytab[k].kwd,
  13423.                               mskkeys ? cktomsk(pnode->key) : pnode->key);
  13424. #else
  13425.                       ckmakxmsg(buf,
  13426.                                1024,
  13427.                                "set terminal key ",
  13428.                                ttkeytab[k].kwd,
  13429.                                " /literal \\",
  13430.                                ckitoa(mskkeys ?
  13431.                                       cktomsk(pnode->key) :
  13432.                                       pnode->key),
  13433.                                " ",
  13434.                                NULL,NULL,NULL,NULL,NULL,NULL,NULL);
  13435. #endif /* COMMENT */
  13436.                       zsout(ZMFILE,buf);
  13437.  
  13438.                       for (j = 0; j < len; j++) {
  13439.                           char ch = pnode->def.literal.string[j];
  13440.                           if (ch <= SP || ch >= DEL ||
  13441.                                ch == '-' || ch == ',' ||
  13442.                                ch == '{' || ch == '}' ||
  13443.                                ch == ';' || ch == '?' ||
  13444.                                ch == '.' || ch == '\'' ||
  13445.                                ch == '\\' || ch == '/' ||
  13446.                                ch == '#') {
  13447.                               ckmakmsg(buf,1024,
  13448.                                        "\\{",ckitoa((int)ch),"}",NULL);
  13449.                               zsout(ZMFILE,buf);
  13450.                           } else {
  13451.                               ckmakmsg(buf,1024,
  13452.                                        ckctoa((char)ch),NULL,NULL,NULL);
  13453.                               zsout(ZMFILE,buf);
  13454.                           }
  13455.                       }
  13456.                       ckmakmsg(buf,1024,"\t; ",keyname(pnode->key),NULL,NULL);
  13457.                       zsoutl(ZMFILE,buf);
  13458.                       break;
  13459.                   }
  13460.                   case esc:
  13461. #ifdef COMMENT
  13462.                     sprintf(buf,
  13463.                        "set terminal key %s /literal \\%d \\{%d}\\{%d}\t; %s",
  13464.                             ttkeytab[k].kwd,
  13465.                             mskkeys ? cktomsk(pnode->key) : pnode->key,
  13466.                             ISDG200(ttkeytab[k].kwval) ? 30 : 27,
  13467.                             pnode->def.esc.key & ~F_ESC,
  13468.                             keyname(pnode->key)
  13469.                             );
  13470. #else
  13471.                     ckmakxmsg(buf,
  13472.                               1024,
  13473.                               "set terminal key ",
  13474.                               ttkeytab[k].kwd,
  13475.                               " /literal \\",
  13476.                               ckitoa(mskkeys ?
  13477.                                      cktomsk(pnode->key) :
  13478.                                      pnode->key),
  13479.                               " \\{",
  13480.                               ckitoa(ISDG200(ttkeytab[k].kwval) ? 30 : 27),
  13481.                               "}\\{",
  13482.                               ckitoa(pnode->def.esc.key & ~F_ESC),
  13483.                               "}\t; ",
  13484.                               keyname(pnode->key),
  13485.                               NULL,NULL
  13486.                               );
  13487. #endif /* COMMENT */
  13488.                     zsoutl(ZMFILE,buf);
  13489.                     break;
  13490.                   case csi:
  13491. #ifdef COMMENT
  13492.                     sprintf(buf,
  13493.                        "set terminal key %s /literal \\%d \\{27}[\\{%d}\t; %s",
  13494.                             ttkeytab[k].kwd,
  13495.                             mskkeys ? cktomsk(pnode->key) : pnode->key,
  13496.                             pnode->def.csi.key & ~F_CSI,
  13497.                             keyname(pnode->key)
  13498.                             );
  13499. #else
  13500.                     ckmakxmsg(buf,
  13501.                               1024,
  13502.                               "set terminal key ",
  13503.                               ttkeytab[k].kwd,
  13504.                               " /literal \\",
  13505.                               ckitoa(mskkeys ?
  13506.                                      cktomsk(pnode->key) :
  13507.                                      pnode->key),
  13508.                               " \\{27}[\\{",
  13509.                               ckitoa(pnode->def.csi.key & ~F_CSI),
  13510.                               "}\t; ",
  13511.                               keyname(pnode->key),
  13512.                               NULL,NULL,NULL,NULL
  13513.                               );
  13514. #endif /* COMMENT */
  13515.                     zsoutl(ZMFILE,buf);
  13516.                     break;
  13517.                   default:
  13518.                     continue;
  13519.                 }
  13520.             }
  13521.         }
  13522. #endif /* OS2 */
  13523.  
  13524.         zsoutl(ZMFILE,"");
  13525.         zsoutl(ZMFILE,"; End");
  13526.         zclose(ZMFILE);
  13527.         return(success = 1);
  13528.     } else {
  13529.         return(success = 0);
  13530.     }
  13531. }
  13532. #endif /* NOSETKEY */
  13533.  
  13534. #define SV_SCRL 0
  13535. #define SV_HIST 1
  13536.  
  13537. #ifdef OS2
  13538. #ifndef NOLOCAL
  13539. static struct keytab trmtrmopt[] = {
  13540.     { "scrollback", SV_SCRL, 0 }
  13541. };
  13542. #endif /* NOLOCAL */
  13543. #endif /* OS2 */
  13544.  
  13545. static struct keytab cmdtrmopt[] = {
  13546. #ifdef CK_RECALL
  13547.     { "history",    SV_HIST, 0 },
  13548. #endif /* CK_RECALL */
  13549. #ifdef OS2
  13550. #ifndef NOLOCAL
  13551.     { "scrollback", SV_SCRL, 0 },
  13552. #endif /* NOLOCAL */
  13553. #endif /* OS2 */
  13554.     { "", 0, 0 }
  13555. };
  13556. static int ncmdtrmopt = (sizeof (cmdtrmopt) / sizeof (struct keytab)) - 1;
  13557.  
  13558. #ifdef OS2
  13559. #ifndef NOLOCAL
  13560. _PROTOTYP(int savscrbk, (int, char *, int));
  13561. #endif /* NOLOCAL */
  13562. #endif /* OS2 */
  13563.  
  13564. #ifdef CK_RECALL
  13565. _PROTOTYP(int savhistory, (char *, int));
  13566. #endif /* CK_RECALL */
  13567.  
  13568. int
  13569. dosave(xx) int xx; {
  13570.     int x, y = 0, disp;
  13571.     char * s = NULL;
  13572.     extern struct keytab disptb[];
  13573. #ifdef ZFNQFP
  13574.     struct zfnfp * fnp;
  13575. #endif /* ZFNQFP */
  13576.  
  13577. #ifndef NOSETKEY
  13578.     if (xx == XSKEY) {                  /* SAVE KEYMAP.. */
  13579.         z = cmofi("Name of Kermit command file","keymap.ksc",&s,xxstring);
  13580.     } else {
  13581. #endif /* NOSETKEY */
  13582.         switch (xx) {
  13583.           case XSCMD:                   /* SAVE COMMAND.. */
  13584.             if ((y = cmkey(cmdtrmopt, ncmdtrmopt, "What to save",
  13585. #ifdef OS2
  13586.                            "scrollback",
  13587. #else
  13588.                            "history",
  13589. #endif /* OS2 */
  13590.                            xxstring)) < 0)
  13591.               return(y);
  13592.             break;
  13593. #ifdef OS2
  13594. #ifndef NOLOCAL
  13595.           case XSTERM:                  /* SAVE TERMINAL.. */
  13596.             if ((y = cmkey(trmtrmopt,1,
  13597.                            "What to save","scrollback",xxstring)) < 0)
  13598.               return(y);
  13599.             break;
  13600. #endif /* NOLOCAL */
  13601. #endif /* OS2 */
  13602.         }
  13603.         z = cmofi("Filename",
  13604.                   ((y == SV_SCRL) ? "scrollbk.txt" : "history.txt"),
  13605.                   &s,
  13606.                   xxstring
  13607.                   );
  13608. #ifndef NOSETKEY
  13609.     }
  13610. #endif /* NOSETKEY */
  13611.     if (z < 0)                          /* Check output-file parse results */
  13612.       return(z);
  13613.     if (z == 2) {
  13614.         printf("?Sorry, %s is a directory name\n",s);
  13615.         return(-9);
  13616.     }
  13617. #ifdef ZFNQFP
  13618.     if ((fnp = zfnqfp(s,TMPBUFSIZ - 1,tmpbuf))) {/* Convert to full pathname */
  13619.         if (fnp->fpath)
  13620.           if ((int) strlen(fnp->fpath) > 0)
  13621.             s = fnp->fpath;
  13622.     }
  13623. #endif /* ZFNQFP */
  13624.  
  13625.     ckstrncpy(line,s,LINBUFSIZ);        /* Make safe copy of pathname */
  13626.     s = line;
  13627. #ifdef MAC
  13628.     z = 0;
  13629. #else
  13630.     /* Get NEW/APPEND disposition */
  13631.     if ((z = cmkey(disptb,2,"Disposition","new",xxstring)) < 0)
  13632.       return(z);
  13633. #endif /* MAC */
  13634.     disp = z;
  13635.     if ((x = cmcfm()) < 0)              /* Get confirmation */
  13636.       return(x);
  13637.  
  13638.     switch (xx) {                       /* Do action.. */
  13639. #ifndef NOSETKEY
  13640.       case XSKEY:                       /* SAVE KEYMAP */
  13641.         return (savkeys(s,disp));
  13642. #endif /* NOSETKEY */
  13643.  
  13644.       case XSCMD:                       /* SAVE COMMAND.. */
  13645. #ifdef OS2
  13646. #ifndef NOLOCAL
  13647.         if (y == SV_SCRL)               /* .. SCROLLBACK */
  13648.           return(success = savscrbk(VCMD,s,disp));
  13649. #endif /* NOLOCAL */
  13650. #endif /* OS2 */
  13651. #ifndef NORECALL
  13652.         if (y == SV_HIST)               /* .. HISTORY */
  13653.           return(success = savhistory(s,disp));
  13654. #endif /* NORECALL */
  13655.         break;
  13656.  
  13657. #ifdef OS2
  13658. #ifndef NOLOCAL
  13659.       case XSTERM:                      /* SAVE TERMINAL SCROLLBACK */
  13660.         return(success = savscrbk(VTERM,s,disp));
  13661. #endif /* NOLOCAL */
  13662. #endif /* OS2 */
  13663.     }
  13664.     success = 0;
  13665.     return(-2);
  13666. }
  13667.  
  13668. /*
  13669.   R E A D T E X T
  13670.  
  13671.   Read text with a custom prompt into given buffer using command parser but
  13672.   with no echoing or entry into recall buffer.
  13673. */
  13674. int
  13675. readtext(prmpt, buffer, bufsiz) char * prmpt; char * buffer; int bufsiz; {
  13676. #ifdef CK_RECALL
  13677.     extern int on_recall;               /* Around Password prompting */
  13678. #endif /* CK_RECALL */
  13679.     int rc;
  13680. #ifndef NOLOCAL
  13681. #ifdef OS2
  13682.     extern int vmode;
  13683.     extern int startflags;
  13684.     int vmode_sav = vmode;
  13685.  
  13686.     if (!prmpt) prmpt = "";
  13687.  
  13688.     if (win95_popup && !(startflags & 96)
  13689. #ifdef IKSD
  13690.          && !inserver
  13691. #endif /* IKSD */
  13692.          )
  13693.       return(popup_readtext(vmode,NULL,prmpt,buffer,bufsiz,0));
  13694.  
  13695.     if (vmode == VTERM) {
  13696.         vmode = VCMD;
  13697.         VscrnIsDirty(VTERM);
  13698.         VscrnIsDirty(VCMD);
  13699.     }
  13700. #endif /* OS2 */
  13701. #endif /* NOLOCAL */
  13702.  
  13703. #ifdef CK_RECALL
  13704.     on_recall = 0;
  13705. #endif /* CK_RECALL */
  13706.     cmsavp(psave,PROMPTL);              /* Save old prompt */
  13707.     cmsetp(prmpt);                      /* Make new prompt */
  13708.     concb((char)escape);                /* Put console in cbreak mode */
  13709.     cmini(1);                           /* and echo mode */
  13710.     if (pflag) prompt(xxstring);        /* Issue prompt if at top level */
  13711.     cmres();                            /* Reset the parser */
  13712.     for (rc = -1; rc < 0; ) {           /* Prompt till they answer */
  13713.         rc = cmtxt("","",&s,NULL);      /* Get a literal line of text */
  13714.         cmres();                        /* Reset the parser again */
  13715.     }
  13716.     ckstrncpy(buffer,s,bufsiz);
  13717.     cmsetp(psave);                      /* Restore original prompt */
  13718.  
  13719. #ifndef NOLOCAL
  13720. #ifdef OS2
  13721.     if (vmode != vmode_sav) {
  13722.         vmode = VTERM;
  13723.         VscrnIsDirty(VCMD);
  13724.         VscrnIsDirty(VTERM);
  13725.     }
  13726. #endif /* OS2 */
  13727. #endif /* NOLOCAL */
  13728.     return(0);
  13729. }
  13730. #endif /* NOICP */
  13731.  
  13732. /* A general function to allow a Password or other information  */
  13733. /* to be read from the command prompt without it going into     */
  13734. /* the recall buffer or being echo'd.                           */
  13735.  
  13736. int
  13737. readpass(prmpt, buffer, bufsiz) char * prmpt; char * buffer; int bufsiz; {
  13738.     int x;
  13739. #ifdef NOICP
  13740.     if (!prmpt) prmpt = "";
  13741.     printf("%s", prmpt);
  13742. #ifdef COMMENT
  13743.     /* Some linkers won't allow this because it's unsafe */
  13744.     gets(buffer);
  13745. #else  /* COMMENT */
  13746.     {
  13747.         int c, i; char * p;
  13748.         p = buffer;
  13749.         for (i = 0; i < bufsiz-1; i++) {
  13750.             if ((c = getchar()) == EOF)
  13751.               break;
  13752.             if (c < SP)
  13753.               break;
  13754.             buffer[i] = c;
  13755.         }
  13756.         buffer[i] = NUL;
  13757.     }
  13758. #endif /* COMMENT */
  13759.     return(1);
  13760. #else  /* NOICP */
  13761. #ifdef CK_RECALL
  13762.     extern int on_recall;               /* around Password prompting */
  13763. #endif /* CK_RECALL */
  13764.     int rc;
  13765. #ifndef NOLOCAL
  13766. #ifdef OS2
  13767.     extern int vmode;
  13768.     extern int startflags;
  13769.     int vmode_sav = vmode;
  13770. #endif /* OS2 */
  13771. #endif /* NOLOCAL */
  13772. #ifdef CKSYSLOG
  13773.     int savlog;
  13774. #endif /* CKSYSLOG */
  13775.     if (!prmpt) prmpt = "";
  13776. #ifndef NOLOCAL
  13777.     debok = 0;                          /* Don't log */
  13778. #ifdef OS2
  13779.     if (win95_popup && !(startflags & 96)
  13780. #ifdef IKSD
  13781.          && !inserver
  13782. #endif /* IKSD */
  13783.          ) {
  13784.         x = popup_readpass(vmode,NULL,prmpt,buffer,bufsiz,0);
  13785.         debok = 1;
  13786.         return(x);
  13787.     }
  13788. #endif /* OS2 */
  13789. #endif /* NOLOCAL */
  13790.  
  13791. #ifdef CKSYSLOG
  13792.     savlog = ckxsyslog;                 /* Save and turn off syslogging */
  13793.     ckxsyslog = 0;
  13794. #endif /* CKSYSLOG */
  13795. #ifndef NOLOCAL
  13796. #ifdef OS2
  13797.     if (vmode == VTERM) {
  13798.         vmode = VCMD;
  13799.         VscrnIsDirty(VTERM);
  13800.         VscrnIsDirty(VCMD);
  13801.     }
  13802. #endif /* OS2 */
  13803. #endif /* NOLOCAL */
  13804. #ifdef CK_RECALL
  13805.     on_recall = 0;
  13806. #endif /* CK_RECALL */
  13807.     cmsavp(psave,PROMPTL);              /* Save old prompt */
  13808.     cmsetp(prmpt);                      /* Make new prompt */
  13809.     concb((char)escape);                /* Put console in cbreak mode */
  13810.     cmini(0);                           /* and no-echo mode */
  13811.     if (pflag) prompt(xxstring);        /* Issue prompt if at top level */
  13812.     cmres();                            /* Reset the parser */
  13813.     for (rc = -1; rc < 0; ) {           /* Prompt till they answer */
  13814.         rc = cmtxt("","",&s,NULL);      /* Get a literal line of text */
  13815.         cmres();                        /* Reset the parser again */
  13816.     }
  13817.     ckstrncpy(buffer,s,bufsiz);
  13818.     printf("\r\n");                     /* Echo a CRLF */
  13819.     cmsetp(psave);                      /* Restore original prompt */
  13820.     cmini(1);                           /* Restore echo mode */
  13821. #ifndef NOLOCAL
  13822. #ifdef OS2
  13823.     if (vmode != vmode_sav) {
  13824.         vmode = VTERM;
  13825.         VscrnIsDirty(VCMD);
  13826.         VscrnIsDirty(VTERM);
  13827.     }
  13828. #endif /* OS2 */
  13829. #endif /* NOLOCAL */
  13830. #ifdef CKSYSLOG
  13831.     ckxsyslog = savlog;                 /* Restore syslogging */
  13832. #endif /* CKSYSLOG */
  13833.     debok = 1;
  13834.     return(0);
  13835. #endif /* NOICP */
  13836. }
  13837.  
  13838. #ifndef NOICP
  13839. struct keytab authtab[] = {             /* Available authentication types */
  13840. #ifdef CK_KERBEROS
  13841.     { "k4",        AUTH_KRB4, CM_INV },
  13842.     { "k5",        AUTH_KRB5, CM_INV },
  13843.     { "kerberos4", AUTH_KRB4, 0      },
  13844.     { "kerberos5", AUTH_KRB5, 0      },
  13845.     { "krb4",      AUTH_KRB4, CM_INV },
  13846.     { "krb5",      AUTH_KRB5, CM_INV },
  13847. #endif /* CK_KERBEROS */
  13848. #ifdef NT
  13849.     { "ntlm",      AUTH_NTLM, 0 },
  13850. #endif /* NT */
  13851. #ifdef CK_SRP
  13852.     { "srp",       AUTH_SRP,  0 },
  13853. #endif /* CK_SRP */
  13854. #ifdef CK_SSL
  13855.     { "ssl",       AUTH_SSL,  0 },
  13856. #endif /* CK_SSL */
  13857.     { "",          0,         0 }
  13858. };
  13859. int authtabn = sizeof(authtab)/sizeof(struct keytab)-1;
  13860.  
  13861. #ifdef CK_KERBEROS
  13862. struct keytab kerbtab[] = {             /* Kerberos authentication types */
  13863.     { "k4",        AUTH_KRB4, CM_INV },
  13864.     { "k5",        AUTH_KRB5, CM_INV },
  13865.     { "kerberos4", AUTH_KRB4, 0      },
  13866.     { "kerberos5", AUTH_KRB5, 0      },
  13867.     { "krb4",      AUTH_KRB4, CM_INV },
  13868.     { "krb5",      AUTH_KRB5, CM_INV }
  13869. };
  13870. int kerbtabn = sizeof(kerbtab)/sizeof(struct keytab);
  13871.  
  13872. static struct keytab krb_s_tbl[] = {    /* AUTHENTICATE command switches: */
  13873.     { "/cache",   KRB_S_CA, CM_ARG }
  13874. };
  13875. static int krb_s_n = sizeof(krb_s_tbl)/sizeof(struct keytab);
  13876.  
  13877. static struct keytab krb_v_tbl[] = {    /* KERBEROS version values: */
  13878.     { "4",    4, 0 },
  13879.     { "5",    5, 0 },                   /* (add others as needed...) */
  13880.     { "auto", 0, 0 }                    /* Note: 0 = auto */
  13881. };
  13882. static int krb_v_n = sizeof(krb_v_tbl)/sizeof(struct keytab);
  13883.  
  13884. static struct keytab krb_a_tbl[] = {    /* KERBEROS actions: */
  13885.     { "destroy",           KRB_A_DE, 0 },
  13886.     { "initialize",        KRB_A_IN, 0 },
  13887.     { "list-credentials",  KRB_A_LC, 0 }
  13888. };
  13889. static int krb_a_n = sizeof(krb_a_tbl)/sizeof(struct keytab);
  13890.  
  13891. static struct keytab krb4_i_tbl[] = {   /* KERBEROS 4 INITIALIZE switches: */
  13892.     { "/brief",            KRB_I_BR, 0 },      /* /BRIEF       */
  13893.     { "/instance",         KRB_I_IN, CM_ARG }, /* /INSTANCE:   */
  13894.     { "/lifetime",         KRB_I_LF, CM_ARG }, /* /LIFETIME:   */
  13895.     { "/not-preauth",      KRB_I_NPA, 0 },     /* /NOT-PREAUTH */
  13896.     { "/password",         KRB_I_PW, CM_ARG }, /* /PASSWORD:   */
  13897. #ifdef OS2
  13898.     { "/popup",            KRB_I_POP, 0 },     /* /POPUP       */
  13899. #endif /* OS2 */
  13900.     { "/preauth",          KRB_I_PA, 0 },      /* /PREAUTH     */
  13901.     { "/realm",            KRB_I_RL, CM_ARG }, /* /REALM:      */
  13902.     { "/verbose",          KRB_I_VB, 0 },      /* /VERBOSE     */
  13903.     { "", 0, 0 }
  13904. };
  13905. static int krb4_i_n = sizeof(krb4_i_tbl)/sizeof(struct keytab) - 1;
  13906.  
  13907. static struct keytab krb5_i_tbl[] = {   /* KERBEROS 5 INITIALIZE switches: */
  13908.     { "/addresses",        KRB_I_ADR, CM_ARG },
  13909.     { "/forwardable",      KRB_I_FW,  0 },         /* /FORWARDABLE */
  13910.     { "/instance",         KRB_I_IN, CM_ARG }, /* /INSTANCE:   */
  13911.     { "/k4",               KRB_I_K4,  CM_INV }, /* /KERBEROS4   */
  13912.     { "/kerberos4",        KRB_I_K4,  0 },      /* /KERBEROS4   */
  13913.     { "/krb4",             KRB_I_K4,  CM_INV }, /* /KERBEROS4   */
  13914.     { "/lifetime",         KRB_I_LF,  CM_ARG }, /* /LIFETIME:   */
  13915.     { "/no-addresses",     KRB_I_NAD, 0 },      /* /NO-ADDRESSES */
  13916.     { "/no-k4",            KRB_I_NK4, CM_INV },/* /NO-KERBEROS4 */
  13917.     { "/no-kerberos4",     KRB_I_NK4, 0 },     /* /NO-KERBEROS4 */
  13918.     { "/no-krb4",          KRB_I_NK4, CM_INV },/* /NO-KERBEROS4 */
  13919.     { "/not-forwardable",  KRB_I_NFW, 0 },         /* /NOT-FORWARDABLE */
  13920.     { "/not-proxiable",    KRB_I_NPR, 0 },     /* /NOT-PROXIABLE   */
  13921.     { "/password",         KRB_I_PW,  CM_ARG }, /* /PASSWORD:   */
  13922. #ifdef OS2
  13923.     { "/popup",            KRB_I_POP, 0 },     /* /POPUP       */
  13924. #endif /* OS2 */
  13925.     { "/postdate",         KRB_I_PD, CM_ARG }, /* /POSTDATE:   */
  13926.     { "/pr",               KRB_I_PR, CM_INV|CM_ABR }, /* to allow for */
  13927.     { "/pro",              KRB_I_PR, CM_INV|CM_ABR }, /* different spellings */
  13928.     { "/prox",             KRB_I_PR, CM_INV|CM_ABR },
  13929.     { "/proxiable",        KRB_I_PR, 0 },      /* /PROXIABLE   */
  13930.     { "/proxyable",        KRB_I_PR, CM_INV }, /* /PROXYABLE   */
  13931.     { "/realm",            KRB_I_RL, CM_ARG }, /* /REALM:      */
  13932.     { "/renew",            KRB_I_RN, 0 },          /* /RENEW       */
  13933.     { "/renewable",        KRB_I_RB, CM_ARG }, /* /RENEWABLE:  */
  13934.     { "/service",          KRB_I_SR, CM_ARG }, /* /SERVICE:    */
  13935.     { "/validate",         KRB_I_VA, 0 },          /* /VALIDATE    */
  13936.     { "", 0, 0 }
  13937. };
  13938. static int krb5_i_n = sizeof(krb5_i_tbl)/sizeof(struct keytab) - 1;
  13939.  
  13940. static struct keytab klctab[] = {       /* List Credentials switches*/
  13941.     { "/addresses",  XYKLCAD, 0 },
  13942.     { "/encryption", XYKLCEN, 0 },
  13943.     { "/flags",      XYKLCFL, 0 }
  13944. };
  13945. static int nklctab = sizeof(klctab)/sizeof(struct keytab);
  13946.  
  13947. extern int krb_action;
  13948. extern struct krb_op_data krb_op;
  13949.  
  13950. extern struct krb5_list_cred_data krb5_lc;
  13951. extern struct krb5_init_data krb5_init;
  13952. extern char * krb5_d_principal;         /* Default principal */
  13953. extern char * krb5_d_instance;
  13954. extern char * krb5_d_realm;             /* Default realm */
  13955. extern char * krb5_d_cc;                /* Default credentials cache */
  13956. extern char * krb5_d_srv;               /* Default service name */
  13957. extern int    krb5_d_lifetime;          /* Default lifetime */
  13958. extern int    krb5_d_forwardable;
  13959. extern int    krb5_d_proxiable;
  13960. extern int    krb5_d_renewable;
  13961. extern int    krb5_autoget;
  13962. extern int    krb5_autodel;
  13963. extern int    krb5_d_getk4;
  13964. extern int    krb5_d_no_addresses;
  13965. extern int    krb5_checkaddrs;
  13966. extern char * krb5_d_addrs[];
  13967. extern char * k5_keytab;                /* Keytab file */
  13968.  
  13969. extern struct krb4_init_data krb4_init;
  13970. extern char * krb4_d_principal;         /* Default principal */
  13971. extern char * krb4_d_realm;             /* Default realm */
  13972. extern char * krb4_d_srv;               /* Default service name */
  13973. extern int    krb4_d_lifetime;          /* Default lifetime */
  13974. extern int    krb4_d_preauth;
  13975. extern char * krb4_d_instance;
  13976. extern int    krb4_autoget;
  13977. extern int    krb4_autodel;
  13978. extern int    krb4_checkaddrs;
  13979. extern char * k4_keytab;                /* Keytab file */
  13980. #endif /* CK_KERBEROS */
  13981.  
  13982. #ifndef NOSHOW
  13983. int
  13984. sho_iks() {
  13985. #ifdef IKSDCONF
  13986. #ifdef CK_LOGIN
  13987.     extern int ckxsyslog, ckxwtmp, ckxanon;
  13988. #ifdef UNIX
  13989.     extern int ckxpriv;
  13990. #endif /* UNIX */
  13991. #ifdef CK_PERMS
  13992.     extern int ckxperms;
  13993. #endif /* CK_PERMS */
  13994.     extern char * anonfile, * userfile, * anonroot;
  13995. #ifdef OS2
  13996.     extern char * anonacct;
  13997. #endif /* OS2 */
  13998. #ifdef NT
  13999.     extern char * iks_domain;
  14000. #endif /* NT */
  14001. #endif /* CK_LOGIN */
  14002. #ifdef CKWTMP
  14003.     extern char * wtmpfile;
  14004. #endif /* CKWTMP */
  14005. #ifdef IKSDB
  14006.     extern char * dbfile;
  14007.     extern int dbenabled;
  14008. #endif /* IKSDB */
  14009. #ifdef CK_LOGIN
  14010.     extern int logintimo;
  14011. #endif /* CK_LOGIN */
  14012.     extern int srvcdmsg, success, iksdcf, noinit, arg_x;
  14013.     extern char * cdmsgfile[], * cdmsgstr, *kermrc;
  14014.     char * bannerfile = NULL;
  14015.     char * helpfile = NULL;
  14016.     extern int xferlog;
  14017.     extern char * xferfile;
  14018.     int i;
  14019.  
  14020.     if (isguest) {
  14021.         printf("?Command disabled\r\n");
  14022.         return(success = 0);
  14023.     }
  14024.  
  14025.     printf("IKS Settings\r\n");
  14026. #ifdef CK_LOGIN
  14027. #ifdef OS2
  14028.     printf("  Anonymous Account:   %s\r\n",anonacct?anonacct:"<none>");
  14029. #endif /* OS2 */
  14030.     printf("  Anonymous Initfile:  %s\r\n",anonfile?anonfile:"<none>");
  14031.     printf("  Anonymous Login:     %d\r\n",ckxanon);
  14032.     printf("  Anonymous Root:      %s\r\n",anonroot?anonroot:"<none>");
  14033. #endif /* CK_LOGIN */
  14034.     printf("  Bannerfile:          %s\r\n",bannerfile?bannerfile:"<none>");
  14035.     printf("  CDfile:              %s\r\n",cdmsgfile[0]?cdmsgfile[0]:"<none>");
  14036.     for ( i=1;i<16 && cdmsgfile[i];i++ )
  14037.         printf("  CDfile:              %s\r\n",cdmsgfile[i]);
  14038.     printf("  CDMessage:           %d\r\n",srvcdmsg);
  14039. #ifdef IKSDB
  14040.     printf("  DBfile:              %s\r\n",dbfile?dbfile:"<none>");
  14041.     printf("  DBenabled:           %d\r\n",dbenabled);
  14042. #endif /* IKSDB */
  14043. #ifdef CK_LOGIN
  14044. #ifdef NT
  14045.     printf("  Default-domain:      %s\r\n",iks_domain?iks_domain:".");
  14046. #endif /* NT */
  14047. #endif /* CK_LOGIN */
  14048.     printf("  Helpfile:            %s\r\n",helpfile?helpfile:"<none>");
  14049.     printf("  Initfile:            %s\r\n",kermrc?kermrc:"<none>");
  14050.     printf("  No-Initfile:         %d\r\n",noinit);
  14051. #ifdef CK_LOGIN
  14052. #ifdef CK_PERM
  14053.     printf("  Permission code:     %0d\r\n",ckxperms);
  14054. #endif /* CK_PERM */
  14055. #ifdef UNIX
  14056.     printf("  Privileged Login:    %d\r\n",ckxpriv);
  14057. #endif /* UNIX */
  14058. #endif /* CK_LOGIN */
  14059.     printf("  Server-only:         %d\r\n",arg_x);
  14060.     printf("  Syslog:              %d\r\n",ckxsyslog);
  14061.     printf("  Timeout (seconds):   %d\r\n",logintimo);
  14062.     printf("  Userfile:            %s\r\n",userfile?userfile:"<none>");
  14063. #ifdef CK_LOGIN
  14064. #ifdef CKWTMP
  14065.     printf("  Wtmplog:             %d\r\n",ckxwtmp);
  14066.     printf("  Wtmpfile:            %s\r\n",wtmpfile?wtmpfile:"<none>");
  14067. #endif /* CKWTMP */
  14068. #endif /* CK_LOGIN */
  14069.     printf("  Xferfile:            %s\r\n",xferfile?xferfile:"<none>");
  14070.     printf("  Xferlog:             %d\r\n",xferlog);
  14071. #else /* IKSDCONF */
  14072.     printf("?Nothing to show.\r\n");
  14073. #endif /* IKSDCONF */
  14074.     return(success = 1);
  14075. }
  14076.  
  14077. #ifdef CK_AUTHENTICATION
  14078. int
  14079. sho_auth(cx) int cx; {
  14080.     extern int auth_type_user[], cmd_rows;
  14081.     int i;
  14082.     char * p;
  14083.     int kv = 0, all = 0, n = 0;
  14084.  
  14085. #ifdef IKSD
  14086.     if (inserver && isguest) {
  14087.         printf("?Sorry, command disabled.\r\n");
  14088.         return(success = 0);
  14089.     }
  14090. #endif /* IKSD */
  14091.     if (cx) {
  14092.         kv = cx;
  14093.     } else if (auth_type_user[0] != AUTHTYPE_AUTO) {
  14094.         kv = auth_type_user[0];
  14095.     } else {
  14096.         all = 1;
  14097.         kv = AUTHTYPE_KERBEROS_V4;
  14098.     }
  14099.     while (kv) {
  14100.         switch (kv) {
  14101.           case AUTHTYPE_KERBEROS_V4:
  14102.             kv = all ? AUTHTYPE_KERBEROS_V5 : 0;
  14103.             if (ck_krb4_is_installed()) {
  14104.                 printf(" Authentication:      Kerberos 4\n");
  14105.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14106.             } else {
  14107.                 printf(" Authentication:      Kerberos 4 (not installed)\n");
  14108.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14109.                 continue;
  14110.             }
  14111. #ifdef CK_KERBEROS
  14112.             printf(" Keytab file:         %s\n",
  14113.                       k4_keytab ? k4_keytab : "(none)");
  14114.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14115.             if (krb_action < 0) {
  14116.                 p = "(none)";
  14117.             } else {
  14118.                 for (p = "", i = 0; i < krb_a_n; i++) {
  14119.                     if (krb_action == krb_a_tbl[i].kwval) {
  14120.                         p = krb_a_tbl[i].kwd;
  14121.                         break;
  14122.                     }
  14123.                 }
  14124.             }
  14125.             printf(" Action:              %s\n", p);
  14126.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14127.             printf(" Default lifetime     %d\n",krb4_d_lifetime);
  14128.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14129.             printf(" Lifetime:            %d (minutes)\n",krb4_init.lifetime);
  14130.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14131.             printf(" Default preauth:     %d\n",krb4_d_preauth);
  14132.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14133.             printf(" Preauth:             %d\n",krb4_init.preauth);
  14134.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14135.             printf(" Default principal:   \"%s\"\n",
  14136.                     krb4_d_principal ? krb4_d_principal : "");
  14137.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14138.             printf(" Principal:           \"%s\"\n",
  14139.                     krb4_init.principal ? krb4_init.principal : "");
  14140.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14141.             printf(" Default realm:       \"%s\"\n",
  14142.                     krb4_d_realm ? krb4_d_realm : "");
  14143.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14144.             printf(" Realm:               \"%s\"\n",
  14145.                     krb4_init.realm ? krb4_init.realm : "");
  14146.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14147.             printf(" Default instance:    \"%s\"\n",
  14148.                     krb4_d_instance ? krb4_d_instance : "");
  14149.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14150.             printf(" Instance:            \"%s\"\n",
  14151.                     krb4_init.instance ? krb4_init.instance : "");
  14152.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14153.             printf(" Auto-Get TGTs:       %d\n",krb4_autoget);
  14154.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14155.             printf(" Auto-Destroy TGTs:   %s\n",
  14156.                     krb4_autodel==KRB_DEL_NO?"never":
  14157.                     krb4_autodel==KRB_DEL_CL?"on-close":"on-exit");
  14158.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14159.             printf(" Check IP Addresses:  %d\n",krb4_checkaddrs);
  14160.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14161. #ifdef COMMENT
  14162.             printf(" Password:    \"%s\"\n",
  14163.                     krb4_init.password  ? krb4_init.password  : "");
  14164.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14165. #endif /* COMMENT */
  14166. #endif /* CK_KERBEROS */
  14167.             printf("\n");
  14168.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14169.             break;
  14170.         case AUTHTYPE_KERBEROS_V5:
  14171.             kv = all ? AUTHTYPE_SSL : 0;
  14172.             if (ck_krb5_is_installed()) {
  14173.                 if (ck_gssapi_is_installed())
  14174.                     printf(" Authentication:      Kerberos 5 plus GSSAPI\n");
  14175.                 else
  14176.                     printf(" Authentication:      Kerberos 5\n");
  14177.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14178.             } else {
  14179.                 printf(" Authentication:      Kerberos 5 (not installed)\n");
  14180.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14181.                 continue;
  14182.             }
  14183.  
  14184. #ifdef CK_KERBEROS
  14185.             printf(" Cache file:          %s\n",
  14186.                     krb_op.cache ? krb_op.cache : "(none)");
  14187.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14188.             printf(" Default cache:       %s\n",
  14189.                     krb5_d_cc ? krb5_d_cc : "(none)");
  14190.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14191.             printf(" Keytab file:         %s\n",
  14192.                       k5_keytab ? k5_keytab : "(none)");
  14193.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14194.             if (krb_action < 0) {
  14195.                 p = "(none)";
  14196.             } else  {
  14197.                 for (p = "", i = 0; i < krb_a_n; i++) {
  14198.                     if (krb_action == krb_a_tbl[i].kwval) {
  14199.                         p = krb_a_tbl[i].kwd;
  14200.                         break;
  14201.                     }
  14202.                 }
  14203.             }
  14204.             printf(" Action:              %s\n", p);
  14205.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14206.  
  14207.             printf(" Default forwardable  %d\n",krb5_d_forwardable);
  14208.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14209.             printf(" Forwardable:         %d\n",krb5_init.forwardable);
  14210.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14211.             printf(" Default lifetime     %d\n",krb5_d_lifetime);
  14212.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14213.             printf(" Lifetime:            %d (minutes)\n",krb5_init.lifetime);
  14214.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14215.             printf(" Postdate:            \"%s\"\n",
  14216.                     krb5_init.postdate ? krb5_init.postdate: "");
  14217.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14218.             printf(" Default proxiable:   %d\n",krb5_d_proxiable);
  14219.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14220.             printf(" Proxiable:           %d\n",krb5_init.proxiable);
  14221.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14222.             printf(" Renew:               %d\n",krb5_init.renew);
  14223.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14224.             printf(" Default renewable:   %d (minutes)\n",krb5_d_renewable);
  14225.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14226.             printf(" Renewable:           %d (minutes)\n",krb5_init.renewable);
  14227.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14228.             printf(" Service:             \"%s\"\n",
  14229.                     krb5_init.service ? krb5_init.service : "");
  14230.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14231.             printf(" Validate:            %d\n",krb5_init.validate);
  14232.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14233.             printf(" Default principal:   \"%s\"\n",
  14234.                     krb5_d_principal ? krb5_d_principal : "");
  14235.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14236.             printf(" Principal:           \"%s\"\n",
  14237.                     krb5_init.principal ? krb5_init.principal : "");
  14238.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14239.             printf(" Default instance:    \"%s\"\n",
  14240.                     krb5_d_instance ? krb5_d_instance : "");
  14241.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14242.             printf(" Default realm:       \"%s\"\n",
  14243.                     krb5_d_realm ? krb5_d_realm : "");
  14244.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14245.             printf(" Realm:               \"%s\"\n",
  14246.                     krb5_init.realm ? krb5_init.realm : "");
  14247.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14248.             printf(" Auto-Get TGTs:       %d\n",krb5_autoget);
  14249.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14250.             printf(" Auto-Destroy TGTs:   %s\n",
  14251.                     krb5_autodel==KRB_DEL_NO?"never":
  14252.                     krb5_autodel==KRB_DEL_CL?"on-close":"on-exit");
  14253.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14254.             printf(" Default get K4 TGTs: %d\n",krb5_d_getk4);
  14255.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14256.             printf(" Get K4 TGTs: %d\n",krb5_init.getk4);
  14257.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14258.             printf(" Check IP Addresses:  %d\n",krb5_checkaddrs);
  14259.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14260.             printf(" No IP Addresses:  %d\n",krb5_d_no_addresses);
  14261.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14262.             printf(" IP-Addresses:        ");
  14263.             if (krb5_init.addrs && krb5_init.addrs[0]) {
  14264.                 for (i = 0; krb5_init.addrs[i]; i++) {
  14265.                     if (i)
  14266.                       printf(",");
  14267.                     printf("%s",krb5_init.addrs[i]);
  14268.                 }
  14269.             } else if (krb5_d_addrs[0]) {
  14270.                 for (i = 0;i < KRB5_NUM_OF_ADDRS && krb5_d_addrs[i];i++) {
  14271.                     if (i)
  14272.                       printf(",");
  14273.                     printf("%s",krb5_d_addrs[i]);
  14274.                 }
  14275.             } else {
  14276.                 printf("(use default)");
  14277.             }
  14278.             printf("\n");
  14279.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14280. #ifdef COMMENT
  14281.             printf(" Password:            \"%s\"\n",
  14282.                     krb5_init.password  ? krb5_init.password  : "");
  14283.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14284. #endif /* COMMENT */
  14285. #endif /* CK_KERBEROS */
  14286.             printf("\n");
  14287.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14288.             break;
  14289. #ifdef CK_SSL
  14290.           case AUTHTYPE_SSL:
  14291.             kv = all ? AUTHTYPE_SRP : 0;
  14292.             if (ck_ssleay_is_installed()) {
  14293.                 printf(" Authentication:      SSL/TLS (%s)\n",
  14294.                         SSLeay_version(SSLEAY_VERSION));
  14295.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14296.             } else {
  14297.                 printf(" Authentication:      SSL/TLS (not installed)\n");
  14298.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14299.                 continue;
  14300.             }
  14301.             printf(" RSA Certs file: %s\n",ssl_rsa_cert_file?
  14302.                   ssl_rsa_cert_file:"(none)");
  14303.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14304.             printf(" RSA Certs Chain file: %s\n",ssl_rsa_cert_chain_file?
  14305.                   ssl_rsa_cert_chain_file:"(none)");
  14306.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14307.             printf(" RSA Key file: %s\n",ssl_rsa_key_file?
  14308.                   ssl_rsa_key_file:"(none)");
  14309.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14310.             printf(" DSA Certs file: %s\n",ssl_dsa_cert_file?
  14311.                   ssl_dsa_cert_file:"(none)");
  14312.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14313.             printf(" DSA Certs Chain file: %s\n",ssl_dsa_cert_chain_file?
  14314.                   ssl_dsa_cert_chain_file:"(none)");
  14315.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14316.             printf(" DH Key file: %s\n",ssl_dh_key_file?
  14317.                   ssl_dh_key_file:"(none)");
  14318.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14319.             printf(" DH Param file: %s\n",ssl_dh_param_file?
  14320.                   ssl_dh_param_file:"(none)");
  14321.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14322.             printf(" CRL file: %s\n",ssl_crl_file?
  14323.                   ssl_crl_file:"(none)");
  14324.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14325.             printf(" CRL dir: %s\n",ssl_crl_dir?
  14326.                     ssl_crl_dir:"(none)");
  14327.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14328.             printf(" Random file: %s\n",ssl_rnd_file?
  14329.                   ssl_rnd_file:"(none)");
  14330.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14331.             printf(" Verify file: %s\n",ssl_verify_file?
  14332.                   ssl_verify_file:"(none)");
  14333.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14334.             printf(" Verify dir: %s\n",ssl_verify_dir?
  14335.                   ssl_verify_dir:"(none)");
  14336.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14337.             printf(" Cipher list: %s\n",ssl_cipher_list ? ssl_cipher_list : 
  14338.             DEFAULT_CIPHER_LIST);
  14339.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14340.             if (ssl_con == NULL) {
  14341.                 SSL_library_init();
  14342.                 ssl_ctx = (SSL_CTX *)
  14343.                   SSL_CTX_new((SSL_METHOD *)TLSv1_method());
  14344.                 if (ssl_ctx != NULL)
  14345.                   ssl_con= (SSL *) SSL_new(ssl_ctx);
  14346.             }
  14347.             if (ssl_con != NULL) {
  14348.                 CHAR * p = NULL;
  14349.                 int i;
  14350.  
  14351.                 for (i = 0; ; i++) {
  14352.                     p = (CHAR *) SSL_get_cipher_list(ssl_con,i);
  14353.                     if (p == NULL)
  14354.                       break;
  14355.                     printf("    %s\n",p);
  14356.                     if (++n > cmd_rows - 3)
  14357.                         if (!askmore()) return(0); else n = 0;
  14358.                 }
  14359.             }
  14360.             printf(" Certs OK? %s\n",ssl_certsok_flag? "yes" : "no");
  14361.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14362.             printf(" Debug mode: %s\n", ssl_debug_flag ? "on" : "off");
  14363.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14364.             printf(" Verbose mode: %s\n", ssl_verbose_flag ? "on" : "off");
  14365.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14366.             printf(" Verify mode: %s\n",
  14367.                     ssl_verify_flag == SSL_VERIFY_NONE ? "none" :
  14368.                     ssl_verify_flag == SSL_VERIFY_PEER ? "peer-cert" :
  14369.                     "fail-if-no-peer-cert");
  14370.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14371.             printf(" SSL only? %s\n", ssl_only_flag ? "yes" : "no");
  14372.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14373.             printf(" TLS only? %s\n", tls_only_flag ? "yes" : "no");
  14374.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14375. #endif /* CK_SSL */
  14376.             break;
  14377.           case AUTHTYPE_NTLM:
  14378.             kv = 0;
  14379.             if (ck_ntlm_is_installed()) {
  14380.                 printf(" Authentication:      NTLM\n");
  14381.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14382.                 printf(" No options\n");
  14383.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14384.             } else {
  14385.                 printf(" Authentication:      NTLM (not installed)\n");
  14386.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14387.                 continue;
  14388.             }
  14389.             printf("\n");
  14390.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14391.             break;
  14392.           case AUTHTYPE_SRP:
  14393.             kv = all ? AUTHTYPE_NTLM : 0;
  14394.             if (ck_srp_is_installed()) {
  14395.                 if (ck_krypto_is_installed())
  14396.                     printf(" Authentication:      SRP plus Krypto API\n");
  14397.                 else
  14398.                     printf(" Authentication:      SRP\n");
  14399.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14400.                 printf(" No options\n");
  14401.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14402.             } else {
  14403.                 printf(" Authentication:      SRP (not installed)\n");
  14404.                 if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14405.                 continue;
  14406.             }
  14407.             printf("\n");
  14408.             if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  14409.             break;
  14410.         }
  14411.     }
  14412.     return(success = 1);
  14413. }
  14414. #endif /* CK_AUTHENTICATION */
  14415. #endif /* NOSHOW */
  14416.  
  14417. #ifdef CK_KERBEROS
  14418.  
  14419. /*  C P _ A U T H  --  AUTHENTICATE command parsing  */
  14420.  
  14421. int
  14422. cp_auth() {                             /* Command_Parse AUTHENTICATE */
  14423.     int c, i, n;                        /* Workers */
  14424.     int rc = 0;                         /* Return code */
  14425.     int getval;                         /* Parsing helpers */
  14426.     int tmpauth = 0;                    /* Temporary authentication type */
  14427.     int kv = 0;                         /* Temporary Kerberos version */
  14428.     int tmp_action = -1;                /* Temporary Kerberos action */
  14429.     int tmp_klc = 0;                    /* Temporary list-credentials */
  14430.     char tmphlp[256];                   /* For building help message */
  14431.     char * p;
  14432.     char * tmppswd  = NULL;             /* Password */
  14433.     char * tmpprinz = NULL;             /* Principal */
  14434.     char * tmprealm = NULL;             /* Realm */
  14435.     char * tmpcache = NULL;             /* Cache file */
  14436.     char * tmpinst  = NULL;             /* K4 Instance */
  14437.     char * tmpaddrs[KRB5_NUM_OF_ADDRS];
  14438. #ifdef CK_RECALL
  14439.     extern int on_recall;               /* around Password prompting */
  14440. #endif /* CK_RECALL */
  14441.     struct stringint pv[KRB_I_MAX+1];   /* Temporary array for switch values */
  14442.     struct FDB kw, sw, fl;              /* FDBs for each parse function */
  14443.  
  14444.     krb_action = -1;                    /* Initialize Kerberos action. */
  14445.     tmp_action = -1;                    /* And our local copy. */
  14446.     for (i = 0; i < KRB5_NUM_OF_ADDRS; i++)
  14447.       tmpaddrs[i] = NULL;
  14448.  
  14449.     if ((y = cmkey(kerbtab,kerbtabn,"authentication type","",xxstring)) < 0)
  14450.       {
  14451.           if (y == -3)
  14452.             printf("?Authentication type not specified - nothing happens\n");
  14453.           return(y);
  14454.       }
  14455.     tmpauth = y;
  14456.     debug(F101,"kerberos authentication","",tmpauth);
  14457.     switch (tmpauth) {
  14458.       case AUTH_KRB4: kv = 4; break;    /* Don't assume values are the same */
  14459.       case AUTH_KRB5: kv = 5; break;
  14460.       default:
  14461.         printf("?Authentication type not supported: \"%s\"\n",atmbuf);
  14462.         return(-9);
  14463.     }
  14464.  
  14465.     /* From here down is Kerberos */
  14466.     ini_kerb();                         /* Reset Init data to defaults */
  14467.  
  14468.     if (kv == 4) {                      /* Set K4 defaults */
  14469.         if (krb4_d_realm)
  14470.           makestr(&tmprealm,krb4_d_realm);
  14471.         if (krb4_d_principal)
  14472.           makestr(&tmpprinz,krb4_d_principal);
  14473.         if (krb4_d_instance)
  14474.           makestr(&tmpinst,krb4_d_instance);
  14475.     } else if (kv == 5) {               /* Set K5 defaults */
  14476.         if (krb5_d_cc)
  14477.           makestr(&tmpcache,krb5_d_cc);
  14478.         if (krb5_d_realm)
  14479.           makestr(&tmprealm,krb5_d_realm);
  14480.         if (krb5_d_principal)
  14481.           makestr(&tmpprinz,krb5_d_principal);
  14482.         if (krb5_d_instance)
  14483.           makestr(&tmpinst,krb5_d_instance);
  14484.     }
  14485.     for (i = 0; i <= KRB_I_MAX; i++) {  /* Initialize switch values */
  14486.         pv[i].sval = NULL;              /* to null pointers */
  14487.         pv[i].ival = 0;                 /* and 0 int values */
  14488.         pv[i].wval = (CK_OFF_T)-1;    /* and -1 wide values */
  14489.     }
  14490.     if (kv == 4) {                      /* Kerberos 4 */
  14491.         pv[KRB_I_LF].ival = krb4_d_lifetime;
  14492.         pv[KRB_I_PA].ival = krb4_d_preauth;
  14493.  
  14494.         if ((n = cmkey(krb_a_tbl,krb_a_n,"Kerberos 4 action","",xxstring)) < 0)
  14495.           {
  14496.               if (n == -3)
  14497.                 printf("?Action not specified - nothing happens.\n");
  14498.               return(n);
  14499.           }
  14500.     } else if (kv == 5) {               /* Kerberos 5 */
  14501.         pv[KRB_I_FW].ival = krb5_d_forwardable;
  14502.         pv[KRB_I_PR].ival = krb5_d_proxiable;
  14503.         pv[KRB_I_LF].ival = krb5_d_lifetime;
  14504.         pv[KRB_I_RB].ival = krb5_d_renewable;
  14505.         pv[KRB_I_K4].ival = krb5_d_getk4;
  14506.         pv[KRB_I_NAD].ival = krb5_d_no_addresses;
  14507.  
  14508.         /* Make help message that shows switches and action keywords */
  14509.         ckstrncpy(tmphlp,"Kerberos 5 action, one of the following:\n ",256);
  14510.         for (i = 0; i < krb_a_n; i++) {
  14511.             ckstrncat(tmphlp,krb_a_tbl[i].kwd,sizeof(tmphlp));
  14512.             if (i == krb_a_n - 1)
  14513.               ckstrncat(tmphlp,"\nor switch",sizeof(tmphlp));
  14514.             else
  14515.               ckstrncat(tmphlp,"   ",sizeof(tmphlp));
  14516.         }
  14517.         /* Set up first set of chained FDB's */
  14518.  
  14519.         cmfdbi(&sw,                     /* First FDB - command switches */
  14520.                _CMKEY,                  /* fcode */
  14521.                tmphlp,                  /* hlpmsg */
  14522.                "",                      /* default (none) */
  14523.                "",                      /* addtl string data */
  14524.                krb_s_n,                 /* Switch table size */
  14525.                4,                       /* addtl numeric data 2: 4 = cmswi */
  14526.                xxstring,                /* Processing function */
  14527.                krb_s_tbl,               /* Switch table */
  14528.                &kw                      /* Pointer to next FDB */
  14529.                );
  14530.         cmfdbi(&kw,                     /* Second FDB - action keywords */
  14531.                _CMKEY,                  /* fcode */
  14532.                "Kerberos action",       /* hlpmsg */
  14533.                "",                      /* default (none) */
  14534.                "",                      /* addtl string data */
  14535.                krb_a_n,                 /* Switch table size */
  14536.                0,                       /* addtl num data (0 = NOT switch) */
  14537.                xxstring,                /* Processing function */
  14538.                krb_a_tbl,               /* Keyword table */
  14539.                NULL                     /* Pointer to next FDB (none) */
  14540.                );
  14541.  
  14542.         /* Parse */
  14543.  
  14544.         while (1) {                     /* Parse 0 or more switches */
  14545.             rc = cmfdb(&sw);            /* Parse something */
  14546.             debug(F101,"kerberos cmfdb 1 rc","",rc);
  14547.             if (rc < 0) {                       /* Error */
  14548.                 if (rc == -3)
  14549.                   printf("?Action not specified - nothing happens.\n");
  14550.                 return(rc);             /* or reparse needed */
  14551.             }
  14552.             if (cmresult.fdbaddr != &sw) /* Break out if not a switch */
  14553.               break;
  14554.             c = cmgbrk();               /* Have switch - get break character */
  14555.             getval = (c == ':' || c == '='); /* Must parse an agument? */
  14556.             if (getval && !(cmresult.kflags & CM_ARG)) {
  14557.                 printf("?This switch does not take arguments\n");
  14558.                 return(-9);             /* OK because nothing malloc'd yet */
  14559.             }
  14560.             if (!getval && (cmgkwflgs() & CM_ARG)) {
  14561.                 printf("?This switch requires an argument\n");
  14562.                 return(-9);
  14563.             }
  14564.             n = cmresult.nresult;       /* Numeric result = switch value */
  14565.             debug(F101,"kerberos command switch","",n);
  14566.  
  14567.             switch (n) {                /* Handle the switch */
  14568.               case KRB_S_CA:            /* /CACHE:<filename> */
  14569.                 p = krb5_d_cc ? krb5_d_cc : "";
  14570.                 if ((y = cmofi("Name of cache file",p,&s,xxstring)) < 0) {
  14571.                     if (y == -3)
  14572.                       s = NULL;
  14573.                     else
  14574.                       return(y);
  14575.                 }
  14576.                 makestr(&tmpcache,s);
  14577.                 break;
  14578.               default:
  14579.                 printf("?Unexpected switch value - internal error\n");
  14580.                 return(-9);             /* (if) nothing malloc'd yet. */
  14581.             }
  14582.         }
  14583.         if (cmresult.fdbaddr != &kw) {  /* Checking... */
  14584.             printf("?Unexpected result - internal error\n");
  14585.             return(-9);                 /* Nothing malloc'd yet. */
  14586.         }
  14587.         n = cmresult.nresult;           /* Get keyword value */
  14588.     } else {
  14589.         printf("?Unexpected Kerberos version - Internal error\n");
  14590.         return(-9);
  14591.     }
  14592.     debug(F101,"kerberos action","",n);
  14593.     switch (n) {
  14594.       case KRB_A_IN:                    /* INITIALIZE */
  14595.       case KRB_A_DE:                    /* DESTROY */
  14596.       case KRB_A_LC:                    /* LIST-CREDENTIALS */
  14597.         tmp_action = n;                 /* OK, set */
  14598.         break;
  14599.       default:                          /* Not OK, punt. */
  14600.         printf("?Unexpected action - internal error\n");
  14601.         return(-9);
  14602.     }
  14603.     if (tmp_action == KRB_A_IN) {       /* Action is INITIALIZE */
  14604.         int x;
  14605.         cmfdbi(&sw,                     /* INITIALIZE switches */
  14606.                _CMKEY,                  /* fcode */
  14607.                "Principal,\n or optional INITIALIZE switch(es)", /* hlpmsg */
  14608.                "",                      /* default (none) */
  14609.                "",                      /* addtl string data */
  14610.                kv == 4 ?  krb4_i_n : krb5_i_n, /* Switch table size */
  14611.                4,                       /* addtl numeric data 2: 4 = cmswi */
  14612.                xxstring,                /* Processing function */
  14613.                kv == 4 ?  krb4_i_tbl : krb5_i_tbl,      /* Switch table */
  14614.                &fl                      /* Pointer to next FDB */
  14615.                );
  14616.         cmfdbi(&fl,                     /* 3rd FDB - command to send from */
  14617.                _CMFLD,                  /* fcode */
  14618.                "Principal",             /* hlpmsg */
  14619.                kv == 4 ? krb4_d_principal : krb5_d_principal, /* principal */
  14620.                "",                      /* addtl string data */
  14621.                0,                       /* addtl numeric data 1 */
  14622.                0,                       /* addtl numeric data 2 */
  14623.                xxstring,
  14624.                NULL,
  14625.                NULL
  14626.                );
  14627.         while (1) {                     /* Parse INIT switches or principal */
  14628.             rc = cmfdb(&sw);
  14629.             debug(F101,"kerberos cmfdb 2 rc","",rc);
  14630.             if (rc < 0) {
  14631.                 if (rc == -3)
  14632.                   printf("?Principal name required\n");
  14633.                 goto kerbx;
  14634.             }
  14635.             debug(F101,"kerberos cmfdb 2 fcode","",cmresult.fcode);
  14636.             if (cmresult.fcode != _CMKEY) /* Not a switch, quit switch loop */
  14637.               break;
  14638.             c = cmgbrk();               /* Switch - get break character */
  14639.             debug(F101,"kerberos cmfdb 2 cmgbrk","",c);
  14640.             getval = (c == ':' || c == '=');
  14641.             if (getval && !(cmresult.kflags & CM_ARG)) {
  14642.                 printf("?This switch does not take arguments\n");
  14643.                 return(-9);             /* OK because nothing malloc'd yet */
  14644.             }
  14645.             if (!getval && (cmgkwflgs() & CM_ARG)) {
  14646.                 printf("?This switch requires an argument\n");
  14647.                 return(-9);
  14648.             }
  14649.             n = cmresult.nresult;       /* Numeric result = switch value */
  14650.             switch (n) {
  14651.               /* These don't take args... */
  14652.               case KRB_I_PA:            /* /PREAUTH */
  14653.               case KRB_I_FW:            /* /FORWARDABLE */
  14654.               case KRB_I_PR:            /* /PROXIABLE */
  14655.               case KRB_I_RN:            /* /RENEW */
  14656.               case KRB_I_VA:            /* /VALIDATE */
  14657.               case KRB_I_NPA:           /* /NOT-PREAUTH */
  14658.               case KRB_I_NFW:           /* /NOT-FORWARDABLE */
  14659.               case KRB_I_NPR:           /* /NOT-PROXIABLE */
  14660.               case KRB_I_VB:            /* /VERBOSE */
  14661.               case KRB_I_BR:            /* /BRIEF */
  14662.               case KRB_I_K4:            /* /KERBEROS4 */
  14663.               case KRB_I_NK4:           /* /NO-KERBEROS4 */
  14664.               case KRB_I_POP:           /* /POPUP */
  14665.               case KRB_I_NAD:           /* /NO-ADDRESSES */
  14666.                 if (getval) {
  14667.                     printf("?This switch does not take a value\n");
  14668.                     rc = -9;
  14669.                     goto kerbx;
  14670.                 }
  14671.                 switch (n) {
  14672.                   case KRB_I_NPA:
  14673.                     pv[KRB_I_PA].ival = 0;
  14674.                     break;
  14675.                   case KRB_I_NFW:
  14676.                     pv[KRB_I_FW].ival = 0;
  14677.                     break;
  14678.                   case KRB_I_NPR:
  14679.                     pv[KRB_I_PR].ival = 0;
  14680.                     break;
  14681.                   case KRB_I_VB:
  14682.                     pv[KRB_I_BR].ival = 0;
  14683.                     break;
  14684.                   case KRB_I_NK4:
  14685.                     pv[KRB_I_K4].ival = 0;
  14686.                     break;
  14687.                   default:
  14688.                     pv[n].ival = 1;
  14689.                 }
  14690.                 break;
  14691.  
  14692.                 /* These do take arguments */
  14693.  
  14694.               case KRB_I_RB:            /* /RENEWABLE:<minutes> */
  14695.                 pv[n].ival = 0;
  14696.                 if (!getval) break;
  14697.                 if ((rc = cmnum("Minutes",ckitoa(krb5_init.renewable),
  14698.                                 10,&y, xxstring)) < 0)
  14699.                   goto kerbx;
  14700.                 pv[n].ival = y;
  14701.                 break;
  14702.  
  14703.               case KRB_I_LF:            /* /LIFETIME:<minutes> */
  14704.                 pv[n].ival = 0;
  14705.                 /* Default is previous value */
  14706.                 sprintf(tmpbuf,"%d",    /* SAFE */
  14707.                         kv == 4 ?
  14708.                         krb4_init.lifetime :
  14709.                         krb5_init.lifetime
  14710.                         );
  14711.                 if (!getval) break;
  14712.                 if ((rc = cmnum("Minutes",tmpbuf,10,&y, xxstring)) < 0)
  14713.                   goto kerbx;
  14714.                 pv[n].ival = y;
  14715.                 break;
  14716.  
  14717.               case KRB_I_PD:            /* /POSTDATE:<timestamp> */
  14718.                 if (pv[n].sval) {
  14719.                     free(pv[n].sval);
  14720.                     pv[n].sval = NULL;
  14721.                 }
  14722.                 if (!getval) break;
  14723.                 if ((rc = cmdate("date-time","",&s,0,xxstring)) < 0)
  14724.                   goto kerbx;
  14725.                 makestr(&(pv[n].sval),s);
  14726.                 break;
  14727.  
  14728.               case KRB_I_SR:            /* /SERVICE:<name> */
  14729.                 if (pv[n].sval) {
  14730.                     free(pv[n].sval);
  14731.                     pv[n].sval = NULL;
  14732.                 }
  14733.                 if (!getval) break;
  14734.                 if ((rc = cmfld("Service-name","",&s,xxstring)) < 0)
  14735.                   goto kerbx;
  14736.                 makestr(&(pv[n].sval),s);
  14737.                 break;
  14738.  
  14739.               case KRB_I_RL:            /* /REALM:<name> */
  14740.                 if (pv[n].sval) {
  14741.                     free(pv[n].sval);
  14742.                     pv[n].sval = NULL;
  14743.                 }
  14744.                 if (!getval) break;
  14745.                 if (kv == 4)
  14746.                   p = krb4_d_realm ? krb4_d_realm : "";
  14747.                 else
  14748.                   p = krb5_d_realm ? krb5_d_realm : "";
  14749.                 if ((rc = cmfld("Realm",p,&s,xxstring)) < 0)
  14750.                   goto kerbx;
  14751.                 makestr(&(pv[n].sval),s);
  14752.                 break;
  14753.  
  14754.               case KRB_I_IN:            /* /INSTANCE:<name> */
  14755.                 if (pv[n].sval) {
  14756.                     free(pv[n].sval);
  14757.                     pv[n].sval = NULL;
  14758.                 }
  14759.                 if (!getval) break;
  14760.                 if (kv == 4)
  14761.                     p = krb4_d_instance ? krb4_d_instance : "";
  14762.                 else
  14763.                     p = krb5_d_instance ? krb5_d_instance : "";
  14764.                 if ((rc = cmfld("Instance",p,&s,xxstring)) < 0)
  14765.                   goto kerbx;
  14766.                 makestr(&(pv[n].sval),s);
  14767.                 break;
  14768.  
  14769.               case KRB_I_PW:            /* /PASSWORD:<password> */
  14770.                 debok = 0;
  14771.                 if (pv[n].sval) {
  14772.                     free(pv[n].sval);
  14773.                     pv[n].sval = NULL;
  14774.                 }
  14775.                 if (!getval) break;
  14776.                 if ((rc = cmfld("Password","",&s,xxstring)) < 0)
  14777.                   if (rc != -3)
  14778.                     goto kerbx;
  14779.                 makestr(&(pv[n].sval),s);
  14780.                 break;
  14781.  
  14782.               case KRB_I_ADR:           /* /ADDRESSES:{<address-list>} */
  14783.                 if (pv[n].sval) {
  14784.                     free(pv[n].sval);
  14785.                     pv[n].sval = NULL;
  14786.                 }
  14787.                 if (!getval) break;
  14788.                 if ((rc = cmfld("List of IP addresses","",&s,xxstring)) < 0)
  14789.                   goto kerbx;
  14790.                 makelist(s,tmpaddrs,KRB5_NUM_OF_ADDRS);
  14791.                 for (i = 0; i < KRB5_NUM_OF_ADDRS && tmpaddrs[i]; i++) {
  14792.                     if (inet_addr(tmpaddrs[i]) == 0xffffffff) {
  14793.                         printf("invalid ip address: %s\n",tmpaddrs[i]);
  14794.                         rc = -9;
  14795.                         goto kerbx;
  14796.                     }
  14797.                 }
  14798.                 pv[KRB_I_NAD].ival = 0;
  14799.                 break;
  14800.  
  14801.               default:
  14802.                 printf("?Unexpected switch value - internal error\n");
  14803.                 rc = -9;
  14804.                 goto kerbx;
  14805.             }
  14806.         }
  14807.         if (cmresult.fcode != _CMFLD) {
  14808.             printf("?Unexected result - internal error\n");
  14809.             rc = -9;
  14810.             goto kerbx;
  14811.         }
  14812.         /* cmresult.sresult may be of the form PRINCIPAL@REALM */
  14813.         i = ckindex("@",cmresult.sresult,0,0,0);
  14814.         if (i != 0) {
  14815.             makestr(&tmprealm,&cmresult.sresult[i]);
  14816.             cmresult.sresult[i-1] = '\0';
  14817.         }
  14818.         makestr(&tmpprinz,cmresult.sresult); /* Principal (user) */
  14819.  
  14820.         if ((rc = cmcfm()) < 0) {       /* Now get confirmation */
  14821.             if (rc == -3) {
  14822.                 printf("?Principal name required\n");
  14823.             }
  14824.             goto kerbx;
  14825.         }
  14826.         if (!tmpprinz || !tmpprinz[0]) {
  14827.             printf("?Principal name required\n");
  14828.             goto kerbx;
  14829.         }
  14830.         if (!pv[KRB_I_RN].ival && !pv[KRB_I_VA].ival) {
  14831.             /* Don't use a password if Validating or Renewing */
  14832.             if (pv[KRB_I_PW].sval) {    /* If they gave a /PASSWORD switch */
  14833.                 makestr(&tmppswd,pv[KRB_I_PW].sval); /* use this value */
  14834.             }
  14835. #ifdef COMMENT
  14836.             /* Password prompting has been moved to ck_krb[45]_initTGT() */
  14837.             else {                      /* Otherwise must prompt for it */
  14838.                 char prmpt[80];
  14839.                 if (pv[KRB_I_RL].sval)
  14840.                   sprintf(prmpt,"%s@%s's Password: ",
  14841.                           tmpprinz,pv[KRB_I_RL].sval);
  14842.                 else if (tmprealm)
  14843.                   sprintf(prmpt,"%s@%s's Password: ",
  14844.                           tmpprinz,tmprealm);
  14845.                 else
  14846.                   sprintf(prmpt,"%s's Password: ",tmpprinz);
  14847. #ifdef OS2
  14848.                 if (pv[KRB_I_POP].ival) {
  14849.                     char passwd[80]="";
  14850.                     readpass(prmpt,passwd,80);
  14851.                     makestr(&tmppswd,passwd);
  14852.                     memset(passwd,0,80);
  14853.                 } else
  14854. #endif /* OS2 */
  14855.                 {
  14856. #ifdef CK_RECALL
  14857.                     on_recall = 0;
  14858. #endif /* CK_RECALL */
  14859.                     cmsavp(psave,PROMPTL); /* Save old prompt */
  14860.                     cmsetp(prmpt);      /* Make new prompt */
  14861.                     concb((char)escape); /* Put console in cbreak mode */
  14862.                     cmini(0);           /* and no-echo mode */
  14863.                     /* Issue prompt if at top level */
  14864.                     if (pflag) prompt(xxstring);
  14865.                     cmres();            /* Reset the parser */
  14866.                     for (rc = -1; rc < 0; ) { /* Prompt till they answer */
  14867.                         /* Get a literal line of text */
  14868.                         rc = cmtxt("","",&s,NULL);
  14869.                         cmres();        /* Reset the parser again */
  14870.                     }
  14871.                     makestr(&tmppswd,s);
  14872.                     printf("\n");       /* Echo a CRLF */
  14873.                     cmsetp(psave);      /* Restore original prompt */
  14874.                 }
  14875.             }
  14876.             x = 0;                      /* Check for password */
  14877.             if (tmppswd)
  14878.               if (*tmppswd)
  14879.                 x = 1;
  14880.             if (!x) {
  14881.                 printf("?Password required\n");
  14882.                 goto kerbx;
  14883.             }
  14884. #endif /* COMMENT */
  14885.         }
  14886.     } else if (kv == 5 && tmp_action == KRB_A_LC) { /* LIST-CREDENTIALS */
  14887.         tmp_klc = 0;
  14888.         while (1) {
  14889.             if ((x = cmkey(klctab,nklctab,"Switch","",xxstring)) < 0) {
  14890.                 if (x == -3) {
  14891.                     if ((rc = cmcfm()) < 0)
  14892.                       goto kerbx;
  14893.                     else
  14894.                       break;
  14895.                 } else {
  14896.                     rc = x;
  14897.                     goto kerbx;
  14898.                 }
  14899.             }
  14900.             tmp_klc |= x;
  14901.         }
  14902.     } else if ((rc = cmcfm()) < 0)      /* DESTROY, just confirm */
  14903.         goto kerbx;
  14904.  
  14905. /* Done - Move confirmed data to final locations */
  14906.  
  14907.     krb_action = tmp_action;            /* Action requested */
  14908.     krb_op.version = kv;                /* Kerberos version */
  14909.     krb_op.cache = tmpcache;            /* Cache file */
  14910.     tmpcache = NULL;                    /* So we don't free it */
  14911.  
  14912.     switch (krb_action) {
  14913.       case KRB_A_IN:                    /* INITIALIZE */
  14914.         if (kv == 5) {
  14915.             krb5_init.forwardable = pv[KRB_I_FW].ival;
  14916.             krb5_init.proxiable   = pv[KRB_I_PR].ival;
  14917.             krb5_init.lifetime    = pv[KRB_I_LF].ival;
  14918.             krb5_init.renew       = pv[KRB_I_RN].ival;
  14919.             krb5_init.renewable   = pv[KRB_I_RB].ival;
  14920.             krb5_init.validate    = pv[KRB_I_VA].ival;
  14921.  
  14922.             /* Here we just reassign the pointers and then set them to NULL */
  14923.             /* so they won't be freed below. */
  14924.  
  14925.             krb5_init.postdate = pv[KRB_I_PD].sval; pv[KRB_I_PD].sval = NULL;
  14926.             krb5_init.service  = pv[KRB_I_SR].sval; pv[KRB_I_SR].sval = NULL;
  14927.             if (pv[KRB_I_RL].sval) {
  14928.                 krb5_init.realm  = pv[KRB_I_RL].sval; pv[KRB_I_RL].sval = NULL;
  14929.             } else if (tmprealm) {
  14930.                 krb5_init.realm = tmprealm; tmprealm = NULL;
  14931.             }
  14932.             if (pv[KRB_I_IN].sval) {
  14933.                 krb5_init.instance = pv[KRB_I_IN].sval;
  14934.                 pv[KRB_I_IN].sval = NULL;
  14935.             } else if ( tmpinst ) {
  14936.                 krb5_init.instance = tmpinst;
  14937.                 tmpinst = NULL;
  14938.             }
  14939.             if (tmpprinz) {
  14940.                 krb5_init.principal = tmpprinz;
  14941.                 tmpprinz = NULL;
  14942.             }
  14943.             krb5_init.password = tmppswd;
  14944.             tmppswd = NULL;
  14945.  
  14946.             krb5_init.getk4 = pv[KRB_I_K4].ival;
  14947.             if (krb5_init.getk4) {
  14948.                 krb4_init.lifetime = pv[KRB_I_LF].ival;
  14949.                 if (krb5_init.realm)
  14950.                     makestr(&krb4_init.realm,krb5_init.realm);
  14951.                 krb4_init.preauth  = krb4_d_preauth;
  14952.                 krb4_init.verbose  = pv[KRB_I_BR].ival ? 0 : 1;
  14953.                 if (krb5_init.principal)
  14954.                     makestr(&krb4_init.principal,krb5_init.principal);
  14955.                 if (krb5_init.principal)
  14956.                     makestr(&krb4_init.password,krb5_init.password);
  14957.             }
  14958.             krb5_init.no_addresses = pv[KRB_I_NAD].ival;
  14959.             if (tmpaddrs[0]) {
  14960.                 for (i = 0; i < KRB5_NUM_OF_ADDRS; i++) {
  14961.                     if (krb5_init.addrs[i]) {
  14962.                         free(krb5_init.addrs[i]);
  14963.                         krb5_init.addrs[i] = NULL;
  14964.                     }
  14965.                     krb5_init.addrs[i] = tmpaddrs[i];
  14966.                     tmpaddrs[i] = NULL;
  14967.                 }
  14968.             }
  14969.         } else if (kv == 4) {           /* Same deal for Kerberos 4 */
  14970.             krb4_init.lifetime = pv[KRB_I_LF].ival;
  14971.             if (pv[KRB_I_RL].sval) {
  14972.                 krb4_init.realm  = pv[KRB_I_RL].sval;
  14973.                 pv[KRB_I_RL].sval = NULL;
  14974.             } else if ( tmprealm ) {
  14975.                 krb4_init.realm  = tmprealm;
  14976.                 tmprealm = NULL;
  14977.             }
  14978.             if (pv[KRB_I_IN].sval) {
  14979.                 krb4_init.instance = pv[KRB_I_IN].sval;
  14980.                 pv[KRB_I_IN].sval = NULL;
  14981.             } else if ( tmpinst ) {
  14982.                 krb4_init.instance = tmpinst;
  14983.                 tmpinst = NULL;
  14984.             }
  14985.             krb4_init.preauth  = pv[KRB_I_PA].ival;
  14986.             krb4_init.verbose  = pv[KRB_I_BR].ival ? 0 : 1;
  14987.  
  14988.             if (tmpprinz) {
  14989.                 krb4_init.principal = tmpprinz;
  14990.                 tmpprinz = NULL;
  14991.             }
  14992.             krb4_init.password = tmppswd;
  14993.             tmppswd = NULL;
  14994.         }
  14995.         break;
  14996.       case KRB_A_LC:                    /* List Credentials */
  14997.         krb5_lc.encryption = tmp_klc & XYKLCEN;
  14998.         krb5_lc.flags = tmp_klc & XYKLCFL;
  14999.         krb5_lc.addr  = tmp_klc & XYKLCAD;
  15000.         break;
  15001.     }
  15002.  
  15003. /* Common exit - Free temporary storage */
  15004.  
  15005.   kerbx:
  15006.     for (i = 0; i <= KRB_I_MAX; i++) {  /* Free malloc'd switch data */
  15007.         if (pv[i].sval)
  15008.           free(pv[i].sval);
  15009.     }
  15010.     for (i = 0; i < KRB5_NUM_OF_ADDRS; i++) {
  15011.         if (tmpaddrs[i])
  15012.           free(tmpaddrs[i]);
  15013.     }
  15014.     if (tmpprinz) free(tmpprinz);       /* And these too. */
  15015.     if (tmppswd)  free(tmppswd);
  15016.     if (tmpcache) free(tmpcache);
  15017.     if (tmprealm) free(tmprealm);
  15018.     if (tmpinst)  free(tmpinst);
  15019.  
  15020.     return(rc);                         /* Return the return code */
  15021. }
  15022. #endif /* CK_KERBEROS */
  15023.  
  15024. #ifdef CK_LOGIN
  15025. int
  15026. #ifdef CK_ANSIC
  15027. ckxlogin(CHAR * userid, CHAR * passwd, CHAR * acct, int promptok)
  15028. #else /* CK_ANSIC */
  15029. ckxlogin(userid, passwd, acct, promptok)
  15030.   CHAR * userid; CHAR * passwd; CHAR * acct; int promptok;
  15031. #endif /* CK_ANSIC */
  15032. /* ckxlogin */ {
  15033. #ifdef CK_RECALL
  15034.     extern int on_recall;               /* around Password prompting */
  15035. #endif /* CK_RECALL */
  15036. #ifdef COMMENT
  15037.     extern int guest;
  15038. #endif /* COMMENT */
  15039.     int rprompt = 0;                    /* Restore prompt */
  15040. #ifdef CKSYSLOG
  15041.     int savlog;
  15042. #endif /* CKSYSLOG */
  15043.  
  15044.     extern int what, srvcdmsg;
  15045.  
  15046.     int x = 0, ok = 0, rc = 0;
  15047.     CHAR * _u = NULL, * _p = NULL, * _a = NULL;
  15048.  
  15049.     debug(F111,"ckxlogin userid",userid,promptok);
  15050.     debug(F110,"ckxlogin passwd",passwd,0);
  15051.  
  15052.     isguest = 0;                        /* Global "anonymous" flag */
  15053.  
  15054.     if (!userid) userid = (CHAR *)"";
  15055.     if (!passwd) passwd = (CHAR *)"";
  15056.  
  15057.     debug(F111,"ckxlogin userid",userid,what);
  15058.  
  15059. #ifdef CK_RECALL
  15060.     on_recall = 0;
  15061. #endif /* CK_RECALL */
  15062.  
  15063. #ifdef CKSYSLOG
  15064.     savlog = ckxsyslog;                 /* Save and turn off syslogging */
  15065. #endif /* CKSYSLOG */
  15066.  
  15067.     if ((!*userid || !*passwd) &&       /* Need to prompt for missing info */
  15068.         promptok) {
  15069.         cmsavp(psave,PROMPTL);          /* Save old prompt */
  15070.         debug(F110,"ckxlogin saved",psave,0);
  15071.         rprompt = 1;
  15072.     }
  15073.     if (!*userid) {
  15074.         if (!promptok)
  15075.           return(0);
  15076.         cmsetp("Username: ");           /* Make new prompt */
  15077.         concb((char)escape);            /* Put console in cbreak mode */
  15078.         cmini(1);
  15079.  
  15080. /* Flush typeahead */
  15081.  
  15082. #ifdef IKS_OPTION
  15083.         debug(F101,
  15084.               "ckxlogin TELOPT_SB(TELOPT_KERMIT).kermit.me_start",
  15085.               "",
  15086.               TELOPT_SB(TELOPT_KERMIT).kermit.me_start
  15087.               );
  15088. #endif /* IKS_OPTION */
  15089.  
  15090.         while (ttchk() > 0) {
  15091.             x = ttinc(0);
  15092.             debug(F101,"ckxlogin flush user x","",x);
  15093.             if (x < 0)
  15094.               doexit(GOOD_EXIT,0);      /* Connection lost */
  15095. #ifdef TNCODE
  15096.             if (sstelnet) {
  15097.                 if (x == IAC) {
  15098.                     x = tn_doop((CHAR)(x & 0xff),ckxech,ttinc);
  15099.                     debug(F101,"ckxlogin user tn_doop","",x);
  15100. #ifdef IKS_OPTION
  15101.                     debug(F101,
  15102.                       "ckxlogin user TELOPT_SB(TELOPT_KERMIT).kermit.me_start",
  15103.                       "",
  15104.                       TELOPT_SB(TELOPT_KERMIT).kermit.me_start
  15105.                       );
  15106. #endif /* IKS_OPTION */
  15107.  
  15108.                     if (x < 0)
  15109.                       goto XCKXLOG;
  15110.                     switch (x) {
  15111.                       case 1: ckxech = 1; break; /* Turn on echoing */
  15112.                       case 2: ckxech = 0; break; /* Turn off echoing */
  15113. #ifdef IKS_OPTION
  15114.                       case 4:                    /* IKS event */
  15115.                         if (!TELOPT_SB(TELOPT_KERMIT).kermit.me_start)
  15116.                           break;                 /* else fall thru... */
  15117. #endif /* IKS_OPTION */
  15118.                       case 6:                    /* Logout */
  15119.                         goto XCKXLOG;
  15120.                     }
  15121.                 }
  15122.             }
  15123. #endif /* TNCODE */
  15124.         }
  15125.         if (pflag) prompt(xxstring);    /* Issue prompt if at top level */
  15126.         cmres();                        /* Reset the parser */
  15127.         for (x = -1; x < 0;) {          /* Prompt till they answer */
  15128.             /* Get a literal line of text */
  15129.             x=cmtxt("Your username, or \"ftp\", or \"anonymous\"","",&s,NULL);
  15130.             if (x == -4 || x == -10) {
  15131.                 printf("\r\n%sLogin cancelled\n",
  15132.                x == -10 ? "Timed out: " : "");
  15133. #ifdef CKSYSLOG
  15134.                 ckxsyslog = savlog;
  15135. #endif /* CKSYSLOG */
  15136.                 doexit(GOOD_EXIT,0);
  15137.             }
  15138.             if (sstate)                 /* Did a packet come instead? */
  15139.               goto XCKXLOG;
  15140.             cmres();                    /* Reset the parser again */
  15141.         }
  15142.         if ((_u = (CHAR *)malloc((int)strlen(s) + 1)) == NULL) {
  15143.             printf("?Internal error: malloc\n");
  15144.             goto XCKXLOG;
  15145.         } else {
  15146.             strcpy((char *)_u,s);       /* safe */
  15147.             userid = _u;
  15148.         }
  15149.     }
  15150.     ok = zvuser((char *)userid);        /* Verify username */
  15151.     debug(F111,"ckxlogin zvuser",userid,ok);
  15152.  
  15153.     if (!*passwd && promptok
  15154. #ifdef COMMENT
  15155.         && guest
  15156. #endif /* COMMENT */
  15157.         ) {
  15158.         char prmpt[80];
  15159.  
  15160. #ifdef CKSYSLOG
  15161.         savlog = ckxsyslog;             /* Save and turn off syslogging */
  15162.         ckxsyslog = 0;
  15163. #endif /* CKSYSLOG */
  15164.  
  15165. /* Flush typeahead again */
  15166.  
  15167.         while (ttchk() > 0) {
  15168.             x = ttinc(0);
  15169.             debug(F101,"ckxlogin flush user x","",x);
  15170. #ifdef TNCODE
  15171.             if (sstelnet) {
  15172.                 if (x == IAC) {
  15173.                     x = tn_doop((CHAR)(x & 0xff),ckxech,ttinc);
  15174.                     debug(F101,"ckxlogin pass tn_doop","",x);
  15175. #ifdef IKS_OPTION
  15176.                     debug(F101,
  15177.                       "ckxlogin pass TELOPT_SB(TELOPT_KERMIT).kermit.me_start",
  15178.                       "",
  15179.                       TELOPT_SB(TELOPT_KERMIT).kermit.me_start
  15180.                       );
  15181. #endif /* IKS_OPTION */
  15182.                     if (x < 0)
  15183.                       goto XCKXLOG;
  15184.                     switch (x) {
  15185.                       case 1: ckxech = 1; break; /* Turn on echoing */
  15186.                       case 2: ckxech = 0; break; /* Turn off echoing */
  15187.                       case 4:                    /* IKS event */
  15188.                         if (!TELOPT_SB(TELOPT_KERMIT).kermit.me_start)
  15189.                           break;                 /* else fall thru... */
  15190.                       case 6:                    /* Logout */
  15191.                         goto XCKXLOG;
  15192.                     }
  15193.                 }
  15194.             }
  15195. #endif /* TNCODE */
  15196.         }
  15197.         if (!strcmp((char *)userid,"anonymous") ||
  15198.             !strcmp((char *)userid,"ftp")) {
  15199.             if (!ok)
  15200.               goto XCKXLOG;
  15201.             ckstrncpy(prmpt,"Enter e-mail address as Password: ",80);
  15202.         } else if (*userid && strlen((char *)userid) < 60) {
  15203. #ifdef NT
  15204.             extern CHAR * pReferenceDomainName;
  15205.             if (pReferenceDomainName)
  15206.               ckmakxmsg(prmpt,
  15207.                        80,
  15208.                        "Enter ",
  15209.                        pReferenceDomainName,
  15210.                        "\\\\",
  15211.                        userid,
  15212.                        "'s Password: ",
  15213.                        NULL,NULL,NULL,NULL,NULL,NULL,NULL
  15214.                        );
  15215.             else
  15216. #endif /* NT */
  15217.               ckmakmsg(prmpt,80,"Enter ",(char *)userid,"'s Password: ",NULL);
  15218.         } else
  15219.           ckstrncpy(prmpt,"Enter Password: ",80);
  15220.         cmsetp(prmpt);                  /* Make new prompt */
  15221.         concb((char)escape);            /* Put console in cbreak mode */
  15222.         if (strcmp((char *)userid,"anonymous") &&
  15223.             strcmp((char *)userid,"ftp")) { /* and if not anonymous */
  15224.             debok = 0;
  15225.             cmini(0);                   /* and no-echo mode */
  15226.         } else {
  15227.             cmini(1);
  15228.         }
  15229.         if (pflag) prompt(xxstring);    /* Issue prompt if at top level */
  15230.         cmres();                        /* Reset the parser */
  15231.         for (x = -1; x < 0;) {          /* Prompt till they answer */
  15232. #ifdef CK_PAM
  15233.         gotemptypasswd=0;
  15234. #endif /* CK_PAM */
  15235.             x = cmtxt("","",&s,NULL);   /* Get a literal line of text */
  15236.             if (x == -4 || x == -10) {
  15237.                 printf("\r\n%sLogin cancelled\n",
  15238.                x == -10 ? "Timed out: " : "");
  15239. #ifdef CKSYSLOG
  15240.                 ckxsyslog = savlog;
  15241. #endif /* CKSYSLOG */
  15242.                 doexit(GOOD_EXIT,0);
  15243.             }
  15244. #ifdef CK_PAM
  15245.         if (!*s)
  15246.           gotemptypasswd = 1;
  15247. #endif /* CK_PAM */
  15248.             if (sstate)                 /* In case of a Kermit packet */
  15249.               goto XCKXLOG;
  15250.             cmres();                    /* Reset the parser again */
  15251.         }
  15252.         printf("\r\n");                 /* Echo a CRLF */
  15253.         if ((_p = (CHAR *)malloc((int)strlen(s) + 1)) == NULL) {
  15254.             printf("?Internal error: malloc\n");
  15255.             goto XCKXLOG;
  15256.         } else {
  15257.             strcpy((char *)_p,s);       /* safe */
  15258.             passwd = _p;
  15259.         }
  15260.     }
  15261. #ifdef CK_PAM
  15262.     else {
  15263.         cmres();                        /* Reset the parser */
  15264.  
  15265.         /* We restore the prompt now because the PAM engine will call  */
  15266.         /* readpass() which will overwrite psave. */
  15267.         if (rprompt) {
  15268.             cmsetp(psave);              /* Restore original prompt */
  15269.             debug(F110,"ckxlogin restored",psave,0);
  15270.             rprompt = 0;
  15271.         }
  15272.     }
  15273. #endif /* CK_PAM */
  15274.  
  15275. #ifdef CKSYSLOG
  15276.     ckxsyslog = savlog;
  15277. #endif /* CKSYSLOG */
  15278.  
  15279.     if (ok) {
  15280.         ok = zvpass((char *)passwd);    /* Check password */
  15281.         debug(F101,"ckxlogin zvpass","",ok);
  15282. #ifdef CK_PAM
  15283.     } else {
  15284.     /* Fake pam password failure for nonexistent users */
  15285.     sleep(1);
  15286.     printf("Authentication failure\n");
  15287. #endif    /* CK_PAM */
  15288.     }
  15289.  
  15290.     if (ok > 0 && isguest) {
  15291. #ifndef NOPUSH
  15292.         nopush = 1;
  15293. #endif /* NOPUSH */
  15294.         srvcdmsg = 1;
  15295.     }
  15296.     rc = ok;                            /* Set the return code */
  15297.     if ((char *)uidbuf != (char *)userid)
  15298.       ckstrncpy(uidbuf,(char *)userid,UIDBUFLEN); /* Remember username */
  15299.  
  15300.   XCKXLOG:                              /* Common exit */
  15301. #ifdef CKSYSLOG
  15302.     ckxsyslog = savlog;                 /* In case of GOTO above */
  15303. #endif /* CKSYSLOG */
  15304.     if (rprompt) {
  15305.         cmsetp(psave);                  /* Restore original prompt */
  15306.         debug(F110,"ckxlogin restored",psave,0);
  15307.     }
  15308.     if (_u || _p || _a) {
  15309.         if (_u) free(_u);
  15310.         if (_p) free(_p);
  15311.         if (_a) free(_a);
  15312.     }
  15313.     return(rc);
  15314. }
  15315.  
  15316. int
  15317. ckxlogout() {
  15318.     doexit(GOOD_EXIT,0);                /* doexit calls zvlogout */
  15319.     return(0);                          /* not reached */
  15320. }
  15321. #endif /* CK_LOGIN */
  15322.  
  15323. #endif /* NOICP */
  15324.