home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / c-kermit / ckuusr.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  357KB  |  13,377 lines
  1. #ifdef SSHTEST
  2. #define SSHBUILTIN
  3. #endif /* SSHTEST */
  4.  
  5. #include "ckcsym.h"
  6. char *userv = "User Interface 9.0.299, 9 Jun 2011";
  7.  
  8. /*  C K U U S R --  "User Interface" for C-Kermit (Part 1)  */
  9.  
  10. /*
  11.   Authors:
  12.     Frank da Cruz <fdc@columbia.edu>,
  13.       The Kermit Project, Columbia University, New York City
  14.     Jeffrey E Altman <jaltman@secure-endpoints.com>
  15.       Secure Endpoints Inc., New York City
  16.  
  17.   Copyright (C) 1985, 2011,
  18.     Trustees of Columbia University in the City of New York.
  19.     All rights reserved.  See the C-Kermit COPYING.TXT file or the
  20.     copyright text in the ckcmai.c module for disclaimer and permissions.
  21. */
  22.  
  23. /*
  24.   Originally the entire user interface was in one module, ckuusr.c.  Over
  25.   the years it has been split into many modules: ckuus2.c, ckuus3.c, ...,
  26.   ckuus7.c.  ckuus2.c contains the HELP command parser and help-text strings;
  27.   ckuusy.c contains the UNIX-style command-line interface; ckuusx.c contains
  28.   routines needed by both the command-line interface and the interactive
  29.   command parser.
  30. */
  31.  
  32. /*
  33.   The ckuus*.c modules depend on the existence of C library features like
  34.   fopen, fgets, feof, (f)printf, argv/argc, etc.  Other functions that are
  35.   likely to vary among different platforms -- like setting terminal modes or
  36.   interrupts -- are invoked via calls to functions that are defined in the
  37.   system- dependent modules, ck?[ft]io.c.  The command line parser processes
  38.   any arguments found on the command line, as passed to main() via argv/argc.
  39.   The interactive parser uses the facilities of the cmd package (developed for
  40.   this program, but usable by any program).  Any command parser may be
  41.   substituted for this one.  The only requirements for the Kermit command
  42.   parser are these:
  43.  
  44.   . Set parameters via global variables like duplex, speed, ttname, etc.  See
  45.     ckcmai.c for the declarations and descriptions of these variables.
  46.  
  47.   . If a command can be executed without the use of Kermit protocol, then
  48.     execute the command directly and set the variable sstate to 0. Examples
  49.     include 'set' commands, local directory listings, the 'connect' command.
  50.  
  51.   . If a command requires the Kermit protocol, set the following variables:
  52.  
  53.      sstate                             string data
  54.        'x' (enter server mode)            (none)
  55.        'r' (send a 'get' command)         cmarg, cmarg2
  56.        'v' (enter receive mode)           cmarg2
  57.        'g' (send a generic command)       cmarg
  58.        's' (send files)                   nfils, cmarg & cmarg2 OR cmlist
  59.        'c' (send a remote host command)   cmarg
  60.  
  61.      cmlist is an array of pointers to strings.
  62.      cmarg, cmarg2 are pointers to strings.
  63.      nfils is an integer.
  64.  
  65.      cmarg can be a filename string (possibly wild), or
  66.     a pointer to a prefabricated generic command string, or
  67.     a pointer to a host command string.
  68.      cmarg2 is an "as-name" - the name to send file(s) under, or
  69.     the name under which to store incoming file(s); must not be wild.
  70.     A null or empty value means to use the file's own name.
  71.      cmlist is a list of filenames, such as passed via argv.
  72.      nfils is an integer, interpreted as follows:
  73.        -1: filespec (possibly wild) in cmarg, must be expanded internally.
  74.     0: send from stdin (standard input).
  75.        >0: number of files to send, from cmlist.
  76.  
  77.   The screen() function is used to update the screen during file transfer.
  78.   The tlog() function writes to a transaction log.
  79.   The debug() function writes to a debugging log.
  80.   The intmsg() and chkint() functions provide the user i/o for interrupting
  81.     file transfers.
  82. */
  83.  
  84. /* Includes */
  85.  
  86. #ifdef MULTINET
  87. #define MULTINET_OLD_STYLE        /* Leave select prototype undefined */
  88. #endif /* MULTINET */
  89.  
  90. #include "ckcdeb.h"
  91. #include "ckcasc.h"
  92. #include "ckcker.h"
  93. #include "ckcnet.h"            /* Network symbols */
  94. #include "ckuusr.h"
  95. #include "ckcxla.h"
  96.  
  97. int g_fncact = -1;            /* Needed for NOICP builds */
  98. int noinit = 0;                /* Flag for skipping init file */
  99. int nscanfile = SCANFILEBUF;
  100.  
  101. int rcdactive = 0;            /* RCD active */
  102. int keepallchars = 0;            /* See cmfld() */
  103.  
  104. int locus = 1;                /* Current LOCUS is LOCAL */
  105. #ifdef OS2
  106. int autolocus = 2;            /* Automatic LOCUS switching: ASK */
  107. #else /* OS2 */
  108. int autolocus = 1;            /* Automatic LOCUS switching enabled */
  109. #endif /* OS2 */
  110.  
  111. #ifndef NOICP
  112. #ifdef CKLEARN
  113. #ifdef VMS
  114. #include <time.h>            /* For CKLEARN */
  115. #endif /* VMS */
  116. #endif /* CKLEARN */
  117. #ifdef OS2
  118. #ifndef NT
  119. #define INCL_NOPM
  120. #define INCL_VIO            /* Needed for ckocon.h */
  121. #include <os2.h>
  122. #undef COMMENT
  123. #else
  124. #define APIRET ULONG
  125. #include <windows.h>
  126. #include <tapi.h>
  127. #include "cknwin.h"
  128. #include "ckntap.h"            /* CK_TAPI definition */
  129. #endif /* NT */
  130. #include "ckowin.h"
  131. #include "ckocon.h"
  132. extern int tcp_avail;
  133. extern bool viewonly;
  134. extern int k95stdout;
  135. extern int tt_scroll;
  136. #ifndef NOTERM
  137. extern tt_status[VNUM];
  138. #endif /* NOTERM */
  139. int display_demo = 1;
  140. #include "ckossh.h"
  141. #ifdef KUI
  142. #include "ikui.h"
  143. #endif /* KUI */
  144. #endif /* OS2 */
  145.  
  146. int optlines = 0;
  147. int didsetlin = 0;
  148.  
  149. #ifdef NEWFTP
  150. extern int ftpget, ftpisopen(), doftpres();
  151. _PROTOTYP(int doftptyp,(int));
  152. _PROTOTYP(VOID doftpglobaltype,(int));
  153. #endif /* NEWFTP */
  154.  
  155. #ifdef VMS
  156. extern int batch;
  157. #endif /* VMS */
  158.  
  159. #ifdef datageneral
  160. #include <packets:common.h>
  161. #define fgets(stringbuf,max,fd) dg_fgets(stringbuf,max,fd)
  162. #endif /* datageneral */
  163.  
  164. extern int xcmdsrc, hints, cmflgs, whyclosed;
  165.  
  166. char * hlptok = NULL;
  167.  
  168. #ifdef CK_TTGWSIZ            /* Whether to use more-prompting */
  169. int xaskmore = 1;            /* Momentary setting */
  170. int saveask  = 1;            /* Permanent setting */
  171. #else
  172. int xaskmore = 0;
  173. int saveask  = 0;
  174. #endif /* CK_TTGWSIZ */
  175.  
  176. #ifndef NOCSETS
  177. extern int nfilc;
  178. extern struct keytab fcstab[];
  179. extern int fcharset;
  180. #endif /* NOCSETS */
  181.  
  182. char * g_pswd = NULL;
  183. int g_pcpt = -1;
  184. int g_pflg = -1;
  185.  
  186. extern int cmd_rows, cmd_cols;
  187.  
  188. #ifdef CKROOT
  189. extern int ckrooterr;
  190. #endif /* CKROOT */
  191.  
  192. extern int inserver, filepeek;
  193.  
  194. #ifdef CKLEARN
  195. FILE * learnfp = NULL;
  196. char * learnfile = NULL;
  197. int learning = 0;
  198. #endif /* CKLEARN */
  199.  
  200. #ifndef NOXFER
  201. extern int atcapr, atdiso, nfils, moving, protocol, sendmode, epktflg, size,
  202.   sndsrc, server, displa, fncnv, fnspath, fnrpath, xfermode, urpsiz,
  203.   spsizf, spsiz, spsizr, spmax, wslotr, prefixing, fncact, reliable,
  204.   setreliable;
  205.  
  206. #ifdef IKSDCONF
  207. extern int iksdcf;
  208. #endif /* IKSDCONF */
  209.  
  210. #ifdef CK_LOGIN
  211. extern int isguest;
  212. #endif /* CK_LOGIN */
  213.  
  214. extern CK_OFF_T sendstart;
  215.  
  216. extern char *cmarg, *cmarg2, **cmlist, *dftty;
  217.  
  218. extern struct keytab fntab[]; extern int nfntab;
  219. extern struct ck_p ptab[NPROTOS];
  220.  
  221. int sndcmd = 0;        /* Last command was a SEND-class command. */
  222.  
  223. int g_xfermode = -1;
  224. int g_proto  = -1;
  225. int g_urpsiz = -1;
  226. int g_spsizf = -1;
  227. int g_spsiz  = -1;
  228. int g_spsizr = -1;
  229. int g_spmax  = -1;
  230. int g_wslotr = -1;
  231. int g_prefixing = -1;
  232. int g_fncnv  = -1;
  233. int g_fnspath = -1;
  234. int g_fnrpath = -1;
  235. int g_fnact  = -1;
  236. int g_displa = -1;
  237. int g_spath  = -1;
  238. int g_rpath  = -1;
  239. char * g_sfilter = NULL;
  240. char * g_rfilter = NULL;
  241.  
  242. extern int patterns;
  243. #ifdef PATTERNS
  244. extern char *txtpatterns[], *binpatterns[];
  245. int g_patterns = -1;
  246. #endif /* PATTERNS */
  247. int g_skipbup = -1;
  248.  
  249. #ifdef PIPESEND
  250. extern int usepipes, pipesend;
  251. extern char * sndfilter;
  252. #endif /* PIPESEND */
  253.  
  254. #ifndef NOSPL
  255. extern int sndxlo, sndxhi, sndxin;
  256. #endif /* NOSPL */
  257.  
  258. extern char fspec[];            /* Most recent filespec */
  259. extern int fspeclen;            /* Length of fspec[] buffer */
  260.  
  261. #ifndef NOFRILLS
  262. extern int rmailf;            /* MAIL command items */
  263. extern char optbuf[];
  264. #endif /* NOFRILLS */
  265.  
  266. extern int
  267.   en_cpy, en_cwd, en_del, en_dir, en_fin, en_get, en_bye, en_mai, en_pri,
  268.   en_hos, en_ren, en_sen, en_spa, en_set, en_typ, en_who, en_ret, en_xit,
  269.   en_mkd, en_rmd, en_asg;
  270.  
  271. #ifndef NOMSEND                /* Multiple SEND */
  272. extern char *msfiles[];
  273. int filesinlist = 0;            /* And ADD ... */
  274. extern struct filelist * filehead;
  275. extern struct filelist * filetail;
  276. extern struct filelist * filenext;
  277. extern int addlist;
  278. #endif /* NOMSEND */
  279.  
  280. static struct keytab addtab[] = {
  281. #ifdef PATTERNS
  282.     { "binary-patterns", ADD_BIN, 0 },
  283. #endif /* PATTERNS */
  284. #ifndef NOMSEND
  285.     { "send-list", ADD_SND, 0 },
  286. #endif /* NOMSEND */
  287. #ifdef PATTERNS
  288.     { "text-patterns", ADD_TXT, 0 },
  289. #endif /* PATTERNS */
  290.     { "", 0, 0 }
  291. };
  292. static int naddtab = sizeof(addtab)/sizeof(struct keytab) - 1;
  293.  
  294. #ifndef NOCSETS
  295. struct keytab assoctab[] = {
  296.     { "file-character-set",     ASSOC_FC, 0 },
  297.     { "transfer-character-set", ASSOC_TC, 0 },
  298.     { "xfer-character-set",     ASSOC_TC, CM_INV }
  299. };
  300. static int nassoc = sizeof(assoctab)/sizeof(struct keytab);
  301. extern int afcset[MAXFCSETS+1];        /* Character-set associations */
  302. extern int axcset[MAXTCSETS+1];
  303. #endif /* NOCSETS */
  304.  
  305. #ifndef ADDCMD
  306. #ifndef NOMSEND
  307. #define ADDCMD
  308. #endif /* NOMSEND */
  309. #ifndef ADDCMD
  310. #ifdef PATTERNS
  311. #define ADDCMD
  312. #endif /* PATTERNS */
  313. #endif /* ADDCMD */
  314. #endif /* ADDCMD */
  315. #endif /* NOXFER */
  316.  
  317. /* External Kermit Variables, see ckmain.c for description. */
  318.  
  319. extern xx_strp xxstring;
  320. extern long xvernum;
  321.  
  322. extern int local, xitsta, binary, msgflg, escape, duplex, quiet, tlevel,
  323.   pflag, zincnt, ckxech, carrier, what, nopush, haveline, bye_active;
  324. #ifdef TNCODE
  325. extern int debses;
  326. extern char tn_msg[];
  327. #endif /* TNCODE */
  328.  
  329. int sleepcan = 1;
  330. int g_binary = -1;
  331. int g_recursive = -1;
  332. int g_matchdot = -1;
  333. extern int nolinks;
  334.  
  335. extern long vernum;
  336. extern char *versio, *copyright[];
  337. extern char *ckxsys;
  338. #ifndef NOHELP
  339. extern char *introtxt[];
  340. extern char *newstxt[];
  341. #endif /* NOHELP */
  342.  
  343. #ifndef OS2
  344. #ifndef UNIX
  345. extern char *PWDCMD;
  346. #endif /* UNIX */
  347. extern char *WHOCMD;
  348. #endif /* OS2 */
  349.  
  350. extern char ttname[];
  351.  
  352. extern CHAR sstate;
  353.  
  354. extern int network;            /* Have active network connection */
  355. extern int nettype;            /* Type of network */
  356. extern int ttnproto;                    /* NET_TCPB protocol */
  357.  
  358. #ifndef NODIAL
  359. extern int dialsta, dialatmo, dialcon, dialcq; /* DIAL status, etc. */
  360. #endif /* NODIAL */
  361.  
  362. #ifdef CK_APC
  363. extern int apcactive, apcstatus;
  364. #endif /* CK_APC */
  365.  
  366. #ifndef NOPUSH
  367. #ifndef NOFRILLS
  368. extern char editor[];
  369. extern char editopts[];
  370. extern char editfile[];
  371. #endif /* NOFRILLS */
  372. #endif /* NOPUSH */
  373.  
  374. #ifdef BROWSER
  375. extern char browser[];            /* Web browser application */
  376. extern char browsopts[];        /* Web browser options */
  377. extern char browsurl[];            /* Most recent URL */
  378. #endif /* BROWSER */
  379. #ifndef NOFTP
  380. char ftpapp[CKMAXPATH+1] = { NUL, NUL }; /* ftp executable */
  381. char ftpopts[128] = { NUL, NUL };    /* ftp command-line options */
  382. #endif /* NOFTP */
  383. extern struct keytab onoff[];        /* On/Off keyword table */
  384.  
  385. #ifdef CK_TMPDIR
  386. int f_tmpdir = 0;            /* Directory changed temporarily */
  387. char savdir[TMPDIRLEN];            /* For saving current directory */
  388. #endif /* CK_TMPDIR */
  389.  
  390. int activecmd = -1;            /* Keyword index of active command */
  391. int doconx = -1;            /* CONNECT-class command active */
  392. int ooflag = 0;                /* User-settable on/off flag */
  393.  
  394. int rcflag = 0;                /* Pointer to home directory string */
  395. int repars,                /* Reparse needed */
  396.     techo = 0;                /* Take echo */
  397. int secho = 1;                /* SCRIPT echo */
  398.  
  399. int xitwarn =            /* Warn about open connection on exit */
  400. #ifdef NOWARN
  401. 0
  402. #else
  403. 1
  404. #endif /* NOWARN */
  405. ;
  406.  
  407. struct keytab onoffsw[] = {
  408.     { "/off", 0, 0 },
  409.     { "/on",  1, 0 }
  410. };
  411.  
  412. #ifdef CKEXEC
  413. struct keytab redirsw[] = {
  414.     { "/redirect", 1, 0 }
  415. };
  416. #endif /* CKEXEC */
  417.  
  418. #ifndef NOXMIT
  419. /* Variables for TRANSMIT command */
  420.  
  421. int xmitx = 1;            /* Whether to echo during TRANSMIT */
  422. int xmitf = 0;            /* Character to fill empty lines */
  423. int xmitl = 0;            /* 0 = Don't send linefeed too */
  424. int xmitp = LF;            /* Host line prompt */
  425. int xmits = 0;            /* Use shift-in/shift-out, 0 = no */
  426. int xmitw = 0;            /* Milliseconds to pause during TRANSMIT */
  427. int xmitt = 1;            /* Seconds to wait for each char to echo */
  428. int xmita = 1;            /* Action upon timeout */
  429.  
  430. #define XMI_BIN 1
  431. #define XMI_TXT 2
  432. #define XMI_CMD 3
  433. #define XMI_TRA 4
  434. #define XMI_VRB 5
  435. #define XMI_QUI 6
  436. #define XMI_NOW 7
  437. #define XMI_NOE 8
  438.  
  439. static struct keytab xmitsw[] = {    /* TRANSMIT command options */
  440.     { "/binary",          XMI_BIN, 0 },
  441. #ifdef PIPESEND
  442.     { "/command",         XMI_CMD, CM_INV|CM_PSH },
  443. #endif /* PIPESEND */
  444.     { "/noecho",          XMI_NOE, 0 },
  445.     { "/nowait",          XMI_NOW, 0 },
  446. #ifdef PIPESEND
  447.     { "/pipe",            XMI_CMD, 0 },
  448. #endif /* PIPESEND */
  449. #ifdef COMMENT
  450.     { "/quiet",           XMI_QUI, 0 },
  451. #endif /* COMMENT */
  452.     { "/text",            XMI_TXT, 0 },
  453.     { "/transparent",     XMI_TRA, 0 },
  454. #ifdef COMMENT
  455.     { "/verbose",         XMI_VRB, 0 },
  456. #endif /* COMMENT */
  457.     { "", 0, 0 }
  458. };
  459. #define NXMITSW sizeof(xmitsw)/sizeof(struct keytab) - 1
  460. static int nxmitsw = NXMITSW;
  461.  
  462. #endif /* NOXMIT */
  463.  
  464. /* Declarations from ck?fio.c module */
  465.  
  466. extern char *SPACMD, *SPACM2;        /* SPACE commands */
  467.  
  468. /* Command-oriented items */
  469.  
  470. #ifdef DCMDBUF
  471. extern char *cmdbuf;            /* Command buffers */
  472. extern char *atmbuf;
  473. extern char *line;            /* Character buffer for anything */
  474. extern char *tmpbuf;            /* Short temporary string buffer */
  475. extern int *ifcmd;
  476. extern int *intime;
  477. extern int *inpcas;
  478. #else
  479. extern char cmdbuf[];            /* Command buffers */
  480. extern char atmbuf[];
  481. extern char line[];            /* Character buffer for anything */
  482. extern char tmpbuf[];            /* Temporary buffer */
  483. extern int ifcmd[];
  484. extern int intime[];
  485. extern int inpcas[];
  486. #endif /* DCMDBUF */
  487.  
  488. #ifndef NOSPL
  489. extern char * prstring[];
  490. #endif /* NOSPL */
  491.  
  492. char *lp;                /* Pointer to line buffer */
  493.  
  494. #ifndef NOSPL
  495. int vareval = 1;            /* Evaluation method */
  496. int unkmacro = 0;            /* Flag for in ON_UNKNOWN_COMMAND */
  497. int oldeval = 0;
  498. char evalbuf[33];            /* EVALUATE result */
  499. extern char * inpbuf;            /* Buffer for INPUT and REINPUT */
  500. char *inpbp;                /* And pointer to same */
  501. int m_found;                /* MINPUT result */
  502. int i_active = 0;            /* INPUT command is active */
  503. char *ms[MINPMAX];            /* Pointers to MINPUT strings */
  504. static int mpinited = 0;        /* Flag they have been initialized */
  505. static int mp[MINPMAX];            /* and MINPUT flags */
  506. extern int fndiags, fnerror, fnsuccess;    /* Function diagnostics */
  507. #ifndef NOSEXP
  508. char * lastsexp = NULL;            /* S-Expressions */
  509. char * sexpval = NULL;
  510. int sexpecho = SET_AUTO;
  511. #endif /* NOSEXP */
  512. #endif /* NOSPL */
  513.  
  514. char psave[PROMPTL] = { NUL };        /* For saving & restoring prompt */
  515.  
  516. extern int success;            /* Command success/failure flag */
  517. extern int cmdlvl;            /* Current position in command stack */
  518.  
  519. #ifndef NOSPL
  520. int                    /* SET INPUT parameters. */
  521. /* Note, INPUT TIMEOUT, intime[], is on the command-level stack. */
  522.   inbufsize = 0,            /* INPUT buffer size */
  523.   indef = 1,                /* default timeout, seconds */
  524.   inecho = 1,                /* 1 = echo on */
  525.   inautodl = 0,                /* INPUT autodownload */
  526.   inintr = 1,                /* INPUT interrupion allowed */
  527.   insilence = 0;            /* 0 = no silence constraint */
  528.  
  529. #ifdef CKFLOAT
  530. CKFLOAT inscale = 1.0;            /* Timeout scale factor */
  531. #endif    /* CKFLOAT */
  532.  
  533. #ifdef OS2
  534. int interm = 1;                /* Terminal emulator displays input */
  535. #endif /* OS2 */
  536. int maclvl = -1;            /* Macro nesting level */
  537. int mecho = 0;                /* Macro echo, 0 = don't */
  538. char varnam[6];                /* For variable names */
  539. extern int macargc[];            /* ARGC from macro invocation */
  540.  
  541. extern char *m_arg[MACLEVEL][NARGS];    /* Stack of macro arguments */
  542. extern char *mrval[];
  543.  
  544. extern char **a_ptr[];            /* Array pointers */
  545. extern int a_dim[];            /* Array dimensions */
  546. extern int a_link[];
  547.  
  548. #ifdef DCMDBUF
  549. extern struct cmdptr *cmdstk;        /* The command stack itself */
  550. #else
  551. extern struct cmdptr cmdstk[];        /* The command stack itself */
  552. #endif /* DCMDBUF */
  553.  
  554. long ck_alarm = 0;            /* SET ALARM value */
  555. char alrm_date[24] = { ' ',' ',' ',' ',' ',' ',' ',' ',' ' };
  556. char alrm_time[24] = { ' ',' ',' ',' ',' ',' ',' ' };
  557.  
  558. struct keytab inputsw[] = {
  559.     { "/clear",   INPSW_CLR, 0 },
  560.     { "/count",   INPSW_COU, CM_ARG },
  561.     { "/nomatch", INPSW_NOM, 0 },
  562.     { "/nowrap",  INPSW_NOW, 0 }
  563. };
  564. static int ninputsw = sizeof(inputsw)/sizeof(struct keytab);
  565.  
  566. /* The following should be reconciled with the above */
  567.  
  568. #ifdef COMMENT                /* INPUT switches not used yet... */
  569. static struct keytab inswtab[] = {
  570. #ifdef COMMENT
  571.     { "/assign",       IN_ASG, CM_ARG },
  572. #endif /* COMMENT */
  573.     { "/autodownload", IN_ADL, CM_ARG },
  574.     { "/case",         IN_CAS, CM_ARG },
  575.     { "/echo",         IN_ECH, CM_ARG },
  576.     { "/interrupts",   IN_NOI, CM_ARG },
  577.     { "/silence",      IN_SIL, CM_ARG },
  578. #ifdef COMMENT
  579.     { "/pattern",      IN_PAT, CM_ARG },
  580. #endif /* COMMENT */
  581.     { "", 0, 0 }
  582. };
  583. static int ninswtab = (sizeof(inswtab) / sizeof(struct keytab)) - 1;
  584. #endif /* COMMENT */
  585.  
  586.  
  587. #endif /* NOSPL */
  588.  
  589. static int x, y, z = 0;            /* Local workers */
  590. static char *s;
  591.  
  592. #ifdef CK_MINPUT
  593. static char c1chars[] = {        /* C1 control chars escept NUL */
  594.     001,002,003,004,005,006,007,010,011,012,013,014,015,016,017,020,
  595.     021,022,023,024,025,026,027,030,031,032,033,034,035,036,037
  596. };
  597. #endif /* CK_MINPUT */
  598.  
  599. #define xsystem(s) zsyscmd(s)
  600.  
  601. /* Top-Level Interactive Command Keyword Table */
  602. /* Keywords must be in lowercase and in alphabetical order. */
  603.  
  604. struct keytab cmdtab[] = {
  605. #ifndef NOPUSH
  606.     { "!",       XXSHE, CM_INV|CM_PSH }, /* Shell escape */
  607. #else
  608.     { "!",       XXNOTAV, CM_INV|CM_PSH },
  609. #endif /* NOPUSH */
  610.     { "#",           XXCOM, CM_INV },    /* Comment */
  611. #ifndef NOSPL
  612.     { "(",           XXSEXP,CM_INV },    /* S-Expression */
  613.     { ".",           XXDEF, CM_INV },    /* Assignment */
  614.     { ":",           XXLBL, CM_INV },    /* Label */
  615. #endif /* NOSPL */
  616. #ifdef CK_REDIR
  617. #ifndef NOPUSH
  618.     { "<",           XXFUN, CM_INV|CM_PSH }, /* REDIRECT */
  619. #else
  620.     { "<",           XXNOTAV, CM_INV|CM_PSH }, /* REDIRECT */
  621. #endif /* NOPUSH */
  622. #endif /* CK_REDIR */
  623. #ifndef NOPUSH
  624.     { "@",           XXSHE, CM_INV|CM_PSH }, /* DCL escape */
  625. #else
  626.     { "@",           XXNOTAV, CM_INV|CM_PSH }, /* DCL escape */
  627. #endif /* NOPUSH */
  628.  
  629. #ifdef CK_RECALL
  630.     { "^",           XXREDO,CM_INV|CM_NOR }, /* Synonym for REDO */
  631. #endif /* CK_RECALL */
  632. #ifndef NOSPL
  633.     { "_asg",        XXASX,   CM_INV },    /* Used internally by FOR, etc */
  634.     { "_assign",     XXASX,   CM_INV },    /* Used internally by FOR, etc */
  635.     { "_decrement",  XX_DECR, CM_INV },
  636.     { "_define",     XXDFX,   CM_INV },    /* Used internally by FOR, etc */
  637.     { "_evaluate",   XX_EVAL, CM_INV },
  638.     { "_forward",    XXXFWD,  CM_INV },    /* Used internally by SWITCH   */
  639.     { "_getargs",    XXGTA,   CM_INV },    /* Used internally by FOR, etc */
  640.     { "_increment",  XX_INCR, CM_INV },
  641.     { "_putargs",    XXPTA,   CM_INV },    /* Used internally by FOR, etc */
  642.     { "_undefine",   XXUNDFX, CM_INV },
  643. #endif /* NOSPL */
  644.  
  645.     { "about",       XXVER,   CM_INV },    /* Synonym for VERSION */
  646. #ifndef NOSPL
  647. #ifdef NEWFTP
  648.     { "account",     XXACCT,  CM_INV }, /* (FTP) Account */
  649. #endif /* NEWFTP */
  650. #ifdef ADDCMD
  651.     { "add",         XXADD, 0 },    /* ADD */
  652. #endif /* ADDCMD */
  653. #ifndef NODIAL
  654.     { "answer",      XXANSW, CM_LOC },    /* ANSWER the phone */
  655. #else
  656.     { "answer",      XXNOTAV, CM_INV|CM_LOC }, /* ANSWER the phone */
  657. #endif /* NODIAL */
  658.     { "apc",         XXAPC, 0 },    /* Application Program Command */
  659. #ifndef NOSPL
  660.     { "array",       XXARRAY, 0 },    /* Array operations */
  661. #endif /* NOSPL */
  662.     { "ascii",       XXASC, CM_INV },    /* == SET FILE TYPE TEXT */
  663.     { "asg",         XXASS, CM_INV },    /* Invisible synonym for ASSIGN */
  664.     { "ask",         XXASK, 0 },    /* ASK for text, assign to variable */
  665.     { "askq",        XXASKQ,0 },    /* ASK quietly (no echo) */
  666. #ifndef NOSPL
  667.     { "ass",         XXASS, CM_INV|CM_ABR }, /* ASSIGN */
  668.     { "assert",      XXASSER, CM_INV },    /* ASSERT */
  669.     { "assign",      XXASS, 0 },    /* ASSIGN */
  670. #endif /* NOSPL */
  671. #ifndef NOXFER
  672. #ifndef NOCSETS
  673.     { "associate",   XXASSOC, 0 },    /* ASSOCIATE */
  674. #else
  675.     { "associate",   XXNOTAV, CM_INV },    /* ASSOCIATE */
  676. #endif /* NOCSETS */
  677. #endif /* NOXFER */
  678. #ifdef CK_KERBEROS
  679. #ifdef CK_AUTHENTICATION
  680.     { "authenticate",XXAUTH, 0 },    /* Authentication */
  681. #else
  682.     { "authenticate",XXAUTH, CM_INV },
  683. #endif /* CK_AUTHENTICATION */
  684. #endif /* CK_KERBEROS */
  685. #endif /* NOSPL */
  686. #ifndef NOFRILLS
  687.     { "back",        XXBACK, 0 },    /* BACK to previous directory */
  688. #else
  689.     { "back",        XXNOTAV,CM_INV },
  690. #endif /* NOFRILLS */
  691.     { "beep",        XXBEEP,CM_INV },    /* BEEP */
  692. #ifndef NOXFER
  693.     { "binary",      XXBIN, CM_INV },    /* == SET FILE TYPE BINARY */
  694. #endif /* NOXFER */
  695. #ifndef NOFRILLS
  696.     { "bug",         XXBUG, CM_INV },    /* BUG report instructions */
  697. #else
  698.     { "bug",         XXNOTAV, CM_INV },
  699. #endif /* NOFRILLS */
  700. #ifdef BROWSER
  701.     { "browse",      XXBROWS, CM_PSH|CM_LOC }, /* BROWSE (start browser) */
  702. #else
  703.     { "browse",      XXNOTAV, CM_INV|CM_PSH|CM_LOC },
  704. #endif /* BROWSER */
  705. #ifndef NOXFER
  706.     { "bye",         XXBYE, 0 },    /* BYE to remote server */
  707. #endif /* NOXFER */
  708. #ifndef NOLOCAL
  709.     { "c",           XXCON, CM_INV|CM_ABR|CM_LOC }, /* (CONNECT) */
  710. #endif /* NOLOCAL */
  711. #ifndef NOFRILLS
  712.     { "cat",         XXCAT, CM_INV },    /* Invisible synonym for TYPE */
  713. #endif /* NOFRILLS */
  714. #ifndef NOSPL
  715.  
  716. #ifndef NOXFER
  717.     { "cautious",    XXCAU, CM_INV },
  718. #endif /* NOXFER */
  719.  
  720. #endif /* NOSPL */
  721.  
  722.     { "cd",          XXCWD, 0 },    /* Change Directory */
  723.     { "cdup",        XXCDUP, CM_INV },    /* Change Directory Up */
  724.  
  725. #ifndef NOXFER
  726. #ifdef PIPESEND
  727.     { "cget",        XXCGET, CM_INV|CM_PSH }, /* CGET */
  728. #else
  729.     { "cget",        XXNOTAV, CM_INV|CM_PSH }, /* CGET */
  730. #endif /* PIPESEND */
  731. #endif /* NOXFER */
  732.     { "ch",          XXCHK,   CM_INV|CM_ABR },
  733.     { "check",       XXCHK,   0 },    /* CHECK for a feature */
  734. #ifdef CK_PERMS
  735. #ifdef UNIX
  736.     { "chmod",       XXCHMOD, 0 },    /* CHMOD */
  737. #else
  738.     { "chmod",       XXNOTAV, CM_INV },
  739. #endif /* UNIX */
  740. #else
  741.     { "chmod",       XXNOTAV, CM_INV },
  742. #endif /* CK_PERMS */
  743. #ifdef CKROOT
  744.     { "chroot",      XXCHRT,  CM_INV },    /* CHROOT */
  745. #endif /* CKROOT */
  746.     { "ckermit",     XXKERMI, CM_INV },    /* CKERMIT (like KERMIT) */
  747.     { "cl",          XXCLO,   CM_ABR|CM_INV },
  748. #ifndef NOFRILLS
  749.     { "clear",       XXCLE, 0 },    /* CLEAR input and/or device buffer */
  750. #else
  751.     { "clear",       XXNOTAV, CM_INV },
  752. #endif /* NOFRILLS */
  753.     { "close",         XXCLO, 0 },    /* CLOSE a log or other file */
  754.     { "cls",         XXCLS, CM_INV },    /* Clear Screen (CLS) */
  755.     { "comment",     XXCOM, CM_INV },    /* Introduce a comment */
  756. #ifndef NOLOCAL
  757.     { "connect",     XXCON, CM_LOC },    /* Begin terminal connection */
  758. #else
  759.     { "connect",     XXNOTAV, CM_LOC },
  760. #endif /* NOLOCAL */
  761.     { "continue",    XXCONT,  CM_INV },    /* CONTINUE */
  762. #ifndef NOFRILLS
  763. #ifdef ZCOPY
  764.     { "co",          XXCPY, CM_INV|CM_ABR },
  765.     { "cop",         XXCPY, CM_INV|CM_ABR },
  766.     { "copy",        XXCPY, 0 },    /* COPY a file */
  767. #else
  768.     { "copy",        XXNOTAV, CM_INV },
  769. #endif /* ZCOPY */
  770.     { "copyright",   XXCPR, CM_INV },    /* COPYRIGHT */
  771. #ifdef ZCOPY
  772.     { "cp",          XXCPY, CM_INV },    /* COPY a file */
  773. #endif /* ZCOPY */
  774. #ifndef NOLOCAL
  775. #ifndef OS2
  776.     { "cq",          XXCQ, CM_INV|CM_LOC }, /* CQ (connect quietly) */
  777. #endif /* OS2 */
  778. #endif /* NOLOCAL */
  779. #ifndef NOXFER
  780. #ifdef PIPESEND
  781.     { "creceive",    XXCREC,CM_INV|CM_PSH }, /* RECEIVE to a command */
  782.     { "csend",       XXCSEN,CM_INV|CM_PSH }, /* SEND from command */
  783. #else
  784.     { "creceive",    XXNOTAV,CM_INV|CM_PSH },
  785.     { "csend",       XXNOTAV,CM_INV|CM_PSH },
  786. #endif /* PIPESEND */
  787. #endif /* NOXFER */
  788. #endif /* NOFRILLS */
  789.  
  790.     { "cwd",         XXCWD,   CM_INV },    /* Traditional synonym for cd */
  791.  
  792. #ifndef NOSPL
  793.     { "date",        XXDATE,  0 },    /* DATE */
  794.     { "dcl",         XXDCL,   CM_INV },    /* DECLARE an array (see ARRAY) */
  795.     { "debug",       XXDEBUG, 0 },    /* Print a debugging msg [9.0]  */
  796.     { "declare",     XXDCL,   CM_INV },    /* DECLARE an array (see ARRAY) */
  797.     { "decrement",   XXDEC,   0 },    /* DECREMENT a numeric variable */
  798.     { "define",      XXDEF,   0 },    /* DEFINE a macro or variable   */
  799. #else
  800.     { "date",        XXNOTAV, CM_INV },
  801.     { "dcl",         XXNOTAV, CM_INV },
  802.     { "declare",     XXNOTAV, CM_INV },
  803.     { "decrement",   XXNOTAV, CM_INV },
  804.     { "define",      XXNOTAV, CM_INV },
  805. #endif /* NOSPL */
  806.  
  807. #ifndef NOFRILLS
  808.     { "delete",      XXDEL, 0 },    /* DELETE a file */
  809. #else
  810.     { "delete",      XXNOTAV, CM_INV },
  811. #endif /* NOFRILLS */
  812.  
  813. #ifndef NODIAL
  814.     { "dial",        XXDIAL,  CM_LOC },    /* DIAL a phone number */
  815. #else
  816.     { "dial",        XXNOTAV, CM_INV|CM_LOC },
  817. #endif /* NODIAL */
  818.  
  819. #ifdef NT
  820.     { "dialer",      XXDIALER, CM_INV }, /* K95 Dialer */
  821. #endif /* NT */
  822.  
  823.     { "directory",   XXDIR, 0 },    /* DIRECTORY of files */
  824.  
  825. #ifndef NOFRILLS
  826. #ifndef NOSERVER
  827.     { "disable",     XXDIS, 0 },    /* DISABLE a server function */
  828. #else
  829.     { "disable",     XXNOTAV, CM_INV },
  830. #endif /* NOSERVER */
  831. #endif /* NOFRILLS */
  832.  
  833. #ifndef NOSPL
  834.     { "do",          XXDO,  0 },    /* DO (execute) a macro */
  835. #else
  836.     { "do",          XXNOTAV, CM_INV },
  837. #endif /* NOSPL */
  838.  
  839.     { "e",           XXEXI, CM_INV|CM_ABR },
  840.  
  841. #ifndef NOFRILLS
  842. #ifndef NOXFER
  843.     { "e-packet",    XXERR, CM_INV },    /* Send an Error-Packet */
  844. #endif /* NOXFER */
  845. #endif /* NOFRILLS */
  846.  
  847.     { "echo",        XXECH, 0 },    /* ECHO text */
  848.  
  849. #ifndef NOFRILLS
  850. #ifndef NOPUSH
  851.     { "edit",        XXEDIT, CM_PSH },    /* EDIT */
  852. #else
  853.     { "edit",        XXNOTAV, CM_INV|CM_PSH }, /* EDIT */
  854. #endif /* NOPUSH */
  855. #endif /* NOFRILLS */
  856.  
  857.     { "eightbit",    XXEIGHT, CM_INV },    /* EIGHTBIT */
  858.  
  859. #ifndef NOSPL
  860.     { "else",        XXELS, CM_INV },    /* ELSE part of IF statement */
  861. #else
  862.     { "else",        XXNOTAV, CM_INV },    /* ELSE part of IF statement */
  863. #endif /* NOSPL */
  864.  
  865. #ifndef NOSERVER
  866. #ifndef NOFRILLS
  867.     { "enable",      XXENA,  0 },    /* ENABLE a server function */
  868. #else
  869.     { "enable",      XXNOTAV, CM_INV },
  870. #endif /* NOFRILLS */
  871. #endif /* NOSERVER */
  872.  
  873. #ifndef NOSPL
  874.     { "end",         XXEND,  0 },    /* END command file or macro */
  875. #else
  876.     { "end",         XXNOTAV, CM_INV },
  877. #endif /* NOSPL */
  878.  
  879.     { "erase",       XXDEL, CM_INV },    /* Synonym for DELETE */
  880.  
  881. #ifndef NOSPL
  882.     { "evaluate",    XXEVAL, 0 },    /* EVALUATE */
  883. #else
  884.     { "evaluate",    XXNOTAV, CM_INV },
  885. #endif /* NOSPL */
  886.  
  887.     { "ex",          XXEXI, CM_INV|CM_ABR }, /* Let "ex" still be EXIT */
  888.  
  889. #ifdef CKEXEC
  890.     { "exec",        XXEXEC, CM_INV|CM_LOC }, /* exec() */
  891. #else
  892.     { "exec",        XXNOTAV, CM_INV|CM_LOC },
  893. #endif /* CKEXEC */
  894.  
  895.     { "exit",       XXEXI, 0 },        /* EXIT from C-Kermit */
  896.     { "extended-options", XXXOPTS,CM_INV|CM_HLP }, /* Extended-Options */
  897.  
  898. #ifdef OS2
  899.     { "extproc",     XXCOM, CM_INV },    /* Dummy command for OS/2 */
  900. #endif /* OS2 */
  901.  
  902. #ifndef NOXFER
  903.     { "f",           XXFIN, CM_INV|CM_ABR }, /* Invisible abbrev for FIN */
  904. #endif /* NOXFER */
  905.  
  906. #ifndef NOSPL
  907.     { "fail",        XXFAIL, CM_INV },    /* FAIL */
  908.  
  909. #ifndef NOXFER
  910.     { "fast",        XXFAST, CM_INV },
  911. #endif /* NOXFER */
  912.  
  913. #ifdef CKCHANNELIO
  914.     { "fclose",      XXF_CL, CM_INV },    /* FCLOSE */
  915.     { "fcount",      XXF_CO, CM_INV },    /* FCOUNT */
  916.     { "fflush",      XXF_FL, CM_INV },    /* FFLUSH */
  917. #endif /* CKCHANNELIO */
  918.  
  919. #ifndef NOXFER
  920.     { "fi",          XXFIN, CM_INV|CM_ABR }, /* FINISH */
  921. #endif /* NOXFER */
  922.  
  923. #ifdef CKCHANNELIO
  924.     { "file",        XXFILE, 0 },    /* FILE */
  925. #endif /* CKCHANNELIO */
  926. #endif /* NOSPL */
  927.  
  928. #ifndef NOXFER
  929.     { "fin",         XXFIN, CM_INV|CM_ABR }, /* FINISH */
  930. #endif /* NOXFER */
  931.  
  932. #ifndef UNIXOROSK
  933.     { "find",        XXGREP, 0 },    /* FIND (grep) */
  934. #else
  935.     { "find",        XXGREP,CM_INV },
  936. #endif /* UNIXOROSK */
  937.  
  938. #ifndef NOXFER
  939.     { "finish",      XXFIN, 0 },    /* FINISH */
  940. #endif /* NOXFER */
  941.  
  942. #ifdef TCPSOCKET
  943.     { "firewall",    XXFIREW, CM_INV|CM_HLP },
  944. #endif /* TCPSOCKET */
  945.  
  946. #ifdef CKCHANNELIO
  947.     { "flist",       XXF_LI, CM_INV },    /* FLIST */
  948.     { "fopen",       XXF_OP, CM_INV },    /* FOPEN */
  949. #endif /* CKCHANNELIO */
  950.  
  951. #ifndef NOSPL
  952.     { "fo",          XXFOR, CM_INV|CM_ABR }, /* Invisible abbrev for... */
  953.     { "for",         XXFOR, 0 },    /* FOR loop */
  954.     { "forward",     XXFWD, CM_INV },    /* FORWARD */
  955. #endif /* NOSPL */
  956. #ifndef NOFRILLS
  957.     { "fot",       XXDIR, CM_INV },    /* "fot" = "dir" (for Chris) */
  958. #endif /* NOFRILLS */
  959.  
  960. #ifdef CKCHANNELIO
  961.     { "fread",      XXF_RE, CM_INV },    /* FREAD */
  962.     { "frewind",    XXF_RW, CM_INV },    /* FREWIND */
  963.     { "fseek",      XXF_SE, CM_INV },    /* FSEEK */
  964.     { "fstatus",    XXF_ST, CM_INV },    /* FSTATUS */
  965. #endif /* CKCHANNELIO */
  966.  
  967. #ifdef TCPSOCKET
  968. #ifndef NOFTP
  969. #ifdef SYSFTP
  970. #ifndef NOPUSH
  971.     { "ftp",       XXFTP,   CM_INV|CM_PSH|CM_LOC }, /* System FTP */
  972. #else
  973.     { "ftp",       XXNOTAV, CM_INV|CM_PSH|CM_LOC },
  974. #endif /* NOPUSH */
  975. #else  /* SYSFTP */
  976.     { "ftp",       XXFTP,   0 },    /* Built-in FTP */
  977. #endif /* SYSFTP */
  978. #else  /* NOFTP */
  979.     { "ftp",       XXNOTAV, CM_INV },    /* No FTP */
  980. #endif /* NOFTP */
  981. #endif /* TCPSOCKET */
  982.  
  983. #ifndef NOSPL
  984.     { "function",    XXFUNC, CM_INV|CM_HLP }, /* (for HELP FUNCTION) */
  985. #endif /* NOSPL */
  986.  
  987. #ifdef CKCHANNELIO
  988.     { "fwrite",      XXF_WR, CM_INV },    /* FWRITE */
  989. #endif /* CKCHANNELIO */
  990.  
  991. #ifndef NOXFER
  992.     { "g",           XXGET, CM_INV|CM_ABR }, /* Invisible abbrev for GET */
  993. #ifndef NOSPL
  994.     { "ge",          XXGET, CM_INV|CM_ABR }, /* Ditto */
  995. #endif /* NOSPL */
  996.     { "get",         XXGET, 0 },    /* GET */
  997. #endif /* NOXFER */
  998. #ifndef NOSPL
  999.     { "getc",        XXGETC, 0 },    /* GETC */
  1000. #ifdef OS2
  1001.     { "getkeycode",  XXGETK, 0 },    /* GETKEYCODE */
  1002. #endif /* OS2 */
  1003. #ifndef NOFRILLS
  1004.     { "getok",       XXGOK, 0 },    /* GETOK (ask for Yes/No/OK) */
  1005. #endif /* NOFRILLS */
  1006. #endif /* NOSPL */
  1007. #ifndef NOSPL
  1008.     { "goto",        XXGOTO,0 },    /* GOTO label in take file or macro */
  1009. #endif /* NOSPL */
  1010. #ifdef UNIXOROSK
  1011.     { "grep",        XXGREP,0 },    /* GREP (find) */
  1012. #else
  1013.     { "grep",        XXGREP,CM_INV },    /* GREP (find) */
  1014. #endif /* UNIXOROSK */
  1015.     { "h",           XXHLP, CM_INV|CM_ABR }, /* Invisible synonym for HELP */
  1016.     { "he",          XXHLP, CM_INV|CM_ABR }, /* Invisible synonym for HELP */
  1017. #ifndef NOFRILLS
  1018.     { "head",        XXHEAD, 0 },
  1019. #endif /* NOFRILLS */
  1020. #ifndef NOLOCAL
  1021.     { "hangup",      XXHAN, CM_LOC },    /* HANGUP the connection */
  1022. #endif /* NOLOCAL */
  1023.     { "hdirectory",  XXHDIR,  CM_INV },    /* DIR sorted by size biggest first */
  1024.     { "HELP",        XXHLP, 0 },    /* Display HELP text */
  1025. #ifndef NOHTTP
  1026. #ifdef TCPSOCKET
  1027.     { "http",        XXHTTP, 0 },    /* HTTP operations */
  1028. #endif /* TCPSOCKET */
  1029. #endif /* NOHTTP */
  1030. #ifndef NOSPL
  1031.     { "i",           XXINP, CM_INV|CM_ABR }, /* Invisible synonym for INPUT */
  1032.     { "if",          XXIF,  0 },         /* IF ( condition ) command */
  1033. #ifdef TCPSOCKET
  1034.     { "iksd",        XXIKSD, CM_INV },         /* Make connection to IKSD */
  1035. #else
  1036.     { "iksd",        XXNOTAV, CM_INV },
  1037. #endif /* TCPSOCKET */
  1038.     { "in",          XXINP, CM_INV|CM_ABR }, /* Invisible synonym for INPUT */
  1039.     { "increment",   XXINC, 0 },    /* Increment a numeric variable */
  1040.     { "input",       XXINP, 0 },    /* INPUT text from comm device */
  1041. #endif /* NOSPL */
  1042.  
  1043. #ifndef NOHELP
  1044.     { "int",         XXINT, CM_INV|CM_ABR },
  1045.     { "intr",        XXINT, CM_INV|CM_ABR },
  1046.     { "INTRO",       XXINT, 0 },
  1047.     { "introduction",XXINT, CM_INV },    /* Print introductory text */
  1048. #else
  1049.     { "intro",       XXNOTAV, CM_INV },
  1050.     { "introduction",XXNOTAV, CM_INV },
  1051. #endif /* NOHELP */
  1052.  
  1053. #ifdef OS2
  1054.     { "k95",         XXKERMI, CM_INV },    /* Hmmm what's this... */
  1055. #endif /* OS2 */
  1056.  
  1057. #ifndef NOSPL
  1058.     { "kcd",         XXKCD,   0      },
  1059. #endif /* NOSPL */
  1060.  
  1061.     { "kermit",      XXKERMI, CM_INV },
  1062.  
  1063. #ifdef OS2
  1064. #ifndef NOKVERBS
  1065.     { "kverb",       XXKVRB, CM_INV|CM_HLP }, /* Keyboard verb */
  1066. #endif /* NOKVERBS */
  1067. #endif /* OS2 */
  1068.  
  1069. #ifndef NOFRILLS
  1070.     { "l",           XXLOG, CM_INV|CM_ABR }, /* Invisible synonym for log */
  1071. #endif /* NOFRILLS */
  1072.  
  1073.     { "lcd",         XXLCWD, CM_INV },
  1074.     { "lcdup",       XXLCDU, CM_INV },
  1075.     { "lcwd",        XXLCWD, CM_INV },
  1076.     { "ldelete",     XXLDEL, CM_INV },
  1077.     { "ldirectory",  XXLDIR, CM_INV },
  1078.  
  1079. #ifdef CKLEARN
  1080.     { "learn",       XXLEARN, 0 },    /* LEARN - automatic script writing */
  1081. #else
  1082.     { "learn",       XXNOTAV, CM_INV },
  1083. #endif /* CKLEARN */
  1084.  
  1085.     { "li",          XXLNOUT, CM_INV|CM_ABR },
  1086.     { "LICENSE",     XXCPR, 0 },    /* LICENSE */
  1087.  
  1088. #ifndef NOSPL
  1089.     { "lineout",     XXLNOUT, 0 },    /* LINEOUT = OUTPUT + eol */
  1090. #endif /* NOSPL */
  1091.  
  1092. #ifdef NT
  1093.     { "link",        XXLINK, 0 },       /* LINK source destination */
  1094. #endif /* NT */
  1095.  
  1096.     { "lmkdir",      XXLMKD, CM_INV },
  1097.     { "lmv",         XXLREN, CM_INV },
  1098.  
  1099. #ifndef NOFRILLS
  1100.     { "lo",          XXLOG,  CM_INV|CM_ABR }, /* Invisible synonym for log */
  1101. #endif /* NOFRILLS */
  1102.  
  1103. #ifndef NOSPL
  1104.     { "local",       XXLOCAL, CM_INV },    /* LOCAL variable declaration */
  1105. #else
  1106.     { "local",       XXNOTAV, CM_INV },
  1107. #endif /* NOSPL */
  1108.  
  1109.     { "locus",       XXLOCU, CM_INV|CM_HLP }, /* "help locus" */
  1110.  
  1111.     { "log",           XXLOG, 0 },    /* Open a log file */
  1112.  
  1113.     { "login",       XXLOGIN,  0 },    /* (REMOTE) LOGIN to server or IKSD */
  1114.     { "logout",      XXLOGOUT, 0 },    /* LOGOUT from server or IKSD */
  1115.  
  1116. #ifndef NOFRILLS
  1117. #ifndef NODIAL
  1118.     { "lookup",      XXLOOK,  0 },    /* LOOKUP */
  1119. #else
  1120.     { "lookup",      XXNOTAV, CM_INV },
  1121. #endif /* NODIAL */
  1122.  
  1123.     { "lpwd",        XXLPWD, CM_INV },
  1124.     { "lrename",     XXLREN, CM_INV },
  1125.     { "lrmdir",      XXLRMD, CM_INV },
  1126.  
  1127. #ifdef UNIXOROSK
  1128.     { "ls",          XXLS,  CM_INV|CM_PSH }, /* UNIX ls command */
  1129. #else
  1130.     { "ls",          XXDIR, CM_INV },    /* Invisible synonym for DIR */
  1131. #endif /* UNIXOROSK */
  1132. #ifndef NOXFER
  1133.     { "mail",        XXMAI, 0 },    /* Send a file as e-mail */
  1134. #endif /* NOXFER */
  1135. #ifndef NOHELP
  1136.     { "manual",      XXMAN, CM_PSH },    /* MAN(UAL) */
  1137. #else
  1138.     { "manual",      XXNOTAV, CM_INV|CM_PSH },
  1139. #endif /* NOHELP */
  1140. #endif /* NOFRILLS */
  1141. #ifdef CK_MKDIR
  1142.     { "md",          XXMKDIR, CM_INV },    /* Synonym for MKDIR */
  1143. #endif /* CK_MKDIR */
  1144.     { "message",     XXMSG, 0 },    /* Print debugging message */
  1145. #ifdef CK_MINPUT
  1146.     { "minput",      XXMINP, 0 },    /* MINPUT */
  1147. #else
  1148.     { "minput",      XXNOTAV, CM_INV },
  1149. #endif /* CK_MINPUT */
  1150. #ifndef NOMSEND
  1151.     { "mget",        XXMGET, 0 },    /* MGET */
  1152. #else
  1153.     { "mget",        XXNOTAV, CM_INV },
  1154. #endif /* NOMSEND */
  1155. #ifdef CK_MKDIR
  1156.     { "mkdir",       XXMKDIR, 0 },    /* MKDIR */
  1157. #else
  1158.     { "mkdir",       XXNOTAV, CM_INV },
  1159. #endif /* CK_MKDIR */
  1160.  
  1161. #ifndef NOXFER
  1162. #ifndef NOMSEND
  1163.     { "mmove",       XXMMOVE, 0 },    /* MMOVE */
  1164. #else
  1165.     { "mmove",       XXNOTAV, CM_INV },
  1166. #endif /* NOMSEND */
  1167. #endif /* NOXFER */
  1168.  
  1169. #ifndef NOFRILLS
  1170.     { "more",        XXMORE, CM_INV },    /* MORE */
  1171. #endif /* NOFRILLS */
  1172.  
  1173. #ifndef NOXFER
  1174.     { "move",        XXMOVE, 0 },    /* MOVE  */
  1175. #endif /* NOXFER */
  1176.  
  1177. #ifndef NOSPL
  1178.     { "mpause",      XXMSL, CM_INV },    /* Millisecond sleep */
  1179. #else
  1180.     { "mpause",      XXNOTAV, CM_INV },
  1181. #endif /* NOSPL */
  1182.  
  1183. #ifndef NOXFER
  1184. #ifndef NOMSEND
  1185.     { "mput",        XXMSE, CM_INV },    /* MPUT = MSEND */
  1186.     { "ms",          XXMSE, CM_INV|CM_ABR },
  1187.     { "msend",       XXMSE, 0 },    /* Multiple SEND */
  1188. #else
  1189.     { "mput",        XXNOTAV, CM_INV },
  1190.     { "msend",       XXNOTAV, CM_INV },
  1191. #endif /* NOMSEND */
  1192. #endif /* NOXFER */
  1193.     { "msg",         XXMSG, CM_INV },    /* Print debugging message */
  1194. #ifndef NOSPL
  1195.     { "msleep",      XXMSL, 0 },    /* Millisecond sleep */
  1196. #else
  1197.     { "msleep",      XXNOTAV, CM_INV },
  1198. #endif /* NOSPL */
  1199. #ifndef NOFRILLS
  1200.     { "mv",          XXREN, CM_INV },    /* Synonym for rename */
  1201. #endif /* NOFRILLS */
  1202. #ifndef NOHELP
  1203.     { "news",        XXNEW, CM_INV },    /* Display NEWS of new features */
  1204. #else
  1205.     { "news",        XXNOTAV, CM_INV },
  1206. #endif /* NOHELP */
  1207.     { "nolocal",     XXNLCL, CM_INV },    /* Disable SET LINE / SET HOST */
  1208.     { "nopush",      XXNPSH, CM_INV },    /* Disable PUSH command/features */
  1209. #ifdef OS2
  1210.     { "noscroll",    XXNSCR, CM_INV },  /* Disable scroll operations */
  1211. #endif /* OS2 */
  1212. #ifndef NOSPL
  1213.     { "o",           XXOUT, CM_INV|CM_ABR }, /* Invisible synonym for OUTPUT */
  1214.     { "open",        XXOPE, 0 },    /* OPEN file for reading or writing */
  1215. #else
  1216.     { "open",        XXOPE, CM_INV },    /* OPEN */
  1217. #endif /* NOSPL */
  1218. #ifndef NOHELP
  1219.     { "options",     XXOPTS,CM_INV|CM_HLP }, /* Options */
  1220. #endif /* NOHELP */
  1221.     { "orientation", XXORIE, 0 },
  1222. #ifndef NOSPL
  1223.     { "output",      XXOUT, 0 },    /* OUTPUT text to comm device */
  1224. #else
  1225.     { "output",      XXNOTAV, CM_INV },
  1226. #endif /* NOSPL */
  1227. #ifdef ANYX25
  1228. #ifndef IBMX25
  1229.     { "pad",         XXPAD, CM_LOC },    /* X.3 PAD commands */
  1230. #endif /* IBMX25 */
  1231. #endif /* ANYX25 */
  1232.  
  1233. #ifdef NEWFTP
  1234.     { "passive",     XXPASV, CM_INV },    /* (FTP) PASSIVE */
  1235. #endif /* NEWFTP */
  1236.  
  1237. #ifndef NOHELP
  1238.     { "patterns",    XXPAT,CM_INV|CM_HLP }, /* Pattern syntax */
  1239. #endif /* NOHELP */
  1240.  
  1241. #ifndef NOSPL
  1242.     { "pause",       XXPAU, 0 },    /* Sleep for specified interval */
  1243. #else
  1244.     { "pause",       XXNOTAV, CM_INV },
  1245. #endif /* NOSPL */
  1246. #ifndef NODIAL
  1247.     { "pdial",       XXPDIA,  CM_LOC },    /* PDIAL (partial dial) */
  1248. #else
  1249.     { "pdial",       XXNOTAV, CM_INV|CM_LOC },
  1250. #endif /* NODIAL */
  1251. #ifdef TCPSOCKET
  1252. #ifndef NOPUSH
  1253.     { "ping",        XXPNG, CM_INV|CM_PSH|CM_LOC }, /* PING */
  1254. #else
  1255.     { "ping",        XXNOTAV, CM_INV|CM_PSH|CM_LOC },
  1256. #endif /* NOPUSH */
  1257. #endif /* TCPSOCKET */
  1258. #ifdef NETCMD
  1259. #ifndef NOPUSH
  1260.     { "pipe",        XXPIPE, CM_PSH },    /* PIPE */
  1261. #else
  1262.     { "pipe",        XXNOTAV, CM_INV|CM_PSH }, /* PIPE */
  1263. #endif /* NOPUSH */
  1264. #endif /* NETCMD */
  1265.  
  1266. #ifndef NOSPL
  1267.     { "pop",         XXEND, CM_INV },    /* Invisible synonym for END */
  1268. #endif /* NOSPL */
  1269. #ifndef NOFRILLS
  1270.     { "print",       XXPRI, 0 },    /* PRINT a file locally */
  1271. #endif /* NOFRILLS */
  1272.  
  1273.     { "prompt",      XXPROMP, CM_INV },    /* Go interactive (from script) */
  1274.  
  1275. #ifndef NOXFER
  1276. #ifdef CK_RESEND
  1277.     { "psend",       XXPSEN, CM_INV },    /* PSEND */
  1278. #else
  1279.     { "psend",       XXNOTAV, CM_INV },
  1280. #endif /* CK_RESEND */
  1281. #endif /* NOXFER */
  1282.  
  1283. #ifdef NETPTY
  1284.     { "pty",         XXPTY, CM_PSH },    /* PTY */
  1285. #else
  1286.     { "pty",         XXNOTAV, CM_INV|CM_PSH },
  1287. #endif /* NETPTY */
  1288.  
  1289. #ifndef NOPUSH
  1290.     { "pu",          XXSHE, CM_INV|CM_ABR|CM_PSH }, /* PU = PUSH */
  1291. #endif /* NOPUSH */
  1292.  
  1293. #ifdef CKPURGE
  1294.     { "purge",       XXPURGE, 0 },    /* PURGE (real) */
  1295. #else
  1296. #ifdef VMS
  1297.     { "purge",       XXPURGE, 0 },    /* PURGE (fake) */
  1298. #else
  1299.     { "purge",       XXNOTAV, CM_INV },
  1300. #endif /* VMS */
  1301. #endif /* CKPURGE */
  1302.  
  1303. #ifndef NOPUSH
  1304.     { "push",        XXSHE, CM_PSH },    /* PUSH command (like RUN, !) */
  1305. #else
  1306.     { "push",        XXNOTAV, CM_INV|CM_PSH },
  1307. #endif /* NOPUSH */
  1308.  
  1309. #ifndef NOXFER
  1310.     { "put",         XXSEN, CM_INV },    /* PUT = SEND */
  1311. #endif /* NOXFER */
  1312.  
  1313. #ifdef UNIX
  1314. #ifndef NOPUTENV
  1315.     { "putenv",      XXPUTE, CM_INV },    /* PUTENV */
  1316. #endif    /* NOPUTENV */
  1317. #endif    /* UNIX */
  1318.  
  1319.     { "pwd",         XXPWD, 0 },    /* Print Working Directory */
  1320.     { "q",           XXQUI, CM_INV|CM_ABR }, /* Invisible synonym for QUIT */
  1321.  
  1322. #ifndef NOXFER
  1323.     { "query",       XXRQUE,CM_INV },    /* (= REMOTE QUERY) */
  1324. #endif /* NOXFER */
  1325.  
  1326.     { "quit",        XXQUI, 0 },    /* QUIT from program = EXIT */
  1327.  
  1328. #ifndef NOXFER
  1329.     { "r",           XXREC, CM_INV|CM_ABR }, /* Inv synonym for RECEIVE */
  1330. #endif /* NOXFER */
  1331.  
  1332. #ifndef NOXFER
  1333.     { "rasg",        XXRASG, CM_INV },    /* REMOTE ASSIGN */
  1334.     { "rassign",     XXRASG, CM_INV },    /* ditto */
  1335.     { "rcd",         XXRCWD, CM_INV },    /* REMOTE CD */
  1336.     { "rcdup",       XXRCDUP,CM_INV },    /* REMOTE CD */
  1337.     { "rcopy",       XXRCPY, CM_INV },    /* REMOTE COPY */
  1338.     { "rcwd",        XXRCWD, CM_INV },    /* REMOTE CWD */
  1339.     { "rdelete",     XXRDEL, CM_INV },    /* REMOTE DELETE */
  1340.     { "rdirectory",  XXRDIR, CM_INV },    /* REMODE DIRECTORY */
  1341. #endif /* NOXFER */
  1342.  
  1343. #ifndef NOSPL
  1344.     { "read",        XXREA, 0 },    /* READ a line from a file */
  1345. #else
  1346.     { "read",        XXNOTAV, CM_INV },
  1347. #endif /* NOSPL */
  1348.  
  1349. #ifndef NOXFER
  1350.     { "receive",     XXREC, 0 },    /* RECEIVE files */
  1351. #endif /* NOXFER */
  1352.  
  1353. #ifndef NODIAL
  1354.     { "red",         XXRED, CM_INV|CM_ABR|CM_LOC }, /* Inv syn for REDIAL */
  1355.     { "redi",        XXRED, CM_INV|CM_ABR|CM_LOC }, /* ditto */
  1356.     { "redial",      XXRED, CM_LOC },    /* REDIAL last DIAL number */
  1357. #else
  1358.     { "red",         XXNOTAV, CM_INV|CM_LOC },
  1359.     { "redi",        XXNOTAV, CM_INV|CM_LOC },
  1360.     { "redial",      XXNOTAV, CM_INV|CM_LOC },
  1361. #endif /* NODIAL */
  1362.  
  1363. #ifdef CK_REDIR
  1364. #ifdef OS2
  1365. #ifndef NOPUSH
  1366.     { "redirect",    XXFUN, CM_INV|CM_PSH }, /* REDIRECT */
  1367. #else
  1368.     { "redirect",    XXNOTAV, CM_INV|CM_PSH },
  1369. #endif /* NOPUSH */
  1370. #else /* OS2 */
  1371. #ifndef NOPUSH
  1372.     { "redirect",    XXFUN, CM_PSH },    /* REDIRECT */
  1373. #else
  1374.     { "redirect",    XXNOTAV, CM_INV|CM_PSH },
  1375. #endif /* NOPUSH */
  1376. #endif /* OS2 */
  1377. #endif /* CK_REDIR */
  1378.  
  1379. #ifdef CK_RECALL
  1380.     { "redo",        XXREDO,  CM_NOR },    /* REDO */
  1381. #else
  1382.     { "redo",        XXNOTAV, CM_INV },
  1383. #endif /* CK_RECALL */
  1384.  
  1385. #ifndef NOXFER
  1386. #ifdef CK_RESEND
  1387.     { "reget",       XXREGET, 0 },    /* REGET */
  1388. #else
  1389.     { "reget",       XXNOTAV, CM_INV },
  1390. #endif /* CK_RESEND */
  1391. #endif /* NOXFER */
  1392.  
  1393. #ifndef NOSPL
  1394.     { "reinput",     XXREI, CM_INV },    /* REINPUT (from INPUT buffer) */
  1395. #else
  1396.     { "reinput",     XXNOTAV, CM_INV },
  1397. #endif /* NOSPL */
  1398.  
  1399. #ifndef NOXFER
  1400. #ifdef ADDCMD
  1401.     { "rem",         XXREM, CM_INV|CM_ABR },
  1402.     { "remo",        XXREM, CM_INV|CM_ABR },
  1403. #endif /* ADDCMD */
  1404.     { "remote",         XXREM, 0 },    /* Send REMOTE command to server */
  1405. #endif /* NOXFER */
  1406.  
  1407. #ifdef ADDCMD
  1408.     { "remove",      XXREMV,0 },    /* REMOVE (something from a list) */
  1409. #else
  1410.     { "remove",      XXNOTAV, CM_INV },
  1411. #endif /* ADDCMD */
  1412.  
  1413. #ifndef NOFRILLS
  1414. #ifndef NORENAME
  1415.     { "rename",      XXREN, 0 },    /* RENAME a local file */
  1416. #else
  1417.     { "rename",      XXNOTAV, CM_INV },
  1418. #endif /* NORENAME */
  1419.     { "replay",      XXTYP, CM_INV },    /* REPLAY (for now, just type) */
  1420. #endif /* NOFRILLS */
  1421.  
  1422. #ifndef NOXFER
  1423. #ifdef CK_RESEND
  1424.     { "rep",         XXTYP, CM_INV|CM_ABR },  /* REPLAY abbreviation */
  1425.     { "reput",       XXRSEN, CM_INV },          /* REPUT = RESEND */
  1426.     { "res",         XXRSEN, CM_INV|CM_ABR }, /* RESEND */
  1427.     { "rese",        XXRSEN, CM_INV|CM_ABR }, /* RESEND */
  1428.     { "resend",      XXRSEN, 0 },    /* RESEND */
  1429. #else
  1430.     { "reput",       XXNOTAV, CM_INV },
  1431.     { "res",         XXNOTAV, CM_INV },
  1432.     { "rese",        XXNOTAV, CM_INV },
  1433.     { "resend",      XXNOTAV, CM_INV },
  1434. #endif /* CK_RESEND */
  1435. #endif /* NOXFER */
  1436.  
  1437.     { "reset",       XXRESET, CM_INV },    /* RESET */
  1438.  
  1439. #ifdef CK_RESEND
  1440. #ifndef NOSPL
  1441.     { "ret",         XXRET, CM_INV|CM_ABR },
  1442. #endif /* NOSPL */
  1443. #endif /* CK_RESEND */
  1444.  
  1445. #ifndef NOXFER
  1446.     { "retrieve",    XXRETR, CM_INV },    /* RETRIEVE */
  1447. #endif /* NOXFER */
  1448.  
  1449. #ifndef NOSPL
  1450.     { "return",      XXRET, 0 },    /* RETURN from a function */
  1451. #else
  1452.     { "return",      XXNOTAV, CM_INV },
  1453. #endif /* NOSPL */
  1454.  
  1455. #ifndef NOXFER
  1456.     { "rexit",       XXRXIT, CM_INV },    /* REMOTE EXIT */
  1457. #endif /* NOXFER */
  1458.  
  1459. #ifdef CK_REXX
  1460. #ifndef NOPUSH
  1461.     { "rexx",        XXREXX, CM_PSH },    /* Execute a Rexx command */
  1462. #else
  1463.     { "rexx",        XXNOTAV, CM_INV|CM_PSH },
  1464. #endif /* NOPUSH */
  1465. #endif /* CK_REXX */
  1466.  
  1467. #ifndef NOXFER
  1468.     { "rhelp",       XXRHLP, CM_INV },    /* REMOTE HELP */
  1469.     { "rhost",       XXRHOS, CM_INV },    /* REMOTE HOST */
  1470.     { "rkermit",     XXRKER, CM_INV },    /* REMOTE KERMIT */
  1471. #endif /* NOXFER */
  1472.  
  1473. #ifdef TCPSOCKET
  1474.     { "rlogin",      XXRLOG, CM_LOC },    /* Make an Rlogin connection */
  1475. #else
  1476.     { "rlogin",      XXNOTAV, CM_INV|CM_LOC },
  1477. #endif /* TCPSOCKET */
  1478.  
  1479. #ifndef NOFRILLS
  1480.     { "rm",          XXDEL, CM_INV },    /* Invisible synonym for delete */
  1481. #endif /* NOFRILLS */
  1482.  
  1483. #ifdef CK_MKDIR
  1484.     { "rmdir",       XXRMDIR, 0 },    /* RMDIR */
  1485. #else
  1486.     { "rmdir",       XXNOTAV, CM_INV },
  1487. #endif /* CK_MKDIR */
  1488.  
  1489. #ifndef NOXFER
  1490.     { "rmessage",    XXRMSG, CM_INV },    /* REMOTE MESSAGE */
  1491.     { "rmkdir",      XXRMKD, CM_INV },    /* REMOTE MKDIR */
  1492.     { "rmsg",        XXRMSG, CM_INV },    /* REMOTE MESSAGE */
  1493. #ifndef NOSPL
  1494.     { "robust",      XXROB,  CM_INV },
  1495. #else
  1496.     { "robust",      XXNOTAV, CM_INV },
  1497. #endif /* NOSPL */
  1498.     { "rprint",      XXRPRI, CM_INV },  /* REMOTE PRINT */
  1499.     { "rpwd",        XXRPWD, CM_INV },    /* REMOTE PWD */
  1500.     { "rquery",      XXRQUE, CM_INV },    /* REMOTE QUERY */
  1501. #endif /* NOXFER */
  1502.  
  1503. #ifdef CK_RECALL
  1504.     { "rr",          XXREDO, CM_INV|CM_NOR },
  1505. #endif /* CK_RECALL */
  1506.  
  1507. #ifndef NOXFER
  1508.     { "rrename",    XXRREN, CM_INV },    /* REMOTE RENAME */
  1509.     { "rrmdir",     XXRRMD, CM_INV },    /* REMOTE REMDIR */
  1510.     { "rset",       XXRSET, CM_INV },    /* REMOTE SET */
  1511.     { "rspace",     XXRSPA, CM_INV },    /* REMOTE SPACE */
  1512.     { "rtype",      XXRTYP, CM_INV },    /* REMOTE TYPE */
  1513. #endif /* NOXFER */
  1514.  
  1515. #ifndef NOPUSH
  1516.     { "run",         XXSHE, CM_PSH },    /* RUN a program or command */
  1517. #else
  1518.     { "run",         XXNOTAV, CM_INV|CM_PSH },
  1519. #endif /* NOPUSH */
  1520.  
  1521. #ifndef NOXFER
  1522.     { "rwho",        XXRWHO, CM_INV },    /* REMOTE WHO */
  1523.     { "s",           XXSEN, CM_INV|CM_ABR }, /* Invisible synonym for send */
  1524. #endif /* NOXFER */
  1525.  
  1526. #ifndef NOSETKEY
  1527. #ifdef OS2
  1528.     { "save",       XXSAVE, 0 },        /* SAVE something */
  1529. #else
  1530.     { "save",       XXSAVE, CM_INV },
  1531. #endif /* OS2 */
  1532. #else
  1533.     { "save",       XXNOTAV, CM_INV },
  1534. #endif /* NOSETKEY */
  1535.  
  1536. #ifndef NOSCRIPT
  1537.     { "sc",        XXLOGI, CM_INV|CM_ABR|CM_LOC },
  1538.     { "scr",       XXLOGI, CM_INV|CM_ABR|CM_LOC },
  1539. #endif /* NOSCRIPT */
  1540.     { "screen",      XXSCRN, 0 },    /* SCREEN actions */
  1541. #ifndef NOSCRIPT
  1542.     { "script",       XXLOGI, CM_LOC },    /* Expect-Send-style script line */
  1543. #else
  1544.     { "script",       XXNOTAV, CM_INV|CM_LOC },
  1545. #endif /* NOSCRIPT */
  1546.  
  1547.     { "search",    XXGREP,CM_INV },    /* Synonym for GREP and FIND */
  1548.  
  1549. #ifndef NOXFER
  1550.     { "send",       XXSEN, 0 },        /* Send (a) file(s) */
  1551. #ifndef NOSERVER
  1552.     { "server",       XXSER, 0 },        /* Be a SERVER */
  1553. #else
  1554.     { "server",       XXNOTAV, CM_INV },
  1555. #endif /* NOSERVER */
  1556. #endif /* NOXFER */
  1557.  
  1558.     { "set",       XXSET, 0 },        /* SET parameters */
  1559.  
  1560. #ifndef NOSPL
  1561. #ifndef NOSEXP
  1562.     { "sexpression", XXSEXP, CM_INV|CM_HLP }, /* SEXPR */
  1563. #endif /* NOSEXP */
  1564.  
  1565. #ifdef SFTP_BUILTIN
  1566.     { "sftp",        XXSFTP, 0 },   /* SFTP */
  1567. #endif /* SFTP_BUILTIN */
  1568.  
  1569. #ifndef NOSHOW
  1570.     { "sh",          XXSHO, CM_INV|CM_ABR }, /* SHOW parameters */
  1571. #endif /* NOSHOW */
  1572.     { "shift",       XXSHIFT, 0 },    /* SHIFT args */
  1573. #else
  1574.     { "shift",       XXNOTAV, CM_INV },
  1575. #endif /* NOSPL */
  1576.  
  1577. #ifndef NOSHOW
  1578.     { "show",        XXSHO, 0 },        /* SHOW parameters */
  1579. #else
  1580.     { "show",        XXNOTAV, CM_INV },
  1581. #endif /* NOSHOW */
  1582.  
  1583. #ifdef NEWFTP
  1584.     { "site",        XXSITE, CM_INV },    /* (FTP) SITE */
  1585. #endif /* NEWFTP */
  1586.  
  1587. #ifdef SSHBUILTIN
  1588.     { "skermit",   XXSKRM, 0 },     /* SKERMIT */
  1589. #endif /* SSHBUILTIN */
  1590.  
  1591. #ifndef NOSPL
  1592. #ifndef NOFRILLS
  1593.     { "sleep",       XXPAU, CM_INV },    /* SLEEP for specified interval */
  1594. #endif /* NOFRILLS */
  1595. #endif /* NOSPL */
  1596.  
  1597. #ifndef NOSPL
  1598.     { "sort",        XXSORT, CM_INV },    /* (see ARRAY) */
  1599. #else
  1600.     { "sort",        XXNOTAV, CM_INV },
  1601. #endif /* NOSPL */
  1602.  
  1603. #ifndef MAC
  1604. #ifndef NOFRILLS
  1605.     { "sp",          XXSPA, CM_INV|CM_ABR },
  1606.     { "spa",         XXSPA, CM_INV|CM_ABR },
  1607. #endif /* NOFRILLS */
  1608.     { "space",       XXSPA, 0 },    /* Show available disk SPACE */
  1609. #endif /* MAC */
  1610.  
  1611. #ifndef NOFRILLS
  1612. #ifndef NOPUSH
  1613.     { "spawn",       XXSHE, CM_INV|CM_PSH }, /* Synonym for PUSH, RUN */
  1614. #else
  1615.     { "spawn",       XXNOTAV, CM_INV|CM_PSH }, /* Synonym for PUSH, RUN */
  1616. #endif /* NOPUSH */
  1617. #endif /* NOFRILLS */
  1618.  
  1619. #ifdef ANYSSH
  1620.     { "ssh",         XXSSH, 0 },
  1621. #endif /* ANYSSH */
  1622.  
  1623. #ifndef NOXFER
  1624.     { "sta",         XXSTA, CM_INV|CM_ABR },
  1625.     { "stat",        XXSTA, CM_INV|CM_ABR },
  1626.     { "statistics",  XXSTA, 0 },    /* Display file transfer stats */
  1627. #endif /* NOXFER */
  1628.  
  1629.     { "status",      XXSTATUS,0 },    /* Show status of previous command */
  1630.  
  1631. #ifndef NOSPL
  1632.     { "stop",        XXSTO,   0 },    /* STOP all take files and macros */
  1633.     { "succeed",     XXSUCC,  CM_INV },    /* SUCCEED */
  1634. #else
  1635.     { "stop",        XXNOTAV, CM_INV },
  1636.     { "succeed",     XXNOTAV, CM_INV },
  1637. #endif /* NOSPL */
  1638.  
  1639. #ifndef NOFRILLS
  1640.     { "SUPPORT",     XXBUG, 0 },    /* Tech support instructions */
  1641. #else
  1642.     { "support",     XXNOTAV, CM_INV },
  1643. #endif /* NOFRILLS */
  1644.  
  1645. #ifndef NOJC
  1646.     { "suspend",     XXSUS, CM_PSH },    /* SUSPEND C-Kermit (UNIX only) */
  1647. #else
  1648.     { "suspend",     XXNOTAV, CM_INV|CM_PSH },
  1649. #endif /* NOJC */
  1650.  
  1651. #ifndef NOSPL
  1652.     { "switch",      XXSWIT, 0 },    /* SWITCH */
  1653. #else
  1654.     { "switch",      XXNOTAV, CM_INV },
  1655. #endif /* NOSPL */
  1656.  
  1657. #ifdef CK_TAPI
  1658.     { "ta",       XXTAK, CM_INV|CM_ABR }, /* (because of TAPI) */
  1659. #endif /* CK_TAPI */
  1660.  
  1661. #ifndef NOFRILLS
  1662.     { "tail",        XXTAIL, 0 },    /* Display end of a local file */
  1663. #endif /* NOFRILLS */
  1664.  
  1665.     { "take",       XXTAK, 0 },        /* TAKE commands from a file */
  1666.  
  1667. #ifdef CK_TAPI
  1668.     { "tapi",       XXTAPI, CM_LOC },    /* Microsoft TAPI commands */
  1669. #else
  1670.     { "tapi",       XXNOTAV, CM_INV|CM_LOC },
  1671. #endif /* CK_TAPI */
  1672.  
  1673. #ifndef NOFRILLS
  1674. #ifdef TCPSOCKET
  1675.     { "tel",         XXTEL, CM_INV|CM_ABR|CM_LOC },
  1676.     { "telnet",      XXTEL, CM_LOC },    /* TELNET (TCP/IP only) */
  1677.     { "telopt",      XXTELOP, CM_INV },    /* TELOPT (ditto) */
  1678. #else
  1679.     { "tel",         XXNOTAV, CM_INV|CM_LOC },
  1680.     { "telnet",      XXNOTAV, CM_INV|CM_LOC },
  1681.     { "telopt",      XXNOTAV, CM_INV },
  1682. #endif /* TCPSOCKET */
  1683. #ifdef OS2
  1684.     { "terminal",    XXTERM, CM_INV|CM_LOC }, /* == SET TERMINAL TYPE */
  1685. #else
  1686.     { "terminal",    XXTERM, CM_INV },
  1687. #endif /* OS2 */
  1688. #endif /* NOFRILLS */
  1689. #ifndef NOXFER
  1690.     { "text",        XXASC, CM_INV },    /* == SET FILE TYPE TEXT */
  1691. #endif /* NOXFER */
  1692.     { "touch",       XXTOUC, 0 },    /* TOUCH */
  1693. #ifndef NOSPL
  1694.     { "trace",       XXTRACE, 0 },    /* TRACE */
  1695. #else
  1696.     { "trace",       XXNOTAV, CM_INV },
  1697. #endif /* NOSPL */
  1698.  
  1699. #ifndef NOCSETS
  1700.     { "translate",   XXXLA, 0 },    /* TRANSLATE local file char sets */
  1701. #else
  1702.     { "translate",   XXNOTAV, CM_INV },
  1703. #endif /* NOCSETS */
  1704.  
  1705. #ifndef NOXMIT
  1706.     { "transmit",    XXTRA, 0 },    /* Send (upload) a file, no protocol */
  1707. #else
  1708.     { "transmit",    XXNOTAV, CM_INV },
  1709. #endif /* NOXMIT */
  1710.  
  1711. #ifndef NOFRILLS
  1712.     { "type",        XXTYP, 0 },    /* Display a local file */
  1713. #endif /* NOFRILLS */
  1714.  
  1715. #ifndef NOSPL
  1716.     { "undcl",       XXUNDCL, CM_INV },
  1717.     { "undeclare",   XXUNDCL, 0 },    /* UNDECLARE an array */
  1718.     { "undefine",    XXUNDEF, 0 },    /* UNDEFINE a variable or macro */
  1719. #else
  1720.     { "undcl",       XXNOTAV, CM_INV },
  1721.     { "undeclare",   XXNOTAV, CM_INV },
  1722.     { "undefine",    XXNOTAV, CM_INV },
  1723. #endif /* NOSPL */
  1724.  
  1725. #ifdef NEWFTP
  1726.     { "user",        XXUSER,  CM_INV }, /* (FTP) USER */
  1727. #endif /* NEWFTP */
  1728.  
  1729.     { "version",     XXVER, 0 },    /* VERSION-number display */
  1730.  
  1731. #ifdef OS2
  1732.     { "viewonly",    XXVIEW, CM_LOC },    /* VIEWONLY Terminal Mode */
  1733. #endif /* OS2 */
  1734.  
  1735.     { "void",        XXVOID, 0 },    /* VOID */
  1736.  
  1737. #ifndef NOSPL
  1738.     { "wait",        XXWAI, 0 },    /* WAIT */
  1739. #else
  1740.     { "wait",        XXNOTAV, CM_INV },
  1741. #endif /* NOSPL */
  1742.  
  1743.     { "wdirectory",  XXWDIR,  CM_INV },    /* Like TOPS-20, reverse chron order */
  1744.     { "wermit",      XXKERMI, CM_INV },
  1745.  
  1746. #ifndef NOXFER
  1747.     { "where",       XXWHERE, 0 },    /* WHERE (did my file go?) */
  1748. #endif /* NOXFER */
  1749.  
  1750. #ifndef NOSPL
  1751.     { "while",       XXWHI, 0 },    /* WHILE loop */
  1752. #else
  1753.     { "while",       XXNOTAV, CM_INV },
  1754. #endif /* NOSPL */
  1755.  
  1756. #ifndef OS2
  1757. #ifndef MAC
  1758. #ifndef NOFRILLS
  1759.     { "who",         XXWHO, CM_PSH },    /* WHO's logged in? */
  1760. #endif /* NOFRILLS */
  1761. #endif /* MAC */
  1762. #endif /* OS2 */
  1763.  
  1764. #ifndef NOHELP
  1765.     { "wildcards",   XXWILD,CM_INV|CM_HLP }, /* Wildcard syntax */
  1766. #endif /* NOHELP */
  1767.  
  1768. #ifndef NOSPL
  1769.     { "wr",          XXWRI, CM_INV|CM_ABR },
  1770.     { "wri",         XXWRI, CM_INV|CM_ABR },
  1771.     { "writ",        XXWRI, CM_INV|CM_ABR },
  1772.     { "write",       XXWRI, 0 },    /* WRITE characters to a file */
  1773.     { "write-line",  XXWRL, CM_INV },    /* WRITE a line to a file */
  1774.     { "writeln",     XXWRL, CM_INV },    /* Pascalisch synonym for write-line */
  1775. #else
  1776.     { "wr",          XXNOTAV, CM_INV },
  1777.     { "wri",         XXNOTAV, CM_INV },
  1778.     { "writ",        XXNOTAV, CM_INV },
  1779.     { "write",       XXNOTAV, CM_INV },
  1780.     { "write-line",  XXNOTAV, CM_INV },
  1781.     { "writeln",     XXNOTAV, CM_INV },
  1782. #endif /* NOSPL */
  1783.  
  1784. #ifndef NOFRILLS
  1785.     { "xecho",       XXXECH,0 },    /* XECHO */
  1786. #endif /* NOFRILLS */
  1787.  
  1788. #ifndef NOSPL
  1789.     { "xif",         XXIFX, CM_INV },    /* Extended IF command (obsolete) */
  1790. #else
  1791.     { "xif",         XXNOTAV, CM_INV },
  1792. #endif /* NOSPL */
  1793.  
  1794. #ifndef NOCSETS
  1795.     { "xlate",       XXXLA, CM_INV },    /* Synonym for TRANSLATE */
  1796. #else
  1797.     { "xlate",       XXNOTAV, CM_INV },
  1798. #endif /* NOCSETS */
  1799.  
  1800. #ifndef NOXMIT
  1801.     { "xm",          XXTRA, CM_INV|CM_ABR }, /* Avoid conflict with XMESSAGE */
  1802. #else
  1803.     { "xm",          XXNOTAV, CM_INV|CM_ABR }, /* Synonym for TRANSMIT */
  1804. #endif /* NOXMIT */
  1805.  
  1806.     { "xmessage",    XXXMSG, 0 },    /* Print debugging message */
  1807.  
  1808. #ifndef NOXMIT
  1809.     { "xmit",        XXTRA, CM_INV },    /* Synonym for TRANSMIT */
  1810. #else
  1811.     { "xmit",        XXNOTAV, CM_INV },
  1812. #endif /* NOXMIT */
  1813.  
  1814. #ifndef OS2
  1815. #ifndef NOJC
  1816.     { "z",           XXSUS, CM_INV|CM_PSH }, /* Synonym for SUSPEND */
  1817. #else
  1818.     { "z",           XXNOTAV, CM_INV|CM_PSH },
  1819. #endif /* NOJC */
  1820. #endif /* OS2 */
  1821.  
  1822. #ifndef NOSPL
  1823.     { "{",           XXMACRO, CM_INV },    /* Immediate macro */
  1824. #endif /* NOSPL */
  1825.     { "", 0, 0 }
  1826. };
  1827. int ncmd = (sizeof(cmdtab) / sizeof(struct keytab)) - 1;
  1828.  
  1829. /* NOTE: Tokens must also be entered above into cmdtab[]. */
  1830.  
  1831. char toktab[] = {
  1832. #ifndef NOPUSH
  1833.     '!',                /* Shell escape */
  1834. #endif /* NOPUSH */
  1835.     '#',                /* Comment */
  1836. #ifndef NOSPL
  1837.     '(',                /* S-Expression */
  1838.     '.',                /* Assignment */
  1839. #endif /* NOSPL */
  1840.     ';',                /* Comment */
  1841. #ifndef NOSPL
  1842.     ':',                /* Label */
  1843. #endif /* NOSPL */
  1844. #ifndef NOPUSH
  1845. #ifdef CK_REDIR
  1846.     '<',                /* REDIRECT */
  1847. #endif /* CK_REDIR */
  1848.     '@',                /* DCL escape */
  1849. #endif /* NOPUSH */
  1850. #ifdef CK_RECALL
  1851.     '^',                /* Command recall */
  1852. #endif /* CK_RECALL */
  1853. #ifndef NOSPL
  1854.     '{',                /* Immediate macro */
  1855. #endif /* NOSPL */
  1856.     '\0'                /* End of this string */
  1857. };
  1858. int xxdot = 0;                /* Used with "." token */
  1859.  
  1860. struct keytab yesno[] = {        /* Yes/No keyword table */
  1861.     { "no",    0, 0 },
  1862.     { "ok",    1, 0 },
  1863.     { "yes",   1, 0 }
  1864. };
  1865. int nyesno = (sizeof(yesno) / sizeof(struct keytab));
  1866.  
  1867. /* Save keyword table */
  1868.  
  1869. struct keytab savtab[] = {
  1870. #ifdef OS2
  1871.     { "command",  XSCMD, 0 },
  1872. #else
  1873. #ifdef CK_RECALL
  1874.     { "command",  XSCMD, 0 },
  1875. #endif /* CK_RECALL */
  1876. #endif /* OS2 */
  1877. #ifndef NOSETKEY
  1878.     { "keymap",   XSKEY, 0 },
  1879. #endif /* NOSETKEY */
  1880. #ifdef OS2
  1881.     { "terminal", XSTERM, 0 },
  1882. #endif /* OS2 */
  1883.     { "", 0, 0 }
  1884. };
  1885. int nsav = (sizeof(savtab) / sizeof(struct keytab)) - 1;
  1886.  
  1887. /* Parameter keyword table */
  1888.  
  1889. struct keytab prmtab[] = {
  1890.     { "alarm",            XYALRM,  0 },
  1891. #ifdef COMMENT                /* SET ANSWER not implemented yet */
  1892. #ifndef NODIAL
  1893.     { "answer",           XYANSWER,0 },
  1894. #endif /* NODIAL */
  1895. #endif /* COMMENT */
  1896.     { "ask-timer",        XYTIMER, 0 },
  1897. #ifndef NOXFER
  1898.     { "attributes",       XYATTR,  0 },
  1899. #endif /* NOXFER */
  1900. #ifdef CK_AUTHENTICATION
  1901.     { "authentication",   XYAUTH,  0 },
  1902. #else  /* CK_AUTHENTICATION */
  1903. #ifdef CK_SSL
  1904.     { "authentication",   XYAUTH,  0 },
  1905. #endif /* CK_SSL */
  1906. #endif /* CK_AUTHENTICATION */
  1907.     { "b",          XYBACK,  CM_INV|CM_ABR|CM_PSH },
  1908.     { "ba",          XYBACK,  CM_INV|CM_ABR|CM_PSH },
  1909. #ifdef VMS
  1910.     { "background",       XYBACK,  CM_INV|CM_PSH },
  1911.     { "batch",            XYBACK,  CM_PSH },
  1912. #else
  1913.     { "background",       XYBACK,  CM_PSH },
  1914.     { "batch",            XYBACK,  CM_INV|CM_PSH },
  1915. #endif /* VMS */
  1916. #ifndef NOLOCAL
  1917.     { "baud",              XYSPEE,  CM_INV|CM_LOC },
  1918. #endif /* NOLOCAL */
  1919.     { "bell",             XYBELL,  0 },
  1920. #ifndef NOXFER
  1921.     { "block-check",        XYCHKT,  0 },
  1922. #endif /* NOXFER */
  1923. #ifdef OS2
  1924. #ifdef BPRINT
  1925.     { "bprinter",         XYBDCP,  CM_INV },
  1926. #endif /* BPRINT */
  1927. #endif /*  OS2 */
  1928. #ifdef BROWSER
  1929.     { "browser",          XYBROWSE,CM_PSH|CM_LOC },
  1930. #endif /* BROWSER */
  1931. #ifndef NOXFER
  1932. #ifdef DYNAMIC
  1933.     { "buffers",          XYBUF,   0 },
  1934. #endif /* DYNAMIC */
  1935. #endif /* NOXFER */
  1936. #ifndef NOLOCAL
  1937. #ifndef MAC
  1938.     { "carrier-watch",    XYCARR,  CM_LOC },
  1939. #endif /* MAC */
  1940. #endif /* NOLOCAL */
  1941. #ifndef NOSPL
  1942.     { "case",             XYCASE,  0 },
  1943. #endif /* NOSPL */
  1944.     { "cd",               XYCD,    0 },
  1945. #ifndef NOXFER
  1946.     { "cl",               XYCLEAR, CM_INV|CM_ABR },
  1947.     { "cle",              XYCLEAR, CM_INV|CM_ABR },
  1948.     { "clea",             XYCLEAR, CM_INV|CM_ABR },
  1949.     { "clear",            XYCLEAR, CM_INV|CM_ABR },
  1950.     { "clear-channel",    XYCLEAR, 0 },
  1951.     { "clearchannel",     XYCLEAR, CM_INV },
  1952. #endif /* NOXFER */
  1953. #ifndef NOLOCAL
  1954.     { "close-on-disconnect", XYDISC, CM_INV|CM_LOC },
  1955. #endif /* NOLOCAL */
  1956.     { "cmd",              XYCMD,   CM_INV },
  1957.     { "command",          XYCMD,   0 },
  1958. #ifdef CK_SPEED
  1959.     { "con",              XYQCTL,  CM_INV|CM_ABR },
  1960. #endif /* CK_SPEED */
  1961.     { "console",          XYCMD,   CM_INV },
  1962. #ifdef CK_SPEED
  1963.     { "control-character",XYQCTL,  0 },
  1964. #endif /* CK_SPEED */
  1965. #ifndef NOSPL
  1966.     { "count",            XYCOUN,  0 },
  1967. #endif /* NOSPL */
  1968. #ifndef NOXFER
  1969.     { "d",          XYDELA,  CM_INV|CM_ABR },
  1970.     { "de",          XYDELA,  CM_INV|CM_ABR },
  1971. #endif /* NOXFER */
  1972.     { "debug",            XYDEBU,  0 },
  1973. #ifdef VMS
  1974.     { "default",          XYDFLT,  0 },
  1975. #else
  1976. #ifndef MAC
  1977.     { "default",          XYDFLT,  CM_INV },
  1978. #endif /* MAC */
  1979. #endif /* VMS */
  1980. #ifndef NOXFER
  1981.     { "delay",              XYDELA,  0 },
  1982.     { "destination",      XYDEST,  0 },
  1983. #endif /* NOXFER */
  1984. #ifndef NODIAL
  1985.     { "di",          XYDIAL,  CM_INV|CM_ABR|CM_LOC },
  1986.     { "dia",          XYDIAL,  CM_INV|CM_ABR|CM_LOC },
  1987.     { "dial",             XYDIAL,  CM_LOC },
  1988. #endif /* NODIAL */
  1989. #ifdef OS2
  1990.     { "dialer",          XYDLR,   CM_INV },
  1991. #endif /* OS2 */
  1992. #ifndef NOLOCAL
  1993.     { "disconnect",       XYDISC,  CM_LOC },
  1994.     { "duplex",              XYDUPL,  CM_LOC },
  1995. #endif /* NOLOCAL */
  1996. #ifndef NOPUSH
  1997. #ifndef NOFRILLS
  1998.     { "editor",           XYEDIT,  CM_PSH },
  1999. #endif /*  NOFRILLS */
  2000. #endif /* NOPUSH */
  2001. #ifdef CK_CTRLZ
  2002.     { "eof",              XYEOF,   CM_INV },
  2003. #endif /* CK_CTRLZ */
  2004. #ifndef NOLOCAL
  2005.     { "escape-character", XYESC,   CM_LOC },
  2006. #endif /* NOLOCAL */
  2007. #ifndef NOSPL
  2008.     { "evaluate",         XYEVAL,  CM_INV },
  2009. #endif /* NOSPL */
  2010.     { "exit",          XYEXIT,  0 },
  2011. #ifndef NOXFER
  2012. #ifdef CK_XYZ
  2013. #ifndef NOPUSH
  2014. #ifndef XYZ_INTERNAL
  2015.     { "external-protocol",XYEXTRN, 0 },
  2016. #endif    /* XYZ_INTERNAL */
  2017. #endif    /* NOPUSH */
  2018. #endif    /* CK_XYZ */
  2019.     { "f-ack-bug",        XYFACKB, CM_INV },
  2020.     { "f-ack-path",       XYFACKP, CM_INV },
  2021. #endif /* NOXFER */
  2022.     { "file",             XYFILE,  0 },
  2023.     { "fl",                 XYFLOW,  CM_INV|CM_ABR },
  2024. #ifndef NOSPL
  2025.     { "flag",             XYFLAG,  0 },
  2026. #endif /* NOSPL */
  2027. #ifdef TCPSOCKET
  2028. #ifndef SYSFTP
  2029. #ifndef NOFTP
  2030.     { "ft",                 XYFTPX,  CM_INV|CM_ABR },
  2031.     { "ftp",                XYFTPX,  0 },
  2032. #endif /* NOFTP */
  2033. #endif /* SYSFTP */
  2034. #endif /* TCPSOCKET */
  2035. #ifdef BROWSER
  2036.     { "ftp-client",       XYFTP,   CM_PSH },
  2037. #endif /* BROWSER */
  2038.     { "flow-control",       XYFLOW,  0 },
  2039. #ifndef NOSPL
  2040.     { "function",         XYFUNC,  0 },
  2041. #endif /* NOSPL */
  2042. #ifdef NEWFTP
  2043.     { "get-put-remote",   XYGPR,   0 },
  2044. #endif /* NEWFTP */
  2045. #ifdef KUI
  2046.     { "gui",              XYGUI,   0 },
  2047. #endif /* KUI */
  2048.     { "handshake",          XYHAND,  0 },
  2049.     { "hints",            XYHINTS, 0 },
  2050. #ifdef NETCONN
  2051.     { "host",             XYHOST,  CM_LOC },
  2052. #endif /* NETCONN */
  2053. #ifndef NOSPL
  2054.     { "i",          XYINPU,  CM_INV|CM_ABR },
  2055. #endif /* NOSPL */
  2056. #ifdef IKSD
  2057.     { "iks",              XYIKS,   0 },
  2058. #else
  2059.     { "iks",              XYIKS,   CM_INV },
  2060. #endif /* IKSD */
  2061. #ifndef NOSPL
  2062.     { "in",          XYINPU,  CM_INV|CM_ABR },
  2063. #endif /* NOSPL */
  2064. #ifndef NOXFER
  2065.     { "incomplete",         XYIFD,   CM_INV },
  2066. #endif /* NOXFER */
  2067. #ifndef NOSPL
  2068.     { "input",            XYINPU,  0 },
  2069. #endif /* NOSPL */
  2070. #ifndef NOSETKEY
  2071.     { "key",          XYKEY,   0 },
  2072. #endif /* NOSETKEY */
  2073.     { "l",                XYLINE,  CM_INV|CM_ABR },
  2074. #ifndef NOCSETS
  2075.     { "language",         XYLANG,  0 },
  2076. #endif /* NOCSETS */
  2077. #ifndef NOLOCAL
  2078.     { "line",             XYLINE,  CM_LOC },
  2079.     { "local-echo",      XYLCLE,  CM_INV|CM_LOC },
  2080. #endif /* NOLOCAL */
  2081. #ifdef LOCUS
  2082.     { "locus",            XYLOCUS, 0 },
  2083. #endif /* LOCUS */
  2084. #ifndef NOSPL
  2085.     { "login",          XYLOGIN, CM_LOC },
  2086. #endif /* NOSPL */
  2087. #ifndef NOSPL
  2088.     { "macro",            XYMACR,  0 },
  2089. #endif /* NOSPL */
  2090.     { "match",            XYMATCH, 0 },
  2091. #ifdef COMMENT
  2092. #ifdef VMS
  2093.     { "messages",         XYMSGS,  0 },
  2094. #endif /* VMS */
  2095. #endif /* COMMENT */
  2096. #ifndef NODIAL
  2097.     { "modem",          XYMODM,  CM_LOC },
  2098. #endif /* NODIAL */
  2099. #ifndef NOLOCAL
  2100. #ifdef OS2MOUSE
  2101.     { "mouse",          XYMOUSE, 0 },
  2102. #endif /* OS2MOUSE */
  2103. #endif /* NOLOCAL */
  2104. #ifdef OS2
  2105.     { "mskermit",         XYMSK,   0 },
  2106. #endif /* OS2 */
  2107. #ifdef NETCONN
  2108.     { "network",          XYNET,   CM_LOC },
  2109. #endif /* NETCONN */
  2110. #ifndef NOSPL
  2111.     { "output",           XYOUTP,  0 },
  2112. #endif /* NOSPL */
  2113.     { "options",          XYOPTS,  0 },
  2114.     { "pause",            XYSLEEP, CM_INV },
  2115. #ifdef ANYX25
  2116. #ifndef IBMX25
  2117.     { "pad",              XYPAD,   CM_LOC },
  2118. #endif /* IBMX25 */
  2119. #endif /* ANYX25 */
  2120.     { "parity",              XYPARI,  0 },
  2121. #ifndef NOLOCAL
  2122. #ifdef OS2
  2123.     { "port",             XYLINE,  CM_LOC },
  2124. #else
  2125.     { "port",             XYLINE,  CM_INV|CM_LOC },
  2126. #endif /* OS2 */
  2127. #endif /* NOLOCAL */
  2128. #ifndef NOFRILLS
  2129.     { "pr",                 XYPROM,  CM_INV|CM_ABR },
  2130.     { "printer",          XYPRTR,  0 },
  2131. #endif /* NOFRILLS */
  2132. #ifdef OS2
  2133.     { "priority",         XYPRTY,  0 },
  2134. #endif /* OS2 */
  2135. #ifdef CK_SPEED
  2136.     { "prefixing",        XYPREFIX, 0 },
  2137. #endif /* CK_SPEED */
  2138. #ifndef NOFRILLS
  2139.     { "prompt",              XYPROM,  0 },
  2140. #endif /* NOFRILLS */
  2141. #ifndef NOXFER
  2142.     { "protocol",      XYPROTO, 0 },
  2143. #endif /* NOXFER */
  2144.     { "q",          XYQUIE,  CM_INV|CM_ABR },
  2145. #ifndef NOXFER
  2146.     { "q8flag",           XYQ8FLG, CM_INV },
  2147. #endif /* NOXFER */
  2148. #ifdef QNX
  2149.     { "qnx-port-lock",    XYQNXPL, 0 },
  2150. #else
  2151.     { "qnx-port-lock",    XYQNXPL, CM_INV },
  2152. #endif /* QNX */
  2153.     { "quiet",          XYQUIE,  0 },
  2154. #ifndef NOXFER
  2155.     { "rec",              XYRECV,  CM_INV|CM_ABR },
  2156.     { "receive",          XYRECV,  0 },
  2157.     { "recv",             XYRECV,  CM_INV },
  2158. #endif /* NOXFER */
  2159.     { "reliable",         XYRELY,  0 },
  2160.     { "rename",           XY_REN,  0 },
  2161. #ifndef NOXFER
  2162.     { "repeat",           XYREPT,  0 },
  2163.     { "retry-limit",      XYRETR,  0 },
  2164. #endif /* NOXFER */
  2165. #ifdef CKROOT
  2166.     { "root",             XYROOT,  0 },
  2167. #endif /* CKROOT */
  2168. #ifndef NOSCRIPT
  2169.     { "script",          XYSCRI,  CM_LOC },
  2170. #endif /* NOSCRIPT */
  2171. #ifndef NOXFER
  2172.     { "send",             XYSEND,  0 },
  2173. #ifndef NOLOCAL
  2174. #ifndef NOSERVER
  2175.     { "ser",              XYSERV,  CM_INV|CM_ABR },
  2176. #endif /* NOSERVER */
  2177. #endif /* NOXFER */
  2178.     { "serial",           XYSERIAL,CM_LOC },
  2179. #endif /* NOLOCAL */
  2180. #ifndef NOSERVER
  2181.     { "server",           XYSERV,  0 },
  2182. #endif /* NOSERVER */
  2183. #ifdef SESLIMIT
  2184. #ifndef NOLOCAL
  2185.     { "session-l",        XYSESS,  CM_INV|CM_ABR },
  2186. #endif /* NOLOCAL */
  2187.     { "session-limit",    XYLIMIT, CM_INV|CM_LOC }, /* Session Limit */
  2188. #endif /* SESLIMIT */
  2189.  
  2190. #ifndef NOLOCAL
  2191.     { "session-log",      XYSESS,  CM_LOC },
  2192. #endif /* NOLOCAL */
  2193.  
  2194. #ifndef NOSPL
  2195. #ifndef NOSEXP
  2196.     { "sexpression",      XYSEXP,  CM_INV },
  2197. #endif /* NOSEXP */
  2198. #endif /* NOSPL */
  2199.  
  2200.     { "sleep",            XYSLEEP, 0 },
  2201.  
  2202. #ifndef NOLOCAL
  2203.     { "speed",              XYSPEE,  CM_LOC },
  2204. #endif /* NOLOCAL */
  2205.  
  2206. #ifdef ANYSSH
  2207.     { "ssh",              XYSSH,   0 },
  2208. #endif /* ANYSSH */
  2209.  
  2210. #ifndef NOSPL
  2211.     { "startup-file",     XYSTARTUP, CM_INV },
  2212. #endif /* NOSPL */
  2213.  
  2214. #ifndef NOLOCAL
  2215. #ifdef HWPARITY
  2216.     { "stop-bits",        XYSTOP, CM_LOC },
  2217. #else
  2218. #ifdef TN_COMPORT
  2219.     { "stop-bits",        XYSTOP, CM_LOC },
  2220. #endif /* TN_COMPORT */
  2221. #endif /* HWPARITY */
  2222. #endif /* NOLOCAL */
  2223.  
  2224. #ifndef NOXFER
  2225. #ifdef STREAMING
  2226.     { "streaming",        XYSTREAM, 0 },
  2227. #endif /* STREAMING */
  2228. #endif /* NOXFER */
  2229.  
  2230. #ifndef NOJC
  2231.     { "suspend",          XYSUSP,  CM_PSH },
  2232. #endif /* NOJC */
  2233. #ifdef CKSYSLOG
  2234.     { "syslog",           XYSYSL,  CM_INV },
  2235. #endif /* CKSYSLOG */
  2236.     { "take",             XYTAKE,  0 },
  2237.  
  2238. #ifdef CK_TAPI
  2239.     { "tapi",             XYTAPI,  CM_LOC },
  2240. #endif /* CK_TAPI */
  2241.  
  2242. #ifndef NOTCPOPTS
  2243. #ifdef TCPSOCKET
  2244.     { "tcp",              XYTCP,   CM_LOC },
  2245. #endif /* TCPSOCKET */
  2246. #endif /* NOTCPOPTS */
  2247.  
  2248. #ifdef TNCODE
  2249.     { "tel",              XYTEL,   CM_INV|CM_ABR },
  2250.     { "telnet",           XYTEL,   0 },
  2251.     { "telopt",           XYTELOP, 0 },
  2252. #endif /* TNCODE */
  2253.  
  2254. #ifndef NOSPL
  2255.     { "temp-directory",   XYTMPDIR,0 },
  2256. #endif /* NOSPL */
  2257.  
  2258. #ifndef NOLOCAL
  2259.     { "terminal",         XYTERM,  CM_LOC },
  2260. #endif /* NOLOCAL */
  2261.  
  2262. #ifdef OS2
  2263.     { "title",          XYTITLE, CM_LOC },
  2264. #endif /* OS2 */
  2265. #ifdef TLOG
  2266.     { "transaction-log",  XYTLOG,  0 },
  2267. #endif /* TLOG */
  2268. #ifndef NOXFER
  2269.     { "transfer",         XYXFER,  0 },
  2270. #endif /* NOXFER */
  2271. #ifndef NOXMIT
  2272.     { "transmit",         XYXMIT,  0 },
  2273. #endif /* NOXMIT */
  2274. #ifndef NOXFER
  2275. #ifndef NOCSETS
  2276.     { "unknown-char-set", XYUNCS,  0 },
  2277. #endif /* NOCSETS */
  2278. #ifndef NOSPL
  2279.     { "variable-evaluation", XYVAREV, CM_INV },
  2280. #endif    /* NOSPL */
  2281. #endif /* NOXFER */
  2282.     { "wait",             XYSLEEP, CM_INV },
  2283. #ifndef NOPUSH
  2284. #ifdef UNIX
  2285.     { "wildcard-expansion", XYWILD, 0 },
  2286. #endif /* UNIX */
  2287. #endif /* NOPUSH */
  2288. #ifdef NT
  2289.     { "w",                XYWIND,  CM_INV|CM_ABR },
  2290.     { "wi",               XYWIND,  CM_INV|CM_ABR },
  2291.     { "win",              XYWIND,  CM_INV|CM_ABR },
  2292. #endif /* NT */
  2293.     { "window-size",      XYWIND,  0 },
  2294. #ifdef NT
  2295.     { "win95",            XYWIN95, 0 },
  2296. #endif /* NT */
  2297. #ifdef ANYX25
  2298.     { "x.25",             XYX25,   CM_LOC },
  2299.     { "x25",              XYX25,   CM_INV|CM_LOC },
  2300. #endif /* ANYX25 */
  2301.     { "xfer",             XYXFER,  CM_INV },
  2302. #ifndef NOXMIT
  2303.     { "xmit",             XYXMIT,  CM_INV },
  2304. #endif /* NOXMIT */
  2305.     { "", 0, 0 }
  2306. };
  2307. int nprm = (sizeof(prmtab) / sizeof(struct keytab)) - 1; /* How many */
  2308.  
  2309. struct keytab scntab[] = {        /* Screen commands */
  2310.     { "clear",   SCN_CLR, 0 },
  2311.     { "cleol",   SCN_CLE, 0 },
  2312.     { "move-to", SCN_MOV, 0 }
  2313. };
  2314. int nscntab = (sizeof(scntab) / sizeof(struct keytab)); /* How many */
  2315.  
  2316. #ifdef ANYSSH                /* SSH command table */
  2317. #ifdef SSHBUILTIN
  2318. int    ssh_pf_lcl_n = 0,
  2319.        ssh_pf_rmt_n = 0;
  2320. struct ssh_pf ssh_pf_lcl[32] = { 0, NULL, 0 }; /* SSH Port Forwarding */
  2321. struct ssh_pf ssh_pf_rmt[32] = { 0, NULL, 0 }; /* structs... */
  2322. extern char * ssh_hst, * ssh_cmd, * ssh_prt;
  2323. extern int    ssh_ver,   ssh_xfw;
  2324. char * ssh_tmpuid = NULL, *ssh_tmpcmd = NULL, *ssh_tmpport = NULL,
  2325.      * ssh_tmpstr = NULL;
  2326.  
  2327. int
  2328.  sshk_type = SSHKT_2D,            /* SSH KEY CREATE /TYPE:x */
  2329.  sshk_bits = 1024,            /* SSH KEY CREATE /BITS:n */
  2330.  sshk_din  = SKDF_OSSH,            /* SSH KEY DISPLAY /IN-FORMAT: */
  2331.  sshk_dout = SKDF_OSSH;            /* SSH KEY DISPLAY /OUT-FORMAT: */
  2332.  
  2333. char
  2334.  * sshk1_comment = NULL,        /* SSH V1 COMMENT */
  2335.  * sshkp_old = NULL,            /* Old key passphrase */
  2336.  * sshkp_new = NULL,            /* New key passphrase */
  2337.  * sshkc_pass = NULL,            /* KEY CREATE /PASS:xxx */
  2338.  * sshkc_comm = NULL,            /* KEY CREATE /V1-RSA-COMMENT:xxx */
  2339.  * sshd_file = NULL,            /* DISPLAY file */
  2340.  * sshk_file = NULL;            /* SSH CREATE KEY file */
  2341.  
  2342. static struct keytab sshclr[] = {
  2343.     { "local-port-forward",  SSHC_LPF, 0 },
  2344.     { "remote-port-forward", SSHC_RPF, 0 },
  2345.     { "", 0, 0 }
  2346. };
  2347. static int nsshclr = (sizeof(sshclr) / sizeof(struct keytab)) - 1;
  2348.  
  2349. struct keytab sshopnsw[] = {
  2350.     { "/command",        SSHSW_CMD, CM_ARG },
  2351.     { "/password",       SSHSW_PWD, CM_ARG },
  2352.     { "/subsystem",      SSHSW_SUB, CM_ARG },
  2353.     { "/user",           SSHSW_USR, CM_ARG },
  2354.     { "/version",        SSHSW_VER, CM_ARG },
  2355.     { "/x11-forwarding", SSHSW_X11, CM_ARG },
  2356.     { "", 0, 0 }
  2357. };
  2358. int nsshopnsw = (sizeof(sshopnsw) / sizeof(struct keytab)) - 1;
  2359.  
  2360. static struct keytab sshkwtab[] = {
  2361.     { "add",                 XSSH_ADD, 0 },
  2362.     { "agent",               XSSH_AGT, 0 },
  2363.     { "clear",               XSSH_CLR, 0 },
  2364.     { "forward-local-port",  XSSH_FLP, CM_INV },
  2365.     { "forward-remote-port", XSSH_FRP, CM_INV },
  2366.     { "key",                 XSSH_KEY, 0 },
  2367.     { "open",                XSSH_OPN, 0 },
  2368.     { "v2",                  XSSH_V2,  0 },
  2369.     { "", 0, 0 }
  2370. };
  2371. static int nsshcmd = (sizeof(sshkwtab) / sizeof(struct keytab)) - 1;
  2372.  
  2373. static struct keytab ssh2tab[] = {
  2374.     { "rekey", XSSH2_RKE, 0 },
  2375.     { "", 0, 0 }
  2376. };
  2377. static int nssh2tab = (sizeof(ssh2tab) / sizeof(struct keytab));
  2378.  
  2379. static struct keytab addfwd[] = {    /* SET SSH ADD command table */
  2380.     { "local-port-forward",  SSHF_LCL, 0 },
  2381.     { "remote-port-forward", SSHF_RMT, 0 },
  2382.     { "", 0, 0 }
  2383. };
  2384. static int naddfwd = (sizeof(addfwd) / sizeof(struct keytab)) - 1;
  2385.  
  2386. static struct keytab sshagent[] = {    /* SET SSH AGENT command table */
  2387.     { "add",    SSHA_ADD, 0 },
  2388.     { "delete", SSHA_DEL, 0 },
  2389.     { "list",   SSHA_LST, 0 },
  2390.     { "", 0, 0 }
  2391. };
  2392. static int nsshagent = (sizeof(sshagent) / sizeof(struct keytab)) - 1;
  2393.  
  2394. static struct keytab sshagtsw[] = {    /* SET SSH AGENT LIST switch table */
  2395.     { "/fingerprint", SSHASW_FP, 0 },
  2396.     { "", 0, 0 }
  2397. };
  2398. static int nsshagtsw = (sizeof(sshagtsw) / sizeof(struct keytab)) - 1;
  2399.  
  2400. static struct keytab sshkey[] = {    /* SET SSH KEY command table */
  2401.     { "change-passphrase",  SSHK_PASS, 0 },
  2402.     { "create",             SSHK_CREA, 0 },
  2403.     { "display",            SSHK_DISP, 0 },
  2404.     { "v1",                 SSHK_V1,   0 },
  2405.     { "", 0, 0 }
  2406. };
  2407. static int nsshkey = (sizeof(sshkey) / sizeof(struct keytab)) - 1;
  2408.  
  2409. static struct keytab sshkv1[] = {    /* SET SSH KEY V1 command table */
  2410.     { "set-comment",  1, 0 }
  2411. };
  2412.  
  2413. static struct keytab sshkpsw[] = {    /* SET SSH KEY PASSPHRASE table */
  2414.     { "/new-passphrase",  2, CM_ARG },
  2415.     { "/old-passphrase",  1, CM_ARG }
  2416. };
  2417.  
  2418. static struct keytab sshkcrea[] = {    /* SSH KEY CREATE table */
  2419.     { "/bits",           SSHKC_BI, CM_ARG },
  2420.     { "/passphrase",     SSHKC_PP, CM_ARG },
  2421.     { "/type",           SSHKC_TY, CM_ARG },
  2422.     { "/v1-rsa-comment", SSHKC_1R, CM_ARG }
  2423. };
  2424. static int nsshkcrea = (sizeof(sshkcrea) / sizeof(struct keytab));
  2425.  
  2426. static struct keytab sshkcty[] = {    /* SSH KEY CREATE /TYPE:xxx */
  2427.     { "srp",    SSHKT_SRP, 0 },
  2428.     { "v1-rsa", SSHKT_1R, 0 },
  2429.     { "v2-dsa", SSHKT_2D, 0 },
  2430.     { "v2-rsa", SSHKT_2R, 0 }
  2431. };
  2432. static int nsshkcty = (sizeof(sshkcty) / sizeof(struct keytab));
  2433.  
  2434. static struct keytab sshdswi[] = {    /* SET SSH KEY DISPLAY /switches */
  2435.     { "/format", SSHKD_OUT, CM_ARG }
  2436. };
  2437. static int nsshdswi = (sizeof(sshdswi) / sizeof(struct keytab));
  2438.  
  2439. #ifdef COMMENT
  2440. static struct keytab sshdifmt[] = {    /* SSH KEY DISPLAY /IN-FORMAT: */
  2441.     { "openssh", SKDF_OSSH, 0 },
  2442.     { "ssh.com", SKDF_SSHC, 0 }
  2443. };
  2444. static int nsshdifmt = (sizeof(sshdifmt) / sizeof(struct keytab));
  2445. #endif /* COMMENT */
  2446.  
  2447. static struct keytab sshdofmt[] = {    /* SSH KEY DISPLAY /IN-FORMAT: */
  2448.     { "fingerprint", SKDF_FING, 0 },
  2449.     { "ietf",        SKDF_IETF, 0 },
  2450.     { "openssh",     SKDF_OSSH, 0 },
  2451.     { "ssh.com",     SKDF_SSHC, 0 }
  2452. };
  2453. static int nsshdofmt = (sizeof(sshdofmt) / sizeof(struct keytab));
  2454.  
  2455. static struct keytab sshkermit[] = { /* SKERMIT */
  2456.     { "open",       SKRM_OPN, 0 }
  2457. };
  2458. static int nsshkermit = (sizeof(sshkermit) / sizeof(struct keytab));
  2459.  
  2460. struct keytab sshkrmopnsw[] = {
  2461.     { "/password",       SSHSW_PWD, CM_ARG },
  2462.     { "/user",           SSHSW_USR, CM_ARG },
  2463.     { "/version",        SSHSW_VER, CM_ARG },
  2464.     { "", 0, 0 }
  2465. };
  2466. int nsshkrmopnsw = (sizeof(sshkrmopnsw) / sizeof(struct keytab)) - 1;
  2467. #endif /* SSHBUILTIN */
  2468.  
  2469. #ifdef SFTP_BUILTIN
  2470. static struct keytab sftpkwtab[] = {    /* SFTP */
  2471.     {  "cd",        SFTP_CD,    0 },
  2472.     {  "chgrp",     SFTP_CHGRP, 0 },
  2473.     {  "chmod",     SFTP_CHMOD, 0 },
  2474.     {  "chown",     SFTP_CHOWN, 0 },
  2475.     {  "delete",    SFTP_RM,    0 },
  2476.     {  "dir",       SFTP_DIR,   0 },
  2477.     {  "get",       SFTP_GET,   0 },
  2478.     {  "mkdir",     SFTP_MKDIR, 0 },
  2479.     {  "open",      SFTP_OPN,   0 },
  2480.     {  "put",       SFTP_PUT,   0 },
  2481.     {  "pwd",       SFTP_PWD,   0 },
  2482.     {  "rename",    SFTP_REN,   0 },
  2483.     {  "rm",        SFTP_RM,    CM_INV },
  2484.     {  "rmdir",     SFTP_RMDIR, 0 },
  2485.     {  "symlink",   SFTP_LINK,  0 },
  2486.     {  "version",   SFTP_VER,   0 }
  2487. };
  2488. static int nsftpkwtab = (sizeof(sftpkwtab) / sizeof(struct keytab));
  2489. #endif /* SFTP_BUILTIN */
  2490. #endif /* ANYSSH */
  2491.  
  2492. #ifdef NETCONN
  2493. struct keytab netkey[] = {        /* SET NETWORK table */
  2494.     { "directory", XYNET_D,  0 },
  2495.     { "type",      XYNET_T,  0 }
  2496. };
  2497. int nnetkey = (sizeof(netkey) / sizeof(struct keytab));
  2498.  
  2499. struct keytab netcmd[] = {
  2500. /*
  2501.   These are the network types.
  2502. */
  2503. #ifdef NETCMD
  2504.     { "command",       NET_CMD,  CM_INV }, /* Command */
  2505. #endif /* NETCMD */
  2506.  
  2507. #ifdef DECNET                /* DECnet / PATHWORKS */
  2508.     { "decnet",        NET_DEC,  0 },
  2509. #endif /* DECNET */
  2510.  
  2511. #ifdef NETDLL
  2512.     { "dll",           NET_DLL,  CM_INV }, /* DLL to be loaded */
  2513. #endif /* NETDLL */
  2514.  
  2515. #ifdef NETFILE
  2516.     { "file",           NET_FILE, CM_INV }, /* FILE (real crude) */
  2517. #endif /* NETFILE */
  2518.  
  2519. #ifdef NPIPE                /* Named Pipes */
  2520.     { "named-pipe",     NET_PIPE,  0 },
  2521. #endif /* NPIPE */
  2522.  
  2523. #ifdef CK_NETBIOS
  2524.     { "netbios",        NET_BIOS,  0 },    /* NETBIOS */
  2525. #endif /* CK_NETBIOS */
  2526.  
  2527. #ifdef DECNET                /* DECnet / PATHWORKS (alias) */
  2528.     { "pathworks",     NET_DEC,  CM_INV },
  2529. #endif /* DECNET */
  2530.  
  2531. #ifdef NETCMD
  2532.     { "pipe",          NET_CMD,  0 },    /* Pipe */
  2533. #endif /* NETCMD */
  2534.  
  2535. #ifdef NETPTY
  2536.     { "pseudoterminal",NET_PTY, 0 },    /* Pseudoterminal */
  2537. #endif /* NETPTY */
  2538.  
  2539. #ifdef NETPTY
  2540.     { "pty",          NET_PTY,  CM_INV }, /* Inv syn for pseudoterm */
  2541. #endif /* NETPTY */
  2542.  
  2543. #ifdef SSHBUILTIN
  2544.     { "ssh",          NET_SSH,  0 },
  2545. #endif /* SSHBUILTIN */
  2546.  
  2547. #ifdef SUPERLAT
  2548.     { "superlat",     NET_SLAT, 0 },    /* Meridian Technologies' SuperLAT */
  2549. #endif /* SUPERLAT */
  2550.  
  2551. #ifdef TCPSOCKET            /* TCP/IP sockets library */
  2552.     { "tcp/ip",       NET_TCPB, 0 },
  2553. #endif /* TCPSOCKET */
  2554. #ifdef SUPERLAT
  2555.     { "tes32",        NET_SLAT, 0 },    /* Emulux TES32 */
  2556. #endif /* SUPERLAT */
  2557. #ifdef ANYX25                /* X.25 */
  2558. #ifdef SUNX25
  2559.     { "x",            NET_SX25, CM_INV|CM_ABR },
  2560.     { "x.25",         NET_SX25, 0 },
  2561.     { "x25",          NET_SX25, CM_INV },
  2562. #else
  2563. #ifdef STRATUSX25
  2564.     { "x",            NET_VX25, CM_INV|CM_ABR },
  2565.     { "x.25",         NET_VX25, 0 },
  2566.     { "x25",          NET_VX25, CM_INV },
  2567. #endif /* STRATUSX25 */
  2568. #endif /* SUNX25 */
  2569. #ifdef IBMX25
  2570.     { "x",            NET_IX25, CM_INV|CM_ABR },
  2571.     { "x.25",         NET_IX25, CM_INV },
  2572.     { "x25",          NET_IX25, CM_INV },
  2573. #endif /* IBMX25 */
  2574. #ifdef HPX25
  2575.     { "x",            NET_IX25, CM_INV|CM_ABR },
  2576.     { "x.25",         NET_IX25, 0 },
  2577.     { "x25",          NET_IX25, CM_INV },
  2578. #endif /* HPX25 */
  2579. #endif /* ANYX25 */
  2580.     { "", 0, 0 }
  2581. };
  2582. int nnets = (sizeof(netcmd) / sizeof(struct keytab));
  2583.  
  2584. #ifndef NOTCPOPTS
  2585. #ifdef TCPSOCKET
  2586.  
  2587. /* TCP options */
  2588.  
  2589. struct keytab tcpopt[] = {
  2590.     { "address",   XYTCP_ADDRESS, 0 },
  2591. #ifdef CK_DNS_SRV
  2592.     { "dns-service-records", XYTCP_DNS_SRV, 0 },
  2593. #endif /* CK_DNS_SRV */
  2594. #ifdef SO_DONTROUTE
  2595.     { "dontroute",   XYTCP_DONTROUTE, 0 },
  2596. #endif /* SO_DONTROUTE */
  2597. #ifndef NOHTTP
  2598.     { "http-proxy", XYTCP_HTTP_PROXY, 0 },
  2599. #endif /* NOHTTP */
  2600. #ifdef SO_KEEPALIVE
  2601.     { "keepalive", XYTCP_KEEPALIVE, 0 },
  2602. #endif /* SO_KEEPALIVE */
  2603. #ifdef SO_LINGER
  2604.     { "linger", XYTCP_LINGER, 0 },
  2605. #endif /* SO_LINGER */
  2606. #ifdef TCP_NODELAY
  2607.     { "nagle",  XYTCP_NAGLE,    CM_INV },
  2608.     { "nodelay", XYTCP_NODELAY, 0 },
  2609. #endif /* TCP_NODELAY */
  2610.     { "reverse-dns-lookup", XYTCP_RDNS, 0 },
  2611. #ifdef SO_RCVBUF
  2612.     { "recvbuf", XYTCP_RECVBUF, 0 },
  2613. #endif /* SO_RCVBUF */
  2614. #ifdef SO_SNDBUF
  2615.     { "sendbuf", XYTCP_SENDBUF, 0 },
  2616. #endif /* SO_SNDBUF */
  2617. #ifdef NT
  2618. #ifdef CK_SOCKS
  2619.     { "socks-server", XYTCP_SOCKS_SVR, 0 },
  2620. #endif /* CK_SOCKS */
  2621. #endif /* NT */
  2622. #ifdef VMS
  2623. #ifdef DEC_TCPIP
  2624.     { "ucx-port-bug", XYTCP_UCX, 0 },
  2625. #endif /* DEC_TCPIP */
  2626. #endif /* VMS */
  2627.     { "",0,0 }
  2628. };
  2629. int ntcpopt = (sizeof(tcpopt) / sizeof(struct keytab));
  2630. #endif /* TCPSOCKET */
  2631. #endif /* NOTCPOPTS */
  2632. #endif /* NETCONN */
  2633.  
  2634. #ifdef OS2
  2635. /* K95 Manual Chapter Table -- Keep these two tables in sync! */
  2636.  
  2637. static char * linktbl[] = {        /* Internal links in k95.htm */
  2638.     "#top",                /* 00 */
  2639.     "#what",                /* 01 */
  2640.     "#install",                /* 02 */
  2641.     "#start",                /* 03 */
  2642.     "#dialer",                /* 04 */
  2643.     "#entries",                /* 05 */
  2644.     "#command",                /* 06 */
  2645.     "#terminal",            /* 07 */
  2646.     "#transfer",            /* 08 */
  2647.     "#hostmode"                /* 09 */
  2648. };
  2649.  
  2650. static struct keytab chaptbl[] = {
  2651.     { "Command-Screen",     6, 0 },
  2652.     { "Contents",           0, 0 },
  2653.     { "Dialer-Entries",     5, 0 },
  2654.     { "File-Transfer",      8, 0 },
  2655.     { "Getting-Started",    3, 0 },
  2656.     { "Host-Mode",          9, 0 },
  2657.     { "Installation",       2, 0 },
  2658.     { "Terminal-Emulation", 7, 0 },
  2659.     { "Using-The-Dialer",   4, 0 },
  2660.     { "What-Is-K95",        1, 0 },
  2661.     { "",                   0, 0 }
  2662. };
  2663. static int nchaptbl = (sizeof(chaptbl) / sizeof(struct keytab) - 1);
  2664. #endif /* OS2 */
  2665.  
  2666. #ifndef NOXFER
  2667. /* Remote Command Table */
  2668.  
  2669. struct keytab remcmd[] = {
  2670. #ifndef NOSPL
  2671.     { "as",        XZASG, CM_INV|CM_ABR },
  2672.     { "asg",       XZASG, CM_INV },
  2673.     { "assign",    XZASG, 0 },
  2674. #endif /* NOSPL */
  2675.     { "cd",        XZCWD, 0 },
  2676.     { "cdup",      XZCDU, CM_INV },
  2677.     { "copy",      XZCPY, 0 },
  2678.     { "cwd",       XZCWD, CM_INV },
  2679.     { "delete",    XZDEL, 0 },
  2680.     { "directory", XZDIR, 0 },
  2681.     { "e",         XZXIT, CM_ABR|CM_INV },
  2682.     { "erase",     XZDEL, CM_INV },
  2683.     { "exit",      XZXIT, 0 },
  2684.     { "help",      XZHLP, 0 },
  2685. #ifndef NOPUSH
  2686.     { "host",      XZHOS, 0 },
  2687. #endif /* NOPUSH */
  2688. #ifndef NOFRILLS
  2689.     { "kermit",    XZKER, 0 },
  2690.     { "l",         XZLGI, CM_ABR|CM_INV },
  2691.     { "lo",        XZLGI, CM_ABR|CM_INV },
  2692.     { "log",       XZLGI, CM_ABR|CM_INV },
  2693.     { "login",     XZLGI, 0 },
  2694.     { "logout",    XZLGO, 0 },
  2695.     { "message",   XZMSG, 0 },
  2696.     { "mkdir",     XZMKD, 0 },
  2697.     { "print",     XZPRI, 0 },
  2698. #endif /* NOFRILLS */
  2699.     { "pwd",       XZPWD, 0 },
  2700. #ifndef NOSPL
  2701.     { "query",       XZQUE, 0 },
  2702. #endif /* NOSPL */
  2703.     { "rename",    XZREN, 0 },
  2704.     { "rmdir",     XZRMD, 0 },
  2705.     { "set",       XZSET, 0 },
  2706.     { "space",       XZSPA, 0 },
  2707. #ifndef NOFRILLS
  2708.     { "type",      XZTYP, 0 },
  2709.     { "who",       XZWHO, 0 },
  2710. #endif /* NOFRILLS */
  2711.     { "", 0, 0}
  2712. };
  2713. int nrmt = (sizeof(remcmd) / sizeof(struct keytab)) - 1;
  2714. #endif /* NOXFER */
  2715.  
  2716. struct keytab logtab[] = {
  2717. #ifdef CKLOGDIAL
  2718.     { "connections",  LOGM, CM_INV },
  2719.     { "cx",           LOGM, 0 },
  2720. #endif /* CKLOGDIAL */
  2721. #ifdef DEBUG
  2722.     { "debugging",    LOGD, 0 },
  2723. #endif /* DEBUG */
  2724.     { "packets",      LOGP, 0 },
  2725. #ifndef NOLOCAL
  2726.     { "session",      LOGS, 0 },
  2727. #endif /* NOLOCAL */
  2728. #ifdef TLOG
  2729.     { "transactions", LOGT, 0 },
  2730. #endif /* TLOG */
  2731.     { "", 0, 0 }
  2732. };
  2733. int nlog = (sizeof(logtab) / sizeof(struct keytab)) - 1;
  2734.  
  2735. struct keytab writab[] = {
  2736. #ifndef NOSPL
  2737.     { "append-file",     LOGW, CM_INV },
  2738. #endif /* NOSPL */
  2739.     { "debug-log",       LOGD, 0 },
  2740.     { "error",           LOGE, 0 },
  2741. #ifndef NOSPL
  2742.     { "file",            LOGW, 0 },
  2743. #endif /* NOSPL */
  2744.     { "packet-log",      LOGP, 0 },
  2745.     { "screen",          LOGX, 0 },
  2746. #ifndef NOLOCAL
  2747.     { "session-log",     LOGS, 0 },
  2748. #endif /* NOLOCAL */
  2749.     { "sys$output",      LOGX, CM_INV },
  2750.     { "t",               LOGT, CM_ABR|CM_INV }, /* Because of a typo in */
  2751.     { "tr",              LOGT, CM_ABR|CM_INV }, /* the book... */
  2752.     { "tra",             LOGT, CM_ABR|CM_INV },
  2753.     { "tran",            LOGT, CM_ABR|CM_INV },
  2754.     { "trans",           LOGT, CM_ABR|CM_INV },
  2755.     { "transa",          LOGT, CM_ABR|CM_INV },
  2756.     { "transac",         LOGT, CM_ABR|CM_INV },
  2757.     { "transact",        LOGT, CM_ABR|CM_INV },
  2758.     { "transacti",       LOGT, CM_ABR|CM_INV },
  2759.     { "transactio",      LOGT, CM_ABR|CM_INV },
  2760.     { "transaction",     LOGT, CM_ABR|CM_INV },
  2761.     { "transaction-log", LOGT, 0 },
  2762.     { "transactions",    LOGT, CM_INV }
  2763. };
  2764. int nwri = (sizeof(writab) / sizeof(struct keytab));
  2765.  
  2766. static struct keytab clrtab[] = {    /* Keywords for CLEAR command */
  2767. #ifndef NOSPL
  2768.     { "alarm",            CLR_ALR,         0 },
  2769. #ifdef CK_APC
  2770.     { "apc",              CLR_APC,         0 },
  2771. #endif /* CK_APC */
  2772. #ifdef PATTERNS
  2773.     { "binary-patterns",  CLR_BIN,         0 },
  2774. #endif /* PATTERNS */
  2775.     { "both",             CLR_DEV|CLR_INP, CM_INV },
  2776. #endif /* NOSPL */
  2777. #ifdef OS2
  2778.     { "command-screen",   CLR_CMD,         0 },
  2779. #endif /* OS2 */
  2780. #ifndef NOSPL
  2781.     { "device",           CLR_DEV,         CM_INV|CM_ABR },
  2782.     { "device-and-input", CLR_DEV|CLR_INP, 0 },
  2783. #endif /* NOSPL */
  2784.     { "device-buffer",    CLR_DEV,         0 },
  2785. #ifndef NODIAL
  2786.     { "dial-status",      CLR_DIA,     0 },
  2787. #endif /* NODIAL */
  2788. #ifndef NOSPL
  2789.     { "input-buffer",     CLR_INP,         0 },
  2790. #endif /* NOSPL */
  2791.     { "keyboard-buffer",  CLR_KBD,         0 },
  2792.     { "send-list",        CLR_SFL,         0 },
  2793. #ifdef OS2
  2794.     { "scr",              CLR_SCL,         CM_INV|CM_ABR },
  2795. #endif /* OS2 */
  2796.     { "screen",           CLR_SCR,         0 },
  2797. #ifdef OS2
  2798.     { "scrollback",       CLR_SCL,         CM_INV },
  2799.     { "terminal-screen",  CLR_TRM,         0 },
  2800. #endif /* OS2 */
  2801. #ifdef PATTERNS
  2802.     { "text-patterns",    CLR_TXT,         0 },
  2803. #endif /* PATTERNS */
  2804.     { "", 0, 0 }
  2805. };
  2806. int nclear = (sizeof(clrtab) / sizeof(struct keytab)) - 1;
  2807.  
  2808. struct keytab clstab[] = {        /* Keywords for CLOSE command */
  2809. #ifndef NOSPL
  2810.     { "!read",           LOGR, CM_INV },
  2811.     { "!write",          LOGW, CM_INV },
  2812. #ifndef NOPUSH
  2813. #endif /* NOPUSH */
  2814. #endif /* NOSPL */
  2815. #ifndef NOSPL
  2816.     { "append-file",     LOGW, CM_INV },
  2817. #endif /* NOSPL */
  2818. #ifndef NOLOCAL
  2819.     { "connection",      9999, 0 },
  2820. #endif /* NOLOCAL */
  2821. #ifdef CKLOGDIAL
  2822.     { "cx-log",          LOGM, 0 },
  2823. #endif /* CKLOGDIAL */
  2824. #ifdef DEBUG
  2825.     { "debug-log",       LOGD, 0 },
  2826. #endif /* DEBUG */
  2827.     { "host",            9999, CM_INV }, /* Synonym for CLOSE CONNECTION */
  2828.     { "line",            9999, CM_INV }, /* Synonym for CLOSE CONNECTION */
  2829.     { "p",               LOGP, CM_INV|CM_ABR },
  2830.     { "packet-log",      LOGP, 0 },
  2831.     { "port",            9999, CM_INV }, /* Synonym for CLOSE CONNECTION */
  2832. #ifndef NOSPL
  2833.     { "read-file",       LOGR, 0 },
  2834. #endif /* NOSPL */
  2835. #ifndef NOLOCAL
  2836.     { "session-log",     LOGS, 0 },
  2837. #endif /* NOLOCAL */
  2838. #ifdef TLOG
  2839.     { "t",               LOGT, CM_ABR|CM_INV }, /* Because of a typo in */
  2840.     { "tr",              LOGT, CM_ABR|CM_INV }, /* the book... */
  2841.     { "tra",             LOGT, CM_ABR|CM_INV },
  2842.     { "tran",            LOGT, CM_ABR|CM_INV },
  2843.     { "trans",           LOGT, CM_ABR|CM_INV },
  2844.     { "transa",          LOGT, CM_ABR|CM_INV },
  2845.     { "transac",         LOGT, CM_ABR|CM_INV },
  2846.     { "transact",        LOGT, CM_ABR|CM_INV },
  2847.     { "transacti",       LOGT, CM_ABR|CM_INV },
  2848.     { "transactio",      LOGT, CM_ABR|CM_INV },
  2849.     { "transaction",     LOGT, CM_ABR|CM_INV },
  2850.     { "transaction-log", LOGT, 0 },
  2851.     { "transactions",    LOGT, CM_INV },
  2852. #endif /* TLOG */
  2853. #ifndef NOSPL
  2854.     { "write-file",      LOGW, 0 },
  2855. #endif /* NOSPL */
  2856.     { "", 0, 0 }
  2857. };
  2858. int ncls = (sizeof(clstab) / sizeof(struct keytab)) - 1;
  2859.  
  2860. /* SHOW command arguments */
  2861.  
  2862. #ifndef NOSHOW
  2863. struct keytab shotab[] = {
  2864. #ifndef NOSPL
  2865.     { "alarm",        SHALRM, 0 },
  2866.     { "arg",          SHARG, CM_INV|CM_ABR },
  2867.     { "arguments",    SHARG, 0 },
  2868.     { "args",         SHARG, CM_INV },
  2869.     { "arrays",       SHARR, 0 },
  2870. #endif /* NOSPL */
  2871.  
  2872. #ifndef NOCSETS
  2873.     { "associations", SHASSOC, 0 },
  2874. #endif /* NOCSETS */
  2875.  
  2876. #ifndef NOXFER
  2877.     { "attributes",   SHATT, 0 },
  2878. #endif /* NOXFER */
  2879.  
  2880. #ifdef CK_AUTHENTICATION
  2881.     { "authentication", SHOAUTH, CM_INV },
  2882. #endif /* CK_AUTHENTICATION */
  2883.  
  2884. #ifndef NOPUSH
  2885. #ifdef BROWSER
  2886.     { "browser",      SHBROWSE, CM_PSH|CM_LOC },
  2887. #endif /*  BROWSER */
  2888. #endif /* NOPUSH */
  2889.     { "cd",           SHCD, 0 },
  2890.     { "character-sets", SHCSE, 0 },
  2891.     { "cmd",          SHCMD, CM_INV },
  2892. #ifndef NOLOCAL
  2893.     { "com",          SHCOM, CM_INV|CM_ABR },
  2894.     { "comm",         SHCOM, CM_INV|CM_ABR },
  2895.     { "communications", SHCOM, 0 },
  2896. #endif /* NOLOCAL */
  2897.     { "command",      SHCMD, 0 },
  2898.     { "connection",   SHCONNX, 0 },
  2899. #ifdef CK_SPEED
  2900.     { "control-prefixing", SHCTL, 0 },
  2901. #endif /* CK_SPEED */
  2902. #ifdef CKLOGDIAL
  2903.     { "cx",           SHCONNX, CM_INV },
  2904. #endif /* CKLOGDIAL */
  2905. #ifndef NOSPL
  2906.     { "count",        SHCOU, 0 },
  2907. #endif /* NOSPL */
  2908.     { "d",            SHDIA, CM_INV|CM_ABR },
  2909. #ifdef VMS
  2910.     { "default",      SHDFLT, 0 },
  2911. #else
  2912.     { "default",      SHDFLT, CM_INV },
  2913. #endif /* VMS */
  2914. #ifndef NODIAL
  2915.     { "dial",         SHDIA, CM_LOC },
  2916. #endif /* NODIAL */
  2917.     { "double/ignore",SHDBL, 0 },
  2918. #ifndef NOPUSH
  2919. #ifndef NOFRILLS
  2920.     { "editor",       SHEDIT, CM_PSH },
  2921. #endif /*  NOFRILLS */
  2922. #endif /* NOPUSH */
  2923. #ifndef NOLOCAL
  2924.     { "escape",       SHESC, CM_LOC },
  2925. #endif /* NOLOCAL */
  2926.     { "exit",         SHEXI, 0 },
  2927.     { "extended-options", SHXOPT, CM_INV },
  2928.     { "features",     SHFEA, 0 },
  2929.     { "file",         SHFIL, 0 },
  2930. #ifndef NOLOCAL
  2931.     { "flow-control", SHOFLO, 0 },
  2932. #endif /* NOLOCAL */
  2933. #ifdef BROWSER
  2934.     { "ftp",          SHOFTP, CM_PSH|CM_LOC },
  2935. #else
  2936. #ifndef NOFTP
  2937. #ifndef SYSFTP
  2938. #ifdef TCPSOCKET
  2939.     { "ftp",          SHOFTP, 0 },    /* (built-in ftp) */
  2940. #endif /* TCPSOCKET */
  2941. #endif /* SYSFTP */
  2942. #endif /* NOFTP */
  2943. #endif /* BROWSER */
  2944. #ifndef NOSPL
  2945.     { "functions",    SHFUN, 0 },
  2946.     { "globals",      SHVAR, 0 },
  2947. #endif /* NOSPL */
  2948. #ifdef KUI
  2949.     { "gui",          SHOGUI, 0 },
  2950. #endif /* KUI */
  2951. #ifdef CK_RECALL
  2952.     { "history",      SHHISTORY, 0 },
  2953. #endif /* CK_RECALL */
  2954.     { "ignore/double",SHDBL, CM_INV },
  2955.     { "iksd",         SHOIKS, CM_INV },
  2956. #ifndef NOSPL
  2957.     { "input",        SHINP, 0 },
  2958. #endif /* NOSPL */
  2959. #ifndef NOSETKEY
  2960.     { "k",            SHKEY, CM_INV|CM_ABR },
  2961.     { "key",          SHKEY, 0 },
  2962. #ifndef NOKVERBS
  2963.     { "kverbs",       SHKVB, 0 },
  2964. #endif /* NOKVERBS */
  2965. #endif /* NOSETKEY */
  2966. #ifdef CK_LABELED
  2967.     { "labeled-file-info", SHLBL, 0 },
  2968. #endif /* CK_LABELED */
  2969. #ifndef NOCSETS
  2970.     { "languages",    SHLNG, 0 },
  2971. #endif /* NOCSETS */
  2972.     { "logs",         SHLOG, 0 },
  2973. #ifndef NOSPL
  2974.     { "macros",       SHMAC, 0 },
  2975. #endif /* NOSPL */
  2976. #ifndef NODIAL
  2977.     { "modem",        SHMOD, CM_LOC },
  2978. #else
  2979.     { "modem-signals",SHCOM, CM_INV|CM_LOC },
  2980. #endif /* NODIAL */
  2981. #ifndef NOLOCAL
  2982. #ifdef OS2MOUSE
  2983.     { "mouse",        SHMOU, CM_LOC },
  2984. #endif /* OS2MOUSE */
  2985. #endif /* NOLOCAL */
  2986. #ifdef NETCONN
  2987.     { "network",      SHNET, CM_LOC },
  2988. #else
  2989.     { "network",      SHNET, CM_INV|CM_LOC },
  2990. #endif /* NETCONN */
  2991.     { "options",      SHOPTS, 0 },
  2992. #ifndef NOSPL
  2993.     { "output",       SHOUTP, CM_INV },
  2994. #endif /* NOSPL */
  2995. #ifdef ANYX25
  2996. #ifndef IBMX25
  2997.     { "pad",          SHPAD,  CM_LOC },
  2998. #endif /* IBMX25 */
  2999. #endif /* ANYX25 */
  3000.     { "parameters",   SHPAR,  CM_INV },
  3001. #ifdef PATTERNS
  3002.     { "patterns",     SHOPAT, 0 },
  3003. #endif /* PATTERNS */
  3004.     { "printer",      SHPRT,  0 },
  3005. #ifdef CK_SPEED
  3006.     { "prefixing",    SHCTL,  CM_INV },
  3007. #endif /* CK_SPEED */
  3008. #ifndef NOXFER
  3009.     { "protocol",     SHPRO,  0 },
  3010. #endif /* NOXFER */
  3011.     { "rename",       SHOREN, 0 },
  3012. #ifndef NOSPL
  3013.     { "scripts",      SHSCR,  CM_LOC },
  3014. #endif /* NOSPL */
  3015.     { "send-list",    SHSFL,  0 },
  3016. #ifndef NOSERVER
  3017.     { "server",       SHSER,  0 },
  3018. #endif /* NOSERVER */
  3019. #ifndef NOSEXP
  3020.     { "sexpression",  SHSEXP, 0 },
  3021. #endif /* NOSEXP */
  3022. #ifdef ANYSSH
  3023.     { "ssh",          SHOSSH, 0 },
  3024. #endif /* ANYSSH */
  3025.     { "stack",        SHSTK,  0 },
  3026.     { "status",       SHSTA,  0 },
  3027. #ifdef STREAMING
  3028.     { "streaming",    SHOSTR, 0 },
  3029. #endif /* STREAMING */
  3030. #ifndef NOLOCAL
  3031. #ifdef OS2
  3032.     { "tabs",          SHTAB, CM_INV|CM_LOC },
  3033. #endif /* OS2 */
  3034. #ifdef CK_TAPI
  3035.     { "tapi",          SHTAPI, CM_LOC },
  3036.     { "tapi-comm",     SHTAPI_C, CM_INV|CM_LOC },
  3037.     { "tapi-location", SHTAPI_L, CM_INV|CM_LOC },
  3038.     { "tapi-modem",    SHTAPI_M, CM_INV|CM_LOC },
  3039. #endif /* CK_TAPI */
  3040.     { "tcp",           SHTCP,  CM_LOC },
  3041. #ifdef TNCODE
  3042.     { "tel",           SHTEL,  CM_INV|CM_ABR },
  3043.     { "telnet",        SHTEL,  0 },
  3044.     { "telopt",        SHTOPT, 0 },
  3045. #endif /* TNCODE */
  3046.     { "terminal",      SHTER,  CM_LOC },
  3047. #endif /* NOLOCAL */
  3048. #ifndef NOXMIT
  3049.     { "tr",            SHXMI, CM_INV|CM_ABR },
  3050.     { "tra",           SHXMI, CM_INV|CM_ABR },
  3051.     { "tran",          SHXMI, CM_INV|CM_ABR },
  3052.     { "trans",         SHXMI, CM_INV|CM_ABR },
  3053. #endif /* NOXMIT */
  3054. #ifndef NOXFER
  3055.     { "transfer",      SHOXFER, 0 },
  3056. #endif /* NOXFER */
  3057. #ifndef NOXMIT
  3058.     { "transmit",      SHXMI, 0 },
  3059. #endif /* NOXMIT */
  3060. #ifdef CK_TRIGGER
  3061.     { "trigger",       SHTRIG, CM_LOC },
  3062. #endif /* CK_TRIGGER */
  3063. #ifndef NOSETKEY
  3064. #ifndef NOKVERBS
  3065. #ifdef OS2
  3066.     { "udk",           SHUDK, CM_LOC },
  3067. #endif /* OS2 */
  3068. #endif /* NOKVERBS */
  3069. #endif /* NOSETKEY */
  3070. #ifndef NOSPL
  3071.     { "variables",     SHBUI, 0 },
  3072. #endif /* NOSPL */
  3073. #ifndef NOFRILLS
  3074.     { "versions",      SHVER, 0 },
  3075. #endif /* NOFRILLS */
  3076. #ifdef OS2
  3077.     { "vscrn",         SHVSCRN, CM_INV|CM_LOC },
  3078. #endif /* OS2 */
  3079.     { "xfer",          SHOXFER,  CM_INV },
  3080. #ifndef NOXMIT
  3081.     { "xmit",          SHXMI,    CM_INV },
  3082. #endif /* NOXMIT */
  3083.     { "", 0, 0 }
  3084. };
  3085. int nsho = (sizeof(shotab) / sizeof(struct keytab)) - 1;
  3086. #endif /* NOSHOW */
  3087.  
  3088. #ifdef ANYX25
  3089. #ifndef IBMX25
  3090. struct keytab padtab[] = {              /* PAD commands */
  3091.     { "clear",      XYPADL, 0 },
  3092.     { "interrupt",  XYPADI, 0 },
  3093.     { "reset",      XYPADR, 0 },
  3094.     { "status",     XYPADS, 0 }
  3095. };
  3096. int npadc = (sizeof(padtab) / sizeof(struct keytab));
  3097. #endif /* IBMX25 */
  3098. #endif /* ANYX25 */
  3099.  
  3100. #ifndef NOSERVER
  3101. static struct keytab kmstab[] = {
  3102.     { "both",    3, 0 },
  3103.     { "local",   1, 0 },
  3104.     { "remote",  2, 0 }
  3105. };
  3106.  
  3107. static struct keytab enatab[] = {    /* ENABLE commands */
  3108.     { "all",        EN_ALL,  0 },
  3109. #ifndef NOSPL
  3110.     { "as",         EN_ASG,  CM_INV|CM_ABR },
  3111.     { "asg",        EN_ASG,  CM_INV },
  3112.     { "assign",     EN_ASG,  0 },
  3113. #endif /* NOSPL */
  3114. #ifndef datageneral
  3115.     { "bye",        EN_BYE,  0 },
  3116. #endif /* datageneral */
  3117.     { "cd",         EN_CWD,  0 },
  3118. #ifdef ZCOPY
  3119.     { "copy",       EN_CPY,  0 },
  3120. #endif /* ZCOPY */
  3121.     { "cwd",        EN_CWD,  CM_INV },
  3122.     { "delete",     EN_DEL,  0 },
  3123.     { "directory",  EN_DIR,  0 },
  3124.     { "enable",     EN_ENA,  CM_INV },
  3125.     { "exit",       EN_XIT,  0 },
  3126.     { "finish",     EN_FIN,  0 },
  3127.     { "get",        EN_GET,  0 },
  3128.     { "host",       EN_HOS,  0 },
  3129.     { "mail",       EN_MAI,  0 },
  3130.     { "mkdir",      EN_MKD,  0 },
  3131.     { "print",      EN_PRI,  0 },
  3132. #ifndef NOSPL
  3133.     { "query",      EN_QUE,  0 },
  3134. #endif /* NOSPL */
  3135.     { "rename",     EN_REN,  0 },
  3136.     { "retrieve",   EN_RET,  CM_INV },
  3137.     { "rmdir",      EN_RMD,  0 },
  3138.     { "send",       EN_SEN,  0 },
  3139.     { "set",        EN_SET,  0 },
  3140.     { "space",      EN_SPA,  0 },
  3141.     { "type",       EN_TYP,  0 },
  3142.     { "who",        EN_WHO,  0 }
  3143. };
  3144. static int nena = (sizeof(enatab) / sizeof(struct keytab));
  3145. #endif /* NOSERVER */
  3146.  
  3147. struct keytab txtbin[] = {
  3148.     { "all",        2, 0 },
  3149.     { "binary",     1, 0 },
  3150.     { "text",       0, 0 }
  3151. };
  3152.  
  3153. #ifndef NOXFER
  3154. static struct keytab sndtab[] = {    /* SEND command options */
  3155.     { "/after",           SND_AFT, CM_ARG },
  3156. #ifndef NOSPL
  3157.     { "/array",           SND_ARR, CM_ARG },
  3158. #endif /* NOSPL */
  3159.     { "/as-name",         SND_ASN, CM_ARG },
  3160.     { "/b",               SND_BIN, CM_INV|CM_ABR },
  3161.     { "/before",          SND_BEF, CM_ARG },
  3162.     { "/binary",          SND_BIN, 0 },
  3163. #ifdef CALIBRATE
  3164.     { "/c",               SND_CMD, CM_INV|CM_ABR },
  3165.     { "/calibrate",       SND_CAL, CM_INV|CM_ARG },
  3166. #endif /* CALIBRATE */
  3167.     { "/command",         SND_CMD, CM_PSH },
  3168.     { "/delete",          SND_DEL, 0 },
  3169. #ifdef UNIXOROSK
  3170.     { "/dotfiles",        SND_DOT, 0 },
  3171. #endif /* UNIXOROSK */
  3172.     { "/except",          SND_EXC, CM_ARG },
  3173. #ifdef PIPESEND
  3174.     { "/filter",          SND_FLT, CM_ARG|CM_PSH },
  3175. #endif /* PIPESEND */
  3176.     { "/filenames",       SND_NAM, CM_ARG },
  3177. #ifdef CKSYMLINK
  3178.     { "/followlinks",      SND_LNK, 0 },
  3179. #endif /* CKSYMLINK */
  3180. #ifdef VMS
  3181.     { "/image",           SND_IMG, 0 },
  3182. #else
  3183.     { "/image",           SND_BIN, CM_INV },
  3184. #endif /* VMS */
  3185. #ifdef CK_LABELED
  3186.     { "/labeled",         SND_LBL, 0 },
  3187. #endif /* CK_LABELED */
  3188.     { "/larger-than",     SND_LAR, CM_ARG },
  3189.     { "/listfile",        SND_FIL, CM_ARG },
  3190. #ifndef NOFRILLS
  3191.     { "/mail",            SND_MAI, CM_ARG },
  3192. #endif /* NOFRILLS */
  3193. #ifdef CK_TMPDIR
  3194.     { "/move-to",         SND_MOV, CM_ARG },
  3195. #endif /* CK_TMPDIR */
  3196.     { "/nobackupfiles",   SND_NOB, 0 },
  3197. #ifdef UNIXOROSK
  3198.     { "/nodotfiles",      SND_NOD, 0 },
  3199. #endif /* UNIXOROSK */
  3200. #ifdef CKSYMLINK
  3201.     { "/nofollowlinks",      SND_NLK, 0 },
  3202. #endif /* CKSYMLINK */
  3203.     { "/not-after",       SND_NAF, CM_ARG },
  3204.     { "/not-before",      SND_NBE, CM_ARG },
  3205.     { "/pathnames",       SND_PTH, CM_ARG },
  3206.     { "/print",           SND_PRI, CM_ARG },
  3207. #ifdef CK_XYZ
  3208.     { "/protocol",        SND_PRO, CM_ARG },
  3209. #else
  3210.     { "/protocol",        SND_PRO, CM_ARG|CM_INV },
  3211. #endif /* CK_XYZ */
  3212.     { "/quiet",           SND_SHH, 0 },
  3213.     { "/recover",         SND_RES, 0 },
  3214. #ifdef RECURSIVE
  3215. /* Systems where we do recursion */
  3216.     { "/recursive",       SND_REC, 0 },
  3217. #else
  3218. #ifdef VMS
  3219. /* Systems that do recursion themselves without our assistance */
  3220. /* if we give them the right kind of wildcard */
  3221.     { "/recursive",       SND_REC, 0 },
  3222. #else
  3223. #ifdef datageneral
  3224.     { "/recursive",       SND_REC, 0 },
  3225. #else
  3226.     { "/recursive",       SND_REC, CM_INV },
  3227. #endif /* datageneral */
  3228. #endif /* VMS */
  3229. #endif /* RECURSIVE */
  3230.     { "/rename-to",       SND_REN, CM_ARG },
  3231.     { "/since",           SND_AFT, CM_INV|CM_ARG },
  3232.     { "/smaller-than",    SND_SMA, CM_ARG },
  3233.     { "/starting-at",     SND_STA, CM_ARG },
  3234. #ifndef NOFRILLS
  3235.     { "/su",              SND_ASN, CM_ARG|CM_INV|CM_ABR },
  3236.     { "/sub",             SND_ASN, CM_ARG|CM_INV|CM_ABR },
  3237.     { "/subject",         SND_ASN, CM_ARG },
  3238. #endif /* NOFRILLS */
  3239. #ifdef RECURSIVE
  3240.     { "/subdirectories",  SND_REC, CM_INV },
  3241. #endif /* RECURSIVE */
  3242.     { "/text",            SND_TXT, 0 },
  3243.     { "/transparent",     SND_XPA, 0 },
  3244.     { "/type",            SND_TYP, CM_ARG }
  3245. };
  3246. #define NSNDTAB sizeof(sndtab)/sizeof(struct keytab)
  3247. static int nsndtab = NSNDTAB;
  3248.  
  3249. #ifndef NOMSEND
  3250. static struct keytab msndtab[] = {    /* MSEND options */
  3251.     { "/after",           SND_AFT, CM_ARG },
  3252.     { "/before",          SND_BEF, CM_ARG },
  3253.     { "/binary",          SND_BIN, 0 },
  3254.     { "/delete",          SND_DEL, 0 },
  3255.     { "/except",          SND_EXC, CM_ARG },
  3256.     { "/filenames",       SND_NAM, CM_ARG },
  3257. #ifdef CKSYMLINK
  3258.     { "/followlinks",      SND_LNK, 0 },
  3259. #endif /* CKSYMLINK */
  3260. #ifdef VMS
  3261.     { "/image",           SND_IMG, 0 },
  3262. #else
  3263.     { "/image",           SND_BIN, CM_INV },
  3264. #endif /* VMS */
  3265. #ifdef CK_LABELED
  3266.     { "/labeled",         SND_LBL, 0 },
  3267. #endif /* CK_LABELED */
  3268.     { "/larger-than",     SND_LAR, CM_ARG },
  3269.     { "/list",            SND_FIL, CM_ARG },
  3270. #ifndef NOFRILLS
  3271.     { "/mail",            SND_MAI, CM_ARG },
  3272. #endif /* NOFRILLS */
  3273. #ifdef CK_TMPDIR
  3274.     { "/move-to",         SND_MOV, CM_ARG },
  3275. #endif /* CK_TMPDIR */
  3276. #ifdef CKSYMLINK
  3277.     { "/nofollowlinks",    SND_NLK, 0 },
  3278. #endif /* CKSYMLINK */
  3279.     { "/not-after",       SND_NAF, CM_ARG },
  3280.     { "/not-before",      SND_NBE, CM_ARG },
  3281.     { "/pathnames",       SND_PTH, CM_ARG },
  3282.     { "/print",           SND_PRI, CM_ARG },
  3283. #ifdef CK_XYZ
  3284.     { "/protocol",        SND_PRO, CM_ARG },
  3285. #endif /* CK_XYZ */
  3286.     { "/quiet",           SND_SHH, 0 },
  3287.     { "/recover",         SND_RES, 0 },
  3288.     { "/rename-to",       SND_REN, CM_ARG },
  3289.     { "/since",           SND_AFT, CM_INV|CM_ARG },
  3290.     { "/smaller-than",    SND_SMA, CM_ARG },
  3291.     { "/starting-at",     SND_STA, CM_ARG },
  3292. #ifndef NOFRILLS
  3293.     { "/subject",         SND_ASN, CM_ARG },
  3294. #endif /* NOFRILLS */
  3295.     { "/text",            SND_TXT, 0 },
  3296.     { "/transparent",     SND_XPA, 0 },
  3297.     { "/type",            SND_TYP, CM_ARG }
  3298. };
  3299. #define NMSNDTAB sizeof(msndtab)/sizeof(struct keytab)
  3300. static int nmsndtab = NMSNDTAB;
  3301. #endif /* NOMSEND */
  3302. #endif /* NOXFER */
  3303.  
  3304. /* CONNECT command switches */
  3305.  
  3306. #define CONN_II  0    /* Idle interval */
  3307. #define CONN_IS  1    /* Idle string */
  3308. #define CONN_IL  2    /* Idle limit */
  3309. #define CONN_NV  3    /* Non-Verbose */
  3310. #define CONN_TL  4    /* Time limit */
  3311. #define CONN_TS  5    /* Trigger string */
  3312. #define CONN_AS  6    /* Asynchronous */
  3313. #define CONN_SY  7    /* Synchronous */
  3314. #define CONN_MAX 7    /* Number of CONNECT switches */
  3315.  
  3316. #ifndef NOLOCAL
  3317. static struct keytab conntab[] = {
  3318. #ifdef OS2
  3319.     { "/asynchronous",    CONN_AS, CM_INV },
  3320. #endif /* OS2 */
  3321. #ifdef XLIMITS
  3322.     { "/idle-interval",   CONN_II, CM_ARG },
  3323.     { "/idle-limit",      CONN_IL, CM_ARG },
  3324.     { "/idle-string",     CONN_IS, CM_ARG },
  3325.     { "/quietly",         CONN_NV, CM_INV },
  3326. #else
  3327.     { "/quietly",         CONN_NV, 0 },
  3328. #endif /* XLIMITS */
  3329. #ifdef OS2
  3330.     { "/synchronous",     CONN_SY, CM_INV },
  3331. #endif /* OS2 */
  3332. #ifdef XLIMITS
  3333.     { "/time-limit",      CONN_TL, CM_ARG },
  3334. #endif /* XLIMITS */
  3335. #ifdef CK_TRIGGER
  3336.     { "/trigger",         CONN_TS, CM_ARG },
  3337. #endif /* CK_TRIGGER */
  3338.     { "",0,0 }
  3339. };
  3340. #define NCONNTAB sizeof(conntab)/sizeof(struct keytab)
  3341. static int nconntab = NCONNTAB;
  3342. #endif /* NOLOCAL */
  3343.  
  3344. #ifndef NOXFER
  3345. static struct keytab stattab[] = {    /* STATISTICS command switches */
  3346.     { "/brief",   1, 0 },
  3347.     { "/verbose", 0, 0 }
  3348. };
  3349. #endif /* NOXFER */
  3350.  
  3351. #ifndef NOSPL
  3352. #ifdef COMMENT
  3353. struct mtab mactab[MAC_MAX] = {        /* Preinitialized macro table */
  3354.     { NULL, NULL, 0 }
  3355. };
  3356. #else
  3357. struct mtab *mactab;            /* Dynamically allocated macro table */
  3358. #endif /* COMMENT */
  3359. int nmac = 0;
  3360.  
  3361. struct keytab mackey[MAC_MAX];        /* Macro names as command keywords */
  3362. #endif /* NOSPL */
  3363.  
  3364. #ifndef NOSPL
  3365. #ifdef  OS2
  3366. struct keytab beeptab[] = {        /* Beep options */
  3367.     { "error", BP_FAIL, 0 },
  3368.     { "information", BP_NOTE, 0 },
  3369.     { "warning", BP_WARN, 0 }
  3370. };
  3371. int nbeeptab = sizeof(beeptab)/sizeof(struct keytab);
  3372.  
  3373. /* CLEAR COMMMAND-SCREEN options */
  3374.  
  3375. #define CLR_C_ALL 0
  3376. #define CLR_C_BOL 1
  3377. #define CLR_C_BOS 2
  3378. #define CLR_C_EOL 3
  3379. #define CLR_C_EOS 4
  3380. #define CLR_C_LIN 5
  3381. #define CLR_C_SCR 6
  3382.  
  3383. struct keytab clrcmdtab[] = {
  3384.     { "all",        CLR_C_ALL, 0 },
  3385.     { "bol",        CLR_C_BOL, 0 },
  3386.     { "bos",        CLR_C_BOS, 0 },
  3387.     { "eol",        CLR_C_EOL, 0 },
  3388.     { "eos",        CLR_C_EOS, 0 },
  3389.     { "line",       CLR_C_LIN, 0 },
  3390.     { "scrollback", CLR_C_SCR, 0 }
  3391. };
  3392. int nclrcmd = sizeof(clrcmdtab)/sizeof(struct keytab);
  3393. #endif /* OS2 */
  3394. #endif /* NOSPL */
  3395.  
  3396. #ifdef COMMENT
  3397. /* Not used at present */
  3398. static struct keytab pagetab[] = {
  3399.     { "/more",   1, CM_INV },
  3400.     { "/nopage", 0, 0 },
  3401.     { "/page",   1, 0 }
  3402. };
  3403. int npagetab = sizeof(pagetab)/sizeof(struct keytab);
  3404. #endif /* COMMENT */
  3405.  
  3406. #define TYP_NOP  0            /* /NOPAGE */
  3407. #define TYP_PAG  1            /* /PAGE */
  3408. #define TYP_HEA  2            /* /HEAD:n */
  3409. #define TYP_TAI  3            /* /TAIL:n */
  3410. #define TYP_PAT  4            /* /MATCH:pattern */
  3411. #define TYP_WID  5            /* /WIDTH:cols */
  3412. #define TYP_COU  6            /* /COUNT */
  3413. #define TYP_OUT  7            /* /OUTPUT:file */
  3414. #define TYP_PFX  8            /* /PREFIX:string */
  3415. #ifdef UNICODE
  3416. #define TYP_XIN  9            /* /TRANSLATE-FROM:charset */
  3417. #define TYP_XUT 10            /* /TRANSLATE-TO:charset */
  3418. #define TYP_XPA 11            /* /TRANSPARENT */
  3419. #endif /* UNICODE */
  3420. #ifdef KUI
  3421. #define TYP_GUI 12            /* /GUI:title */
  3422. #define TYP_HIG 13            /* /HEIGHT:rows */
  3423. #endif /* KUI */
  3424. #define TYP_NUM 14            /* /NUMBER */
  3425.  
  3426. static struct keytab typetab[] = {    /* TYPE command switches */
  3427.     { "/count",          TYP_COU, 0 },
  3428. #ifdef UNICODE
  3429.     { "/character-set",  TYP_XIN, CM_ARG },
  3430. #endif /* UNICODE */
  3431. #ifdef KUI
  3432.     { "/gui",            TYP_GUI, CM_ARG },
  3433. #endif /* KUI */
  3434.     { "/head",           TYP_HEA, CM_ARG },
  3435. #ifdef KUI
  3436.     { "/height",         TYP_HIG, CM_ARG },
  3437. #endif /* KUI */
  3438.     { "/match",          TYP_PAT, CM_ARG },
  3439. #ifdef CK_TTGWSIZ
  3440.     { "/more",           TYP_PAG, CM_INV },
  3441.     { "/nopage",         TYP_NOP, 0 },
  3442.     { "/number",         TYP_NUM, 0 },
  3443.     { "/output",         TYP_OUT, CM_ARG },
  3444.     { "/page",           TYP_PAG, 0 },
  3445. #endif /* CK_TTGWSIZ */
  3446.     { "/prefix",         TYP_PFX, CM_ARG },
  3447.     { "/tail",           TYP_TAI, CM_ARG },
  3448. #ifdef UNICODE
  3449.     { "/translate-to",   TYP_XUT, CM_ARG },
  3450.     { "/transparent",    TYP_XPA, 0 },
  3451. #endif /* UNICODE */
  3452.     { "/width",          TYP_WID, CM_ARG },
  3453. #ifdef UNICODE
  3454.     { "/xlate-to",       TYP_XUT, CM_INV|CM_ARG },
  3455. #endif /* UNICODE */
  3456.     { "", 0, 0 }
  3457. };
  3458. int ntypetab = sizeof(typetab)/sizeof(struct keytab) - 1;
  3459.  
  3460. int typ_page = -1;            /* TYPE /[NO]PAGE default */
  3461. int typ_wid  = -1;
  3462.  
  3463. #ifndef NOSPL
  3464. #define TRA_ALL 999            /* TRACE command */
  3465. #define TRA_ASG 0
  3466. #define TRA_CMD 1
  3467.  
  3468. int tra_asg = 0;
  3469. int tra_cmd = 0;
  3470.  
  3471. static struct keytab tracetab[] = {    /* TRACE options */
  3472.     { "all",            TRA_ALL, 0 },
  3473.     { "assignments",    TRA_ASG, 0 },
  3474.     { "command-level",  TRA_CMD, 0 }
  3475. };
  3476. static int ntracetab = sizeof(tracetab)/sizeof(struct keytab);
  3477. #endif /* NOSPL */
  3478.  
  3479. #ifndef NOSHOW
  3480. VOID
  3481. showtypopts() {
  3482.     printf(" TYPE ");
  3483.     if (typ_page > -1) {
  3484.     prtopt(&optlines,typ_page ? "/PAGE" : "/NOPAGE");
  3485.     } else
  3486.       prtopt(&optlines,"(no options set)");
  3487.     if (typ_wid > -1) {
  3488.     ckmakmsg(tmpbuf,TMPBUFSIZ,"/WIDTH:",ckitoa(typ_wid),NULL,NULL);
  3489.     prtopt(&optlines,tmpbuf);
  3490.     }
  3491.     prtopt(&optlines,"");
  3492. }
  3493. #endif /* NOSHOW */
  3494.  
  3495. #ifdef LOCUS
  3496. /* isauto == 1 if locus is being switched automatically */
  3497.  
  3498. VOID
  3499. setlocus(x, isauto) int x, isauto; {
  3500.     extern int quitting;
  3501.     if (x) x = 1;
  3502.     if (x && locus) return;
  3503.     if (!x && !locus) return;
  3504.     /* Get here if it actually needs to be changed */
  3505. #ifdef OS2
  3506.     if (isauto &&            /* Automatically switching */
  3507.     !quitting &&            /* not exiting */
  3508.     autolocus == 2) {        /* and AUTOLOCUS is set to ASK */
  3509.     char locmsg[300];
  3510.     ckmakmsg(locmsg,300,
  3511.          "Switching Locus to ",
  3512.          x ? "LOCAL" : "REMOTE",
  3513.          " for file management commands\n"
  3514.                  "such as CD, DIRECTORY, DELETE, RENAME.  Type HELP SET\n"
  3515.                  "LOCUS at the K-95> prompt for further info.  Use the\n"
  3516. #ifdef KUI
  3517.                   "Actions menu or SET LOCUS command to disable automatic\n"
  3518.                   "Locus switching or to disable these queries.",
  3519. #else /* KUI */
  3520.                   "SET LOCUS command to disable automatic locus switching\n"
  3521.                   "or to disable these queries.",
  3522. #endif /* KUI */
  3523.                   NULL);
  3524.     if (uq_ok(locmsg,"OK to switch Locus?",3,NULL,1)) {
  3525.         locus = x;
  3526. #ifdef KUI
  3527.         KuiSetProperty(KUI_LOCUS,x,0);
  3528. #endif /* KUI */
  3529.         return;
  3530.     }
  3531.     } else {
  3532. #endif /* OS2 */
  3533.         if (isauto && msgflg && !quitting)
  3534.           printf("Switching LOCUS for file-management commands to %s %s.\n",
  3535.          x ? "LOCAL" : "REMOTE",
  3536.          "(HELP LOCUS for info)"
  3537.          );
  3538.     locus = x;
  3539. #ifdef OS2
  3540. #ifdef KUI
  3541.     KuiSetProperty(KUI_LOCUS,x,0);
  3542. #endif /* KUI */
  3543.     }
  3544. #endif /* OS2 */
  3545. }
  3546.  
  3547. VOID
  3548. setautolocus(x) int x; {
  3549.     autolocus = x;
  3550. #ifdef KUI
  3551.     KuiSetProperty(KUI_AUTO_LOCUS,x,0);
  3552. #endif /* KUI */
  3553. }
  3554. #endif /* LOCUS */
  3555.  
  3556. int
  3557. settypopts() {                /* Set TYPE option defaults */
  3558.     int xp = -1;
  3559.     int c, getval;
  3560.     while (1) {
  3561.     if ((y = cmswi(typetab,ntypetab,"Switch","",xxstring)) < 0) {
  3562.         if (y == -3)
  3563.           break;
  3564.         else
  3565.           return(y);
  3566.     }
  3567.     c = cmgbrk();
  3568.     if ((getval = (c == ':' || c == '=')) && !(cmgkwflgs() & CM_ARG)) {
  3569.         printf("?This switch does not take an argument\n");
  3570.         return(-9);
  3571.     }
  3572.     switch (y) {
  3573.       case TYP_NOP: xp = 0; break;
  3574.       case TYP_PAG: xp = 1; break;
  3575.       case TYP_WID:
  3576.         if (getval)
  3577.           if ((x = cmnum("Column at which to truncate",
  3578.                  ckitoa(cmd_cols),10,&y,xxstring)) < 0)
  3579.         return(x);
  3580.         typ_wid = y;
  3581.         break;
  3582.  
  3583.           default:
  3584.         printf("?Sorry, this option can not be set\n");
  3585.         return(-9);
  3586.     }
  3587.     }
  3588.     if ((x = cmcfm()) < 0)        /* Get confirmation */
  3589.       return(x);
  3590.     if (xp > -1) typ_page = xp;        /* Confirmed, save defaults */
  3591.     return(success = 1);
  3592. }
  3593.  
  3594. /* Forward declarations of functions local to this module */
  3595.  
  3596. #ifdef UNIX
  3597. _PROTOTYP (int douchmod, ( void ) );
  3598. #endif /* UNIX */
  3599. #ifdef CKPURGE
  3600. _PROTOTYP (int dopurge,  ( void ) );
  3601. #endif /* CKPURGE */
  3602. #ifndef NOSPL
  3603. _PROTOTYP (int doundef,  ( int  ) );
  3604. _PROTOTYP (int doask,    ( int  ) );
  3605. _PROTOTYP (int dodef,    ( int  ) );
  3606. _PROTOTYP (int doelse,   ( void ) );
  3607. _PROTOTYP (int dofor,    ( void ) );
  3608. #endif /* NOSPL  */
  3609. #ifndef NODIAL
  3610. _PROTOTYP (int dodial,   ( int  ) );
  3611. #endif /* NODIAL */
  3612. _PROTOTYP (int dodel,    ( void ) );
  3613. _PROTOTYP (int dopaus,   ( int  ) );
  3614. #ifndef NOPUSH
  3615. #ifdef TCPSOCKET
  3616. _PROTOTYP (int doping,   ( void ) );
  3617. _PROTOTYP (int doftp,    ( void ) );
  3618. #endif /* TCPSOCKET */
  3619. #endif /* NOPUSH */
  3620. #ifndef NORENAME
  3621. #ifndef NOFRILLS
  3622. _PROTOTYP (int dorenam,  ( void ) );
  3623. #endif /* NOFRILLS */
  3624. #endif /* NORENAME */
  3625. #ifdef ZCOPY
  3626. _PROTOTYP (int docopy,   ( void ) );
  3627. #endif /* ZCOPY */
  3628. #ifdef NT
  3629. _PROTOTYP (int dolink,   ( void ));
  3630. #endif /* NT */
  3631. #ifdef CK_REXX
  3632. _PROTOTYP (int dorexx,   ( void ) );
  3633. #endif /* CK_REXX */
  3634.  
  3635. #ifdef TNCODE
  3636. static struct keytab telcmd[] = {
  3637.     { "abort", TN_ABORT, CM_INV },    /* Emotionally toned - don't show */
  3638.     { "ao",    TN_AO,    0 },
  3639.     { "ayt",   TN_AYT,   0 },
  3640.     { "break", BREAK,    0 },
  3641.     { "cancel",TN_ABORT, 0 },
  3642.     { "dmark", TN_DM,    0 },
  3643.     { "do",    DO,       0 },
  3644.     { "dont",  DONT,     0 },
  3645.     { "ec",    TN_EC,    0 },
  3646.     { "el",    TN_EL,    0 },
  3647.     { "eof",   TN_EOF,   0 },
  3648.     { "eor",   TN_EOR,   0 },
  3649. #ifdef CK_KERBEROS
  3650. #ifdef KRB5
  3651. #define TN_FWD 1
  3652.     { "forward", TN_FWD, CM_INV },
  3653. #endif /* KRB5 */
  3654. #endif /* CK_KERBEROS */
  3655.     { "ga",    TN_GA,    0 },
  3656.     { "ip",    TN_IP,    0 },
  3657.     { "nop",   TN_NOP,   0 },
  3658.     { "sak",   TN_SAK,   CM_INV },
  3659.     { "sb",    SB,       0 },
  3660.     { "se",    SE,       0 },
  3661.     { "susp",  TN_SUSP,  0 },
  3662.     { "will",  WILL,     0 },
  3663.     { "wont",  WONT,     0 }
  3664. };
  3665. static int ntelcmd = (sizeof(telcmd) / sizeof(struct keytab));
  3666.  
  3667. static struct keytab tnopts[] = {
  3668. #ifdef CK_AUTHENTICATION
  3669.     { "auth",   TELOPT_AUTHENTICATION,   0 },
  3670. #else
  3671.     { "auth",   TELOPT_AUTHENTICATION,   CM_INV },
  3672. #endif /* CK_AUTHENTICATION */
  3673.     { "binary", TELOPT_BINARY, 0 },
  3674. #ifdef TN_COMPORT
  3675.     { "c",      TELOPT_COMPORT, CM_INV|CM_ABR},
  3676.     { "co",     TELOPT_COMPORT, CM_INV|CM_ABR},
  3677.     { "com",    TELOPT_COMPORT, CM_INV|CM_ABR},
  3678.     { "com-port-control", TELOPT_COMPORT, 0 },
  3679.     { "comport-control", TELOPT_COMPORT, CM_INV},
  3680. #else  /* TN_COMPORT */
  3681.     { "com-port-control", TELOPT_COMPORT, CM_INV },
  3682.     { "comport-control", TELOPT_COMPORT, CM_INV},
  3683. #endif /* TN_COMPORT */
  3684.     { "echo", TELOPT_ECHO, 0 },
  3685. #ifdef CK_ENCRYPTION
  3686.     { "encrypt", TELOPT_ENCRYPTION, 0 },
  3687. #else
  3688.     { "encrypt", TELOPT_ENCRYPTION, CM_INV },
  3689. #endif /* CK_ENCRYPTION */
  3690. #ifdef CK_FORWARD_X
  3691.     { "forward-x", TELOPT_FORWARD_X, 0 },
  3692. #else
  3693.     { "forward-x", TELOPT_FORWARD_X, CM_INV },
  3694. #endif /* CK_FORWARD_X */
  3695. #ifdef IKS_OPTION
  3696.     { "kermit", TELOPT_KERMIT, 0 },
  3697. #else
  3698.     { "kermit", TELOPT_KERMIT, CM_INV },
  3699. #endif /* IKS_OPTION */
  3700.     { "lflow",  TELOPT_LFLOW, CM_INV },
  3701.     { "logout", TELOPT_LOGOUT, CM_INV },
  3702. #ifdef CK_NAWS
  3703.     { "naws", TELOPT_NAWS, 0 },
  3704. #else
  3705.     { "naws", TELOPT_NAWS, CM_INV },
  3706. #endif /* CK_NAWS */
  3707. #ifdef CK_ENVIRONMENT
  3708.     { "new-environment", TELOPT_NEWENVIRON,  0 },
  3709. #else
  3710.     { "new-environment", TELOPT_NEWENVIRON,  CM_INV },
  3711. #endif /* CK_ENVIRONMENT */
  3712.     { "pragma-heartbeat",TELOPT_PRAGMA_HEARTBEAT,  CM_INV },
  3713.     { "pragma-logon",    TELOPT_PRAGMA_LOGON,  CM_INV },
  3714.     { "pragma-sspi",     TELOPT_SSPI_LOGON,  CM_INV },
  3715.     { "sak",   TELOPT_IBM_SAK, CM_INV },
  3716. #ifdef CK_SNDLOC
  3717.     { "send-location",   TELOPT_SNDLOC,  0 },
  3718. #else
  3719.     { "send-location",   TELOPT_SNDLOC,  CM_INV },
  3720. #endif /* CK_SNDLOC */
  3721.     { "sga", TELOPT_SGA, 0 },
  3722. #ifdef CK_SSL
  3723.     { "start-tls",       TELOPT_START_TLS,  0 },
  3724. #else
  3725.     { "start-tls",       TELOPT_START_TLS,  CM_INV },
  3726. #endif /* CK_SSL */
  3727.     { "ttype", TELOPT_TTYPE, 0 },
  3728. #ifdef CK_ENVIRONMENT
  3729.     { "xdisplay-location", TELOPT_XDISPLOC, 0 },
  3730. #else
  3731.     { "xdisplay-location", TELOPT_XDISPLOC, CM_INV },
  3732. #endif /* CK_ENVIRONMENT */
  3733.     { "", 0, 0 }
  3734. };
  3735. static int ntnopts = (sizeof(tnopts) / sizeof(struct keytab)) - 1;
  3736.  
  3737. static struct keytab tnsbopts[] = {
  3738. #ifdef CK_NAWS
  3739.     { "naws", TELOPT_NAWS, 0 },
  3740. #endif /* CK_NAWS */
  3741.     { "", 0, 0 }
  3742. };
  3743. static int ntnsbopts = (sizeof(tnsbopts) / sizeof(struct keytab)) - 1;
  3744. #endif /* TNCODE */
  3745.  
  3746. #ifdef TCPSOCKET
  3747. #ifndef NOPUSH
  3748. #ifdef SYSFTP
  3749. int
  3750. doftp() {                /* (External) FTP command */
  3751.     char *p, *f;            /* (See doxftp() for internal one) */
  3752.     int x;
  3753.  
  3754.     if (network)            /* If we have a current connection */
  3755.       ckstrncpy(line,ttname,LINBUFSIZ);    /* get the host name */
  3756.     else *line = '\0';            /* as default host */
  3757.     for (p = line; *p; p++)        /* Remove ":service" from end. */
  3758.       if (*p == ':') { *p = '\0'; break; }
  3759.     if ((x = cmtxt("IP host name or number", line, &s, xxstring)) < 0)
  3760.       return(x);
  3761.     if (nopush) {
  3762.         printf("?Sorry, FTP command disabled\n");
  3763.         return(success = 0);
  3764.     }
  3765. /* Construct FTP command */
  3766. #ifdef VMS
  3767. #ifdef MULTINET                /* TGV MultiNet */
  3768.     ckmakmsg(line,LINBUFSIZ,"multinet ftp ",s,NULL,NULL);
  3769. #else
  3770.     ckmakmsg(line,LINBUFSIZ,"ftp ",s,NULL,NULL);
  3771. #endif /* MULTINET */
  3772. #else                    /* Not VMS */
  3773. #ifdef OS2ORUNIX
  3774. #ifndef NOFTP
  3775.     f = ftpapp;
  3776.     if (!f) f = "";
  3777.     if (!f[0]) f = "ftp";
  3778.     ckmakmsg(line,LINBUFSIZ,f," ",s,NULL);
  3779. #ifdef OS2
  3780.     p = line + strlen(ftpapp);
  3781.     while (p != line) {
  3782.         if (*p == '/') *p = '\\';
  3783.         p--;
  3784.     }
  3785. #endif /* OS2 */
  3786. #else /* NOFTP */
  3787.     ckmakmsg(line,LINBUFSIZ,"ftp ",s,NULL,NULL);
  3788. #endif /* NOFTP */
  3789. #else /* OS2ORUNIX */
  3790.     ckmakmsg(line,LINBUFSIZ,"ftp ",s,NULL,NULL);
  3791. #endif /* OS2ORUNIX */
  3792. #endif /* VMS */
  3793.     conres();                /* Make console normal  */
  3794. #ifdef DEC_TCPIP
  3795.     printf("\n");            /* Prevent prompt-stomping */
  3796. #endif /* DEC_TCPIP */
  3797.     x = zshcmd(line);
  3798.     concb((char)escape);
  3799.     return(success = x);
  3800. }
  3801. #endif /* SYSFTP */
  3802.  
  3803. int
  3804. doping() {                /* PING command */
  3805.     char *p;                /* just runs ping program */
  3806.     int x;
  3807.  
  3808.     if (network)            /* If we have a current connection */
  3809.       ckstrncpy(line,ttname,LINBUFSIZ);    /* get the host name */
  3810.     else *line = '\0';            /* as default host to be pinged. */
  3811.     for (p = line; *p; p++)        /* Remove ":service" from end. */
  3812.       if (*p == ':') { *p = '\0'; break; }
  3813.     if ((x = cmtxt("IP host name or number", line, &s, xxstring)) < 0)
  3814.       return(x);
  3815.     if (nopush) {
  3816.         printf("?Sorry, PING command disabled\n");
  3817.         return(success = 0);
  3818.     }
  3819.  
  3820.     /* Construct PING command */
  3821. #ifdef VMS
  3822. #ifdef MULTINET                /* TGV MultiNet */
  3823.     ckmakmsg(line,LINBUFSIZ,"multinet ping ",s," /num=1",NULL);
  3824. #else
  3825.     ckmakmsg(line,LINBUFSIZ,"ping ",s," 56 1",NULL); /* Other VMS TCP/IP's */
  3826. #endif /* MULTINET */
  3827. #else                    /* Not VMS */
  3828.     ckmakmsg(line,LINBUFSIZ,"ping ",s,NULL,NULL);
  3829. #endif /* VMS */
  3830.     conres();                /* Make console normal  */
  3831. #ifdef DEC_TCPIP
  3832.     printf("\n");            /* Prevent prompt-stomping */
  3833. #endif /* DEC_TCPIP */
  3834.     x = zshcmd(line);
  3835.     concb((char)escape);
  3836.     return(success = x);
  3837. }
  3838. #endif /* NOPUSH */
  3839. #endif /* TCPSOCKET */
  3840.  
  3841. static VOID
  3842. doend(x) int x; {
  3843. #ifndef NOSPL
  3844.     /* Pop from all FOR/WHILE/XIF/SWITCH's */
  3845.     debug(F101,"doend maclvl 1","",maclvl);
  3846.     while ((maclvl > 0) &&
  3847.        (m_arg[maclvl-1][0]) &&
  3848.        (cmdstk[cmdlvl].src == CMD_MD) &&
  3849.        (!strncmp(m_arg[maclvl-1][0],"_xif",4) ||
  3850.         !strncmp(m_arg[maclvl-1][0],"_for",4) ||
  3851.         !strncmp(m_arg[maclvl-1][0],"_whi",4) ||
  3852.         !strncmp(m_arg[maclvl-1][0],"_swi",4))) {
  3853.     debug(F110,"END popping",m_arg[maclvl-1][0],0);
  3854.     dogta(XXPTA);            /* Put args back */
  3855.     popclvl();            /* Pop up two levels */
  3856.     popclvl();
  3857.     debug(F101,"doend maclvl 2","",maclvl);
  3858.     }
  3859.     if (maclvl > -1) {
  3860.     if (mrval[maclvl])        /* Free previous retval if any */
  3861.       free(mrval[maclvl]);
  3862.     mrval[maclvl] = malloc(16);    /* Room for up to 15 digits */
  3863.     if (mrval[maclvl])        /* Record current retval */
  3864.       ckmakmsg(mrval[maclvl],16,ckitoa(x),NULL,NULL,NULL);
  3865.     }
  3866. #endif /* NOSPL */
  3867.     popclvl();                /* Now pop out of macro or TAKE file */
  3868. #ifndef NOSPL
  3869. #ifdef DEBUG
  3870.     if (deblog) {
  3871.     debug(F101,"END maclvl 3","",maclvl);
  3872.     debug(F111,"END mrval[maclvl]",mrval[maclvl],maclvl);
  3873.     debug(F111,"END mrval[maclvl+1]",mrval[maclvl+1],maclvl+1);
  3874.     }
  3875. #endif /* DEBUG */
  3876. #endif /* NOSPL */
  3877. }
  3878.  
  3879. #ifdef CKROOT
  3880. int
  3881. dochroot() {
  3882.     if ((x = cmdir("Name of new root directory","",&s,xxstring)) < 0) {
  3883.     if (x == -3) {
  3884.         printf("?Directory name required\n");
  3885.         return(-9);
  3886.     }
  3887.     return(x);
  3888.     }
  3889.     ckstrncpy(line,s,LINBUFSIZ);
  3890.     s = line;
  3891.     if ((x = cmcfm()) < 0) return(x);
  3892.     s = brstrip(s);
  3893.     x = zsetroot(s);
  3894.     if (x < 0) {
  3895.     char * m = NULL;
  3896.     switch (x) {
  3897.       case -1:
  3898.       case -2: m = "Not a directory"; break;
  3899.       case -3: m = "Internal error"; break;
  3900.       case -4: m = "Access denied"; break;
  3901.       case -5: m = "Off limits"; break;
  3902.     }
  3903.     if (m) printf("%s: \"%s\"\n", m, s);
  3904.     return(m ? -9 : -2);
  3905.     } else {
  3906.     nopush = 1;
  3907.     return(success = 1);
  3908.     }
  3909. }
  3910. #endif /* CKROOT */
  3911.  
  3912. #ifndef NOXFER
  3913. static char * asnbuf = NULL;        /* As-name buffer pointer */
  3914.  
  3915. char sndxnam[] = { "_array_x_" };    /* (with replaceable x!) */
  3916.  
  3917. /*
  3918.   The new SEND command, replacing BSEND, CSEND, PSEND, etc etc.
  3919.   Call with cx = top-level keyword value.  Returns:
  3920.     < 0  On parse error.
  3921.     0    On other type of failure (e.g. requested operation not allowed).
  3922.     1    On success with sstate set to 's' so protocol will begin.
  3923. */
  3924.  
  3925. /*  D O X S E N D  --  Parse SEND and related commands with switches  */
  3926.  
  3927. int
  3928. doxsend(cx) int cx; {
  3929.     int c, i, n, wild, confirmed = 0;    /* Workers */
  3930.     int x, y;                /* of the world... */
  3931.     int getval = 0;            /* Whether to get switch value */
  3932.     extern char * snd_move;        /* Directory to move sent files to */
  3933.     extern char * snd_rename;        /* What to rename sent files to */
  3934.     extern char * filefile;        /* File containing filenames to send */
  3935.     extern int xfiletype;        /* Send only text (or binary) files */
  3936.     extern struct keytab pathtab[];    /* PATHNAMES option keywords */
  3937.     extern int npathtab;        /* How many of them */
  3938.     extern int recursive;        /* Recursive directory traversal */
  3939.     extern int rprintf;            /* REMOTE PRINT flag */
  3940.     extern int fdispla;            /* TRANSFER DISPLAY setting */
  3941.     extern int skipbup;            /* Skip backup files when sending */
  3942.     struct stringint pv[SND_MAX+1];    /* Temporary array for switch values */
  3943.     struct FDB sf, sw, fl, cm;        /* FDBs for each parse function */
  3944.     int mlist = 0;            /* Flag for MSEND or MMOVE */
  3945.     char * m;                /* For making help messages */
  3946.     extern struct keytab protos[];    /* File transfer protocols */
  3947.     extern int xfrxla, g_xfrxla, nprotos;
  3948.     extern char sndbefore[], sndafter[], *sndexcept[]; /* Selection criteria */
  3949.     extern char sndnbefore[], sndnafter[];
  3950.     extern CK_OFF_T sndsmaller, sndlarger, calibrate;
  3951. #ifndef NOSPL
  3952.     int range[2];            /* Array range */
  3953.     char ** ap = NULL;            /* Array pointer */
  3954.     int arrayx = -1;            /* Array index */
  3955. #endif /* NOSPL */
  3956.  
  3957. #ifdef NEWFTP
  3958.     if ((ftpget == 1) || ((ftpget == 2) && ftpisopen())) {
  3959.     if (cx == XXMAI) {
  3960.         printf("?Sorry, No MAIL with FTP\n");
  3961.         return(-9);
  3962.     }
  3963.     return(doftpput(cx,0));
  3964.     }
  3965. #endif /* NEWFTP */
  3966.  
  3967.     for (i = 0; i <= SND_MAX; i++) {    /* Initialize switch values */
  3968.     pv[i].sval = NULL;        /* to null pointers */
  3969.     pv[i].ival = -1;        /* and -1 int values */
  3970.     pv[i].wval = (CK_OFF_T)-1;    /* and -1 wide values */
  3971.     }
  3972. #ifndef NOSPL
  3973.     range[0] = -1;
  3974.     range[1] = -1;
  3975.     sndxin = -1;            /* Array index */
  3976. #endif /* NOSPL */
  3977.     sndarray = NULL;            /* Array pointer */
  3978.  
  3979. #ifdef UNIXOROSK
  3980.     g_matchdot = matchdot;        /* Match dot files */
  3981. #endif /* UNIXOROSK */
  3982.     g_recursive = recursive;        /* Recursive sending */
  3983.     recursive = 0;            /* Save global value, set local */
  3984.     debug(F101,"xsend entry fncnv","",fncnv);
  3985.  
  3986.     /* Preset switch values based on top-level command that called us */
  3987.  
  3988.     switch (cx) {
  3989.       case XXMSE:            /* MSEND */
  3990.     mlist = 1; break;
  3991.       case XXCSEN:            /* CSEND */
  3992.     pv[SND_CMD].ival = 1; break;
  3993.       case XXMMOVE:            /* MMOVE */
  3994.     mlist = 1;
  3995.       case XXMOVE:            /* MOVE */
  3996.     pv[SND_DEL].ival = 1; break;
  3997.       case XXRSEN:            /* RESEND */
  3998.     pv[SND_BIN].ival = 1;        /* Implies /BINARY */
  3999.     pv[SND_RES].ival = 1; break;
  4000.       case XXMAI:            /* MAIL */
  4001.     pv[SND_MAI].ival = 1; break;
  4002.     }
  4003.  
  4004.     /* Set up chained parse functions... */
  4005.  
  4006.     cmfdbi(&sw,                /* First FDB - command switches */
  4007.        _CMKEY,            /* fcode */
  4008.        "Filename, or switch",    /* hlpmsg */
  4009.        "",                /* default */
  4010.        "",                /* addtl string data */
  4011. #ifdef NOMSEND
  4012.        nsndtab,            /* addtl numeric data 1: tbl size */
  4013. #else
  4014.        mlist ? nmsndtab : nsndtab,    /* addtl numeric data 1: tbl size */
  4015. #endif /* NOMSEND */
  4016.        4,                /* addtl numeric data 2: 4 = cmswi */
  4017.        xxstring,            /* Processing function */
  4018. #ifdef NOMSEND
  4019.        sndtab,            /* Keyword table */
  4020. #else
  4021.        mlist ? msndtab : sndtab,
  4022. #endif /* NOMSEND */
  4023.        &sf                /* Pointer to next FDB */
  4024.        );
  4025.     cmfdbi(&sf,                /* 2nd FDB - file to send */
  4026.        _CMIFI,            /* fcode */
  4027.        "File(s) to send",        /* hlpmsg */
  4028.        "",                /* default */
  4029.        "",                /* addtl string data */
  4030.        nolinks,            /* addtl numeric data 1 */
  4031.        0,                /* addtl numeric data 2 */
  4032.        xxstring,
  4033.        NULL,
  4034.        mlist ? &cm : &fl
  4035.        );
  4036.     cmfdbi(&fl,                /* 3rd FDB - command to send from */
  4037.        _CMFLD,            /* fcode */
  4038.        "Command",            /* hlpmsg */
  4039.        "",                /* default */
  4040.        "",                /* addtl string data */
  4041.        0,                /* addtl numeric data 1 */
  4042.        0,                /* addtl numeric data 2 */
  4043.        xxstring,
  4044.        NULL,
  4045.        &cm
  4046.        );
  4047.     cmfdbi(&cm,                /* 4th FDB - Confirmation */
  4048.        _CMCFM,            /* fcode */
  4049.        "",                /* hlpmsg */
  4050.        "",                /* default */
  4051.        "",                /* addtl string data */
  4052.        0,                /* addtl numeric data 1 */
  4053.        0,                /* addtl numeric data 2 */
  4054.        NULL,
  4055.        NULL,
  4056.        NULL
  4057.        );
  4058.  
  4059.     while (1) {                /* Parse 0 or more switches */
  4060.     x = cmfdb(&sw);            /* Parse something */
  4061.     debug(F101,"xsend cmfdb","",x);
  4062.     if (x < 0)            /* Error */
  4063.       goto xsendx;            /* or reparse needed */
  4064.     if (cmresult.fcode != _CMKEY)    /* Break out if not a switch */
  4065.       break;
  4066. /*
  4067.   They gave a switch, but let's see how they terminated it.
  4068.   If they ended it with : or =, then we must parse a value.
  4069.   If they ended it with anything else, then we must NOT parse a value.
  4070. */
  4071.     c = cmgbrk();            /* Get break character */
  4072.     getval = (c == ':' || c == '='); /* to see how they ended the switch */
  4073.     if (getval && !(cmresult.kflags & CM_ARG)) {
  4074.         printf("?This switch does not take arguments\n");
  4075.         x = -9;
  4076.         goto xsendx;
  4077.     }
  4078.     if (!getval && (cmgkwflgs() & CM_ARG)) {
  4079.         printf("?This switch requires an argument\n");
  4080.         x = -9;
  4081.         goto xsendx;
  4082.     }
  4083.     n = cmresult.nresult;        /* Numeric result = switch value */
  4084.     debug(F101,"xsend switch","",n);
  4085.  
  4086.     switch (n) {            /* Process the switch */
  4087.       case SND_CMD:            /* These take no args */
  4088.         if (nopush) {
  4089.         printf("?Sorry, system command access is disabled\n");
  4090.         x = -9;
  4091.         goto xsendx;
  4092.         }
  4093. #ifdef PIPESEND
  4094.         else if (sndfilter) {
  4095.         printf(
  4096. "?Sorry, no SEND /COMMAND or CSEND when SEND FILTER selected\n");
  4097.         x = -9;
  4098.         goto xsendx;
  4099.         }
  4100. #endif /* PIPESEND */
  4101.         sw.hlpmsg = "Command, or switch"; /* Change help message */
  4102.         pv[n].ival = 1;        /* Just set the flag */
  4103.         pv[SND_ARR].ival = 0;
  4104.         break;
  4105.  
  4106.       case SND_REC:            /* /RECURSIVE */
  4107.         recursive = 2;        /* Set the real variable */
  4108.         pv[SND_PTH].ival = PATH_REL; /* Give them relative pathnames */
  4109.         pv[n].ival = 1;        /* Just set the flag */
  4110.         break;
  4111.  
  4112.       case SND_RES:            /* /RECOVER (resend) */
  4113.         pv[SND_ARR].ival = 0;
  4114.         pv[SND_BIN].ival = 1;    /* Implies /BINARY */
  4115.       case SND_NOB:            /* /NOBACKUP */
  4116.       case SND_DEL:            /* /DELETE */
  4117.       case SND_SHH:            /* /QUIET */
  4118.         pv[n].ival = 1;        /* Just set the flag */
  4119.         break;
  4120.  
  4121. #ifdef UNIXOROSK
  4122. /* Like recursive, these are set immediately because they affect cmifi() */
  4123.       case SND_DOT:            /* /DOTFILES */
  4124.         matchdot = 1;
  4125.         break;
  4126.       case SND_NOD:            /* /NODOTFILES */
  4127.         matchdot = 0;
  4128.         break;
  4129. #endif /* UNIXOROSK */
  4130.  
  4131.       /* File transfer modes - each undoes the others */
  4132.  
  4133.       case SND_BIN:            /* Binary */
  4134.       case SND_TXT:            /* Text */
  4135.       case SND_IMG:            /* Image */
  4136.       case SND_LBL:            /* Labeled */
  4137.         pv[SND_BIN].ival = 0;
  4138.         pv[SND_TXT].ival = 0;
  4139.         pv[SND_IMG].ival = 0;
  4140.         pv[SND_LBL].ival = 0;
  4141.         pv[n].ival = 1;
  4142.         break;
  4143.  
  4144. #ifdef CKSYMLINK
  4145.       case SND_LNK:
  4146.       case SND_NLK:
  4147.         nolinks = (n == SND_NLK) ? 2 : 0;
  4148.         cmfdbi(&sf,            /* Redo cmifi() */
  4149.            _CMIFI,        /* fcode */
  4150.            "File(s) to send",    /* hlpmsg */
  4151.            "",            /* default */
  4152.            "",            /* addtl string data */
  4153.            nolinks,        /* addtl numeric data 1 */
  4154.            0,            /* addtl numeric data 2 */
  4155.            xxstring,
  4156.            NULL,
  4157.            mlist ? &cm : &fl
  4158.            );
  4159.         break;
  4160. #endif /* CKSYMLINK */
  4161.  
  4162.       case SND_EXC:            /* Excludes */
  4163.         if (!getval) break;
  4164.         if ((x = cmfld("Pattern","",&s,xxstring)) < 0) {
  4165.         if (x == -3) {
  4166.             printf("?Pattern required\n");
  4167.             x = -9;
  4168.         }
  4169.         goto xsendx;
  4170.         }
  4171.         if (pv[n].sval) free(pv[n].sval);
  4172.         y = strlen(s);
  4173.         if (y > 256) {
  4174.         printf("?Pattern too long - 256 max\n");
  4175.         x = -9;
  4176.         goto xsendx;
  4177.         }
  4178.         pv[n].sval = malloc(y+1);
  4179.         if (pv[n].sval) {
  4180.         strcpy(pv[n].sval,s);    /* safe */
  4181.         pv[n].ival = 1;
  4182.         }
  4183.         break;
  4184.  
  4185.       case SND_MOV:            /* MOVE after */
  4186.       case SND_REN:            /* RENAME after */
  4187.         if (!getval) break;
  4188.         if ((x = cmfld(n == SND_MOV ?
  4189.        "device and/or directory for source file after sending" :
  4190.        "new name for source file after sending",
  4191.                "",
  4192.                &s,
  4193.                n == SND_MOV ? xxstring : NULL
  4194.                )) < 0) {
  4195.         if (x == -3) {
  4196.             printf("%s\n", n == SND_MOV ?
  4197.                "?Destination required" :
  4198.                "?New name required"
  4199.                );
  4200.             x = -9;
  4201.         }
  4202.         goto xsendx;
  4203.         }
  4204.         if (pv[n].sval) free(pv[n].sval);
  4205.         s = brstrip(s);
  4206.         y = strlen(s);
  4207.         if (y > 0) {
  4208.         pv[n].sval = malloc(y+1);
  4209.         if (pv[n].sval) {
  4210.             strcpy(pv[n].sval,s); /* safe */
  4211.             pv[n].ival = 1;
  4212.         }
  4213.         }
  4214.         break;
  4215.  
  4216.       case SND_SMA:            /* Smaller / larger than */
  4217.       case SND_LAR: {
  4218.           CK_OFF_T w;
  4219.           if (!getval) break;
  4220.           if ((x = cmnumw("Size in bytes","0",10,&w,xxstring)) < 0)
  4221.         goto xsendx;
  4222.           pv[n].wval = w;
  4223.           break;
  4224.       }
  4225.       case SND_AFT:            /* Send /AFTER:date-time */
  4226.       case SND_BEF:            /* Send /BEFORE:date-time */
  4227.       case SND_NAF:            /* Send /NOT-AFTER:date-time */
  4228.       case SND_NBE:            /* Send /NOT-BEFORE:date-time */
  4229.         if (!getval) break;
  4230.         if ((x = cmdate("File date-time","",&s,0,xxstring)) < 0) {
  4231.         if (x == -3) {
  4232.             printf("?Date-time required\n");
  4233.             x = -9;
  4234.         }
  4235.         goto xsendx;
  4236.         }
  4237.         if (pv[n].sval) free(pv[n].sval);
  4238.         pv[n].sval = malloc((int)strlen(s)+1);
  4239.         if (pv[n].sval) {
  4240.         strcpy(pv[n].sval,s);    /* safe */
  4241.         pv[n].ival = 1;
  4242.         }
  4243.         break;
  4244.  
  4245.       case SND_MAI:            /* Send as mail (= MAIL) */
  4246. #ifdef IKSD
  4247.         if (inserver && !ENABLED(en_mai)) {
  4248.         printf("?Sorry, sending files as mail is disabled\n");
  4249.         return(-9);
  4250.         }
  4251. #endif /* IKSD */
  4252.         pv[n].ival = 1;
  4253.         if (!getval) break;
  4254.         if ((x = cmfld("e-mail address","",&s,xxstring)) < 0) {
  4255.         if (x == -3) {
  4256.             printf("?address required\n");
  4257.             x = -9;
  4258.         }
  4259.         goto xsendx;
  4260.         }
  4261.         s = brstrip(s);
  4262.         if (pv[n].sval) free(pv[n].sval);
  4263.         pv[n].sval = malloc((int)strlen(s)+1);
  4264.         if (pv[n].sval)
  4265.           strcpy(pv[n].sval,s);    /* safe */
  4266.         break;
  4267.  
  4268.       case SND_PRI:            /* Send to be printed (REMOTE PRINT) */
  4269. #ifdef IKSD
  4270.         if (inserver && !ENABLED(en_mai)) {
  4271.         printf("?Sorry, sending files for printing is disabled\n");
  4272.         return(-9);
  4273.         }
  4274. #endif /* IKSD */
  4275.         pv[n].ival = 1;
  4276.         if (!getval) break;
  4277.         if ((x = cmfld("Print options","",&s,xxstring)) < 0)
  4278.           if (x != -3) goto xsendx;
  4279.         s = brstrip(s);
  4280.         if (pv[n].sval) free(pv[n].sval);
  4281.         pv[n].sval = malloc((int)strlen(s)+1);
  4282.         if (pv[n].sval)
  4283.           strcpy(pv[n].sval,s);    /* safe */
  4284.         break;
  4285.  
  4286.       case SND_ASN:            /* As-name */
  4287.         debug(F101,"xsend /as-name getval","",getval);
  4288.         if (!getval) break;
  4289.         if ((x = cmfld("Name to send under","",&s,NULL)) < 0) {
  4290.         if (x == -3) {
  4291.             printf("?name required\n");
  4292.             x = -9;
  4293.         }
  4294.         goto xsendx;
  4295.         }
  4296.         s = brstrip(s);
  4297.         if ((y = strlen(s)) > 0) {
  4298.         if (pv[n].sval) free(pv[n].sval);
  4299.         pv[n].sval = malloc(y+1);
  4300.         if (pv[n].sval) {
  4301.             strcpy(pv[n].sval,s); /* safe */
  4302.             pv[n].ival = 1;
  4303.         }
  4304.         }
  4305.         break;
  4306.  
  4307.       case SND_STA: {        /* Starting position (= PSEND) */
  4308.           CK_OFF_T w;
  4309.           if (!getval) break;
  4310.           if ((x = cmnumw("0-based position","0",10,&w,xxstring)) < 0)
  4311.         goto xsendx;
  4312.           pv[n].wval = w;
  4313.           break;
  4314.       }
  4315.       case SND_PRO:            /* Protocol to use */
  4316.         if (!getval) break;
  4317.         if ((x = cmkey(protos,nprotos,"File-transfer protocol","",
  4318.                xxstring)) < 0) {
  4319.         if (x == -3) {
  4320.             printf("?name of protocol required\n");
  4321.             x = -9;
  4322.         }
  4323.         goto xsendx;
  4324.         }
  4325.         pv[n].ival = x;
  4326.         break;
  4327.  
  4328. #ifdef PIPESEND
  4329.       case SND_FLT:            /* Filter */
  4330.         debug(F101,"xsend /filter getval","",getval);
  4331.         if (!getval) break;
  4332.         if ((x = cmfld("Filter program to send through","",&s,NULL)) < 0) {
  4333.         if (x == -3)
  4334.           s = "";
  4335.         else
  4336.           goto xsendx;
  4337.         }
  4338.         if (*s) s = brstrip(s);
  4339.         y = strlen(s);
  4340.         for (x = 0; x < y; x++) {    /* Make sure they included "\v(...)" */
  4341.         if (s[x] != '\\') continue;
  4342.         if (s[x+1] == 'v') break;
  4343.         }
  4344.         if (x == y) {
  4345.         printf(
  4346.         "?Filter must contain a replacement variable for filename.\n"
  4347.                );
  4348.         x = -9;
  4349.         goto xsendx;
  4350.         }
  4351.         pv[n].ival = 1;
  4352.         if (pv[n].sval) {
  4353.         free(pv[n].sval);
  4354.         pv[n].sval = NULL;
  4355.         }
  4356.         if ((y = strlen(s)) > 0) {
  4357.         if ((pv[n].sval = malloc(y+1)))
  4358.           strcpy(pv[n].sval,s);    /* safe */
  4359.         }
  4360.         break;
  4361. #endif /* PIPESEND */
  4362.  
  4363.       case SND_PTH:            /* Pathnames */
  4364.         if (!getval) {
  4365.         pv[n].ival = PATH_REL;
  4366.         break;
  4367.         }
  4368.         if ((x = cmkey(pathtab,npathtab,"","absolute",xxstring)) < 0)
  4369.           goto xsendx;
  4370.         pv[n].ival = x;
  4371.         break;
  4372.  
  4373.       case SND_NAM:            /* Filenames */
  4374.         if (!getval) break;
  4375.         if ((x = cmkey(fntab,nfntab,"","converted",xxstring)) < 0)
  4376.           goto xsendx;
  4377.         debug(F101,"xsend /filenames","",x);
  4378.         pv[n].ival = x;
  4379.         break;
  4380.  
  4381. #ifdef CALIBRATE
  4382.           case SND_CAL: {        /* /CALIBRATE */
  4383.           CK_OFF_T w;
  4384.           if (getval) {
  4385.           if ((x = cmnumw("number of Kbytes to send",
  4386.                   "1024",10,&w,xxstring)) < 0)
  4387.             goto xsendx;
  4388.           } else
  4389.         w = (CK_OFF_T)1024;
  4390.           pv[n].wval = w;
  4391.           pv[SND_ARR].ival = 0;
  4392.           break;
  4393.       }
  4394. #endif /* CALIBRATE */
  4395.  
  4396.       case SND_FIL:            /* Name of file containing filnames */
  4397.         if (!getval) break;
  4398.         if ((x = cmifi("Name of file containing list of filenames",
  4399.                    "",&s,&y,xxstring)) < 0) {
  4400.         if (x == -3) {
  4401.             printf("?Filename required\n");
  4402.             x = -9;
  4403.         }
  4404.         goto xsendx;
  4405.         } else if (y) {
  4406.         printf("?Wildcards not allowed\n");
  4407.         x = -9;
  4408.         goto xsendx;
  4409.         }
  4410.         if (pv[n].sval)
  4411.           free(pv[n].sval);
  4412.         if (s) if (*s) {
  4413.         if ((pv[n].sval = malloc((int)strlen(s)+1))) {
  4414.             strcpy(pv[n].sval,s);
  4415.             pv[n].ival = 1;
  4416.             pv[SND_ARR].ival = 0;
  4417.         }
  4418.         }
  4419.         break;
  4420.  
  4421. #ifndef NOSPL
  4422.       case SND_ARR:            /* SEND /ARRAY: */
  4423.         if (!getval) break;
  4424.         ap = NULL;
  4425.         if ((x = cmfld("Array name (a single letter will do)",
  4426.                "",
  4427.                &s,
  4428.                NULL
  4429.                )) < 0) {
  4430.         if (x == -3)
  4431.           break;
  4432.         else
  4433.           return(x);
  4434.         }
  4435.         if ((x = arraybounds(s,&(range[0]),&(range[1]))) < 0) {
  4436.         printf("?Bad array: %s\n",s);
  4437.         return(-9);
  4438.         }
  4439.         if (!(ap = a_ptr[x])) {
  4440.         printf("?No such array: %s\n",s);
  4441.         return(-9);
  4442.         }
  4443.         pv[n].ival = 1;
  4444.         pv[SND_CMD].ival = 0;    /* Undo any conflicting ones... */
  4445.         pv[SND_RES].ival = 0;
  4446.         pv[SND_CAL].ival = 0;
  4447.         pv[SND_FIL].ival = 0;
  4448.         arrayx = x;
  4449.         break;
  4450. #endif /* NOSPL */
  4451.  
  4452.       case SND_XPA:            /* /TRANSPARENT */
  4453.         pv[n].ival = 1;
  4454.         break;
  4455.  
  4456.       case SND_TYP:            /* Only files of given type */
  4457.         if (!getval) break;
  4458.         if ((x = cmkey(txtbin,3,"","all",xxstring)) < 0)
  4459.           goto xsendx;
  4460.         pv[n].ival = (x == 2) ? -1 : x;
  4461.         break;
  4462.  
  4463.       default:
  4464.         printf("?Unexpected switch value - %d\n",cmresult.nresult);
  4465.         x = -9;
  4466.         goto xsendx;
  4467.     }
  4468.     }
  4469.     debug(F101,"xsend cmresult fcode","",cmresult.fcode);
  4470.  
  4471. #ifdef COMMENT
  4472.     /* List switch parsing results in debug log */
  4473.     for (i = 0; i <= SND_MAX; i++) {
  4474.     ckmakmsg(line,LINBUFSIZ,"xsend switch ",ckitoa(i),NULL,NULL);
  4475.     debug(F111,line, pv[i].sval, pv[i].ival);
  4476.     }
  4477. #endif /* COMMENT */
  4478.  
  4479. /* Now we have all switches, plus maybe a filename or command, or nothing */
  4480.  
  4481. #ifdef PIPESEND
  4482.     if (protocol != PROTO_K && pv[SND_CMD].ival > 0) {
  4483.     printf("?Sorry, %s works only with Kermit protocol\n",
  4484.            (cx == XXCSEN) ? "CSEND" : "SEND /COMMAND");
  4485.     x = -9;
  4486.     goto xsendx;
  4487.     }
  4488.     if (pv[SND_RES].ival > 0 ||    /* /RECOVER */
  4489.     pv[SND_STA].wval > 0) {    /* or /STARTING */
  4490.     if (sndfilter || pv[SND_FLT].ival > 0) {
  4491.         printf("?Sorry, no /RECOVER or /START if SEND FILTER selected\n");
  4492.         x = -9;
  4493.         goto xsendx;
  4494.     }
  4495.     }
  4496. #endif /* PIPESEND */
  4497.  
  4498.     cmarg = "";
  4499.     cmarg2 = "";
  4500.     line[0] = NUL;
  4501.     s = line;
  4502.     wild = 0;
  4503.  
  4504.     switch (cmresult.fcode) {        /* How did we get out of switch loop */
  4505.       case _CMIFI:            /* Input filename */
  4506.     ckstrncpy(line,cmresult.sresult,LINBUFSIZ); /* Name */
  4507.     if (pv[SND_ARR].ival > 0)
  4508.       cmarg2 = line;
  4509.     else
  4510.       wild = cmresult.nresult;    /* Wild flag */
  4511.     if (!recursive && !wild)
  4512.       nolinks = 0;
  4513.     break;
  4514.       case _CMFLD:            /* Field */
  4515.     /* Only allowed with /COMMAND and /ARRAY */
  4516.     if (pv[SND_CMD].ival < 1 && pv[SND_ARR].ival < 1) {
  4517. #ifdef CKROOT
  4518.         if (ckrooterr)
  4519.           printf("?Off limits: %s\n",cmresult.sresult);
  4520.         else
  4521. #endif /* CKROOT */
  4522.           printf("?%s - \"%s\"\n",
  4523.            iswild(cmresult.sresult) ?
  4524.            "No files match" : "File not found",
  4525.            cmresult.sresult
  4526.            );
  4527.         x = -9;
  4528.         goto xsendx;
  4529.     }
  4530.     ckstrncpy(line,cmresult.sresult,LINBUFSIZ);
  4531.     if (pv[SND_ARR].ival > 0)
  4532.       cmarg2 = line;
  4533.     break;
  4534.       case _CMCFM:            /* Confirmation */
  4535.     /* s = ""; */
  4536.     confirmed = 1;
  4537.     break;
  4538.       default:
  4539.     printf("?Unexpected function code: %d\n",cmresult.fcode);
  4540.     x = -9;
  4541.     goto xsendx;
  4542.     }
  4543.     debug(F110,"xsend string",s,0);
  4544.     debug(F101,"xsend confirmed","",confirmed);
  4545.  
  4546.     /* Save and change protocol and transfer mode */
  4547.     /* Global values are restored in main parse loop */
  4548.  
  4549.     g_proto = protocol;            /* Save current global protocol */
  4550.     g_urpsiz = urpsiz;
  4551.     g_spsizf = spsizf;
  4552.     g_spsiz = spsiz;
  4553.     g_spsizr = spsizr;
  4554.     g_spmax = spmax;
  4555.     g_wslotr = wslotr;
  4556.     g_prefixing = prefixing;
  4557.     g_fncact = fncact;
  4558.     g_fncnv = fncnv;
  4559.     g_fnspath = fnspath;
  4560.     g_fnrpath = fnrpath;
  4561.     g_xfrxla = xfrxla;
  4562.  
  4563.     if (pv[SND_PRO].ival > -1) {    /* Change according to switch */
  4564.     protocol = pv[SND_PRO].ival;
  4565.         if (ptab[protocol].rpktlen > -1) /* copied from initproto() */
  4566.             urpsiz = ptab[protocol].rpktlen;
  4567.         if (ptab[protocol].spktflg > -1)
  4568.             spsizf = ptab[protocol].spktflg;
  4569.         if (ptab[protocol].spktlen > -1) {
  4570.             spsiz = ptab[protocol].spktlen;
  4571.             if (spsizf)
  4572.           spsizr = spmax = spsiz;
  4573.         }
  4574.         if (ptab[protocol].winsize > -1)
  4575.             wslotr = ptab[protocol].winsize;
  4576.         if (ptab[protocol].prefix > -1)
  4577.             prefixing = ptab[protocol].prefix;
  4578.         if (ptab[protocol].fnca > -1)
  4579.             fncact  = ptab[protocol].fnca;
  4580.         if (ptab[protocol].fncn > -1)
  4581.             fncnv   = ptab[protocol].fncn;
  4582.         if (ptab[protocol].fnsp > -1)
  4583.             fnspath = ptab[protocol].fnsp;
  4584.         if (ptab[protocol].fnrp > -1)
  4585.             fnrpath = ptab[protocol].fnrp;
  4586.     }
  4587.     debug(F101,"xsend protocol","",protocol);
  4588.  
  4589.     if (pv[SND_NOB].ival > -1) {    /* /NOBACKUP (skip backup file) */
  4590.     g_skipbup = skipbup;
  4591.     skipbup = 1;
  4592.     }
  4593.     if (pv[SND_REC].ival > 0)        /* /RECURSIVE */
  4594.       recursive = 2;
  4595.  
  4596.     if (pv[SND_TYP].ival > -1) {    /* /TYPE */
  4597.     xfiletype = pv[SND_TYP].ival;
  4598.     if (xfiletype == 2)
  4599.       xfiletype = -1;
  4600.     }
  4601.     g_binary = binary;            /* Save global transfer mode */
  4602. #ifdef PATTERNS
  4603.     g_patterns = patterns;        /* Save FILE PATTERNS setting */
  4604. #endif /* PATTERNS */
  4605.     if (pv[SND_BIN].ival > 0) {        /* Change according to switch */
  4606.     /* If they said /BINARY they mean /BINARY */
  4607.     patterns = 0;            /* So no pattern-based switching */
  4608.     g_xfermode = xfermode;        /* or automatic transfer mode */
  4609.     xfermode = XMODE_M;
  4610.     binary = XYFT_B;
  4611.     debug(F101,"doxsend /BINARY xfermode","",xfermode);
  4612.     } else if (pv[SND_TXT].ival > 0) {    /* Ditto for /TEXT */
  4613.     patterns = 0;
  4614.     g_xfermode = xfermode;
  4615.     xfermode = XMODE_M;
  4616.     binary = XYFT_T;
  4617.     debug(F101,"doxsend /TEXT xfermode","",xfermode);
  4618.     } else if (pv[SND_IMG].ival > 0) {
  4619. #ifdef VMS
  4620.     binary = XYFT_I;
  4621. #else
  4622.     binary = XYFT_B;
  4623. #endif /* VMS */
  4624.     }
  4625. #ifdef CK_LABELED
  4626.     else if (pv[SND_LBL].ival > 0) {
  4627.     binary = XYFT_L;
  4628.     }
  4629. #endif /* CK_LABELED */
  4630.     debug(F101,"xsend binary","",binary);
  4631.  
  4632.     if (pv[SND_XPA].ival > 0)        /* /TRANSPARENT */
  4633.       xfrxla = 0;            /* Don't translate character sets */
  4634.  
  4635.     /* Check for legal combinations of switches, filenames, etc */
  4636.  
  4637. #ifdef PIPESEND
  4638.     if (pv[SND_CMD].ival > 0) {    /* COMMAND - strip any braces */
  4639.     debug(F110,"SEND /COMMAND before stripping",s,0);
  4640.     s = brstrip(s);
  4641.     debug(F110,"SEND /COMMAND after stripping",s,0);
  4642.     if (!*s) {
  4643.         printf("?Sorry, a command to send from is required\n");
  4644.         x = -9;
  4645.         goto xsendx;
  4646.     }
  4647.     cmarg = s;
  4648.     }
  4649. #endif /* PIPESEND */
  4650.  
  4651. /* Set up /MOVE and /RENAME */
  4652.  
  4653.     if (pv[SND_DEL].ival > 0 &&
  4654.     (pv[SND_MOV].ival > 0 || pv[SND_REN].ival > 0)) {
  4655.     printf("?Sorry, /DELETE conflicts with /MOVE or /RENAME\n");
  4656.     x = -9;
  4657.     goto xsendx;
  4658.     }
  4659. #ifdef CK_TMPDIR
  4660.     if (pv[SND_MOV].ival > 0) {
  4661.     int len;
  4662.     char * p = pv[SND_MOV].sval;
  4663. #ifdef CK_LOGIN
  4664.     if (isguest) {
  4665.         printf("?Sorry, /MOVE-TO not available to guests\n");
  4666.         x = -9;
  4667.         goto xsendx;
  4668.     }
  4669. #endif /* CK_LOGIN */
  4670.     len = strlen(p);
  4671.     if (!isdir(p)) {        /* Check directory */
  4672. #ifdef CK_MKDIR
  4673.         char * s = NULL;
  4674.         s = (char *)malloc(len + 4);
  4675.         if (s) {
  4676.         strcpy(s,p);        /* safe */
  4677. #ifdef datageneral
  4678.         if (s[len-1] != ':') { s[len++] = ':'; s[len] = NUL; }
  4679. #else
  4680.         if (s[len-1] != '/') { s[len++] = '/'; s[len] = NUL; }
  4681. #endif /* datageneral */
  4682.         s[len++] = 'X';
  4683.         s[len] = NUL;
  4684.         x = zmkdir(s);
  4685.         free(s);
  4686.         if (x < 0) {
  4687.             printf("?Can't create \"%s\"\n",p);
  4688.             x = -9;
  4689.             goto xsendx;
  4690.         }
  4691.         }
  4692. #else
  4693.         printf("?Directory \"%s\" not found\n",p);
  4694.         x = -9;
  4695.         goto xsendx;
  4696. #endif /* CK_MKDIR */
  4697.     }
  4698.         zfnqfp(p,LINBUFSIZ,tmpbuf);
  4699.     makestr(&snd_move,tmpbuf);
  4700.     }
  4701. #endif /* CK_TMPDIR */
  4702.  
  4703.     if (pv[SND_REN].ival > 0) {        /* /RENAME */
  4704.     char * p = pv[SND_REN].sval;
  4705. #ifdef CK_LOGIN
  4706.     if (isguest) {
  4707.         printf("?Sorry, /RENAME-TO not available to guests\n");
  4708.         x = -9;
  4709.         goto xsendx;
  4710.     }
  4711. #endif /* CK_LOGIN */
  4712.     if (!p) p = "";
  4713.     if (!*p) {
  4714.         printf("?New name required for /RENAME\n");
  4715.         x = -9;
  4716.         goto xsendx;
  4717.     }
  4718.     p = brstrip(p);
  4719. #ifndef NOSPL
  4720.     /* If name given is wild, rename string must contain variables */
  4721.     if (wild) {
  4722.         char * s = tmpbuf;
  4723.         x = TMPBUFSIZ;
  4724.         zzstring(p,&s,&x);
  4725.         if (!strcmp(tmpbuf,p)) {
  4726.         printf(
  4727.     "?/RENAME for file group must contain variables such as \\v(filename)\n"
  4728.                );
  4729.         x = -9;
  4730.         goto xsendx;
  4731.         }
  4732.     }
  4733. #endif /* NOSPL */
  4734.     makestr(&snd_rename,p);
  4735.     }
  4736.  
  4737. /* Handle /RECOVER and /START */
  4738.  
  4739. #ifdef CK_RESEND
  4740.     if (pv[SND_RES].ival > 0 && binary != XYFT_B && !filepeek
  4741. #ifdef PATTERNS
  4742.     && !patterns
  4743. #else
  4744. #ifdef VMS
  4745. /* VMS sets text/binary automatically later when it opens the file */
  4746.     && 0
  4747. #endif /* VMS */
  4748. #endif /* PATTERNS */
  4749.     ) {
  4750.     printf("?Sorry, /BINARY required\n");
  4751.     x = -9;
  4752.     goto xsendx;
  4753.     }
  4754.     if (pv[SND_STA].wval > 0) {        /* /START */
  4755.     if (wild) {
  4756.         printf("?Sorry, wildcards not permitted with /START\n");
  4757.         x = -9;
  4758.         goto xsendx;
  4759.     }
  4760.     if (sizeof(int) < 4) {
  4761.         printf("?Sorry, this command needs at least 32-bit integers\n");
  4762.         x = -9;
  4763.         goto xsendx;
  4764.     }
  4765. #ifdef CK_XYZ
  4766.     if (protocol != PROTO_K) {
  4767.         printf("?Sorry, SEND /START works only with Kermit protocol\n");
  4768.         x = -9;
  4769.         goto xsendx;
  4770.     }
  4771. #endif /* CK_XYZ */
  4772.     }
  4773. #ifdef CK_XYZ
  4774.     if (pv[SND_RES].ival > 0) {
  4775.     if (protocol != PROTO_K && protocol != PROTO_Z) {
  4776.         printf(
  4777.     "Sorry, /RECOVER is possible only with Kermit or ZMODEM protocol\n"
  4778.            );
  4779.         x = -9;
  4780.         goto xsendx;
  4781.     }
  4782.     }
  4783. #endif /* CK_XYZ */
  4784. #endif /* CK_RESEND */
  4785.  
  4786.     if (protocol == PROTO_K) {
  4787.     if ((pv[SND_MAI].ival > 0 ||    /* MAIL */
  4788.          pv[SND_PRI].ival > 0 ||    /* PRINT */
  4789.          pv[SND_RES].ival > 0    /* RESEND */
  4790.          ) &&
  4791.         (!atdiso || !atcapr)) {    /* Disposition attribute off? */
  4792.         printf("?Sorry, ATTRIBUTE DISPOSITION must be ON\n");
  4793.         x = -9;
  4794.         goto xsendx;
  4795.     }
  4796.     }
  4797.  
  4798. #ifdef CK_XYZ
  4799.     if (wild && (protocol == PROTO_X || protocol == PROTO_XC)) {
  4800.     printf(
  4801. "Sorry, you can only send one file at a time with XMODEM protocol\n"
  4802.            );
  4803.     x = -9;
  4804.     goto xsendx;
  4805.     }
  4806. #endif /* CK_XYZ */
  4807.  
  4808.     if (!confirmed) {            /* CR not typed yet, get more fields */
  4809.     char *m;
  4810.     if (mlist) {            /* MSEND or MMOVE */
  4811.         nfils = 0;            /* We already have the first one */
  4812. #ifndef NOMSEND
  4813.         msfiles[nfils++] = line;    /* Store pointer */
  4814.         lp = line + (int)strlen(line) + 1; /* Point past it */
  4815.         debug(F111,"xsend msend",msfiles[nfils-1],nfils-1);
  4816.         while (1) {            /* Get more filenames */
  4817.         char *p;
  4818.         if ((x = cmifi("Names of files to send, separated by spaces",
  4819.                    "", &s,&y,xxstring)) < 0) {
  4820.             if (x != -3)
  4821.               goto xsendx;
  4822.             if ((x = cmcfm()) < 0)
  4823.               goto xsendx;
  4824.             break;
  4825.         }
  4826.         msfiles[nfils++] = lp;    /* Got one, count it, point to it, */
  4827.         p = lp;            /* remember pointer, */
  4828.         while ((*lp++ = *s++))    /* and copy it into buffer */
  4829.           if (lp > (line + LINBUFSIZ)) { /* Avoid memory leak */
  4830.               printf("?MSEND list too long\n");
  4831.               line[0] = NUL;
  4832.               x = -9;
  4833.               goto xsendx;
  4834.           }
  4835.         debug(F111,"xsend msend",msfiles[nfils-1],nfils-1);
  4836.         if (nfils == 1) fspec[0] = NUL; /* Take care of \v(filespec) */
  4837. #ifdef ZFNQFP
  4838.         zfnqfp(p,TMPBUFSIZ,tmpbuf);
  4839.         p = tmpbuf;
  4840. #endif /* ZFNQFP */
  4841.         if (((int)strlen(fspec) + (int)strlen(p) + 1) < fspeclen) {
  4842.             strcat(fspec,p);    /* safe */
  4843.             strcat(fspec," ");    /* safe */
  4844.         } else
  4845. #ifdef COMMENT
  4846.           printf("WARNING - \\v(filespec) buffer overflow\n");
  4847. #else
  4848.           debug(F101,"doxsend filespec buffer overflow","",0);
  4849. #endif /* COMMENT */
  4850.         }
  4851. #endif /* NOMSEND */
  4852.     } else {            /* Regular SEND */
  4853.         char *p; int y;
  4854.         nfils = -1;
  4855.         if (pv[SND_MAI].ival > 0)
  4856.           m = (pv[SND_MAI].sval) ?
  4857.         "e-mail address (optional)" :
  4858.           "e-mail address (required)";
  4859.         else if (pv[SND_PRI].ival > 0)
  4860.           m = "printer options (optional)";
  4861.         else if (wild)
  4862.           m =
  4863. "\nOptional as-name template containing replacement variables \
  4864. like \\v(filename)";
  4865.         else
  4866.           m = "Optional name to send it with";
  4867.         if ((x = cmtxt(m,"",&p,NULL)) < 0)
  4868.           goto xsendx;
  4869.         if (!p) p = "";
  4870.         if (*p) {            /* If some text was given... */
  4871.         p = brstrip(p);        /* Replace /AS-NAME: value if any */
  4872.         if ((y = strlen(p)) > 0) {
  4873.                     if (pv[SND_MAI].ival > 0) {
  4874.                         makestr(&pv[SND_MAI].sval, p);
  4875.                     } else {
  4876.             if (pv[SND_ASN].sval) free(pv[SND_ASN].sval);
  4877.             pv[SND_ASN].sval = malloc(y+1);
  4878.             if (pv[SND_ASN].sval) {
  4879.                 strcpy(pv[SND_ASN].sval,p);    /* safe */
  4880.                 pv[SND_ASN].ival = 1;
  4881.             }
  4882.             }
  4883.         }
  4884.         }
  4885.     }
  4886.     }
  4887.     /* Set cmarg2 from as-name, however we got it. */
  4888.  
  4889.     if (pv[SND_ASN].ival > 0 && pv[SND_ASN].sval && !*cmarg2) {
  4890.     int x;
  4891.     x = strlen(line);
  4892.     ckstrncpy(line+x+2,pv[SND_ASN].sval,LINBUFSIZ-x-1);
  4893.     cmarg2 = line+x+2;
  4894.     debug(F110,"doxsend cmarg2",cmarg2,0);
  4895.     }
  4896.  
  4897. #ifndef NOFRILLS
  4898.     if ((pv[SND_MAI].ival > 0) && (pv[SND_PRI].ival > 0)) {
  4899.     printf("Sorry, /MAIL and /PRINT are conflicting options\n");
  4900.     x = -9;
  4901.     goto xsendx;
  4902.     }
  4903.     n = 0;                /* /MAIL or /PRINT? */
  4904.     if (pv[SND_MAI].ival > 0)
  4905.       n = SND_MAI;
  4906.     else if (pv[SND_PRI].ival > 0)
  4907.       n = SND_PRI;
  4908.     if (n) {                /* Yes... */
  4909. #ifdef DEBUG
  4910.     char * p;
  4911.     if (n == SND_MAI)
  4912.       p = "/MAIL";
  4913.     else
  4914.       p = "/PRINT";
  4915.     debug(F111,"xsend",p,n);
  4916. #endif /* DEBUG */
  4917. #ifdef CK_XYZ
  4918.     if (protocol != PROTO_K) {
  4919.         printf("Sorry, %s available only with Kermit protocol\n",
  4920.            (n == SND_MAI) ? "/MAIL" : "/PRINT"
  4921.            );
  4922.         x = -9;
  4923.         goto xsendx;
  4924.     }
  4925. #endif /* CK_XYZ */
  4926.     debug(F101,"xsend print/mail wild","",wild);
  4927.     *optbuf = NUL;            /* Wipe out any old options */
  4928.     s = pv[n].sval;            /* mail address or print switch val */
  4929.     if (!s) s = "";
  4930.     debug(F110,"doxsend mail address or printer options",s,0);
  4931.     if (n == SND_MAI && !*s) {
  4932.         printf("?E-mail address required\n");
  4933.         x = -9;
  4934.         goto xsendx;
  4935.     } else if ((int)strlen(s) > 94) { /* Ensure legal size */
  4936.         printf("?%s too long\n",
  4937.            (n == SND_MAI) ?
  4938.            "E-mail address" :
  4939.            "Print option string"
  4940.            );
  4941.         x = -9;
  4942.         goto xsendx;
  4943.     }
  4944.     ckstrncpy(optbuf,s,OPTBUFLEN);    /* OK, copy to option buffer */
  4945.     cmarg = line;            /* File to send */
  4946.     if (n == SND_MAI) {
  4947.         debug(F110,"xsend mailing",cmarg,0);
  4948.         debug(F110,"xsend address:",optbuf,0);
  4949.         rmailf = 1;
  4950.     } else {
  4951.         debug(F110,"xsend printing",cmarg,0);
  4952.         debug(F110,"xsend options",optbuf,0);
  4953.         rprintf = 1;
  4954.     }
  4955.     }
  4956. #endif /* NOFRILLS */
  4957.  
  4958. #ifdef CALIBRATE
  4959.     if (pv[SND_CAL].wval > 0) {        /* Handle /CALIBRATE */
  4960.     if (confirmed) {
  4961.         calibrate = pv[SND_CAL].wval * (CK_OFF_T)1024;
  4962.         sndsrc = -9;
  4963.         nfils = 1;
  4964.         wild = 0;
  4965. #ifndef NOMSEND
  4966.         addlist = 0;
  4967. #endif /* NOMSEND */
  4968.         ckstrncpy(line,"CALIBRATION",LINBUFSIZ);
  4969.         s = cmarg = line;
  4970.         if (!cmarg2) cmarg2 = "";
  4971.         debug(F110,"doxsend cmarg2 calibrate",cmarg2,0);
  4972.     } else if (line[0]) {
  4973.         calibrate = 0;
  4974.         pv[SND_CAL].ival = 0;
  4975.         pv[SND_CAL].wval = 0;
  4976.     }
  4977.     }
  4978. #endif /* CALIBRATE */
  4979.  
  4980.     if (pv[SND_FIL].ival > 0) {
  4981.     if (confirmed && !calibrate) {
  4982.         if (zopeni(ZMFILE,pv[SND_FIL].sval) < 1) {
  4983.         debug(F110,"xsend can't open",pv[SND_FIL].sval,0);
  4984.         printf("?Failure to open %s\n",filefile);
  4985.         x = -9;
  4986.         goto xsendx;
  4987.         }
  4988.         makestr(&filefile,pv[SND_FIL].sval); /* Open, remember name */
  4989.         debug(F110,"xsend opened",filefile,0);
  4990.         wild = 1;
  4991.     }
  4992.     }
  4993.  
  4994.     /* SEND alone... */
  4995.  
  4996. #ifndef NOSPL
  4997.     if (confirmed && pv[SND_ARR].ival > 0) {
  4998.     if (!*cmarg2) {
  4999.         sndxnam[7] = (char)((arrayx == 1) ? 64 : arrayx + ARRAYBASE);
  5000.         cmarg2 = sndxnam;
  5001.     }
  5002.     cmarg = "";
  5003.     goto sendend;
  5004.     }
  5005. #endif /* NOSPL */
  5006.  
  5007.     if (confirmed && !line[0] && !filefile && !calibrate) {
  5008. #ifndef NOMSEND
  5009.     if (filehead) {            /* OK if we have a SEND-LIST */
  5010.         nfils = filesinlist;
  5011.         sndsrc = nfils;        /* Like MSEND */
  5012.         addlist = 1;        /* But using a different list... */
  5013.         filenext = filehead;
  5014.         goto sendend;
  5015.     }
  5016. #endif /* NOMSEND */
  5017.     printf("?Filename required but not given\n");
  5018.     x = -9;
  5019.     goto xsendx;
  5020.     }
  5021.  
  5022.     /* Not send-list or array */
  5023.  
  5024. #ifndef NOMSEND
  5025.     addlist = 0;            /* Don't use SEND-LIST. */
  5026.     filenext = NULL;
  5027. #endif /* NOMSEND */
  5028.  
  5029.     if (mlist) {            /* MSEND or MMOVE */
  5030. #ifndef NOMSEND
  5031.     cmlist = msfiles;        /* List of files to send */
  5032.     sndsrc = nfils;
  5033.     cmarg2 = "";
  5034.     sendstart = (CK_OFF_T)0;
  5035. #endif /* NOMSEND */
  5036. #ifdef PIPESEND
  5037.     pipesend = 0;
  5038. #endif /* PIPESEND */
  5039.     } else if (filefile) {        /* File contains list of filenames */
  5040.     s = "";
  5041.     cmarg = "";
  5042.     cmarg2 = "";
  5043.     line[0] = NUL;
  5044.     nfils = 1;
  5045.     sndsrc = 1;
  5046.  
  5047.     } else if (!calibrate && pv[SND_ARR].ival < 1 && pv[SND_CMD].ival < 1) {
  5048.  
  5049.     nfils = sndsrc = -1;    /* Not MSEND, MMOVE, /LIST, or /ARRAY */
  5050.     if (                /* or /COMMAND */
  5051.  
  5052. #ifndef NOFRILLS
  5053.         !rmailf && !rprintf        /* Not MAIL or PRINT */
  5054. #else
  5055.         1
  5056. #endif /* NOFRILLS */
  5057.         ) {
  5058.         CK_OFF_T y = (CK_OFF_T)1;
  5059.         if (!wild)
  5060.           y = zchki(s);
  5061.         if (y < (CK_OFF_T)0) {
  5062.         printf("?Read access denied - \"%s\"\n", s);
  5063.         x = -9;
  5064.         goto xsendx;
  5065.         }
  5066.         if (s != line)        /* We might already have done this. */
  5067.           ckstrncpy(line,s,LINBUFSIZ); /* Copy of string just parsed. */
  5068.         else
  5069.           debug(F110,"doxsend line=s",line,0);
  5070.         cmarg = line;        /* File to send */
  5071.     }
  5072.     zfnqfp(cmarg,fspeclen,fspec);
  5073.     }
  5074.     if (!mlist) {            /* For all but MSEND... */
  5075. #ifdef PIPESEND
  5076.     if (pv[SND_CMD].ival > 0)    /* /COMMAND sets pipesend flag */
  5077.       pipesend = 1;
  5078.     debug(F101,"xsend /COMMAND pipesend","",pipesend);
  5079.     if (pipesend && filefile) {
  5080.         printf("?Invalid switch combination\n");
  5081.         x = -9;
  5082.         goto xsendx;
  5083.     }
  5084. #endif /* PIPESEND */
  5085.  
  5086. #ifndef NOSPL
  5087.     /* If as-name given and filespec is wild, as-name must contain variables */
  5088.     debug(F111,"doxsend cmarg2 wild",cmarg2,wild);
  5089.     if (wild && *cmarg2) {
  5090.         char * s = tmpbuf;
  5091.         x = TMPBUFSIZ;
  5092.         zzstring(cmarg2,&s,&x);
  5093.         if (!strcmp(tmpbuf,cmarg2)) {
  5094.         printf(
  5095.     "?As-name for file group must contain variables such as \\v(filename)\n"
  5096.                );
  5097.         x = -9;
  5098.         goto xsendx;
  5099.         }
  5100.     }
  5101. #endif /* NOSPL */
  5102.  
  5103.     /* Strip braces from as-name */
  5104.     debug(F110,"xsend cmarg2 before stripping",cmarg2,0);
  5105.     cmarg2 = brstrip(cmarg2);
  5106.     debug(F110,"xsend filename",cmarg,0);
  5107.     debug(F110,"xsend as-name",cmarg2,0);
  5108.  
  5109.     /* Copy as-name to a safe place */
  5110.  
  5111.     if (asnbuf) {
  5112.         free(asnbuf);
  5113.         asnbuf = NULL;
  5114.     }
  5115.     if ((y = strlen(cmarg2)) > 0) {
  5116.         asnbuf = (char *) malloc(y + 1);
  5117.         if (asnbuf) {
  5118.         strcpy(asnbuf,cmarg2);    /* safe */
  5119.         cmarg2 = asnbuf;
  5120.         } else cmarg2 = "";
  5121.     }
  5122.  
  5123. #ifdef CK_RESEND
  5124.     debug(F111,"xsend pv[SND_STA].ival","",pv[SND_STA].ival);
  5125.     if (pv[SND_STA].wval > (CK_OFF_T)-1) { /* /START position */
  5126.         if (wild) {
  5127.         printf("?/STARTING-AT may not be used with multiple files.\n");
  5128.         x = -9;
  5129.         goto xsendx;
  5130.         } else
  5131.           sendstart = pv[SND_STA].wval;
  5132.     } else
  5133.       sendstart = (CK_OFF_T)0;
  5134.     debug(F101,"xsend /STARTING","",sendstart);
  5135. #endif /* CK_RESEND */
  5136.     }
  5137.  
  5138. sendend:                /* Common successful exit */
  5139.     moving = 0;
  5140.     if (pv[SND_SHH].ival > 0) {        /* SEND /QUIET... */
  5141.     g_displa = fdispla;
  5142.     fdispla = 0;
  5143.     debug(F101,"xsend display","",fdispla);
  5144.     }
  5145.  
  5146. #ifndef NOSPL                /* SEND /ARRAY... */
  5147.     if (pv[SND_ARR].ival > 0) {
  5148.     if (!ap) { x = -2; goto xsendx; } /* (shouldn't happen) */
  5149.     if (range[0] == -1)        /* If low end of range not specified */
  5150.       range[0] = 1;            /* default to 1 */
  5151.     if (range[1] == -1)        /* If high not specified */
  5152.       range[1] = a_dim[arrayx];    /* default to size of array */
  5153.     if ((range[0] < 0) ||        /* Check range */
  5154.         (range[0] > a_dim[arrayx]) ||
  5155.         (range[1] < range[0]) ||
  5156.         (range[1] > a_dim[arrayx])) {
  5157.         printf("?Bad array range - [%d:%d]\n",range[0],range[1]);
  5158.         x = -9;
  5159.         goto xsendx;
  5160.     }
  5161.     sndarray = ap;            /* Array pointer */
  5162.     sndxin = arrayx;        /* Array index */
  5163.     sndxlo = range[0];        /* Array range */
  5164.     sndxhi = range[1];
  5165.     sndxnam[7] = (char)((sndxin == 1) ? 64 : sndxin + ARRAYBASE);
  5166.  
  5167. #ifdef COMMENT
  5168.     printf("SENDING FROM ARRAY: &%c[]...\n", /* debugging */
  5169.            (sndxin == 1) ? 64 : sndxin + ARRAYBASE);
  5170.     printf("Lo=%d\nHi=%d\n", sndxlo, sndxhi);
  5171.     printf("cmarg=[%s]\ncmarg2=[%s]\n", cmarg, cmarg2);
  5172.     while ((x = agnbyte()) > -1) {
  5173.         putchar((char)x);
  5174.     }
  5175.     return(1);
  5176. #endif /* COMMENT */
  5177.     }
  5178. #endif /* NOSPL */
  5179.  
  5180.     if (pv[SND_ARR].ival < 1) {        /* File selection & disposition... */
  5181.  
  5182.     if (pv[SND_DEL].ival > 0)    /* /DELETE was specified */
  5183.       moving = 1;
  5184.     debug(F101,"xsend /DELETE","",moving);
  5185.     if (pv[SND_AFT].ival > 0)    /* Copy SEND criteria */
  5186.       ckstrncpy(sndafter,pv[SND_AFT].sval,19);
  5187.     if (pv[SND_BEF].ival > 0)
  5188.       ckstrncpy(sndbefore,pv[SND_BEF].sval,19);
  5189.     if (pv[SND_NAF].ival > 0)
  5190.       ckstrncpy(sndnafter,pv[SND_NAF].sval,19);
  5191.     if (pv[SND_NBE].ival > 0)
  5192.       ckstrncpy(sndnbefore,pv[SND_NBE].sval,19);
  5193.     if (pv[SND_EXC].ival > 0)
  5194.       makelist(pv[SND_EXC].sval,sndexcept,NSNDEXCEPT);
  5195.     if (pv[SND_SMA].wval > (CK_OFF_T)-1)
  5196.       sndsmaller = pv[SND_SMA].wval;
  5197.     if (pv[SND_LAR].wval > (CK_OFF_T)-1)
  5198.       sndlarger = pv[SND_LAR].wval;
  5199.     if (pv[SND_NAM].ival > -1) {
  5200.         g_fncnv = fncnv;        /* Save global value */
  5201.         fncnv = pv[SND_NAM].ival;
  5202.         debug(F101,"xsend fncnv","",fncnv);
  5203.     }
  5204.     if (pv[SND_PTH].ival > -1) {
  5205.         g_spath = fnspath;        /* Save global values */
  5206.         fnspath = pv[SND_PTH].ival;
  5207. #ifndef NZLTOR
  5208.         if (fnspath != PATH_OFF) {
  5209.         g_fncnv = fncnv;    /* Bad bad... */
  5210.         fncnv = XYFN_C;
  5211.         }
  5212. #endif /* NZLTOR */
  5213.         debug(F101,"xsend fnspath","",fnspath);
  5214.         debug(F101,"xsend fncnv","",fncnv);
  5215.     }
  5216.     }
  5217.  
  5218. #ifdef PIPESEND
  5219.     if (pv[SND_FLT].ival > 0) {
  5220.     makestr(&sndfilter,pv[SND_FLT].sval);
  5221.     debug(F110,"xsend /FILTER", sndfilter, 0);
  5222.     }
  5223. #endif /* PIPESEND */
  5224.  
  5225. #ifdef CK_APC
  5226. /* MOVE not allowed in APCs */
  5227.     if (moving &&
  5228.     (apcactive == APC_LOCAL || apcactive == APC_REMOTE)
  5229.     && !(apcstatus & APC_UNCH))
  5230.       return(success = 0);
  5231. #endif /* CK_APC */
  5232. #ifdef IKS_OPTION
  5233.     if (
  5234. #ifdef CK_XYZ
  5235.         protocol == PROTO_K &&
  5236. #endif /* CK_XYZ */
  5237.         !iks_wait(KERMIT_REQ_START,1)) {
  5238.         printf("?A Kermit Server is not available to process this command.\n");
  5239.         printf("?Start a RECEIVE command to complement this command.\n");
  5240.     }
  5241. #endif /* IKS_OPTION */
  5242.  
  5243. #ifdef IKSD
  5244. #ifdef CK_LOGIN
  5245.     if (moving && inserver && isguest) {
  5246.         printf("?File deletion not allowed for guests.\n");
  5247.     return(-9);
  5248.     }
  5249. #endif /* CK_LOGIN */
  5250. #endif /* IKSD */
  5251.  
  5252.     sstate = 's';            /* Set start state to SEND */
  5253.     sndcmd = 1;
  5254. #ifdef CK_RESEND
  5255.     if (pv[SND_RES].ival > 0)        /* Send sendmode appropriately */
  5256.       sendmode = SM_RESEND;
  5257.     else if (pv[SND_STA].ival > 0)
  5258.       sendmode = SM_PSEND;
  5259.     else
  5260. #endif /* CK_RESEND */
  5261.     if (mlist)
  5262.       sendmode = SM_MSEND;
  5263.     else
  5264.       sendmode = SM_SEND;
  5265. #ifdef MAC
  5266.     what = W_SEND;
  5267.     scrcreate();
  5268. #endif /* MAC */
  5269.     if (local && pv[SND_SHH].ival != 0) { /* If in local mode, */
  5270.     displa = 1;            /* turn on file transfer display */
  5271.     }
  5272.     x = 0;
  5273.  
  5274.   xsendx:                /* Common exit, including failure */
  5275.     debug(F101,"doxsend sndsrc","",sndsrc);
  5276.     for (i = 0; i <= SND_MAX; i++) {    /* Free malloc'd memory */
  5277.     if (pv[i].sval)
  5278.       free(pv[i].sval);
  5279.     }
  5280.     return(x);
  5281. }
  5282. #endif /* NOXFER */
  5283.  
  5284. #ifndef NOLOCAL
  5285. /*  D O X C O N N  --  CONNECT command parsing with switches */
  5286.  
  5287. #ifdef XLIMITS
  5288. #define XLIMORTRIGGER
  5289. #else
  5290. #ifdef CK_TRIGGER
  5291. #define XLIMORTRIGGER
  5292. #endif /* CK_TRIGGER */
  5293. #endif /*  XLIMITS */
  5294.  
  5295. #ifdef CKTIDLE
  5296. int tt_idlelimit = 0;            /* Terminal idle limit */
  5297. int tt_idleact = IDLE_RET;        /* Terminal idle action */
  5298. #endif /* CKTIDLE */
  5299.  
  5300. #ifdef OS2                /* K95 only: */
  5301. extern int
  5302.   tt_idlesnd_tmo;            /*   Idle interval */
  5303. int tt_timelimit = 0;            /*   Time limit, 0 = none */
  5304. extern char *                /* Parse results - strings: */
  5305.   tt_idlesnd_str;            /*   Idle string */
  5306. #endif /* OS2 */
  5307.  
  5308. #ifdef CK_TRIGGER
  5309. extern char *tt_trigger[];
  5310. extern CHAR *tt_trmatch[];
  5311. extern char *triggerval;
  5312. static char *g_tt_trigger[TRIGGERS];
  5313. #endif /* CK_TRIGGER */
  5314.  
  5315. #ifdef OS2
  5316. static int g_tt_idlesnd_tmo, g_tt_timelimit; /* For saving and restoring */
  5317. static int g_tt_idlelimit, g_tt_saved = 0;
  5318. static char * g_tt_idlesnd_str;        /* global settings */
  5319. #endif /* OS2 */
  5320.  
  5321. static struct stringint pv[CONN_MAX+1];
  5322.  
  5323. VOID
  5324. resconn() {
  5325.     int i;
  5326.  
  5327. #ifdef OS2
  5328.     if ( g_tt_saved ) {
  5329.         tt_idlelimit   = g_tt_idlelimit;
  5330.         tt_idlesnd_tmo = g_tt_idlesnd_tmo;
  5331.         tt_timelimit   = g_tt_timelimit;
  5332.         tt_idlesnd_str = g_tt_idlesnd_str;
  5333.         g_tt_saved = 0;
  5334.     }
  5335. #endif /* OS2 */
  5336.  
  5337. #ifdef CK_TRIGGER
  5338.     for (i = 0; i < TRIGGERS; i++)
  5339.       tt_trigger[i] = g_tt_trigger[i];
  5340. #endif /* CK_TRIGGER */
  5341.  
  5342.     for (i = 0; i <= CONN_MAX; i++) {    /* Free malloc'd memory */
  5343.     if (pv[i].sval)
  5344.       free(pv[i].sval);
  5345.         pv[i].sval = NULL;
  5346.     }
  5347. }
  5348.  
  5349. int
  5350. doxconn(cx) int cx; {
  5351.     int c, i, n;            /* Workers */
  5352.     int x, y;
  5353.     int getval = 0;            /* Whether to get switch value */
  5354.     int async = 0;                      /* Make an async connect */
  5355.     struct FDB sw, cm;            /* FDBs for each parse function */
  5356.     extern FILE * tfile[];
  5357.     extern char * macp[];
  5358.  
  5359. #ifdef OS2
  5360.     g_tt_idlesnd_tmo = tt_idlesnd_tmo;    /* Save global settings */
  5361.     g_tt_timelimit   = tt_timelimit;
  5362.     g_tt_idlelimit   = tt_idlelimit;
  5363.     g_tt_idlesnd_str = tt_idlesnd_str;
  5364.     g_tt_saved = 1;
  5365. #endif /* OS2 */
  5366.  
  5367. #ifdef CK_TRIGGER
  5368.     if (!tt_trigger[0]) {        /* First initialization */
  5369.     for (i = 1; i < TRIGGERS; i++)
  5370.       tt_trigger[i] = NULL;
  5371.     }
  5372.     for (i = 0; i < TRIGGERS; i++)
  5373.       g_tt_trigger[i] = tt_trigger[i];
  5374.     if (triggerval) {
  5375.     free(triggerval);
  5376.     triggerval = NULL;
  5377.     }
  5378. #endif /* CK_TRIGGER */
  5379.  
  5380.     for (i = 0; i <= CONN_MAX; i++) {    /* Initialize switch values */
  5381.     pv[i].sval = NULL;        /* to null pointers */
  5382.     pv[i].ival = -1;        /* and -1 int values */
  5383.     pv[i].wval = (CK_OFF_T)-1;
  5384.     }
  5385.     if (cx == XXCQ)            /* CQ == CONNECT /QUIETLY */
  5386.       pv[CONN_NV].ival = 1;
  5387.  
  5388.     /* Set up chained parse functions... */
  5389.  
  5390.     cmfdbi(&sw,                /* First FDB - command switches */
  5391.        _CMKEY,            /* fcode */
  5392.        "Switch",            /* hlpmsg */
  5393.        "",                /* default */
  5394.        "",                /* addtl string data */
  5395.        nconntab,            /* addtl numeric data 1: tbl size */
  5396.        4,                /* addtl numeric data 2: 4 = cmswi */
  5397.        xxstring,            /* Processing function */
  5398.        conntab,            /* Keyword table */
  5399.        &cm                /* Pointer to next FDB */
  5400.        );
  5401.     cmfdbi(&cm,                /* 2nd FDB - Confirmation */
  5402.        _CMCFM,            /* fcode */
  5403.        "",                /* hlpmsg */
  5404.        "",                /* default */
  5405.        "",                /* addtl string data */
  5406.        0,                /* addtl numeric data 1 */
  5407.        0,                /* addtl numeric data 2 */
  5408.        NULL,
  5409.        NULL,
  5410.        NULL
  5411.        );
  5412.  
  5413.     while (1) {                /* Parse 0 or more switches */
  5414.     x = cmfdb(&sw);            /* Parse switch or confirmation */
  5415.     debug(F101,"doxconn cmfdb","",x);
  5416.     if (x < 0) {            /* Error */
  5417.         if (x == -9 || x == -2)
  5418.           printf("?No switches match - \"%s\"\n",atmbuf);
  5419.         goto xconnx;        /* or reparse needed */
  5420.     }
  5421.     if (cmresult.fcode != _CMKEY)    /* Break out if not a switch */
  5422.       break;
  5423.     c = cmgbrk();            /* Get break character */
  5424.     getval = (c == ':' || c == '='); /* to see how they ended the switch */
  5425.     if (getval && !(cmresult.kflags & CM_ARG)) {
  5426.         printf("?This switch does not take arguments\n");
  5427.         x = -9;
  5428.         goto xconnx;
  5429.     }
  5430.     if (!getval && (cmgkwflgs() & CM_ARG)) {
  5431.         printf("?This switch requires an argument\n");
  5432.         return(-9);
  5433.     }
  5434.     n = cmresult.nresult;        /* Numeric result = switch value */
  5435.     debug(F101,"doxconn switch","",n);
  5436.  
  5437.     switch (n) {            /* Process the switch */
  5438. #ifdef OS2
  5439.       case CONN_AS:            /* Asynchronous */
  5440.             pv[CONN_AS].ival = 1;
  5441.             pv[CONN_SY].ival = 0;
  5442.             break;
  5443.           case CONN_SY:                 /* Synchronous */
  5444.             pv[CONN_SY].ival = 1;
  5445.             pv[CONN_AS].ival = 0;
  5446.             break;
  5447. #endif /* OS2 */
  5448.       case CONN_NV:            /* Non-verbal */
  5449.         pv[n].ival = 1;
  5450.         break;
  5451. #ifdef XLIMITS
  5452.       case CONN_II:            /* Idle-interval */
  5453.       case CONN_IL:            /* Idle-limit */
  5454.       case CONN_TL:            /* Time-limit */
  5455.         if (!getval) break;
  5456.         if ((x = cmnum("Seconds","0",10,&y,xxstring)) < 0)
  5457.           goto xconnx;
  5458.         pv[n].ival = y;
  5459.         break;
  5460.       case CONN_IS:            /* Idle-string */
  5461. #endif /* XLIMITS */
  5462. #ifdef CK_TRIGGER
  5463.       case CONN_TS:            /* Trigger-string */
  5464. #endif /* CK_TRIGGER */
  5465. #ifdef XLIMORTRIGGER
  5466.         if (!getval) break;
  5467.         if ((x = cmfld("String (enclose in braces if it contains spaces)",
  5468.                "",&s,xxstring)) < 0) {
  5469.         if (x == -3) {
  5470.             printf("?String required\n");
  5471.             x = -9;
  5472.         }
  5473.         goto xconnx;
  5474.         }
  5475.         if (n != CONN_TS)
  5476.           s = brstrip(s);
  5477.         if ((y = strlen(s)) > 0) {
  5478.         if (pv[n].sval) free(pv[n].sval);
  5479.         pv[n].sval = malloc(y+1);
  5480.         if (pv[n].sval) {
  5481.             strcpy(pv[n].sval,s); /* safe */
  5482.             pv[n].ival = 1;
  5483.         }
  5484.         }
  5485.         break;
  5486. #endif /* XLIMORTRIGGER */
  5487.       default:
  5488.         printf("?Unexpected switch value - %d\n",cmresult.nresult);
  5489.         x = -9;
  5490.         goto xconnx;
  5491.     }
  5492.     }
  5493.     debug(F101,"doxconn cmresult.fcode","",cmresult.fcode);
  5494.     if (cmresult.fcode != _CMCFM) {
  5495.     printf("?Unexpected function code: %d\n",cmresult.fcode);
  5496.     x = -9;
  5497.     goto xconnx;
  5498.     }
  5499.  
  5500.     /* Command was confirmed so we can pre-pop command level. */
  5501.     /* This is so CONNECT module won't think we're executing a script */
  5502.     /* if CONNECT was the final command in the script. */
  5503.  
  5504.     if (cmdlvl > 0)
  5505.       prepop();
  5506.  
  5507. #ifdef OS2                /* Make results available globally */
  5508.     if (pv[CONN_IL].ival > -1)        /* Idle limit */
  5509.       tt_idlelimit = pv[CONN_IL].ival;
  5510.     if (pv[CONN_II].ival > -1)        /* Idle limit */
  5511.       tt_idlesnd_tmo = pv[CONN_II].ival;
  5512.     if (pv[CONN_IS].sval)        /* Idle string */
  5513.       if (tt_idlesnd_str = (char *)malloc((int)strlen(pv[CONN_IS].sval)+1))
  5514.     strcpy(tt_idlesnd_str,pv[CONN_IS].sval); /* safe */
  5515.     if (pv[CONN_TL].ival > -1)        /* Session limit */
  5516.       tt_timelimit = pv[CONN_TL].ival;
  5517.     async = (pv[CONN_AS].ival > 0 ||
  5518.              pv[CONN_SY].ival <= 0 && cmdlvl == 0) ? 1 : 0;
  5519. #endif /* OS2 */
  5520.  
  5521. #ifdef CK_TRIGGER
  5522.     if (pv[CONN_TS].sval)        /* Trigger strings */
  5523.       makelist(pv[CONN_TS].sval,tt_trigger,TRIGGERS);
  5524.     for (i = 0; i < TRIGGERS; i++)    /* Trigger match pointers */
  5525.       tt_trmatch[i] = NULL;
  5526.     if (triggerval) {            /* Reset trigger value */
  5527.     free(triggerval);
  5528.     triggerval = NULL;
  5529.     }
  5530. #endif /* CK_TRIGGER */
  5531.  
  5532. #ifdef SSHCMD
  5533. /*
  5534.   2010/03/01...
  5535.   The previous connection was through the external ssh client and now, with
  5536.   that connection closed, the user says "connect" and expects a new connection
  5537.   to be made to the same host, because that's how all the other connection
  5538.   methods work, so (and this is quite a hack)...
  5539. */
  5540.     if (!ckstrcmp("ssh ",ttname,4,0)) {    /* Previous "host" was "ssh blah" */
  5541.     _PROTOTYP (int redossh, ( void ) );
  5542.     extern int ttyfd;
  5543.     if (ttyfd < 0) {        /* And connection is no longer open */
  5544.         int xx;
  5545.         xx = redossh();        /* So redo the SSH connection */
  5546.         if (xx < 0) return(xx);
  5547.         goto xconnx;
  5548.     }
  5549.     }
  5550. #endif    /* SSHCMD */
  5551.     x = doconect((pv[CONN_NV].ival > 0) ? 1 : 0, async);
  5552.     {
  5553.     int xx;
  5554.     debug(F101,"doxconn doconect returns","",x);
  5555.     if ((xx = ttchk()) < 0) dologend();
  5556.     debug(F101,"doxconn ttchk returns","",xx);
  5557.     }
  5558.  
  5559. #ifdef CK_TRIGGER
  5560.     debug(F111,"doxconn doconect triggerval",triggerval,x);
  5561. #endif /* CK_TRIGGER */
  5562.  
  5563.   xconnx:
  5564.     /* Back from CONNECT -- Restore global settings */
  5565.  
  5566.     if (!async)
  5567.       resconn();
  5568.  
  5569.     success = (x > 0) ? 1 : 0;
  5570.     return(x);
  5571. }
  5572. #endif /* NOLOCAL */
  5573.  
  5574. #ifdef ADDCMD
  5575. /* cx == XXADD or XXREMV */
  5576. /* fc == ADD_BIN or ADD_TXT */
  5577. static int
  5578. doadd(cx,fc) int cx, fc; {
  5579. #ifdef PATTERNS
  5580.     char * tmp[FTPATTERNS];
  5581.     char **p = NULL;
  5582.     int i, j, k, n = 0, x = 0, last;
  5583.  
  5584. #endif /* PATTERNS */
  5585.     if (cx != XXADD && cx != XXREMV) {
  5586.     printf("?Unexpected function code: %d\n",cx);
  5587.     return(-9);
  5588.     }
  5589. #ifdef PATTERNS
  5590.     while (n < FTPATTERNS) {        /* Collect new patterns */
  5591.     tmp[n] = NULL;
  5592.     if ((x = cmfld("Pattern","",&s,xxstring)) < 0)
  5593.       break;
  5594.     ckstrncpy(line,s,LINBUFSIZ);
  5595.     s = brstrip(line);
  5596.     makestr(&(tmp[n++]),s);
  5597.     }
  5598.     if (x == -3)
  5599.       x = cmcfm();
  5600.     if (x < 0)
  5601.       goto xdoadd;
  5602.     p = (fc == ADD_BIN) ? binpatterns : txtpatterns; /* Which list */
  5603.     last = 0;
  5604.     for (i = 0; i < FTPATTERNS; i++) { /* Find last one in list */
  5605.     if (!p[i]) {
  5606.         last = i;
  5607.         break;
  5608.     }
  5609.     }
  5610.     if (cx == XXADD) {            /* Adding */
  5611.     if (last + n > FTPATTERNS) {    /* Check if too many */
  5612.         printf("?Too many patterns - %d is the maximum\n", FTPATTERNS);
  5613.         goto xdoadd;
  5614.     }
  5615.         for (i = 0; i < n; i++) {        /* Copy in the new ones. */
  5616.           for (j = 0, x = 0; x == 0 && j < last ; j++ )
  5617.             x = !ckstrcmp(tmp[i],p[j],-1,filecase); /* match */
  5618.           if (x == 0)
  5619.             makestr(&(p[last++]),tmp[i]);
  5620.         }
  5621.         makestr(&(p[last]),NULL);    /* Null-terminate the list */
  5622.         x = 1;
  5623.         goto xdoadd;                    /* Done */
  5624.     } else if (cx == XXREMV) {        /* Remove something(s) */
  5625.     int j, k;
  5626.     if (last == 0)                    /* List is empty */
  5627.       goto xdoadd;                    /* Nothing to remove */
  5628.     for (i = 0; i < n; i++) {            /* i = Patterns they typed */
  5629.         for (j = 0; j < last; j++) {        /* j = Patterns in list */
  5630.         /* Change this to ckstrcmp()... */
  5631.         if (filecase)
  5632.                   x = !ckstrcmp(tmp[i],p[j],-1,filecase); /* match */
  5633.         else
  5634.           x = ckstrcmp(tmp[i],p[j],-1,0); /* Case-independent match */
  5635.         if (x) {                    /* This one matches */
  5636.             makestr(&(p[j]),NULL);      /* Free it */
  5637.             for (k = j; k < last; k++)  /* Move the rest up */
  5638.               p[k] = p[k+1];
  5639.             p[k] = NULL;            /* Erase last one */
  5640.             if (!p[k])
  5641.               break;
  5642.         }
  5643.         }
  5644.     }
  5645.     }
  5646.   xdoadd:                /* Common exit */
  5647.     for (i = 0; i < n; i++)
  5648.       if (tmp[i])
  5649.     free(tmp[i]);
  5650.     return(x);
  5651. #endif /* PATTERNS */
  5652. }
  5653.  
  5654. /* ADD SEND-LIST */
  5655.  
  5656. static int
  5657. addsend(cx) int cx; {
  5658. #ifndef NOMSEND
  5659.     extern struct keytab fttab[];
  5660.     extern int nfttyp;
  5661.     struct filelist * flp;
  5662.     char * fmode = "";
  5663.     int xmode = 0;
  5664.     int xbinary = 0;
  5665. #endif /* NOMSEND */
  5666.  
  5667. #ifdef NOMSEND
  5668.     printf("?Sorry, ADD/REMOVE SEND-LIST not available.\n");
  5669.     return(-9);
  5670. #endif /* NOMSEND */
  5671.     if (cx == XXREMV) {
  5672.     printf("?Sorry, REMOVE SEND-LIST not implemented yet.\n");
  5673.     return(-9);
  5674.     }
  5675. #ifndef NOMSEND
  5676. #ifndef XYZ_INTERNAL
  5677.     if (protocol != PROTO_K) {
  5678.        printf("?Sorry, ADD SEND-LIST does not work with external protocols\n");
  5679.        return(-9);
  5680.     }
  5681. #endif /* XYZ_INTERNAL */
  5682.  
  5683.     x = cmifi("File specification to add","", &s,&y,xxstring);
  5684.     if (x < 0) {
  5685.     if (x == -3) {
  5686.         printf("?A file specification is required\n");
  5687.         return(-9);
  5688.     } else
  5689.       return(x);
  5690.     }
  5691.     ckstrncpy(tmpbuf,s,TMPBUFSIZ);
  5692.     s = tmpbuf;
  5693.     if (filesinlist == 0)        /* Take care of \v(filespec) */
  5694.       fspec[0] = NUL;
  5695.     zfnqfp(s,LINBUFSIZ,line);
  5696.     s = line;
  5697.     if (((int)strlen(fspec) + (int)strlen(s) + 1) < fspeclen) {
  5698.     strcat(fspec,s);        /* safe */
  5699.     strcat(fspec," ");        /* safe */
  5700.     } else
  5701.       printf("WARNING - \\v(filespec) buffer overflow\n");
  5702.  
  5703.  
  5704.     xbinary = binary;
  5705.     if ((patterns || filepeek)        /* FILE PATTERNS or SCAN is ON */
  5706. #ifdef CK_LABELED
  5707.     && binary != XYFT_L        /* And not if FILE TYPE LABELED */
  5708. #endif /* CK_LABELED */
  5709. #ifdef VMS
  5710.     && binary != XYFT_I        /* or FILE TYPE IMAGE */
  5711. #endif /* VMS */
  5712.     ) {
  5713.     int k, x;
  5714.     x = -1;
  5715.     k = scanfile(line,&x,nscanfile);
  5716.     if (k > 0) xbinary = (k == FT_BIN) ? XYFT_B : XYFT_T;
  5717.     }
  5718.     fmode = gfmode(xbinary,0);
  5719.     if ((x = cmkey(fttab,nfttyp,
  5720.            "type of file transfer", fmode, xxstring)) < 0)
  5721.       return(x);
  5722.     xmode = x;
  5723.  
  5724.     cmarg2 = "";
  5725.     if ((x = cmfld(y ?
  5726.   "\nAs-name template containing replacement variables such as \\v(filename)" :
  5727.   "Name to send it with", "",&s,NULL)) < 0)
  5728.       if (x != -3)
  5729.     return(x);
  5730. #ifndef NOSPL
  5731.     if (y && *s) {
  5732.     char * p = tmpbuf;
  5733.     x = TMPBUFSIZ;
  5734.     zzstring(s,&p,&x);
  5735.     if (!strcmp(tmpbuf,s)) {
  5736.         printf(
  5737.   "?As-name for file group must contain variables such as \\v(filename)\n"
  5738.            );
  5739.         return(-9);
  5740.     }
  5741.     }
  5742. #endif /* NOSPL */
  5743.     ckstrncpy(tmpbuf,s,TMPBUFSIZ);
  5744.     cmarg2 = tmpbuf;
  5745.  
  5746.     if ((x = cmcfm()) < 0)
  5747.       return(x);
  5748.     flp = (struct filelist *) malloc(sizeof(struct filelist));
  5749.     if (flp) {
  5750.     if (filetail)
  5751.       filetail->fl_next = flp;
  5752.     filetail = flp;
  5753.     if (!filehead)
  5754.       filehead = flp;
  5755.     x = (int) strlen(line);    /* Length of filename */
  5756.     s = (char *) malloc(x + 1);
  5757.     if (s) {
  5758.         strcpy(s,line);        /* safe */
  5759.         flp->fl_name = s;
  5760.         flp->fl_mode = xmode;
  5761.         x = (int) strlen(cmarg2);    /* Length of as-name */
  5762.         if (x < 1) {
  5763.         flp->fl_alias = NULL;
  5764.         } else {
  5765.         s = (char *) malloc(x + 1);
  5766.         if (s) {
  5767.             strcpy(s,cmarg2);    /* safe */
  5768.             flp->fl_alias = s;
  5769.         } else {
  5770.             printf("Sorry, can't allocate space for as-name");
  5771.             return(-9);
  5772.         }
  5773.         }
  5774.         flp->fl_next = NULL;
  5775.         filesinlist++;        /* Count this node */
  5776.         return(success = 1);    /* Finished adding this node */
  5777.     } else {
  5778.         printf("Sorry, can't allocate space for name");
  5779.         return(-9);
  5780.     }
  5781.     } else {
  5782.     printf("Sorry, can't allocate file list node");
  5783.     return(-9);
  5784.     }
  5785. #endif /* NOMSEND */
  5786. }
  5787. #endif /* ADDCMD */
  5788.  
  5789. #ifndef NOHTTP                /* HTTP ops... */
  5790. #ifdef TCPSOCKET
  5791. #define HTTP_GET 0            /* GET */
  5792. #define HTTP_PUT 1            /* PUT */
  5793. #define HTTP_POS 2            /* POST */
  5794. #define HTTP_IDX 3            /* INDEX */
  5795. #define HTTP_HED 4                      /* HEAD */
  5796. #define HTTP_DEL 5                      /* DELETE */
  5797. #define HTTP_CON 6                      /* CONNECT */
  5798. #define HTTP_OPN 7                      /* OPEN */
  5799. #define HTTP_CLS 8                      /* CLOSE */
  5800.  
  5801. static struct keytab httptab[] = {
  5802.     { "close",   HTTP_CLS, 0 },
  5803.     { "connect", HTTP_CON, 0 },
  5804.     { "delete",  HTTP_DEL, 0 },
  5805.     { "get",     HTTP_GET, 0 },
  5806.     { "head",    HTTP_HED, 0 },
  5807.     { "index",   HTTP_IDX, 0 },
  5808.     { "open",    HTTP_OPN, 0 },
  5809.     { "put",     HTTP_PUT, 0 },
  5810.     { "post",    HTTP_POS, 0 }
  5811. };
  5812. static int nhttptab = sizeof(httptab)/sizeof(struct keytab);
  5813.  
  5814. /* HTTP switches */
  5815. #define HT_SW_AG 0            /* /AGENT */
  5816. #define HT_SW_HD 1            /* /HEADER */
  5817. #define HT_SW_US 2            /* /USER */
  5818. #define HT_SW_PW 3            /* /PASSWORD */
  5819. #define HT_SW_AR 4                      /* /ARRAY */
  5820. #define HT_SW_TP 5                      /* /TOSCREEN */
  5821.  
  5822. static struct keytab httpswtab[] = {
  5823.     { "/agent",    HT_SW_AG, CM_ARG },
  5824. #ifndef NOSPL
  5825.     { "/array",    HT_SW_AR, CM_ARG },
  5826. #endif /* NOSPL */
  5827.     { "/header",   HT_SW_HD, CM_ARG },
  5828.     { "/password", HT_SW_PW, CM_ARG },
  5829.     { "/toscreen", HT_SW_TP, 0 },
  5830.     { "/user",     HT_SW_US, CM_ARG },
  5831.     { "", 0, 0 }
  5832. };
  5833. static int nhttpswtab = sizeof(httpswtab)/sizeof(struct keytab) - 1;
  5834.  
  5835. /* HTTP PUT/POST switches */
  5836. #define HT_PP_MT 0            /* /MIME-TYPE */
  5837.  
  5838. static struct keytab httpptab[] = {
  5839.     { "/mime-type", HT_PP_MT, CM_ARG },
  5840.     { "", 0, 0 }
  5841. };
  5842. static int nhttpptab = sizeof(httpptab)/sizeof(struct keytab) - 1;
  5843.  
  5844. #define HTTP_MAXHDR 8
  5845.  
  5846. static int
  5847. xdohttp(action, lfile, rf, dfile, agent, hdr, user, pass, mime, array, type)
  5848.     int action;
  5849.     char *lfile, *rf, *dfile, *agent, *hdr, *user, *pass, *mime, array;
  5850.     int type;
  5851. /* xdohttp */ {
  5852.     int i, rc = 0;
  5853.     char * hdrlist[HTTP_MAXHDR];
  5854.     char rfile[CKMAXPATH+1];
  5855.     extern int httpfd;
  5856.  
  5857.     /* Check for a valid state to execute the command */
  5858.     if (inserver) {
  5859.         printf("?The HTTP command may not be used from the IKS\r\n");
  5860.     } else if (httpfd == -1) {
  5861.         if (http_reopen() < 0)
  5862.       printf("?No connection\n");
  5863.         else
  5864.       rc = 1;
  5865.     } else {
  5866.     rc = 1;
  5867.     }
  5868.  
  5869.     /* If the command is not valid, exit with failure */
  5870.     if (rc == 0)
  5871.         return(success = 0);
  5872.  
  5873.     if (action != HTTP_CON && rf[0] != '/') {
  5874.         rfile[0] = '/';
  5875.         ckstrncpy(&rfile[1],rf,CKMAXPATH);
  5876.     } else {
  5877.         ckstrncpy(rfile,rf,CKMAXPATH);
  5878.     }
  5879.     for (i = 0; i < HTTP_MAXHDR; i++)    /* Initialize header list */
  5880.       hdrlist[i] = NULL;
  5881.     makelist(hdr,hdrlist,HTTP_MAXHDR);    /* Make header list */
  5882.  
  5883. #ifdef BETADEBUG
  5884.     for (i = 0; i < nhttptab; i++)    /* Find action keyword */
  5885.       if (httptab[i].kwval == action)
  5886.     break;
  5887.     if (i == nhttptab) {        /* Shouldn't happen... */
  5888.     printf("?Invalid action - %d\n",action);
  5889.     return(0);            /* Failure */
  5890.     }
  5891.  
  5892.     printf("HTTP action:  %s\n",httptab[i].kwd);
  5893.     printf(" Agent:       %s\n",agent ? agent : "(null)");
  5894.  
  5895.     if (hdrlist[1]) {
  5896.     printf(" Header list: 1. %s\n",hdrlist[0]);
  5897.     for (i = 1; i < HTTP_MAXHDR && hdrlist[i]; i++)
  5898.       printf("%15d. %s\n",i+1,hdrlist[i]);
  5899.     } else
  5900.       printf(" Header:      %s\n",hdrlist[0] ? hdrlist[0] : "(null)");
  5901.  
  5902.     printf(" User:        %s\n",user ? user : "(null)");
  5903. #ifdef COMMENT
  5904.     printf(" Password:    %s\n",pass ? pass : "(null)");
  5905. #endif /* COMMENT */
  5906.  
  5907. #ifndef NOSPL
  5908.     if (array)
  5909.       printf(" Array:       \\%%%c[]\n", array);
  5910.     else
  5911.       printf(" Array:       (none)\n");
  5912. #endif /* NOSPL */
  5913.  
  5914.     if (action == HTTP_PUT || action == HTTP_POS)
  5915.       printf(" Mime-type:   %s\n",mime ? mime : "(null)");
  5916.  
  5917.     printf(" Local file:  %s\n",lfile ? lfile : "(null)");
  5918.     printf(" Remote file: %s\n",rfile ? rfile : "(null)");
  5919.     printf(" Destination file: %s\n",dfile ? dfile : "(null)");
  5920. #endif /* BETADEBUG */
  5921.  
  5922.     /* The http_xxxx() functions return 0 on success, -1 on failure */
  5923.     switch (action) {
  5924.       case HTTP_CON: {
  5925.       extern int ttyfd;
  5926.       rc = http_connect(httpfd,agent,hdrlist,user,pass,array,rfile);
  5927.       break;
  5928.       }
  5929.       case HTTP_DEL:
  5930.         rc = http_delete(agent,hdrlist,user,pass,array,rfile);
  5931.         break;
  5932.       case HTTP_GET:
  5933.         rc = http_get(agent,hdrlist,user,pass,array,lfile,rfile,type);
  5934.         break;
  5935.       case HTTP_HED:
  5936.         rc = http_head(agent,hdrlist,user,pass,array,lfile,rfile,type);
  5937.         break;
  5938.       case HTTP_PUT:
  5939.         rc = http_put(agent,hdrlist,mime,user,pass,array,lfile,rfile,dfile,
  5940.               type);
  5941.         break;
  5942.       case HTTP_POS:
  5943.         rc = http_post(agent,hdrlist,mime,user,pass,array,lfile,rfile,dfile,
  5944.                type);
  5945.         break;
  5946.       case HTTP_IDX:
  5947.         rc = http_index(agent,hdrlist,user,pass,array,lfile,rfile,type);
  5948.         break;
  5949.       default:
  5950.         rc = -1;
  5951.     }
  5952.     return(rc == 0 ? 1 : 0);            /* Success is set by caller */
  5953. }
  5954. #endif /* TCPSOCKET */
  5955. #endif /* NOHTTP */
  5956.  
  5957. #ifndef NOSPL                /* ARRAY ops... */
  5958. static struct keytab arraytab[] = {
  5959.     { "clear",     ARR_CLR, 0 },
  5960.     { "copy",      ARR_CPY, 0 },
  5961.     { "dcl",       ARR_DCL, CM_INV },
  5962.     { "declare",   ARR_DCL, 0 },
  5963.     { "destroy",   ARR_DST, CM_INV },
  5964.     { "equate",    ARR_EQU, CM_INV },
  5965.     { "link",      ARR_EQU, 0 },
  5966.     { "resize",    ARR_RSZ, 0 },
  5967.     { "set",       ARR_SET, 0 },
  5968. #ifndef NOSHOW
  5969.     { "show",      ARR_SHO, 0 },
  5970. #endif /* NOSHOW */
  5971.     { "sort",      ARR_SRT, 0 },
  5972.     { "undeclare", ARR_DST, 0 },
  5973.     { "", 0, 0 }
  5974. };
  5975. static int narraytab = sizeof(arraytab)/sizeof(struct keytab) - 1;
  5976.  
  5977. #ifdef CKLEARN
  5978. static struct keytab learnswi[] = {
  5979.     { "/close",    2, 0 },
  5980.     { "/off",      0, 0 },
  5981.     { "/on",       1, 0 }
  5982. };
  5983. #endif /* CKLEARN */
  5984.  
  5985. int
  5986. arrayitoa(x) int x; {            /* Array index to array letter */
  5987.     if (x == 1)
  5988.       return(64);
  5989.     else if (x < 0 || x > (122 - ARRAYBASE))
  5990.       return(-1);
  5991.     else
  5992.       return(x + ARRAYBASE);
  5993. }
  5994.  
  5995. int
  5996. arrayatoi(c) int c; {            /* Array letter to array index */
  5997.     if (c == 64)
  5998.       c = 96;
  5999.     if (c > 63 && c < 91)
  6000.       c += 32;
  6001.     if (c < ARRAYBASE || c > 122)
  6002.       return(-1);
  6003.     return(c - ARRAYBASE);
  6004. }
  6005.  
  6006. static int                /* Declare an array */
  6007. dodcl(cx) int cx; {
  6008.     int i, n, v, lo, hi, rc = 0;
  6009.     int isdynamic = 0;
  6010.     char tmpbuf[64];
  6011.     char ** p = NULL;
  6012.     char tmp[64];            /* Local temporary string buffer */
  6013.     if ((y = cmfld("Array name","",&s,NULL)) < 0) { /* Parse array name */
  6014.     if (y == -3) {
  6015.         printf("?Array name required\n");
  6016.         return(-9);
  6017.     } else return(y);
  6018.     }
  6019.     ckstrncpy(line,s,LINBUFSIZ);
  6020.     s = line;
  6021.     x = arraybounds(s,&lo,&hi);        /* Check syntax and get bounds */
  6022.     debug(F111,"dodcl arraybounds",s,x);
  6023.     if (x < 0) {            /* Error - Maybe it's a variable */
  6024.     char * p;            /* whose value is an array name */
  6025.     int n;
  6026.     p = tmpbuf;
  6027.     n = 63;
  6028.     p[0] = NUL;
  6029.     if (s[0] == CMDQ && s[1] == '&')
  6030.       s++;
  6031.     if (zzstring(s,&p,&n) > -1) {
  6032.         s = tmpbuf;
  6033.         x = arraybounds(s,&lo,&hi);
  6034.         debug(F111,"dodcl arraybounds 2",s,x);
  6035.     }
  6036.     if (x < 0) {
  6037.         printf("?Bad array name - \"%s\"\n",s);
  6038.         return(-9);
  6039.     }
  6040.     }
  6041.     debug(F101,"dodcl hi","",hi);
  6042.     debug(F101,"dodcl lo","",lo);
  6043.     debug(F101,"dodcl lo+1","",lo+1);
  6044.  
  6045.     if (lo == -1 && hi == -1) {        /* Have good array name and bounds */
  6046.     isdynamic = 1;
  6047.     n = CMDBL / 5;
  6048.     } else if (hi > -1) {
  6049.     printf("?Segment notation not allowed in array declarations\n");
  6050.     return(-9);
  6051.     } else if ((lo+1) < 0) {
  6052.     debug(F101,"dodcl underflow","",lo+1);
  6053.         printf("?Dimension underflow\n");
  6054.         return(-9);
  6055.     } else
  6056.       n = lo;
  6057.     x = arrayitoa(x);
  6058.     if (cx == XXUNDCL) {
  6059.     n = 0;
  6060.     v = 0;
  6061.     if ((y = cmcfm()) < 0)
  6062.       return(y);
  6063.     } else {
  6064.     p = (char **)malloc(sizeof(char **)*(n+1));
  6065.     if (!p) {
  6066.         printf("?Memory allocation error\n");
  6067.         return(-9);
  6068.     }
  6069.     v = 0;                /* Highest initialized member */
  6070.     p[0] = NULL;            /* Element 0 */
  6071.     keepallchars = 1;
  6072.     while (n > 0 && v < n) {    /* Parse initializers */
  6073.         p[v+1] = NULL;
  6074.         ckmakxmsg(tmp,
  6075.               64,
  6076.               "Initial value for \\&",
  6077.               ckctoa((char)x),
  6078.               "[",
  6079.               ckitoa(v+1),
  6080.               "]",
  6081.               NULL,NULL,NULL,NULL,NULL,NULL,NULL
  6082.               );
  6083.         
  6084.         rc = cmfld((char *)tmp,"",&s,xxstring); /* Get field */
  6085.         if (rc < 0) {        /* Error... */
  6086.         if (rc == -3) {        /* Empty element */
  6087.             if (cmflgs == 1)    /* because end of line? */
  6088.               break;        /* Yes, done initializing */
  6089.             else        /* No, it's just empty */
  6090.               continue;        /* Go on to next one. */
  6091.         } else {        /* Other parse error */
  6092.             goto dclx;        /* Go free temp pointers */
  6093.         }
  6094.         }
  6095.         rc = 1;
  6096.         if (v == 0 && !strcmp(s,"=")) /* Skip the = sign. */
  6097.           continue;
  6098.         s = brstrip(s);        /* Strip any braces */
  6099.         makestr(&(p[++v]),s);
  6100.     }
  6101.     keepallchars = 0;
  6102.     if ((y = cmtxt("Carriage return to confirm","",&s,NULL)) < 0)
  6103.       return(y);
  6104.     if (isdynamic)
  6105.       n = v;
  6106.     }
  6107.     if (dclarray((char)x,n) < 0) {    /* Declare the array */
  6108.     printf("?Declare failed\n");
  6109.     goto dclx;
  6110.     }
  6111.     for (i = 1; i <= v; i++) {        /* Add any initial values */
  6112.     tmp[0] = '&';
  6113.     ckmakmsg(&tmp[1],63,ckctoa((char)x),"[",ckitoa(i),"]");
  6114.     if (addmac(tmp,p[i]) < 0) {
  6115.         printf("Array initialization error: %s %s\n",tmp,p[i]);
  6116.         rc = -9;
  6117.         goto dclx;
  6118.     }
  6119.     }
  6120.   dclx:
  6121.     if (p) {
  6122.     for (i = 1; i <= v; i++)
  6123.       if (p[i]) free(p[i]);
  6124.     free((char *)p);
  6125.     }
  6126.     debug(F101,"DCL rc","",rc);
  6127.     return(success = rc);
  6128. }
  6129.  
  6130. static int
  6131. rszarray() {
  6132.     int i, x, y, n, lo, hi, islink = -1;
  6133.     char c, * s, ** ap = NULL;
  6134.     if ((x = cmfld("Array name","",&s,NULL)) < 0) { /* Parse array name */
  6135.     if (x == -3) {
  6136.         printf("?Array name required\n");
  6137.         return(-9);
  6138.     } else return(x);
  6139.     }
  6140.     ckstrncpy(line,s,LINBUFSIZ);    /* Make safe copy of name */
  6141.     s = line;
  6142.     x = arraybounds(s,&lo,&hi);
  6143.     if (x < 0) {            /* Parse the name, get index */
  6144.     printf("?Bad array reference - \"%s\"\n", s);
  6145.     return(-9);
  6146.     }
  6147.     if (lo < 0 && hi < 0) {
  6148.     y = cmnum("New size","",10,&lo,xxstring);
  6149.     if (y < 0) {
  6150.         if (y == -3)
  6151.           printf("?New size required\n");
  6152.         return(y);
  6153.     }
  6154.     }
  6155.     if ((y = cmcfm()) < 0)
  6156.       return(y);
  6157.     if (a_link[x] > -1) {        /* Link? */
  6158.     islink = x;            /* Yes follow it */
  6159.     x = a_link[x];            /* and remember */
  6160.     }
  6161.     if (!a_ptr[x]) {
  6162.     printf("?Array not declared - \"%s\"\n", s);
  6163.     return(-9);
  6164.     }
  6165.     if (lo < 0) {
  6166.     printf("?New size required\n");
  6167.     return(-9);
  6168.     }
  6169.     if (hi > -1) {
  6170.     printf("?Array segments not allowed for this operation\n");
  6171.     return(-9);
  6172.     }
  6173.     c = arrayitoa(x);            /* Get array letter */
  6174.     if (c == '@') {            /* Argument vector array off limits */
  6175.     printf("?Sorry, \\&@[] is read-only\n");
  6176.     return(-9);
  6177.     }
  6178.     if (lo == 0) {            /* If new size is 0... */
  6179.     dclarray(c,0);            /* Undeclare the array */
  6180.     return(success = 1);
  6181.     }
  6182.     n = a_dim[x];            /* Current size */
  6183.     ap = (char **) malloc((lo+1) * sizeof(char *)); /* New array */
  6184.     y = (n < lo) ? n : lo;
  6185.     for (i = 0; i <= y; i++)        /* Copy the part that fits */
  6186.       ap[i] = a_ptr[x][i];
  6187.     if (n < lo) {            /* If original array smaller */
  6188.     for (; i <= lo; i++)        /* initialize extra elements in */
  6189.       ap[i] = NULL;            /* new array to NULL. */
  6190.     } else if (n > lo) {        /* If new array smaller */
  6191.     for (; i <= lo; i++)        /* deallocate leftover elements */
  6192.       makestr(&(a_ptr[x][i]),NULL);    /* from original array. */
  6193.     }
  6194.     free((char *)a_ptr[x]);        /* Free original array list */
  6195.     a_ptr[x] = ap;            /* Replace with new one */
  6196.     a_dim[x] = lo;            /* Record the new dimension */
  6197.     if (islink > -1) {            /* Was this a link? */
  6198.     a_ptr[islink] = ap;        /* If so point to the resized array */
  6199.     a_dim[islink] = lo;
  6200.     } else {                /* If not are there links to here? */
  6201.     for (i = 0; i < (int) 'z' - ARRAYBASE; i++) { /* Any linked arrays? */
  6202.         if (i != x && a_link[i] == x) {     /* Find and update them */
  6203.         a_ptr[i] = ap;
  6204.         a_dim[i] = lo;
  6205.         }
  6206.     }
  6207.     }
  6208.     return(success = 1);
  6209. }
  6210.  
  6211. static int
  6212. copyarray() {
  6213.     int i, j, x1, lo1, hi1, x2, lo2, hi2, whole = 0;
  6214.     char c1, c2, * a1, * a2;
  6215.     if ((y = cmfld("Name of source array","",&s,NULL)) < 0)
  6216.       return(y);
  6217.     ckstrncpy(line,s,LINBUFSIZ);
  6218.     a1 = line;
  6219.     if ((x1 = arraybounds(a1,&lo1,&hi1)) < 0) {
  6220.     printf("?Bad array reference - \"%s\"\n", a1);
  6221.     return(-9);
  6222.     } else if (!a_ptr[x1]) {
  6223.     printf("?Array not declared - \"%s\"\n", a1);
  6224.     return(-9);
  6225.     }
  6226.     c1 = arrayitoa(x1);
  6227.  
  6228.     if ((y = cmfld("Name of destination array","",&s,NULL)) < 0)
  6229.       return(y);
  6230.     ckstrncpy(tmpbuf,s,TMPBUFSIZ);
  6231.     a2 = tmpbuf;
  6232.     if ((x2 = arraybounds(a2,&lo2,&hi2)) < 0) {
  6233.     printf("?Bad array reference - \"%s\"\n", a2);
  6234.     return(-9);
  6235.     }
  6236.     c2 = arrayitoa(x2);
  6237.  
  6238.     if ((x = cmcfm()) < 0)
  6239.       return(x);
  6240.  
  6241.     if (c2 == '@') {            /* Argument vector array off limits */
  6242.     printf("?Sorry, \\&@[] is read-only\n");
  6243.     return(-9);
  6244.     }
  6245.     if (lo1 < 0 && lo2 < 0 && hi1 < 0 && hi2 < 0) /* Special case for */
  6246.       whole = 1;                      /* whole array... */
  6247.  
  6248.     if (lo1 < 0) lo1 = whole ? 0 : 1;    /* Supply lower bound of source */
  6249.     if (hi1 < 0) hi1 = a_dim[x1];    /* Supply upper bound of source */
  6250.     if (lo2 < 0) lo2 = whole ? 0 : 1;    /* Lower bound of target */
  6251.     if (hi2 < 0) hi2 = lo2 + hi1 - lo1;    /* Upper bound of target */
  6252.     if (a_ptr[x2]) {            /* Target array is already declared? */
  6253.     if (hi2 > a_dim[x2])        /* If upper bound out of range */
  6254.       hi2 = a_dim[x2];        /* shrink to fit */
  6255.     } else {                /* Otherwise... */
  6256.     x2 = dclarray(c2, hi2);        /* declare the target array */
  6257.     }
  6258.     for (i = lo1, j = lo2; i <= hi1 && j <= hi2; i++,j++) { /* Copy */
  6259.     makestr(&(a_ptr[x2][j]),a_ptr[x1][i]);
  6260.     }
  6261.     return(success = 1);
  6262. }
  6263.  
  6264. static int                /* Undeclare an array */
  6265. unarray() {
  6266.     int x, y, n, rc = 0;
  6267.     char c, * s;
  6268.  
  6269.     if ((y = cmfld("Array name","",&s,NULL)) < 0) { /* Parse array name */
  6270.     if (y == -3) {
  6271.         printf("?Array name required\n");
  6272.         return(-9);
  6273.     } else return(y);
  6274.     }
  6275.     ckstrncpy(line,s,LINBUFSIZ);    /* Make safe copy of name */
  6276.     s = line;
  6277.     if ((y = cmcfm()) < 0)
  6278.       return(y);
  6279.     if ((x = arraybounds(s,&y,&n)) < 0) { /* Parse the name, get index */
  6280.     printf("?Bad array reference - \"%s\"\n", s);
  6281.     return(-9);
  6282.     }
  6283.     if (y > 0 || n > 0) {
  6284.     printf("?Partial arrays can not be destroyed\n");
  6285.     return(-9);
  6286.     }
  6287.     c = arrayitoa(x);            /* Get array letter */
  6288.     if (a_ptr[x]) {            /* If array is declared */
  6289.     if (c == '@') {            /* Argument vector array off limits */
  6290.         printf("?Sorry, \\&@[] is read-only\n");
  6291.         return(-9);
  6292.     }
  6293.     rc = dclarray(c,-1);        /* Undeclare the array */
  6294.     } else                /* It wasn't declared */
  6295.       rc = 1;
  6296.     if (rc > -1) {            /* Set return code and success */
  6297.     success = 1;
  6298.     rc = 1;
  6299.     } else {
  6300.     success = 0;
  6301.     printf("?Failed - destroy \"\\&%c[]\"\n", c);
  6302.     rc = -9;
  6303.     }
  6304.     return(rc);
  6305. }
  6306.  
  6307. static int
  6308. clrarray(cx) int cx; {
  6309.     int i, x, lo, hi;
  6310.     char c, * s, * val = NULL;
  6311.  
  6312.     if ((x = cmfld("Array name","",&s,NULL)) < 0) { /* Parse array name */
  6313.     if (x == -3) {
  6314.         printf("?Array name required\n");
  6315.         return(-9);
  6316.     } else return(x);
  6317.     }
  6318.     ckstrncpy(line,s,LINBUFSIZ);    /* Make safe copy of name */
  6319.     s = line;
  6320.     if (cx == ARR_SET) {        /* SET */
  6321.     if ((x = cmtxt("Value","",&val,xxstring)) < 0)
  6322.       return(x);
  6323.     ckstrncpy(tmpbuf,val,TMPBUFSIZ); /* Value to set */
  6324.     val = tmpbuf;
  6325.     if (!*val) val = NULL;
  6326.     } else if ((x = cmcfm()) < 0)    /* CLEAR */
  6327.       return(x);
  6328.  
  6329.     if ((x = arraybounds(s,&lo,&hi)) < 0) { /* Parse the name */
  6330.     printf("?Bad array reference - \"%s\"\n", s);
  6331.     return(-9);
  6332.     }
  6333.     c = arrayitoa(x);            /* Get array letter */
  6334.     if (!a_ptr[x]) {            /* If array is declared */
  6335.     printf("?Array %s is not declared\n", s);
  6336.     return(-9);
  6337.     } else if (c == '@') {        /* Argument vector array off limits */
  6338.     printf("?Sorry, \\&@[] is read-only\n");
  6339.     return(-9);
  6340.     }
  6341.     if (lo < 0) lo = 0;
  6342.     if (hi < 0) hi = a_dim[x];
  6343.     for (i = lo; i <= hi; i++)        /* Clear/Set selected range */
  6344.       makestr(&(a_ptr[x][i]),val);
  6345.  
  6346.     return(success = 1);
  6347. }
  6348.  
  6349. extern char **aa_ptr[CMDSTKL][28];
  6350. extern int aa_dim[CMDSTKL][28];
  6351.  
  6352. static int                /* Create symbolic link to an array */
  6353. linkarray() {
  6354.     int i = 0, x, y, lo, hi, flag = 0;
  6355.     char c, * s, * p;
  6356.  
  6357.     if ((x = cmfld("Array name not currently in use","",&s,NULL)) < 0) {
  6358.     if (x == -3) {
  6359.         printf("?Array name required\n");
  6360.         return(-9);
  6361.     } else return(x);
  6362.     }
  6363.     ckstrncpy(line,s,LINBUFSIZ);    /* Make safe copy of link name */
  6364.     s = line;
  6365.     if ((x = cmfld("Name of existing array","",&p,xxstring)) < 0) {
  6366.     if (x == -3) {
  6367.         printf("?Array name required\n");
  6368.         return(-9);
  6369.     } else return(x);
  6370.     }
  6371.     ckstrncpy(tmpbuf,p,TMPBUFSIZ);    /* Make safe copy of array name */
  6372.     p = tmpbuf;
  6373.     if ((x = cmcfm()) < 0)
  6374.       return(x);
  6375.  
  6376.     if ((x = arraybounds(s,&lo,&hi)) < 0) { /* Parse the link name */
  6377.     printf("?Bad array reference - \"%s\"\n", s);
  6378.     return(-9);
  6379.     }
  6380.     if (a_ptr[x]) {            /* Must not already exist */
  6381.     c = arrayitoa(x);
  6382.     printf("?Array already exists: \\&%c[]\n", c);
  6383.     return(-9);
  6384.     }
  6385.     if (lo > -1 || hi > -1) {
  6386.     printf("?Sorry, whole arrays only: %s\n",s);
  6387.     return(-9);
  6388.     }
  6389.     if ((y = arraybounds(p,&lo,&hi)) < 0) { /* Parse the array name */
  6390.     printf("?Bad array reference - \"%s\"\n", s);
  6391.     return(-9);
  6392.     }
  6393.     if (lo > -1 || hi > -1) {
  6394.     printf("?Sorry, whole arrays only: %s\n",p);
  6395.     return(-9);
  6396.     }
  6397.     if (x == y) {
  6398.     for (i = cmdlvl; i >= 0; i--)
  6399.       if (aa_ptr[i][x]) {
  6400.           flag++;
  6401.           break;
  6402.       }
  6403.     }
  6404.     if (flag) {
  6405.     a_ptr[x] = aa_ptr[i][y];    /* Link to saved copy */
  6406.     a_dim[x] = aa_dim[i][y];
  6407.     } else {                /* Otherwise... */
  6408.     c = arrayitoa(y);        /* Check if it's declared */
  6409.     if (!a_ptr[y]) {
  6410.         printf("?Array is not declared: \\&%c[]\n", c);
  6411.         return(-9);
  6412.     }
  6413.     if (a_link[y] > -1) {        /* And if it's a link itself */
  6414.         printf("?Links to links not allowed: \\&%c[]\n", c);
  6415.         return(-9);
  6416.     }
  6417.     a_ptr[x] = a_ptr[y];        /* All OK, make the link */
  6418.     a_dim[x] = a_dim[y];
  6419.     }
  6420.     a_link[x] = y;
  6421.     return(success = 1);
  6422. }
  6423. #endif /* NOSPL */
  6424.  
  6425. #ifndef NOCSETS
  6426. static char * dcsetname = NULL;
  6427.  
  6428. /* Get Display Character-Set Name */
  6429.  
  6430. char *
  6431. getdcset() {
  6432.     char * s;
  6433.     int y;
  6434. #ifdef PCFONTS
  6435.     extern int tt_font, ntermfont;
  6436.     extern struct keytab term_font[];
  6437. #endif /* PCFONTS */
  6438.  
  6439.     s = "";
  6440. #ifdef OS2
  6441.     y = os2getcp();            /* Default is current code page */
  6442.     switch (y) {
  6443.       case 437: s = "cp437"; break;
  6444.       case 850: s = "cp850"; break;
  6445.       case 852: s = "cp852"; break;
  6446.       case 857: s = "cp857"; break;
  6447.       case 858: s = "cp858"; break;
  6448.       case 862: s = "cp862"; break;
  6449.       case 866: s = "cp866"; break;
  6450.       case 869: s = "cp869"; break;
  6451.       case 1250: s = "cp1250"; break;
  6452.       case 1251: s = "cp1251"; break;
  6453.       case 1252: s = "cp1252"; break;
  6454.       case 1253: s = "cp1253"; break;
  6455.       case 1254: s = "cp1254"; break;
  6456.       case 1255: s = "cp1255"; break;
  6457.       case 1256: s = "cp1256"; break;
  6458.       case 1257: s = "cp1257"; break;
  6459.       case 1258: s = "cp1258"; break;
  6460.     }
  6461. #ifdef PCFONTS
  6462. /*
  6463.    If the user has loaded a font with SET TERMINAL FONT then we want
  6464.    to change the default code page to the font that was loaded.
  6465. */
  6466.     if (tt_font != TTF_ROM) {
  6467.     for (y = 0; y < ntermfont; y++ ) {
  6468.         if (term_font[y].kwval == tt_font) {
  6469.         s = term_font[y].kwd;
  6470.         break;
  6471.         }
  6472.     }
  6473.     }
  6474. #endif /* PCFONTS */
  6475. #else /* OS2 */
  6476. #ifdef COMMENT
  6477.     /* Hack not needed as of C-Kermit 7.1 */
  6478.     if (fcharset == FC_1LATIN) {
  6479.     s = "latin1-iso";        /* Hack to avoid reporting "cp1252" */
  6480.     } else {                /* Report current file character set */
  6481. #endif /* COMMENT */
  6482.     for (y = 0; y <= nfilc; y++)
  6483.       if (fcstab[y].kwval == fcharset) {
  6484.           s = fcstab[y].kwd;
  6485.           break;
  6486.       }
  6487. #ifdef COMMENT
  6488.     }
  6489. #endif /* COMMENT */
  6490. #endif /* OS2 */
  6491.     makestr(&dcsetname,s);        /* Return stable pointer */
  6492.     return((char *)dcsetname);
  6493. }
  6494. #endif /* NOCSETS */
  6495.  
  6496. #ifndef NOFRILLS
  6497. static int
  6498. doclear() {
  6499.     if ((x = cmkey(clrtab,nclear,"item to clear",
  6500. #ifdef NOSPL
  6501.            "device-buffer"
  6502. #else
  6503.            "device-and-input"
  6504. #endif /* NOSPL */
  6505.            ,xxstring)) < 0) return(x);
  6506. #ifndef NOSPL
  6507. #ifdef OS2
  6508.     if (x == CLR_CMD || x == CLR_TRM) {
  6509.     if ((z = cmkey(clrcmdtab,nclrcmd,"how much screen to clear\n",
  6510.                "all",xxstring)) < 0)
  6511.       return(z);
  6512.     }
  6513. #endif /* OS2 */
  6514. #endif /* NOSPL */
  6515.     if ((y = cmcfm()) < 0)
  6516.       return(y);
  6517.  
  6518.     /* Clear device input buffer if requested */
  6519.     y = (x & CLR_DEV) ? ttflui() : 0;
  6520.  
  6521.     if (x & CLR_SCR)            /* CLEAR SCREEN */
  6522.       y = ck_cls();            /* (= SCREEN CLEAR = CLS) */
  6523.  
  6524.     if (x & CLR_KBD) {            /* CLEAR KEYBOARD */
  6525.     int n;
  6526.     n = conchk();
  6527.     y = 0;
  6528.     while (n-- > 0 && (y = coninc(0) > -1))
  6529.       ;
  6530.     y = (y > -1) ? 0 : -1;
  6531.     }
  6532.  
  6533. #ifndef NOSPL
  6534.     /* Clear INPUT command buffer if requested */
  6535.     if (x & CLR_INP) {
  6536.     for (z = 0; z < inbufsize; z++)
  6537.       inpbuf[z] = NUL;
  6538.     inpbp = inpbuf;
  6539.     y = 0;
  6540.     }
  6541. #ifdef CK_APC
  6542.     if (x & CLR_APC) {
  6543.     debug(F101,"Executing CLEAR APC","",apcactive);
  6544.     apcactive = 0;
  6545.     y = 0;
  6546.     }
  6547. #endif /* CK_APC */
  6548.     if (x & CLR_ALR) {
  6549.     setalarm(0L);
  6550.     y = 0;
  6551.     }
  6552. #endif /* NOSPL */
  6553.  
  6554. #ifdef PATTERNS
  6555.     if (x & (CLR_TXT|CLR_BIN)) {
  6556.     int i;
  6557.     for (i = 0; i < FTPATTERNS; i++) {
  6558.         if (x & CLR_TXT)
  6559.           makestr(&txtpatterns[i],NULL);
  6560.         if (x & CLR_BIN)
  6561.           makestr(&binpatterns[i],NULL);
  6562.     }
  6563.     y = 0;
  6564.     }
  6565. #endif /* PATTERNS */
  6566.  
  6567. #ifndef NODIAL
  6568.     if (x & CLR_DIA) {
  6569.     dialsta = DIA_UNK;
  6570.     y = 0;
  6571.     }
  6572. #endif /* NODIAL */
  6573.  
  6574. #ifndef NOMSEND
  6575.     if (x & CLR_SFL) {            /* CLEAR SEND-LIST */
  6576.     if (filehead) {
  6577.         struct filelist * flp, * next;
  6578.         flp = filehead;
  6579.         while (flp) {
  6580.         if (flp->fl_name)
  6581.           free(flp->fl_name);
  6582.         if (flp->fl_alias)
  6583.           free(flp->fl_alias);
  6584.         next = flp->fl_next;
  6585.         free((char *)flp);
  6586.         flp = next;
  6587.         }
  6588.     }
  6589.     filesinlist = 0;
  6590.     filehead = NULL;
  6591.     filetail = NULL;
  6592.     addlist = 0;
  6593.     y = 0;
  6594.     }
  6595. #endif /* NOMSEND */
  6596.  
  6597. #ifdef OS2
  6598. #ifndef NOLOCAL
  6599.     switch (x) {
  6600.       case CLR_SCL:
  6601.     clearscrollback(VTERM);
  6602.     break;
  6603.       case CLR_CMD:
  6604.     switch ( z ) {
  6605.       case CLR_C_ALL:
  6606.         clear();
  6607.         break;
  6608.       case CLR_C_BOS:
  6609.         clrboscr_escape(VCMD,SP);
  6610.         break;
  6611.       case CLR_C_BOL:
  6612.         clrbol_escape(VCMD,SP);
  6613.         break;
  6614.       case CLR_C_EOL:
  6615.         clrtoeoln(VCMD,SP);
  6616.         break;
  6617.       case CLR_C_EOS:
  6618.         clreoscr_escape(VCMD,SP);
  6619.         break;
  6620.       case CLR_C_LIN:
  6621.         clrline_escape(VCMD,SP);
  6622.         break;
  6623.       case CLR_C_SCR:
  6624.         clearscrollback(VCMD);
  6625.         break;
  6626.     default:
  6627.         printf("Not implemented yet, sorry.\n");
  6628.         break;
  6629.     }
  6630.     break;
  6631.  
  6632. #ifndef NOTERM
  6633.       case CLR_TRM:
  6634.      switch ( z ) {
  6635.       case CLR_C_ALL:
  6636.          if (VscrnGetBufferSize(VTERM) > 0 ) {
  6637.          VscrnScroll(VTERM, UPWARD, 0,
  6638.                  VscrnGetHeight(VTERM)-(tt_status[VTERM]?2:1),
  6639.                  VscrnGetHeight(VTERM) -
  6640.                  (tt_status[VTERM]?1:0), TRUE, SP
  6641.                  );
  6642.          cleartermscreen(VTERM);
  6643.          }
  6644.          break;
  6645.       case CLR_C_BOS:
  6646.         clrboscr_escape(VTERM,SP);
  6647.         break;
  6648.       case CLR_C_BOL:
  6649.         clrbol_escape(VTERM,SP);
  6650.         break;
  6651.       case CLR_C_EOL:
  6652.         clrtoeoln(VTERM,SP);
  6653.         break;
  6654.       case CLR_C_EOS:
  6655.         clreoscr_escape(VTERM,SP);
  6656.         break;
  6657.       case CLR_C_LIN:
  6658.         clrline_escape(VTERM,SP);
  6659.         break;
  6660.      case CLR_C_SCR:
  6661.          clearscrollback(VTERM);
  6662.          break;
  6663.      default:
  6664.          printf("Not implemented yet, sorry.\n");
  6665.          break;
  6666.     }
  6667.     break;
  6668. #endif /* NOTERM */
  6669.     }
  6670.     y = 0;
  6671. #endif /* NOLOCAL */
  6672. #endif /* OS2 */
  6673.     return(success = (y == 0));
  6674. }
  6675. #endif /* NOFRILLS */
  6676.  
  6677. #ifndef NOSPL
  6678. static int
  6679. doeval(cx) int cx; {
  6680.     char *p;
  6681.     char vnambuf[VNAML], * vnp = NULL;    /* These must be on the stack */
  6682.     if (!oldeval) {
  6683.     if ((y = cmfld("Variable name","",&s,
  6684.                ((cx == XX_EVAL) ? xxstring : NULL))) < 0) {
  6685.         if (y == -3) {
  6686.         printf("?Variable name required\n");
  6687.         return(-9);
  6688.         } else return(y);
  6689.     }
  6690.     ckstrncpy(vnambuf,s,VNAML);    /* Make a copy. */
  6691.     vnp = vnambuf;
  6692.     if (vnambuf[0] == CMDQ &&
  6693.         (vnambuf[1] == '%' || vnambuf[1] == '&'))
  6694.       vnp++;
  6695.     y = 0;
  6696.     if (*vnp == '%' || *vnp == '&') {
  6697.         if ((y = parsevar(vnp,&x,&z)) < 0)
  6698.           return(y);
  6699.     }
  6700.     }
  6701.     if ((x = cmtxt("Integer arithmetic expression","",&s,xxstring)) < 0)
  6702.       return(x);
  6703.     p = evala(s);
  6704.     if (!p) p = "";
  6705.     if (oldeval && *p)
  6706.       printf("%s\n", p);
  6707.     ckstrncpy(evalbuf,p,32);
  6708.     if (!oldeval)
  6709.       return(success = addmac(vnambuf,p));
  6710.     else
  6711.       return(success = *p ? 1 : 0);
  6712. }
  6713. #endif /* NOSPL */
  6714.  
  6715. #ifdef TNCODE
  6716. static int
  6717. dotelopt() {
  6718.     if ((x = cmkey(telcmd, ntelcmd, "TELNET command", "", xxstring)) < 0 )
  6719.       return(x);
  6720.     switch (x) {
  6721.       case WILL:
  6722.       case WONT:
  6723.       case DO:
  6724.       case DONT:
  6725.     if ((y = cmkey(tnopts,ntnopts,"TELNET option","",xxstring)) < 0)
  6726.       return(y);
  6727.     if ((z = cmcfm()) < 0) return(z);
  6728.  
  6729.     switch (x) {
  6730.       case WILL:
  6731.         if (TELOPT_UNANSWERED_WILL(y))
  6732.           return(success = 0);
  6733.         break;
  6734.       case WONT:
  6735.         if (TELOPT_UNANSWERED_WONT(y))
  6736.           return(success = 0);
  6737.         break;
  6738.       case DO:
  6739.         if (TELOPT_UNANSWERED_DO(y))
  6740.           return(success = 0);
  6741.         break;
  6742.       case DONT:
  6743.         if (TELOPT_UNANSWERED_DONT(y))
  6744.           return(success = 0);
  6745.         break;
  6746.     }
  6747.     if (local) {
  6748.         success = ((tn_sopt(x,y) > -1) ? 1 : 0);
  6749.     } else {
  6750.         printf("ff%02x%02x\n",x,y);
  6751.         success = 1;
  6752.     }
  6753.     if (success) {
  6754.         switch (x) {
  6755.           case WILL:
  6756.         TELOPT_UNANSWERED_WILL(y) = 1;
  6757.         break;
  6758.           case WONT:
  6759.         if ( TELOPT_ME(y) )
  6760.           TELOPT_UNANSWERED_WONT(y) = 1;
  6761.         break;
  6762.           case DO:
  6763.         TELOPT_UNANSWERED_DO(y) = 1;
  6764.         break;
  6765.           case DONT:
  6766.         if ( TELOPT_ME(y) )
  6767.           TELOPT_UNANSWERED_DONT(y) = 1;
  6768.         break;
  6769.         }
  6770.         if (tn_wait("XXTELOP") < 0) {
  6771.         tn_push();
  6772.         success = 0;
  6773.         }
  6774.     }
  6775.     return(success);
  6776.       case SB:
  6777.     if ((y=cmkey(tnsbopts,ntnsbopts,"TELNET option","",xxstring)) < 0)
  6778.       return(y);
  6779.     switch (y) {
  6780.       case TELOPT_NAWS:
  6781.         /* Some compilers require switch() to have at least 1 case */
  6782. #ifdef CK_NAWS
  6783.         TELOPT_SB(TELOPT_NAWS).naws.x = 0;
  6784.         TELOPT_SB(TELOPT_NAWS).naws.y = 0;
  6785.         if (local)
  6786.           return(success = ((tn_snaws() > -1) ? 1 : 0));
  6787.         else
  6788.           return(success = 0);
  6789. #else
  6790.         return(success = 0);
  6791. #endif /* CK_NAWS */
  6792.     }
  6793.         return(success = 0);
  6794.  
  6795. #ifdef CK_KERBEROS
  6796. #ifdef KRB5
  6797.       case TN_FWD:
  6798.         success = (kerberos5_forward() == AUTH_SUCCESS);
  6799.         return(success);
  6800. #endif /* KRB5 */
  6801. #endif /* CK_KERBEROS */
  6802.  
  6803.       default:
  6804.     if ((z = cmcfm()) < 0) return(z);
  6805. #ifndef NOLOCAL
  6806.     if (local) {
  6807.         CHAR temp[3];
  6808.         if (network && IS_TELNET()) { /* TELNET */
  6809.         temp[0] = (CHAR) IAC;
  6810.         temp[1] = x;
  6811.         temp[2] = NUL;
  6812.         success = (ttol((CHAR *)temp,2) > -1 ? 1 : 0);
  6813.         if (tn_deb || debses || deblog) {
  6814.             /* TN_MSG_LEN is in ckctel.h */
  6815.             ckmakmsg(tn_msg,256,"TELNET SENT ",TELCMD(x),NULL,NULL);
  6816.             debug(F101,tn_msg,"",x);
  6817.             if (debses || tn_deb) tn_debug(tn_msg);
  6818.         }
  6819.         return(success);
  6820.         }
  6821.             return(success = 0);
  6822.     } else {
  6823. #endif /* NOLOCAL */
  6824.         printf("ff%02x\n",x);
  6825.         return(success = 1);
  6826. #ifndef NOLOCAL
  6827.     }
  6828. #endif /* NOLOCAL */
  6829.     }
  6830. }
  6831. #endif /* TNCODE */
  6832.  
  6833.  
  6834. #ifndef NOPUSH
  6835. #ifndef NOFRILLS
  6836. static int
  6837. doedit() {
  6838. #ifdef OS2
  6839.     char * p = NULL;
  6840. #endif /* OS2 */
  6841.     if (!editor[0]) {
  6842.     s = getenv("EDITOR");
  6843.     if (s) ckstrncpy(editor,s,CKMAXPATH);
  6844.     editor[CKMAXPATH] = NUL;
  6845.     if (!editor[0]) {
  6846.         printf("?Editor not defined - use SET EDITOR to define\n");
  6847.         return(-9);
  6848.     }
  6849.     }
  6850.     ckstrncpy(tmpbuf,editfile,TMPBUFSIZ);
  6851. /*
  6852.   cmiofi() lets us parse the name of an existing file, or the name of
  6853.   a nonexistent file to be created.
  6854. */
  6855.     x = cmiofi("File to edit", (char *)tmpbuf, &s, &y, xxstring);
  6856.     debug(F111,"edit",s,x);
  6857.     if (x < 0 && x != -3)
  6858.       return(x);
  6859.     if (x == -3) {
  6860.     tmpbuf[0] = NUL;
  6861.     } else {
  6862.     ckstrncpy(tmpbuf,s,TMPBUFSIZ);
  6863.     }
  6864.     if ((z = cmcfm()) < 0) return(z);
  6865.     if (y) {
  6866.     printf("?A single file please\n");
  6867.     return(-9);
  6868.     }
  6869.     if (nopush) {
  6870.     printf("?Sorry, editing not allowed\n");
  6871.     return(success = 0);
  6872.     }
  6873.     if (tmpbuf[0]) {
  6874.     /* Get full path in case we change directories between EDIT commands */
  6875.     zfnqfp(tmpbuf, CKMAXPATH, editfile);
  6876.     editfile[CKMAXPATH] = NUL;
  6877. #ifdef OS2
  6878.     p = editfile;            /* Flip the stupid slashes */
  6879.     while (*p) {
  6880.         if (*p == '/') *p = '\\';
  6881.         p++;
  6882.     }
  6883. #endif /* OS2 */
  6884.     } else
  6885.       editfile[0] = NUL;
  6886.     if (editfile[0]) {
  6887.     if (zchki(editfile) < (CK_OFF_T)0 && zchko(editfile) < 0) {
  6888.         printf("?Access denied: %s\n",editfile);
  6889.         return(-9);
  6890.     }
  6891.     }
  6892.     x = 0;
  6893.     if (editopts[0]) {
  6894. #ifdef OS2
  6895.     x = ckindex("%1",(char *)editopts,0,0,1);
  6896.     if (x > 0)
  6897.       editopts[x] = 's';
  6898.     else
  6899. #endif /* OS2 */
  6900.       x = ckindex("%s",(char *)editopts,0,0,1);
  6901.     }
  6902.     if (((int)strlen(editopts) + (int)strlen(editfile) + 1) < TMPBUFSIZ) {
  6903.     if (x)
  6904.       sprintf(tmpbuf,editopts,editfile);
  6905.     else
  6906.       sprintf(tmpbuf,"%s %s",editopts,editfile);
  6907.     }
  6908.     s = line;
  6909.     ckmakmsg(s,LINBUFSIZ,editor," ",tmpbuf,NULL);
  6910. #ifdef OS2
  6911.     p = s + strlen(editor);        /* And again with the slashes */
  6912.     while (p != s) {
  6913.     if (*p == '/') *p = '\\';
  6914.     p--;
  6915.     }
  6916. #endif /* OS2 */
  6917.     conres();
  6918.     x = zshcmd(s);
  6919.     concb((char)escape);
  6920.     return(x);
  6921. }
  6922. #endif /* NOFRILLS */
  6923. #endif /* NOPUSH */
  6924.  
  6925. #ifdef BROWSER
  6926. static int
  6927. dobrowse() {
  6928. #ifdef OS2
  6929.     char * p = NULL;
  6930. #endif /* OS2 */
  6931.     if (nopush) {
  6932.     printf("?Sorry, browsing not allowed\n");
  6933.     return(success = 0);
  6934.     }
  6935. #ifndef NT
  6936.     /* Windows lets the Shell Execute the URL if no Browser is defined */
  6937.     if (!browser[0]) {
  6938.     s = getenv("BROWSER");
  6939.     if (s) ckstrncpy(browser,s,CKMAXPATH);
  6940.     browser[CKMAXPATH] = NUL;
  6941.     if (!browser[0]) {
  6942.         printf("?Browser not defined - use SET BROWSER to define\n");
  6943.         return(-9);
  6944.     }
  6945.     }
  6946. #endif /* NT */
  6947.     ckstrncpy(tmpbuf,browsurl,TMPBUFSIZ);
  6948.     if ((x = cmtxt("URL",(char *)browsurl,&s,xxstring)) < 0)
  6949.       return(x);
  6950.     ckstrncpy(browsurl,s,4096);
  6951.     x = 0;
  6952.     if (browsopts[0]) {
  6953. #ifdef OS2
  6954.     x = ckindex("%1",(char *)browsopts,0,0,1);
  6955.     if (x > 0)
  6956.       browsopts[x] = 's';
  6957.     else
  6958. #endif /* OS2 */
  6959.       x = ckindex("%s",(char *)browsopts,0,0,1);
  6960.     }
  6961.     if (((int)strlen(browsopts) + (int)strlen(browsurl) + 1) < TMPBUFSIZ) {
  6962.     if (x)
  6963.       sprintf(tmpbuf,browsopts,browsurl);
  6964.     else
  6965.       sprintf(tmpbuf,"%s %s",browsopts,browsurl);
  6966.     }
  6967. #ifdef NT
  6968.     if (!browser[0])
  6969.       return(success = Win32ShellExecute(browsurl));
  6970. #endif /* NT */
  6971.     s = line;
  6972.     ckmakmsg(s,LINBUFSIZ,browser," ",tmpbuf,NULL);
  6973. #ifdef OS2
  6974.     p = line + strlen(browser);        /* Flip slashes */
  6975.     while (p != line) {
  6976.     if (*p == '/') *p = '\\';
  6977.     p--;
  6978.     }
  6979. #endif /* OS2 */
  6980.     conres();
  6981.     x = zshcmd(s);
  6982.     concb((char)escape);
  6983.     return(x);
  6984. }
  6985. #endif /* BROWSER */
  6986.  
  6987. #ifdef CK_RECALL
  6988. static int
  6989. doredo() {            /* Find a previous cmd and redo it */
  6990.     extern int on_recall, in_recall;
  6991.     int x;
  6992.     char * p;
  6993.  
  6994.     if ((x = cmtxt(
  6995. "pattern, or first few characters of a previous command",
  6996.            "*",&s,xxstring)) < 0)
  6997.       return(x);
  6998.     ckstrncpy(line,s,LINBUFSIZ);
  6999.     x = strlen(s);
  7000.     s = line;
  7001.     if (*s == '{') {            /* Braces disable adding * to end */
  7002.     if (s[x-1] == '}') {
  7003.         s[x-1] = NUL;
  7004.         s++;
  7005.         x--;
  7006.     }
  7007.     } else {                /* No braces, add * to end. */
  7008.     s[x] = '*';
  7009.     s[x+1] = NUL;
  7010.     }
  7011.  
  7012.     while (x > 0 && s[x] == '*' && s[x-1] == '*') s[x--] = NUL;
  7013.  
  7014.     if (!on_recall || !in_recall) {
  7015.     printf("?Sorry, command recall can't be used now.\n");
  7016.     return(-9);
  7017.     }
  7018.     if ((p = cmgetcmd(s))) {        /* Look for it history buffer */
  7019.     ckmakmsg(cmdbuf,CMDBL,p,"\r",NULL,NULL); /* Copy to command buffer */
  7020.     if (!quiet)            /* Echo it */
  7021.       printf("%s\n",cmdbuf);
  7022.     cmaddnext();            /* Force re-add to history buffer */
  7023.     return(cmflgs = -1);        /* Force reparse */
  7024.     } else {
  7025.     printf("?Sorry - \"%s\" not found\n", s);
  7026.     return(-9);
  7027.     }
  7028. }
  7029. #endif /* CK_RECALL */
  7030.  
  7031. #ifndef NOXFER
  7032. #ifndef NOCSETS
  7033. static int
  7034. doassoc()  {                /* ASSOCIATE */
  7035.     extern struct keytab tcstab[];
  7036.     extern int ntcs;
  7037.     if ((x = cmkey(assoctab, nassoc, "", "", xxstring)) < 0 )
  7038.       return(x);
  7039.  
  7040.     switch (x) {            /* Associate what? */
  7041.  
  7042.       case ASSOC_TC:            /* Transfer character-set... */
  7043.     if ((x = cmkey(tcstab, ntcs,
  7044.                "transfer character-set name","",xxstring)) < 0)
  7045.       return(x);
  7046.     if ((y = cmkey(fcstab, nfilc,
  7047.                "with file character-set","", xxstring)) < 0)
  7048.       if (y != -3)
  7049.         return(y);
  7050.     if ((z = cmcfm()) < 0)
  7051.       return(z);
  7052.     axcset[x] = y;
  7053.     return(success = 1);
  7054.  
  7055.       case ASSOC_FC:            /* File character-set... */
  7056.     if ((x = cmkey(fcstab, nfilc,
  7057.                "file character-set name","",xxstring)) < 0)
  7058.       return(x);
  7059.     if ((y = cmkey(tcstab, ntcs,
  7060.                "with transfer character-set","", xxstring)) < 0)
  7061.       if (y != -3)
  7062.         return(y);
  7063.     if ((z = cmcfm()) < 0)
  7064.       return(z);
  7065.     afcset[x] = y;
  7066.     return(success = 1);
  7067.  
  7068.       default:
  7069.     return(-2);
  7070.     }
  7071. }
  7072. #endif /* NOCSETS */
  7073. #endif /* NOXFER */
  7074.  
  7075. #ifndef NOHELP
  7076. static int
  7077. domanual() {
  7078. #ifdef OS2
  7079.     if ((x = cmcfm()) < 0)
  7080.       return(x);
  7081.     if (nopush) {
  7082.     printf("?Sorry, access to system commands is disabled.\n");
  7083.     return(-9);
  7084.     }
  7085.     y = mxlook(mactab,"manual",nmac);
  7086.     if (y > -1) {
  7087.     z = maclvl;            /* Save the current maclvl */
  7088.     dodo(y,NULL,cmdstk[cmdlvl].ccflgs); /* Run the macro */
  7089.     while (maclvl > z) {
  7090.         debug(F101,"XXMAN loop maclvl 1","",maclvl);
  7091.         sstate = (CHAR) parser(1);
  7092.         debug(F101,"XXMAN loop maclvl 2","",maclvl);
  7093.         if (sstate) proto();
  7094.     }
  7095.     debug(F101,"XXMAN loop exit maclvl","",maclvl);
  7096.     return(success);
  7097.     }
  7098.     return(success = 0);
  7099. #else
  7100.     if ((x = cmtxt(
  7101. #ifdef UNIX
  7102.            "Carriage return to confirm the command, or manual topic",
  7103. #else
  7104.            "Carriage return to confirm the command, or help topic",
  7105. #endif /* UNIX */
  7106.            "kermit",
  7107.            &s,
  7108.            xxstring
  7109.            )
  7110.      ) < 0)
  7111.       return(x);
  7112. #endif /* OS2 */
  7113.  
  7114. #ifdef UNIX
  7115.     ckmakmsg(tmpbuf,TMPBUFSIZ,"man ",s,NULL,NULL);
  7116. #else
  7117.     ckmakmsg(tmpbuf,TMPBUFSIZ,"help ",s,NULL,NULL);
  7118. #endif /* UNIX */
  7119.     debug(F110,"MANUAL",tmpbuf,0);
  7120.     if (nopush) {
  7121.     printf("?Sorry, access to system commands is disabled.\n");
  7122.     return(-9);
  7123.     } else {
  7124.     conres();            /* Restore the console */
  7125.     success = zshcmd(tmpbuf);
  7126.     concb((char)escape);        /* Restore CBREAK mode */
  7127.     return(success);
  7128.     }
  7129. }
  7130. #endif /* NOHELP */
  7131.  
  7132. #ifndef NOHTTP
  7133. #ifdef TCPSOCKET
  7134. static struct keytab sslswtab[] = {
  7135.     { "/ssl", 1, 0 },
  7136.     { "/tls", 1, 0 }
  7137. };
  7138.  
  7139. #ifndef NOURL
  7140. struct urldata http_url = {NULL,NULL,NULL,NULL,NULL,NULL,NULL};
  7141. #endif /* NOURL */
  7142.  
  7143. static int
  7144. dohttp() {                /* HTTP */
  7145.     struct FDB sw, kw, fi;
  7146.     int n, getval, allinone = 0;
  7147.     char c, * p;
  7148.     char rdns[128];
  7149.  
  7150.     char * http_agent = NULL;        /* Parse results */
  7151.     char * http_hdr   = NULL;
  7152.     char * http_user  = NULL;
  7153.     char * http_pass  = NULL;
  7154.     char * http_mime  = NULL;
  7155.     char * http_lfile = NULL;
  7156.     char * http_rfile = NULL;
  7157.     char * http_dfile = NULL;
  7158.     char   http_array = NUL;
  7159.     int    http_action = -1;
  7160.  
  7161.     char * http_host = NULL;
  7162.     char * http_srv  = NULL;
  7163.     int    http_ssl  = 0;
  7164.  
  7165.     static char * http_d_agent = NULL;
  7166.     static char * http_d_user = NULL;
  7167.     static char * http_d_pass = NULL;
  7168.  
  7169.     static int    http_d_type = 0;
  7170.     int           http_type = http_d_type;
  7171.  
  7172. #ifdef OS2
  7173.     p = "Kermit 95";            /* Default user agent */
  7174. #else
  7175.     p = "C-Kermit";
  7176. #endif /* OS2 */
  7177.     makestr(&http_agent,p);
  7178.     makestr(&http_mime,"text/HTML");    /* MIME type default */
  7179.     rdns[0] = '\0';
  7180.  
  7181.     cmfdbi(&sw,                /* 1st FDB - general switches */
  7182.        _CMKEY,                /* fcode */
  7183.        "OPEN, CLOSE, GET, HEAD, PUT, INDEX, or POST,\n or switch", /* hlpmsg */
  7184.        "",                /* default */
  7185.        "",                /* addtl string data */
  7186.        nhttpswtab,            /* addtl numeric data 1: tbl size */
  7187.        4,                /* addtl numeric data 2: 4 = cmswi */
  7188.        xxstring,            /* Processing function */
  7189.        httpswtab,            /* Keyword table */
  7190.        &kw                /* Pointer to next FDB */
  7191.        );
  7192.     cmfdbi(&kw,                /* 2nd FDB - commands */
  7193.        _CMKEY,                /* fcode */
  7194.        "Command",            /* hlpmsg */
  7195.        "",                /* default */
  7196.        "",                /* addtl string data */
  7197.        nhttptab,            /* addtl numeric data 1: tbl size */
  7198.        0,                /* addtl numeric data 2: 0 = keyword */
  7199.        xxstring,            /* Processing function */
  7200.        httptab,                /* Keyword table */
  7201.        NULL                /* Pointer to next FDB */
  7202.        );
  7203.  
  7204.     while (1) {
  7205.     x = cmfdb(&sw);            /* Parse something */
  7206.     if (x < 0)            /* Error */
  7207.       goto xhttp;
  7208.     n = cmresult.nresult;
  7209.     if (cmresult.fdbaddr == &kw)    /* Command - exit this loop */
  7210.       break;
  7211.     c = cmgbrk();            /* Switch... */
  7212.     getval = (c == ':' || c == '=');
  7213.     x = -9;
  7214.     if (getval && !(cmgkwflgs() & CM_ARG)) {
  7215.         printf("?This switch does not take an argument\n");
  7216.         goto xhttp;
  7217.     }
  7218.     switch (cmresult.nresult) {    /* Handle each switch */
  7219.           case HT_SW_TP:                /* /TOSCREEN */
  7220.             http_type = 1;
  7221.             break;
  7222.       case HT_SW_AG:        /* /AGENT */
  7223.         if (getval) {
  7224.         if ((x = cmfld("User agent",p,&s,xxstring)) < 0)
  7225.           goto xhttp;
  7226.         } else {
  7227.         s = p;
  7228.         }
  7229.         makestr(&http_agent,s);
  7230.         break;
  7231.       case HT_SW_HD:        /* /HEADER */
  7232.         s = NULL;
  7233.         if (getval) {
  7234.         if ((x = cmfld("Header line","",&s,xxstring)) < 0) {
  7235.             if (x == -3)
  7236.               s = NULL;
  7237.             else
  7238.               goto xhttp;
  7239.         }
  7240.         }
  7241.         makestr(&http_hdr,s);
  7242.         break;
  7243.       case HT_SW_US:        /* /USER */
  7244.         s = NULL;
  7245.         if (getval) {
  7246.         if ((x = cmfld("User ID","",&s,xxstring)) < 0) {
  7247.                   if (x == -3)
  7248.                     s = "";
  7249.                   else
  7250.             goto xhttp;
  7251.                 }
  7252.         }
  7253.         makestr(&http_user,s);
  7254.         break;
  7255.       case HT_SW_PW:        /* /PASSWORD */
  7256.         debok = 0;
  7257.         s = NULL;
  7258.         if (getval) {
  7259.         if ((x = cmfld("Password","",&s,xxstring)) < 0)
  7260.           goto xhttp;
  7261.         }
  7262.         makestr(&http_pass,s);
  7263.         break;
  7264. #ifndef NOSPL
  7265.       case HT_SW_AR: {        /* /ARRAY: */
  7266.           char * s2, array = NUL;
  7267.           if (!getval) {
  7268.           printf("?This switch requires an argument\n");
  7269.           x = -9;
  7270.           goto xhttp;
  7271.           }
  7272.           if ((x = cmfld("Array name (a single letter will do)",
  7273.                  "",
  7274.                  &s,
  7275.                  NULL
  7276.                  )) < 0) {
  7277.           if (x == -3) {
  7278.               printf("?Array name required\n");
  7279.               x = -9;
  7280.               goto xhttp;
  7281.           } else
  7282.             goto xhttp;
  7283.           }
  7284.           if (!*s) {
  7285.           printf("?Array name required\n");
  7286.           x = -9;
  7287.           goto xhttp;
  7288.           }
  7289.           s2 = s;
  7290.           if (*s == CMDQ) s++;
  7291.           if (*s == '&') s++;
  7292.           if (!isalpha(*s)) {
  7293.           printf("?Bad array name - \"%s\"\n",s2);
  7294.           x = -9;
  7295.           goto xhttp;
  7296.           }
  7297.           array = *s++;
  7298.           if (isupper(array))
  7299.         array = tolower(array);
  7300.           if (*s && (*s != '[' || *(s+1) != ']')) {
  7301.           printf("?Bad array name - \"%s\"\n",s2);
  7302.           http_array = NUL;
  7303.           x = -9;
  7304.           goto xhttp;
  7305.           }
  7306.           http_array = array;
  7307.           break;
  7308.       }
  7309. #endif /* NOSPL */
  7310.       default:
  7311.         x = -2;
  7312.         goto xhttp;
  7313.     }
  7314.     }
  7315.     http_action = n;            /* Save the action */
  7316.     if (http_action == HTTP_PUT || http_action == HTTP_POS) {
  7317.     cmfdbi(&sw,            /* 1st FDB - switch */
  7318.            _CMKEY,            /* fcode */
  7319.            "Local filename\n Or switch", /* help */
  7320.            "",            /* default */
  7321.            "",            /* addtl string data */
  7322.            nhttpptab,        /* keyword table size */
  7323.            4,            /* addtl numeric data 2: 4 = cmswi */
  7324.            xxstring,        /* Processing function */
  7325.            httpptab,        /* Keyword table */
  7326.            &fi            /* Pointer to next FDB */
  7327.            );
  7328.     cmfdbi(&fi,            /* 2nd FDB - filename */
  7329.            _CMIFI,            /* fcode */
  7330.            "Local filename",    /* hlpmsg */
  7331.            "",            /* default */
  7332.            "",            /* addtl string data */
  7333.            0,            /* addtl numeric data 1 */
  7334.            0,            /* addtl numeric data 2 */
  7335.            xxstring,
  7336.            NULL,
  7337.            NULL
  7338.            );
  7339.     while (1) {
  7340.         x = cmfdb(&sw);
  7341.         if (x < 0)
  7342.           goto xhttp;        /* Free any malloc'd temp strings */
  7343.         n = cmresult.nresult;
  7344.         if (cmresult.fcode != _CMKEY)
  7345.           break;
  7346.         c = cmgbrk();        /* Switch... */
  7347.         getval = (c == ':' || c == '=');
  7348.         if (getval && !(cmgkwflgs() & CM_ARG)) {
  7349.         printf("?This switch does not take an argument\n");
  7350.         x = -9;
  7351.         goto xhttp;
  7352.         }
  7353.         switch (n) {
  7354.           case HT_PP_MT:
  7355.         s = "text/HTML";
  7356.         if (getval) {
  7357.             if ((x = cmfld("MIME type",
  7358.                    "text/HTML",&s,xxstring)) < 0)
  7359.               goto xhttp;
  7360.         }
  7361.         makestr(&http_mime,s);
  7362.         break;
  7363.           default:
  7364.         x = -2;
  7365.         goto xhttp;
  7366.         }
  7367.     }
  7368.     makestr(&http_lfile,cmresult.sresult);
  7369.     n = ckindex("/",http_lfile,-1,1,0);
  7370.     if (n)
  7371.       p = &http_lfile[n];
  7372.     else
  7373.       p = http_lfile;
  7374.     if ((x = cmfld("URL or remote filename",p,&s,xxstring)) < 0) {
  7375.           if (x == -3) {
  7376.             printf("?%s what?\n",(http_action == HTTP_PUT) ? "Put" : "Post");
  7377.             x = -9;
  7378.           }
  7379.           goto xhttp;
  7380.         }
  7381.     if (!*s) s = NULL;
  7382.     makestr(&http_rfile,s);
  7383.  
  7384.     if ((x = cmtxt("Response filename","",&s,xxstring)) < 0) {
  7385.           if (x != -3)
  7386.             goto xhttp;
  7387.         }
  7388.         if (*s)
  7389.           makestr(&http_dfile,s);
  7390.     }
  7391.     switch (http_action) {
  7392.       case HTTP_DEL:            /* DELETE */
  7393.     if ((x = cmfld("URL or remote source file","",&s,xxstring)) < 0) {
  7394.           if (x == -3) {
  7395.             printf("?Delete what?\n");
  7396.             x = -9;
  7397.           }
  7398.           goto xhttp;
  7399.         }
  7400.     makestr(&http_rfile,s);
  7401.     break;
  7402.       case HTTP_CON:            /* CONNECT */
  7403.         if ((x = cmfld("Remote host[:port]","",&s,xxstring)) < 0) {
  7404.           if (x == -3) {
  7405.             printf("?Remote host[:port] is required\n");
  7406.             x = -9;
  7407.           }
  7408.           goto xhttp;
  7409.         }
  7410.     makestr(&http_rfile,s);
  7411.     break;
  7412.       case HTTP_HED: {            /* HEAD */
  7413.       char buf[CKMAXPATH+1];
  7414.       if ((x = cmfld("URL or remote source file","",&s,xxstring)) < 0) {
  7415.           if (x == -3) {
  7416.           printf("?Head of what?\n");
  7417.           x = -9;
  7418.           }
  7419.           goto xhttp;
  7420.       }
  7421.       makestr(&http_rfile,s);
  7422.  
  7423.       if (http_array || http_type) { /* Default result filename */
  7424.           p = "";             /* None if /ARRAY or /TOSCREEN */
  7425.       } else {
  7426.           n = ckindex("/",http_rfile,-1,1,0); /* Otherwise strip path */
  7427.           if (n)                          /* and add ".head" */
  7428.         p = &http_rfile[n];
  7429.           else
  7430.         p = http_rfile;
  7431.           ckmakmsg(buf,CKMAXPATH,p,".head",NULL,NULL);
  7432.           p = buf;
  7433.       }
  7434.       if ((x = cmofi("Local filename",p,&s,xxstring)) < 0) {
  7435.           if (x != -3)
  7436.         goto xhttp;
  7437.       }
  7438.       makestr(&http_lfile,s);
  7439.       break;
  7440.       }
  7441.       case HTTP_GET:            /* GET */
  7442.       case HTTP_IDX: {            /* INDEX */
  7443.       extern int wildena;
  7444.       int tmp;
  7445.       char * lfile = "";
  7446.       if ((x = cmfld("URL or remote source file","",&s,xxstring)) < 0) {
  7447.           if (x == -3) {
  7448.           printf("?Get what?\n");
  7449.           x = -9;
  7450.           }
  7451.           goto xhttp;
  7452.       }
  7453.       makestr(&http_rfile,s);
  7454.       if (http_action == HTTP_GET && !http_type)
  7455.         zstrip(http_rfile,&lfile);
  7456.       /* URLs often contain question marks or other metacharacters */
  7457.       /* cmofi() doesn't like them */
  7458.       tmp = wildena;
  7459.       wildena = 0;
  7460.       if ((x = cmofi("Local filename",lfile,&s,xxstring)) < 0) {
  7461.           wildena = tmp;
  7462.           if (x != -3)
  7463.         goto xhttp;
  7464.       }
  7465.       wildena = tmp;
  7466.       makestr(&http_lfile,s);
  7467.       break;
  7468.       }
  7469.       case HTTP_OPN: {
  7470.       int sslswitch = 0;
  7471. #ifdef CK_SSL
  7472.       struct FDB sw, fl;
  7473.       cmfdbi(&sw,
  7474.          _CMKEY,        /* fcode */
  7475.          "IP host name or address, or switch", /* hlpmsg */
  7476.          "",            /* default */
  7477.          "",            /* addtl string data */
  7478.          2,            /* addtl numeric data 1: tbl size */
  7479.          4,            /* addtl numeric data 2: 4 = cmswi */
  7480.          xxstring,        /* Processing function */
  7481.          sslswtab,        /* Keyword table */
  7482.          &fl            /* Pointer to next FDB */
  7483.          );
  7484.       cmfdbi(&fl,            /* 2nd FDB - host */
  7485.          _CMFLD,        /* fcode */
  7486.          "",            /* hlpmsg */
  7487.          "",            /* default */
  7488.          "",            /* addtl string data */
  7489.          0,            /* addtl numeric data 1 */
  7490.          0,            /* addtl numeric data 2 */
  7491.          xxstring,
  7492.          NULL,
  7493.          NULL
  7494.          );
  7495.       x = cmfdb(&sw);        /* Parse switch or host */
  7496.       if (x < 0)            /* Error */
  7497.         goto xhttp;
  7498.       if (cmresult.fcode == _CMFLD) { /* Host */
  7499.           s = cmresult.sresult;      /* Set up expected pointer */
  7500.           goto havehost;              /* Go parse rest of command */
  7501.       }
  7502.       sslswitch = 1;        /* /SSL or /TLS switch - set flag */
  7503. #endif /* CK_SSL */
  7504.  
  7505.       /* Parse host */
  7506.  
  7507.       if ((x = cmfld("URL, hostname, or ip-address","",&s,xxstring)) < 0) {
  7508.           if (x == -3) {
  7509.           printf("?Open what?\n");
  7510.           x = -9;
  7511.           }
  7512.           goto xhttp;
  7513.       }
  7514.  
  7515.     havehost:            /* Come here with s -> host */
  7516. #ifdef CK_URL
  7517.       x = urlparse(s,&http_url);    /* Was a URL given? */
  7518.       if (x < 1) {            /* Not a URL */
  7519. #endif /* CK_URL */
  7520.           makestr(&http_host,s);
  7521.           if ((x =
  7522.            cmfld("Service name or port number",
  7523.              sslswitch ? "https" : "http",&s,xxstring)) < 0)
  7524.         goto xhttp;
  7525.           else
  7526.         makestr(&http_srv,s);
  7527. #ifdef CK_URL
  7528.       } else if (ckstrcmp(http_url.svc,"http",-1,0) && /* Non-HTTP URL */
  7529.              ckstrcmp(http_url.svc,"https",-1,0)) {
  7530.           printf("?Non-HTTP URL\n");
  7531.           x = -9;
  7532.           goto xhttp;
  7533.       } else {            /* Have HTTP URL */
  7534.           makestr(&http_srv, http_url.svc);
  7535.           makestr(&http_user,http_url.usr);
  7536.           makestr(&http_pass,http_url.psw);
  7537.           makestr(&http_host,http_url.hos);
  7538.           if (http_url.por)
  7539.         makestr(&http_srv,http_url.por);
  7540.           makestr(&http_rfile,http_url.pth);
  7541.       }
  7542.       if (http_rfile) {        /* Open, GET, and Close */
  7543.           printf("?Directory/file path not allowed in HTTP OPEN URL\n");
  7544.           x = -9;
  7545.           goto xhttp;
  7546.       }
  7547.       if (!ckstrcmp("https",http_srv,-1,0) || sslswitch ||
  7548.           !ckstrcmp("443",http_srv,-1,0))
  7549.         http_ssl = 1;
  7550. #endif /* CK_URL */
  7551.       break;
  7552.       }
  7553.       case HTTP_CLS:
  7554.         break;
  7555.     }
  7556.     if ((x = cmcfm()) < 0)
  7557.       goto xhttp;
  7558.  
  7559.     if (http_action == HTTP_OPN) {
  7560.         x = (http_open(http_host,http_srv,http_ssl,rdns,128,http_agent) == 0);
  7561.         if (x) {
  7562.             if (!quiet) {
  7563.               if (rdns[0])
  7564.                 printf("Connected to %s [%s]\r\n",http_host,rdns);
  7565.               else
  7566.                 printf("Connected to %s\r\n",http_host);
  7567.             }
  7568.             if (http_agent) {
  7569.                 if (http_d_agent)
  7570.           free(http_d_agent);
  7571.                 http_d_agent = http_agent;
  7572.                 http_agent = NULL;
  7573.             }
  7574.             if (http_user) {
  7575.                 if (http_d_user)
  7576.           free(http_d_user);
  7577.                 http_d_user = http_user;
  7578.                 http_user = NULL;
  7579.             }
  7580.             if (http_pass) {
  7581.                 if (http_d_pass) {
  7582.                     memset(http_d_pass,0,strlen(http_d_pass));
  7583.                     free(http_d_pass);
  7584.                 }
  7585.                 http_d_pass = http_pass;
  7586.                 http_pass = NULL;
  7587.             }
  7588.             http_d_type = http_type;
  7589.         } else {
  7590.             if (!quiet)
  7591.           printf("?HTTP Connection failed.\r\n");
  7592.         }
  7593.     } else if (http_action == HTTP_CLS) {
  7594.         if (http_d_agent) {
  7595.             free(http_d_agent);
  7596.             http_d_agent = NULL;
  7597.         }
  7598.         if (http_d_user) {
  7599.             free(http_d_user);
  7600.             http_d_user = NULL;
  7601.         }
  7602.         if (http_d_pass) {
  7603.             memset(http_d_pass,0,strlen(http_d_pass));
  7604.             free(http_d_pass);
  7605.             http_d_pass = NULL;
  7606.         }
  7607.         http_d_type = 0;
  7608.         x = (http_close() == 0);
  7609.     }
  7610.     if ((http_action != HTTP_CLS) &&
  7611.     (http_action != HTTP_CON) && http_rfile) { /* Remote file is URL? */
  7612.  
  7613.     /* All-in-one actions when a URL is given... */
  7614.  
  7615. #ifdef CK_URL
  7616.     if (urlparse(http_rfile,&http_url) > 0) { /* Have URL? */
  7617.         if (ckstrcmp(http_url.svc,"http",-1,0) && /* It's an HTTP URL? */
  7618.         ckstrcmp(http_url.svc,"https",-1,0)) {
  7619.         printf("?Non-HTTP URL\n");
  7620.         x = -9;
  7621.         goto xhttp;
  7622.         } else {            /* Yes, collect the pieces */
  7623.         makestr(&http_srv, http_url.svc);
  7624.         makestr(&http_user,http_url.usr);
  7625.         makestr(&http_pass,http_url.psw);
  7626.         makestr(&http_host,http_url.hos);
  7627.         if (http_url.por)
  7628.           makestr(&http_srv,http_url.por);
  7629.         makestr(&http_rfile,http_url.pth);
  7630.         }
  7631.         if (!http_rfile) {        /* Still have a path? */
  7632.                 makestr(&http_rfile,"/");
  7633.         }
  7634.         if (!ckstrcmp("https",http_srv,-1,0) || /* Check for SSL/TLS */
  7635.         !ckstrcmp("443",http_srv,-1,0))
  7636.           http_ssl = 1;
  7637.         if (http_isconnected())    /* Close any open HTTP connection */
  7638.           http_close();
  7639.         if (http_pass == NULL && http_d_pass != NULL)
  7640.           makestr(&http_pass,http_d_pass);
  7641.         x = (http_open(http_host,
  7642.                http_srv,http_ssl,rdns,128,http_d_agent) == 0);
  7643.         if (x < 0) {
  7644.         x = 0;
  7645.         goto xhttp;
  7646.         }
  7647.         allinone = 1;
  7648.     }
  7649. #endif /* CK_URL */
  7650.         if (http_pass == NULL && http_d_pass != NULL)
  7651.       makestr(&http_pass,http_d_pass);
  7652.  
  7653.     if (http_action == HTTP_OPN && allinone) {
  7654.         http_action = HTTP_GET;
  7655.     }
  7656.         x = xdohttp(http_action,
  7657.                     http_lfile,
  7658.             http_rfile,
  7659.                     http_dfile,
  7660.             http_agent ? http_agent : http_d_agent,
  7661.             http_hdr,
  7662.             http_user  ? http_user  : http_d_user,
  7663.             http_pass  ? http_pass  : http_d_pass,
  7664.             http_mime,
  7665.             http_array,
  7666.             http_type
  7667.             );
  7668.     if (allinone)
  7669.       x = (http_close() == 0);
  7670.     }
  7671.  
  7672.   xhttp:
  7673.     if (http_agent) free(http_agent);
  7674.     if (http_hdr)   free(http_hdr);
  7675.     if (http_user)  free(http_user);
  7676.     if (http_pass) {
  7677.         memset(http_pass,0,strlen(http_pass));
  7678.         free(http_pass);
  7679.     }
  7680.     if (http_mime)  free(http_mime);
  7681.     if (http_lfile) free(http_lfile);
  7682.     if (http_rfile) free(http_rfile);
  7683.     if (http_dfile) free(http_dfile);
  7684.     if (http_host)  free(http_host);
  7685.     if (http_srv)   free(http_srv);
  7686.  
  7687.     if (x > -1)
  7688.       success = x;
  7689.     return(x);
  7690. }
  7691. #endif /* TCPSOCKET */
  7692. #endif /* NOHTTP */
  7693.  
  7694.  
  7695. #ifndef NOSPL
  7696. static int
  7697. dotrace() {
  7698.     int on = 1;
  7699.     struct FDB sw, kw;
  7700.     cmfdbi(&sw,                /* 1st FDB - switch */
  7701.        _CMKEY,            /* fcode */
  7702.        "Trace object;\n Or switch", /* help */
  7703.        "",                /* default */
  7704.        "",                /* addtl string data */
  7705.        2,                /* keyword table size */
  7706.        4,                /* addtl numeric data 2: 4 = cmswi */
  7707.        xxstring,            /* Processing function */
  7708.        onoffsw,            /* Keyword table */
  7709.        &kw                /* Pointer to next FDB */
  7710.        );
  7711.     cmfdbi(&kw,                /* 2nd FDB - Trace object */
  7712.        _CMKEY,            /* fcode */
  7713.        "Trace object",        /* help */
  7714.        "all",            /* default */
  7715.        "",                /* addtl string data */
  7716.        ntracetab,            /* keyword table size */
  7717.        0,                /* addtl numeric data 2: 0 = keyword */
  7718.        xxstring,            /* Processing function */
  7719.        tracetab,            /* Keyword table */
  7720.        NULL                /* Pointer to next FDB */
  7721.        );
  7722.     if ((x = cmfdb(&sw)) < 0)
  7723.       return(x);
  7724.     if (cmresult.fdbaddr == &sw) {
  7725.     on = cmresult.nresult;
  7726.     if ((x = cmkey(tracetab, ntracetab,"","all",xxstring)) < 0)
  7727.       return(x);
  7728.     } else {
  7729.     x = cmresult.nresult;
  7730.     }
  7731.     if ((y = cmcfm()) < 0)
  7732.       return(y);
  7733.  
  7734.     switch (x) {
  7735.       case TRA_ASG:
  7736.     tra_asg = on;
  7737.     break;
  7738.       case TRA_CMD:
  7739.     tra_cmd = on;
  7740.     break;
  7741.       case TRA_ALL:
  7742.     tra_asg = on;
  7743.     tra_cmd = on;
  7744.     break;
  7745.       default:
  7746.     return(-2);
  7747.     }
  7748.     printf("TRACE %s\n", on ? "ON" : "OFF");
  7749.     return(success = 1);
  7750. }
  7751. #endif /* NOSPL */
  7752.  
  7753.  
  7754. static int
  7755. doprompt() {
  7756.     extern int xcmdsrc;
  7757.     if ((x = cmtxt("Optional message","",&s,xxstring)) < 0)
  7758.       return(x);
  7759. #ifdef NOSPL
  7760.     printf("?Sorry, PROMPT requires script programming language\n");
  7761.     return(-9);
  7762. #else
  7763.     debug(F101,"Prompt cmdlvl","",cmdlvl);
  7764.     cmdlvl++;
  7765.     if (cmdlvl > CMDSTKL) {
  7766.     printf("?Command stack overflow: %d\n",cmdlvl);
  7767.     cmdlvl--;
  7768.     return(-9);
  7769.     }
  7770.     xcmdsrc = CMD_KB;
  7771.     cmdstk[cmdlvl].src = CMD_KB;    /* Say we're at the prompt */
  7772.     cmdstk[cmdlvl].lvl = 0;
  7773.     cmdstk[cmdlvl].ccflgs = cmdstk[cmdlvl-1].ccflgs;
  7774.     if (tra_cmd)
  7775.       printf("[%d] +P: \"(prompt)\"\n",cmdlvl);
  7776.     concb((char)escape);
  7777.     if (!quiet)
  7778.       printf(
  7779. "(Recursive command prompt: Resume script with CONTINUE, STOP to stop...)\n"
  7780.             );
  7781.     if (*s) {                /* If prompt given */
  7782.     makestr(&(prstring[cmdlvl-1]),cmgetp()); /* Save current prompt */
  7783.     cmsetp(s);            /* Set new one */
  7784.     }
  7785.     return(success = 1);
  7786. #endif /* NOSPL */
  7787. }
  7788.  
  7789. #ifdef CKLEARN
  7790. VOID
  7791. learncmd(s) char *s; {            /* Record commands in learned script */
  7792.     char buf[64];
  7793.     int i, k;
  7794.     if (learnfp && learning) {        /* Only if open and on */
  7795.     k = ckstrncpy(buf,s,64);
  7796.     for (i = 0; i < k; i++) {    /* Get top-level command keyword */
  7797.         if (buf[i] <= SP) {
  7798.         buf[i] = NUL;
  7799.         break;
  7800.         }
  7801.     }
  7802.     k = lookup(cmdtab,buf,ncmd,NULL); /* Look it up */
  7803.     if (k == XXCON || k == XXLEARN)      /* Don't record CONNECT or LEARN */
  7804.       return;
  7805.     if (k == XXTEL) {
  7806.         fputs("SET HOST /NETWORK:TCP",learnfp);
  7807.         fputs(&s[i],learnfp);
  7808.         fputs(" TELNET /TELNET",learnfp);
  7809.         fputs("\nIF FAIL STOP 1 Connection failed\n",learnfp);
  7810.     } else {
  7811.         fputs(s,learnfp);
  7812.         fputs("\n",learnfp);
  7813.     }
  7814.     }
  7815. }
  7816. #endif /* CKLEARN */
  7817.  
  7818.  
  7819. #ifdef SSHCMD
  7820. /*
  7821.   2010/03/01...
  7822.   Reopen a connection that was made with an external ssh client
  7823.   after it has been closed.
  7824.  */
  7825. int
  7826. redossh() {
  7827.     int x, netsave;
  7828.     x = nettype;
  7829.     debug(F111,"redossh nettype",ttname,nettype);
  7830.     if ((y = setlin(XXSSH,0,1)) < 0) {
  7831.     if (errno)
  7832.       printf("?%s\n",ck_errstr());
  7833.     else
  7834.       return(y);
  7835.     nettype = x;            /* Failed, restore net type. */
  7836.     success = 0;
  7837.     return(y);
  7838.     }
  7839.     netsave = x;
  7840.     return(y);
  7841. }
  7842. #endif    /* SSHCMD */
  7843.  
  7844. /*
  7845.   Like hmsga() in ckuus2.c but takes a single substitution parameter, s2,
  7846.   which replaces every occurrence of "%s" in the first argument.
  7847.   Added to print text containing the copyright year, so the year doesn't 
  7848.   have to be hardwired into lots of scattered text strings.
  7849. */
  7850. int                                     /* Print an array of lines, */
  7851. #ifdef CK_ANSIC
  7852. hmsgaa(char *s[], char *s2)        /* pausing at end of each screen. */
  7853. #else
  7854. hmsgaa(s,s2) char *s[]; char *s2;
  7855. #endif    /* CK_ANSIC */
  7856. {
  7857.     extern int hmtopline;
  7858. #ifdef OS2
  7859.     extern int tt_rows[], tt_cols[];
  7860. #else /* OS2 */
  7861.     extern int tt_rows, tt_cols;
  7862. #endif /* OS2 */
  7863.     int x, y, i, j, k, n;
  7864.     if ((x = cmcfm()) < 0) return(x);
  7865.  
  7866. #ifdef CK_TTGWSIZ
  7867. #ifdef OS2
  7868.     ttgcwsz();
  7869. #else /* OS2 */
  7870.     /* Check whether window size changed */
  7871.     if (ttgwsiz() > 0) {
  7872.         if (tt_rows > 0 && tt_cols > 0) {
  7873.             cmd_rows = tt_rows;
  7874.             cmd_cols = tt_cols;
  7875.         }
  7876.     }
  7877. #endif /* OS2 */
  7878. #endif /* CK_TTGWSIZ */
  7879.  
  7880.     printf("\n");                       /* Start off with a blank line */
  7881.     n = (hmtopline > 0) ? hmtopline : 1; /* Line counter */
  7882.     for (i = 0; *s[i]; i++) {
  7883.         printf((char *)s[i],s2);    /* Print a line. */
  7884.     printf("\n");
  7885.         y = (int)strlen(s[i]);
  7886.         k = 1;
  7887.         for (j = 0; j < y; j++)         /* See how many newlines were */
  7888.           if (s[i][j] == '\n') k++;     /* in the string... */
  7889.         n += k;
  7890.         if (n > (cmd_rows - 3) && *s[i+1]) /* After a screenful, give them */
  7891.           if (!askmore()) return(0);    /* a "more?" prompt. */
  7892.           else n = 0;
  7893.     }
  7894.     printf("\n");
  7895.     return(0);
  7896. }
  7897.  
  7898. /*  D O C M D  --  Do a command  */
  7899.  
  7900. /*
  7901.  Returns:
  7902.    -2: user typed an illegal command
  7903.    -1: reparse needed
  7904.     0: parse was successful (even tho command may have failed).
  7905. */
  7906. #ifdef DEBUG
  7907. int cmdstats[256] = { -1, -1 };
  7908. #endif /* DEBUG */
  7909.  
  7910. int
  7911. docmd(cx) int cx; {
  7912.     extern int nolocal, cmkwflgs;
  7913.  
  7914.     debug(F101,"docmd entry, cx","",cx);
  7915.     activecmd = cx;
  7916.     doconx = ((activecmd == XXCON)  || (activecmd == XXTEL) ||
  7917.           (activecmd == XXRLOG) || (activecmd == XXPIPE) ||
  7918.               (activecmd == XXIKSD) || (activecmd == XXPTY));
  7919. /*
  7920.   Originally all commands were handled with a big switch() statement,
  7921.   but eventually this started blowing up compilers.  Now we have a series
  7922.   of separate if statements and small switches, with the commands that are
  7923.   most commonly executed in scipts and loops coming first, to speed up
  7924.   compute-bound scripts.
  7925.   */
  7926.  
  7927. #ifdef DEBUG
  7928.     if (cmdstats[0] == -1) {        /* Count commands */
  7929.     int i;                /* for tuning... */
  7930.     for (i = 0; i < 256; i++)
  7931.       cmdstats[i] = 0;
  7932.     }
  7933. #endif /* DEBUG */
  7934.  
  7935.     switch (cx) {
  7936.       case -4:                /* EOF */
  7937. #ifdef OSK
  7938.     if (msgflg)  printf("\n");
  7939. #else
  7940.     if (msgflg)  printf("\r\n");
  7941. #endif /* OSK */
  7942.       doexit(GOOD_EXIT,xitsta);
  7943.       case -3:                /* Null command */
  7944.     return(0);
  7945.       case -9:                /* Like -2, but errmsg already done */
  7946.       case -1:                /* Reparse needed */
  7947.     return(cx);
  7948.       case -6:                /* Special */
  7949.       case -2:                /* Error, maybe */
  7950.  
  7951. #ifndef NOSPL
  7952. /*
  7953.   Maybe they typed a macro name.  Let's look it up and see.
  7954. */
  7955.     if (cx == -6)            /* If they typed CR */
  7956.       ckstrncat(cmdbuf,"\015",CMDBL); /*  add it back to command buffer. */
  7957.     if (ifcmd[cmdlvl] == 2)        /* Watch out for IF commands. */
  7958.       ifcmd[cmdlvl]--;
  7959.     repars = 1;            /* Force reparse */
  7960.     cmres();
  7961.     cx = XXDO;            /* Try DO command */
  7962. #else
  7963.     return(cx);
  7964. #endif /* NOSPL */
  7965.       default:
  7966.     if (cx < 0)
  7967.       return(cx);
  7968.     break;
  7969.     }
  7970. #ifdef DEBUG
  7971.     if (cx < 256)
  7972.       cmdstats[cx]++;
  7973. #endif /* DEBUG */
  7974.  
  7975.     if ((cmkwflgs & CM_PSH)
  7976. #ifndef NOPUSH
  7977.     && nopush
  7978. #endif /* NOPUSH */
  7979.     ) {
  7980.     printf("?Access to system disabled\n");
  7981.     return(-9);
  7982.     }
  7983.     if ((cmkwflgs & CM_LOC)
  7984. #ifndef NOLOCAL
  7985.     && nolocal
  7986. #endif /* NOLOCAL */
  7987.     ) {
  7988.     printf("?Connections disabled\n");
  7989.     return(-9);
  7990.     }
  7991.  
  7992. #ifndef NOSPL
  7993.     /* Used in FOR loops */
  7994.  
  7995.     if (cx == XX_INCR || cx == XXINC  || /* _INCREMENT, INCREMENT */
  7996.     cx == XX_DECR || cx == XXDEC)     /* _DECREMENT, DECREMENT */
  7997.       return(doincr(cx));
  7998.  
  7999.     /* Define (or change the definition of) a macro or variable */
  8000.  
  8001.     if (cx == XXUNDEF || cx == XXUNDFX) {
  8002. #ifdef IKSD
  8003.     if (inserver && !ENABLED(en_asg)) {
  8004.         printf("?Sorry, DEFINE/ASSIGN disabled\n");
  8005.         return(-9);
  8006.     }
  8007. #endif /* IKSD */
  8008.     return(doundef(cx));        /* [_]UNDEFINE */
  8009.     }
  8010.     if (cx == XXDEF || cx == XXASS ||
  8011.     cx == XXDFX || cx == XXASX) {
  8012. #ifdef IKSD
  8013.     if (inserver && !ENABLED(en_asg)) {
  8014.         printf("?Sorry, DEFINE/ASSIGN disabled\n");
  8015.         return(-9);
  8016.     }
  8017. #endif /* IKSD */
  8018.     if (atmbuf[0] == '.' && !atmbuf[1]) /* "." entered as keyword */
  8019.       xxdot = 1;            /* i.e. with space after it... */
  8020.     return(dodef(cx));        /* DEFINE, ASSIGN, etc... */
  8021.     }
  8022.  
  8023.     /* IF, WHILE, and friends  */
  8024.  
  8025.     if (cx == XXIF || cx == XXIFX || cx == XXWHI || cx == XXASSER) {
  8026.     return(doif(cx));
  8027.     }
  8028.     if (cx == XXSWIT) {            /* SWITCH */
  8029.     return(doswitch());
  8030.     }
  8031.  
  8032.     /* GOTO, FORWARD, and _FORWARD (used internally by FOR, WHILE, etc) */
  8033.  
  8034.     if (cx == XXGOTO || cx == XXFWD || cx == XXXFWD) { /* GOTO or FORWARD */
  8035.     /* Note, here we don't set SUCCESS/FAILURE flag */
  8036. #ifdef COMMENT
  8037.     if ((y = cmfld("label","",&s,xxstring)) < 0) {
  8038.         if (y == -3) {
  8039.         if (cx != XXXFWD) {
  8040.             printf("?Label name required\n");
  8041.             return(-9);
  8042.         }
  8043.         } else
  8044.           return(y);
  8045.     }
  8046.     ckstrncpy(tmpbuf,s,TMPBUFSIZ);
  8047.     if ((x = cmcfm()) < 0) return(x);
  8048. #else
  8049.     if ((y = cmtxt("label","",&s,xxstring)) < 0) {
  8050.         if (y == -3) {
  8051.         if (cx != XXXFWD) {
  8052.             printf("?GOTO: Label name required: \"%s\" \"%s\"\n",
  8053.                atmbuf,
  8054.                cmdbuf);
  8055.             return(-9);
  8056.         }
  8057.         } else
  8058.           return(y);
  8059.     }
  8060.     ckstrncpy(tmpbuf,brstrip(s),TMPBUFSIZ);
  8061. #endif /* COMMENT */
  8062.     s = tmpbuf;
  8063.     debug(F111,"GOTO target",s,cx);
  8064.     return(dogoto(s,cx));
  8065.     }
  8066.     if (cx == XXDO || cx == XXMACRO) {    /* DO (a macro) */
  8067.     char mnamebuf[16];        /* (buffer for controlled temp name) */
  8068.     struct FDB kw, fl;
  8069.     int mx;                /* Macro index (on stack!) */
  8070.  
  8071.     debug(F101,"XXMACRO 0",line,cx);
  8072.     if (cx == XXDO) {
  8073.         if (nmac == 0) {
  8074.         printf("\n?No macros defined\n");
  8075.         return(-9);
  8076.         }
  8077.         for (y = 0; y < nmac; y++) { /* copy the macro table into a */
  8078.         mackey[y].kwd = mactab[y].kwd; /* regular keyword table */
  8079.         mackey[y].kwval = y;    /* with value = pointer to macro tbl */
  8080.         mackey[y].flgs = mactab[y].flgs;
  8081.         }
  8082.         cmfdbi(&kw,            /* First FDB - macro name */
  8083.            _CMKEY,        /* fcode */
  8084.            "Macro",        /* hlpmsg */
  8085.            "",            /* default */
  8086.            "",            /* addtl string data */
  8087.            nmac,        /* addtl numeric data 1: tbl size */
  8088.            0,            /* addtl numeric data 2: 0 = cmkey */
  8089.            xxstring,        /* Processing function */
  8090.            mackey,        /* Keyword table */
  8091.            &fl            /* Pointer to next FDB */
  8092.            );
  8093.         cmfdbi(&fl,            /* 2nd FDB - for "{" */
  8094.            _CMFLD,        /* fcode */
  8095.            "",            /* hlpmsg */
  8096.            "",
  8097.            "",            /* addtl string data */
  8098.            0,            /* addtl numeric data 1 */
  8099.            0,            /* addtl numeric data 2 */
  8100.            xxstring,
  8101.            NULL,
  8102.            NULL
  8103.            );
  8104.         x = cmfdb(&kw);        /* Parse something */
  8105.         if (x < 0) {        /* Error */
  8106.         if (x == -3) {
  8107.             printf("?Macro name required\n");
  8108.             return(-9);
  8109.         } else
  8110.           return(x);
  8111.         }
  8112.         if (cmresult.fcode == _CMKEY) {
  8113.         extern int mtchanged;
  8114.         char * macroname = NULL;
  8115.  
  8116.         /* In case args include an \fexec() that changes the macro table */
  8117.  
  8118.         mx = x;            /* Save macro index on stack */
  8119.         mtchanged = 0;        /* Mark state of macro table */
  8120.         makestr(¯oname,mactab[mx].kwd); /* Save name */
  8121.  
  8122.         if ((y = cmtxt("optional arguments","",&s,xxstring)) < 0)
  8123.           return(y);        /* Get macro args */
  8124.  
  8125.         if (mtchanged) {    /* Macro table changed? */
  8126.             mx = mlook(mactab,macroname,nmac); /* Look up name again */
  8127.         }
  8128.         if (macroname)
  8129.           free(macroname);
  8130.  
  8131.         return(dodo(mx,s,cmdstk[cmdlvl].ccflgs) < 1 ?
  8132.                (success = 0) : 1);
  8133.         }
  8134.         ckstrncpy(line,cmresult.sresult,LINBUFSIZ);    /* _CMFLD */
  8135.         if (atmbuf[0] == '{') {
  8136.         if ((y = cmcfm()) < 0)
  8137.           return(y);
  8138.         }
  8139.     } else {            /* XXMACRO ("immediate macro") */
  8140.         int k = 0;
  8141.         line[k++] = '{';
  8142.         line[k++] = SP;
  8143.         line[k] = NUL;
  8144.         debug(F111,"XXMACRO A",line,k);
  8145.         if ((y = cmtxt("Braced list of commands","",&s,xxstring)) < 0)
  8146.           return(y);
  8147.         k = ckstrncpy(line+k,s,LINBUFSIZ-k);
  8148.         debug(F111,"XXMACRO B",line,k);
  8149.     }
  8150.     x = strlen(line);
  8151.     if ((line[0] == '{' && line[x-1] != '}') || line[0] == '}')
  8152.       return(-2);
  8153.     if (line[0] != '{' && line[x-1] != '}') {
  8154.         /* Unknown command.  If ON_UNKNOWN_COMMAND macro is defined, */
  8155.         /* parse args and then execute it, but only if it is not */
  8156.         /* already active. */
  8157.         int k = -1;
  8158.         if (!unkmacro) {
  8159.         k = mxlook(mactab,"on_unknown_command",nmac);
  8160.         }
  8161.         if (k > -1) {
  8162.         ckstrncpy(tmpbuf,atmbuf,TMPBUFSIZ);
  8163.         z = maclvl;        /* Save the current maclvl */
  8164.         if ((y = cmtxt("text","",&s,xxstring)) < 0)
  8165.           return(y);
  8166.         ckstrncat(tmpbuf," ",TMPBUFSIZ);
  8167.         ckstrncat(tmpbuf,s,TMPBUFSIZ);
  8168.         unkmacro = 1;
  8169.         debug(F110,"ON_UNKNOWN_COMMAND",s,0);
  8170.         dodo(k,tmpbuf,cmdstk[cmdlvl].ccflgs); /* Run the macro */
  8171.         while (maclvl > z) {
  8172.             sstate = (CHAR) parser(1);
  8173.             if (sstate) proto();
  8174.         }
  8175.         debug(F101,"UNKMAC loop exit maclvl","",maclvl);
  8176.         unkmacro = 0;
  8177.         return(success);
  8178.         }
  8179.             if (x > 0)
  8180.           printf("?Not a command or macro name: \"%s\"\n",line);
  8181.             else
  8182.           printf("?Not a command or macro name.\n");
  8183.         return(-9);
  8184.     }
  8185.     s = brstrip(line);
  8186.     sprintf(mnamebuf," ..tmp:%03d",cmdlvl);    /* safe (16) */
  8187.     x = addmac(mnamebuf,s);
  8188.     return(dodo(x,NULL,cmdstk[cmdlvl].ccflgs) < 1 ? (success = 0) : 1);
  8189.     }
  8190.  
  8191.     if (cx == XXLBL) {            /* LABEL */
  8192.     if ((x = cmfld("label","",&s,xxstring)) < 0) {
  8193.         if (x == -3) {
  8194. #ifdef COMMENT
  8195.         printf("?LABEL: Label name required: \"%s\"\n", cmdbuf);
  8196.         return(-9);
  8197. #else
  8198.         s = "";
  8199. #endif /* COMMENT */
  8200.         } else return(x);
  8201.  
  8202.     }
  8203.     debug(F111,"LABEL",s,x);
  8204.     if ((x = cmcfm()) < 0) return(x);
  8205.     return(0);
  8206.     }
  8207.  
  8208.     if (cx == XXEVAL || cx == XX_EVAL) /* _EVALUATE,  EVALUATE  */
  8209.       return(doeval(cx));
  8210.  
  8211. #ifndef NOSEXP
  8212.     if (cx == XXSEXP) {            /* Lisp-like S-Expression */
  8213.     struct stringarray * q;
  8214.     char /* *p, *r, */ *tmp, *m;
  8215.     int i, k, n, quote = 0, contd = 0, size = 0, len = 0;
  8216.     extern int sexprc, sexppv;
  8217.  
  8218.     tmp = tmpbuf;            /* Buffer to collect SEXP */
  8219.     tmpbuf[0] = NUL;        /* Clear it */
  8220.     size = TMPBUFSIZ;        /* Capacity of buffer */
  8221.     sexprc = -1;            /* Assume bad input */
  8222.     n = 0;                /* Paren balance counter */
  8223.  
  8224.     while (1) {            /* Allow SEXP on multiple lines */
  8225.         m = contd ?
  8226.           "Continuation of S-Expression" :
  8227.         "S-Expression (\"help sexp\" for details)";
  8228.         x = cmtxt(m,"",&s,xxstring);
  8229.         if (x < 0)
  8230.           return(x);
  8231.         if (!*s)            /* Needed for (=) and (:) */
  8232.           s = cmdbuf+1;        /* I can't explain why. */
  8233.         k = ckmakmsg(tmp, size, contd ? " " : "(", s, NULL, NULL);
  8234.         if (k < 1) {
  8235.         printf("?SEXP too long - %d max\n",TMPBUFSIZ);
  8236.         return(-9);
  8237.         }
  8238.         debug(F111,contd ? "sexp contd" : "sexp",s,k);
  8239.  
  8240.         for (i = len; i < len+k; i++) { /* Check balance  */
  8241.         if (!quote && tmpbuf[i] == CMDQ) {
  8242.             quote = 1;
  8243.             continue;
  8244.         }
  8245.         if (quote) {
  8246.             quote = 0;
  8247.             continue;
  8248.         }
  8249.         if (tmpbuf[i] == '(')
  8250.           n++;
  8251.         else if (tmpbuf[i] == ')')
  8252.           n--;
  8253.         }
  8254.         if (n == 0) {        /* Break when balanced */
  8255.         break;
  8256.         }
  8257.         if (n < 0) {        /* Too many right parens */
  8258.         printf("?Unbalanced S-Expression: \"%s\"\n",tmpbuf);
  8259.         return(-9);
  8260.         }
  8261.         contd++;            /* Need more right parens */
  8262.         cmini(ckxech);        /* so keep parsing */
  8263.         tmp += k;            /* adjust buffer pointer */
  8264.         size -= k;            /* and capacity */
  8265.         len += k;            /* and length so far */
  8266.     }
  8267.     s = tmpbuf;
  8268.     makestr(&lastsexp,s);
  8269.     q = cksplit(1,SEXPMAX,s,NULL,NULL,8,0,0); /* Precheck for > 1 SEXP */
  8270.     debug(F101,"sexp split","",q->a_size);
  8271.  
  8272.     if (q->a_size == 1) {        /* We should get exactly one back */
  8273.         char * result, * dosexp();
  8274.         sexprc = 0;            /* Reset out-of-band return code */
  8275.         result = dosexp(s);        /* Get result */
  8276.         debug(F111,"sexp result",result,sexprc);
  8277.         if (sexprc == 0) {        /* Success */
  8278.         /* Echo the result if desired */
  8279.         if ((!xcmdsrc && sexpecho != SET_OFF) || sexpecho == SET_ON)
  8280.           printf(" %s\n",result ? result : "");
  8281.         makestr(&sexpval,result);
  8282.         success = sexppv > -1 ? sexppv : 1;
  8283.         return(success);
  8284.         }
  8285.     }
  8286.     if (sexprc < 0)
  8287.       printf("?Invalid S-Expression: \"%s\"\n",lastsexp);
  8288.     return(-9);
  8289.     }
  8290. #endif /* NOSEXP */
  8291.  
  8292. #endif /* NOSPL */
  8293.  
  8294.     if (cx == XXECH || cx == XXXECH || cx == XXVOID
  8295. #ifndef NOSPL
  8296.     || cx == XXAPC
  8297. #endif /* NOSPL */
  8298.     ) {                /* ECHO or APC */
  8299.     if ((x = cmtxt((cx == XXECH || cx == XXXECH) ?
  8300.                "Text to be echoed" :
  8301.                ((cx == XXVOID) ? "Text" :
  8302.             "Application Program Command text"),
  8303.                "",
  8304.                &s,
  8305.                xxstring
  8306.                )
  8307.          ) < 0)
  8308.       return(x);
  8309.     if (!s) s = "";
  8310. #ifdef COMMENT
  8311. /* This is to preserve the pre-8.0 behavior but it's too confusing */
  8312.     x = strlen(s);
  8313.     x = (x > 1) ? ((s[0] == '"' && s[x-1] == '"') ? 1 : 0) : 0;
  8314. #endif /* COMMENT */
  8315.     s = brstrip(s);            /* Strip braces and doublequotes */
  8316.     if (cx == XXECH) {        /* ECHO */
  8317. #ifndef NOSPL
  8318.         if (!fndiags || fnsuccess) {
  8319. #endif /* NOSPL */
  8320. #ifdef COMMENT
  8321.         /* The "if (x)" business preserves previous behavior */
  8322.         /* by putting back the doublequotes if they were included. */
  8323.         if (x)
  8324.           printf("\"%s\"\n",s);
  8325.         else
  8326. #endif /* COMMENT */
  8327.           printf("%s\n",s);
  8328. #ifndef NOSPL
  8329.         }
  8330. #endif /* NOSPL */
  8331.     } else if (cx == XXXECH) {    /* XECHO */
  8332.         if (x)
  8333.           printf("\"%s\"",s);
  8334.         else
  8335.           printf("%s",s);
  8336. #ifdef UNIX
  8337.         fflush(stdout);
  8338. #endif /* UNIX */
  8339.     } else if (cx == XXAPC) {    /* APC */
  8340. #ifdef CK_APC
  8341.         if (apcactive == APC_LOCAL ||
  8342.         (apcactive == APC_REMOTE && !(apcstatus & APC_UNCH)))
  8343.           return(success = 0);
  8344. #endif /* CK_APC */
  8345.         if (!local) {
  8346.         printf("%c_%s%c\\",ESC,s,ESC);
  8347. #ifdef UNIX
  8348.         fflush(stdout);
  8349. #endif /* UNIX */
  8350.  
  8351.         } else {            /* Local mode - have connection */
  8352. #ifndef NOSPL
  8353.         if (ckmakxmsg(tmpbuf,    /* Form APC string in buffer */
  8354.                   TMPBUFSIZ,
  8355.                   ckctoa((char)ESC),
  8356.                   ckctoa('_'),
  8357.                   s,
  8358.                   ckctoa((char)ESC),
  8359.                   ckctoa('\\'),
  8360.                   NULL,NULL,NULL,NULL,NULL,NULL,NULL
  8361.                   ) > 0)
  8362.           return(success = dooutput(tmpbuf, XXOUT));
  8363.         printf("?Too long\n");
  8364.         return(-9);
  8365. #else
  8366.         printf("%c_%s%c\\",ESC,s,ESC);
  8367. #endif /* NOSPL */
  8368.         }
  8369.     }
  8370.     return(success = 1);
  8371.     }
  8372.  
  8373. #ifndef NOSPL
  8374. /* Copy macro args from/to two levels up, used internally by _floop et al. */
  8375.     if (cx == XXGTA || cx == XXPTA) {    /* _GETARGS, _PUTARGS */
  8376.     int x;
  8377.     debug(F101,"docmd XXGTA","",XXGTA);
  8378.     debug(F101,"docmd cx","",cx);
  8379.     debug(F101,"docmd XXGTA maclvl","",maclvl);
  8380.     x = dogta(cx);
  8381.     debug(F101,"docmd dogta returns","",x);
  8382.     debug(F101,"docmd dogta maclvl","",maclvl);
  8383.     return(x);
  8384.     }
  8385. #endif /* NOSPL */
  8386.  
  8387. #ifndef NOSPL
  8388. #ifdef CKCHANNELIO
  8389.     if (cx == XXFILE)
  8390.       return(dofile(cx));
  8391.     else if (cx == XXF_RE || cx == XXF_WR || cx == XXF_OP ||
  8392.          cx == XXF_CL || cx == XXF_SE || cx == XXF_RW ||
  8393.          cx == XXF_FL || cx == XXF_LI || cx == XXF_ST || cx == XXF_CO)
  8394.       return(dofile(cx));
  8395. #endif /* CKCHANNELIO */
  8396.  
  8397. /* ASK, ASKQ, READ */
  8398.     if (cx == XXASK  || cx == XXASKQ || cx == XXREA ||
  8399.     cx == XXRDBL || cx == XXGETC || cx == XXGETK) {
  8400.     return(doask(cx));
  8401.     }
  8402. #endif /* NOSPL */
  8403.  
  8404. #ifndef NOFRILLS
  8405. #ifndef NOHELP
  8406.     if (cx == XXBUG) {            /* BUG */
  8407.     if ((x = cmcfm()) < 0) return(x);
  8408.     return(dobug());
  8409.     }
  8410. #endif    /* NOHELP */
  8411. #endif    /* NOFRILLS */
  8412.  
  8413. #ifndef NOXFER
  8414.     if (cx == XXBYE) {            /* BYE */
  8415.     extern int ftp_cmdlin;
  8416.     if ((x = cmcfm()) < 0) return(x);
  8417.  
  8418. #ifdef NEWFTP
  8419.     if ((ftpget == 1) || ((ftpget == 2) && ftpisopen())) {
  8420.         extern int stayflg, ftp_fai;
  8421.         success = ftpbye();
  8422.         if (ftp_cmdlin && !stayflg && !local)
  8423.           doexit(ftp_fai ? BAD_EXIT : GOOD_EXIT,-1);
  8424.         else
  8425.           return(success);
  8426.     }
  8427. #endif /* NEWFTP */
  8428.  
  8429.     if (!local) {
  8430.         printf("?No connection - use EXIT to quit.\n");
  8431.         return(-9);
  8432.     }
  8433.  
  8434. #ifdef CK_XYZ
  8435.     if (protocol != PROTO_K) {
  8436.         printf("?Sorry, BYE only works with Kermit protocol\n");
  8437.         return(-9);
  8438.     }
  8439. #endif /* CK_XYZ */
  8440.  
  8441. #ifdef IKS_OPTION
  8442.         if (
  8443. #ifdef CK_XYZ
  8444.             protocol == PROTO_K &&
  8445. #endif /* CK_XYZ */
  8446.             !iks_wait(KERMIT_REQ_START,1)) {
  8447.         printf(
  8448.          "?A Kermit Server is not available to process this command\n");
  8449.         return(-9);            /* Correct the return code */
  8450.         }
  8451. #endif /* IKS_OPTION */
  8452.  
  8453.     bye_active = 1;
  8454.     sstate = setgen('L',"","","");
  8455.     if (local) ttflui();        /* If local, flush tty input buffer */
  8456.     return(0);
  8457.     }
  8458. #endif /* NOXFER */
  8459.  
  8460.     if (cx == XXBEEP) {            /* BEEP */
  8461.         int x;
  8462. #ifdef OS2
  8463.     int y;
  8464.         if ((y = cmkey(beeptab, nbeeptab, "which kind of beep", "information",
  8465.                xxstring)) < 0 )
  8466.       return (y);
  8467.         if ((x = cmcfm()) < 0) return(x);
  8468.         bleep((short)y);        /* y is one of the BP_ values */
  8469. #else  /* OS2 */
  8470.         if ((x = cmcfm()) < 0) return(x);
  8471. #ifndef NOSPL
  8472.         bleep(BP_NOTE);
  8473. #else
  8474.     putchar('\07');
  8475. #endif /* NOSPL */
  8476. #endif /* OS2 */
  8477.         return(0);
  8478.     }
  8479.  
  8480. #ifndef NOFRILLS
  8481.     if (cx == XXCLE)            /* CLEAR */
  8482.       return(success = doclear());
  8483. #endif /* NOFRILLS */
  8484.  
  8485.     if (cx == XXCOM) {            /* COMMENT */
  8486.     if ((x = cmtxt("Text of comment line","",&s,NULL)) < 0)
  8487.       return(x);
  8488.     /* Don't change SUCCESS flag for this one */
  8489.     return(0);
  8490.     }
  8491.  
  8492. #ifndef NOLOCAL
  8493.     if (cx == XXCON || cx == XXCQ)    /* CONNECT or CONNECT /QUIETLY */
  8494.       return(doxconn(cx));
  8495. #endif /* NOLOCAL */
  8496.  
  8497. #ifndef NOFRILLS
  8498. #ifdef ZCOPY
  8499.     if (cx == XXCPY) {            /* COPY a file */
  8500. #ifdef IKSD
  8501.     if (inserver && !ENABLED(en_cpy)) {
  8502.         printf("?Sorry, COPY is disabled\n");
  8503.         return(-9);
  8504.     }
  8505. #endif /* IKSD */
  8506. #ifdef CK_APC
  8507.     if (apcactive == APC_LOCAL ||
  8508.         (apcactive == APC_REMOTE && !(apcstatus & APC_UNCH))
  8509.         )
  8510.       return(success = 0);
  8511. #endif /* CK_APC */
  8512.     return(docopy());
  8513.     }
  8514. #endif /* ZCOPY */
  8515. #ifdef NT
  8516.     if ( cx == XXLINK ) {
  8517. #ifdef IKSD
  8518.         if (inserver && !ENABLED(en_cpy)) {
  8519.             printf("?Sorry, LINK (COPY) is disabled\n");
  8520.             return(-9);
  8521.         }
  8522. #endif /* IKSD */
  8523. #ifdef CK_APC
  8524.         if (apcactive == APC_LOCAL ||
  8525.             (apcactive == APC_REMOTE && !(apcstatus & APC_UNCH))
  8526.             )
  8527.           return(success = 0);
  8528. #endif /* CK_APC */
  8529.         return(dolink());
  8530.     }
  8531. #endif /* NT */
  8532. #endif /* NOFRILLS */
  8533.  
  8534.     /* CD and friends */
  8535.     if (cx == XXCWD  || cx == XXCDUP || cx == XXBACK ||
  8536.     cx == XXLCWD || cx == XXLCDU || cx == XXKCD) {
  8537. #ifdef LOCUS
  8538.     if (!locus) {
  8539.         if (cx == XXCWD) {
  8540. #ifdef NOXFER
  8541.                 return(-2);
  8542. #else
  8543.                 return(dormt(XZCWD));
  8544. #endif /* NOXFER */
  8545.         } else if (cx == XXCDUP) {
  8546. #ifdef NOXFER
  8547.                 return(-2);
  8548. #else
  8549.                 return(dormt(XZCDU));
  8550. #endif /* NOXFER */
  8551.             }
  8552.     }
  8553. #endif /* LOCUS */
  8554. #ifdef IKSD
  8555.     if (inserver && !ENABLED(en_cwd)) {
  8556.         printf("?Sorry, changing directories is disabled\n");
  8557.         return(-9);
  8558.     }
  8559. #endif /* IKSD */
  8560.     return(success = docd(cx));
  8561.     }
  8562.  
  8563.     if (cx == XXCHK)            /* CHECK */
  8564.       return(success = dochk());
  8565.  
  8566.     if (cx == XXCLO) {            /* CLOSE */
  8567.     x = cmkey(clstab,ncls,"\"CONNECTION\", or log or file to close",
  8568.           "connection",xxstring);
  8569.     if (x == -3) {
  8570.         printf("?You must say which file or log\n");
  8571.         return(-9);
  8572.     }
  8573.     if (x < 0) return(x);
  8574.     if ((y = cmcfm()) < 0) return(y);
  8575. #ifndef NOLOCAL
  8576.     if (x == 9999) {        /* CLOSE CONNECTION */
  8577.         x = clsconnx(0);
  8578.         switch (x) {
  8579.           case 0:
  8580.         if (msgflg) printf("?Connection was not open\n");
  8581.           case -1:
  8582.         return(0);
  8583.           case 1:
  8584.         whyclosed = WC_CLOS;
  8585.         return(1);
  8586.         }
  8587.         return(0);
  8588.     }
  8589. #endif /* NOLOCAL */
  8590.     y = doclslog(x);
  8591.     success = (y == 1);
  8592.     return(success);
  8593.     }
  8594.  
  8595. #ifndef NOSPL
  8596.     if (cx == XXDCL || cx == XXUNDCL) {    /* DECLARE an array */
  8597.     return(dodcl(cx));
  8598.     }
  8599. #endif /* NOSPL */
  8600.  
  8601. #ifndef NODIAL
  8602.     if (cx == XXRED  || cx == XXDIAL || cx == XXPDIA ||
  8603.     cx == XXANSW || cx == XXLOOK) { /* DIAL, REDIAL etc */
  8604. #ifdef VMS
  8605.     extern int batch;
  8606. #else
  8607. #ifdef UNIXOROSK
  8608.     extern int backgrd;
  8609. #endif /* UNIXOROSK */
  8610. #endif /* VMS */
  8611.     x = dodial(cx);
  8612.     debug(F101,"dodial returns","",x);
  8613.     if ((cx == XXDIAL || cx == XXRED || cx == XXANSW) &&
  8614.         (x > 0) &&            /* If DIAL or REDIAL succeeded */
  8615.         (dialsta != DIA_PART) &&    /* and it wasn't partial */
  8616.         (dialcon > 0)) {
  8617.         if ((dialcon == 1 ||    /* And DIAL CONNECT is ON, */
  8618.         ((dialcon == 2) &&    /* or DIAL CONNECT is AUTO */
  8619.          !xcmdsrc        /* and we're at top level... */
  8620. #ifdef VMS
  8621.          && !batch        /* Not if running from batch */
  8622. #else
  8623. #ifdef UNIXOROSK
  8624.          && !backgrd        /* Not if running in background */
  8625. #endif /* UNIXOROSK */
  8626. #endif /* VMS */
  8627.          ))) /* Or AUTO */
  8628.           x = doconect(dialcq,    /* Then also CONNECT */
  8629.                            cmdlvl == 0 ? 1 : 0
  8630.                );
  8631.         if (ttchk() < 0)
  8632.           dologend();
  8633.     }
  8634.     return(success = x);
  8635.     }
  8636. #endif /* NODIAL */
  8637.  
  8638. #ifndef NOPUSH
  8639. #ifdef CK_REXX
  8640.     if (cx == XXREXX) {            /* REXX */
  8641.         extern int nopush;
  8642.         if ( nopush )
  8643.           return(success=0);
  8644.         return(dorexx());
  8645.     }
  8646. #endif /* CK_REXX */
  8647. #endif /* NOPUSH */
  8648.  
  8649. #ifndef NOFRILLS
  8650.     if (cx == XXDEL || cx == XXLDEL) {    /* DELETE */
  8651. #ifdef LOCUS
  8652.     if (!locus && cx != XXLDEL) {
  8653. #ifdef NOXFER
  8654.         return(-2);
  8655. #else
  8656.         return(dormt(XZDEL));
  8657. #endif /* NOXFER */
  8658.         }
  8659. #endif /* LOCUS */
  8660. #ifdef IKSD
  8661.     if (inserver && (!ENABLED(en_del)
  8662. #ifdef CK_LOGIN
  8663.              || isguest
  8664. #endif /* CK_LOGIN */
  8665.              )) {
  8666.         printf("?Sorry, DELETE is disabled\n");
  8667.         return(-9);
  8668.     }
  8669. #endif /* IKSD */
  8670. #ifdef CK_APC
  8671.     if ((apcactive == APC_LOCAL) ||
  8672.         ((apcactive == APC_REMOTE) && (!(apcstatus & APC_UNCH))))
  8673.       return(success = 0);
  8674. #endif /* CK_APC */
  8675.     return(dodel());
  8676.     }
  8677. #endif /* NOFRILLS */
  8678.  
  8679.     if (cx == XXTOUC)            /* TOUCH */
  8680.       return(dodir(cx));
  8681.  
  8682.     /* DIRECTORY commands */
  8683.  
  8684.     if (cx == XXDIR  || cx == XXLS || cx == XXLDIR ||
  8685.     cx == XXWDIR || cx == XXHDIR) {
  8686. #ifdef LOCUS
  8687.     if (!locus && cx != XXLDIR) {
  8688. #ifdef NOXFER
  8689.         return(-2);
  8690. #else
  8691.         return(dormt(XZDIR));
  8692. #endif /* NOXFER */
  8693.         }
  8694. #endif /* LOCUS */
  8695. #ifdef IKSD
  8696.     if (inserver && !ENABLED(en_dir)) {
  8697.         printf("?Sorry, DIRECTORY is disabled\n");
  8698.         return(-9);
  8699.     }
  8700. #endif /* IKSD */
  8701.     return(dodir(cx));
  8702.     }
  8703.  
  8704. #ifndef NOSPL
  8705.     if (cx == XXELS)            /* ELSE */
  8706.       return(doelse());
  8707. #endif /* NOSPL */
  8708.  
  8709. #ifndef NOSERVER
  8710. #ifndef NOFRILLS
  8711.     if (cx == XXENA || cx == XXDIS) {    /* ENABLE, DISABLE */
  8712.     s = (cx == XXENA) ?
  8713.       "Server function to enable" :
  8714.         "Server function to disable";
  8715.  
  8716.     if ((x = cmkey(enatab,nena,s,"",xxstring)) < 0) {
  8717.         if (x == -3) {
  8718.         printf("?Name of server function required\n");
  8719.         return(-9);
  8720.         } else return(x);
  8721.     }
  8722.     if ((y = cmkey(kmstab,3,"mode","both",xxstring)) < 0) {
  8723.         if (y == -3) {
  8724.         printf("?Please specify remote, local, or both\n");
  8725.         return(-9);
  8726.         } else return(y);
  8727.     }
  8728.     if (cx == XXDIS)        /* Disabling, not enabling */
  8729.       y = 3 - y;
  8730.     if ((z = cmcfm()) < 0) return(z);
  8731. #ifdef CK_APC
  8732.     if ((apcactive == APC_LOCAL) ||
  8733.         ((apcactive == APC_REMOTE) && (!(apcstatus & APC_UNCH))))
  8734.       return(success = 0);
  8735. #endif /* CK_APC */
  8736. #ifdef IKSD
  8737.         /* This may seem like it duplicates the work in doenable()  */
  8738.         /* but this code returns failure whereas doenable() returns */
  8739.         /* success.                                                 */
  8740.         if (inserver &&
  8741. #ifdef IKSDCONF
  8742.             iksdcf &&
  8743. #endif /* IKSDCONF */
  8744.             (x == EN_HOS || x == EN_PRI || x == EN_MAI || x == EN_WHO ||
  8745.               isguest))
  8746.             return(success = 0);
  8747. #endif /* IKSD */
  8748.     return(doenable(y,x));
  8749.     }
  8750. #endif /* NOFRILLS */
  8751. #endif /* NOSERVER */
  8752.  
  8753. #ifndef NOSPL
  8754.     if (cx == XXRET) {            /* RETURN */
  8755.     if ((x = cmtxt("Optional return value","",&s,NULL)) < 0)
  8756.       return(x);
  8757.     s = brstrip(s);            /* Strip braces */
  8758.     if (cmdlvl == 0)        /* At top level, nothing happens... */
  8759.       return(success = 1);
  8760.     switch (cmdstk[cmdlvl].src) {    /* Action depends on command source */
  8761.       case CMD_TF:            /* Command file */
  8762.         popclvl();            /* Pop command level */
  8763.         return(success = 1);    /* always succeeds */
  8764.       case CMD_MD:            /* Macro */
  8765.       case CMD_KB:            /* Prompt */
  8766.         return(doreturn(s));    /* Trailing text is return value. */
  8767.       default:            /* Shouldn't happen */
  8768.         return(-2);
  8769.     }
  8770.     }
  8771. #endif /* NOSPL */
  8772.  
  8773. #ifndef NOSPL
  8774.     if (cx == XXOPE)            /* OPEN */
  8775.       return(doopen());
  8776. #endif /* NOSPL */
  8777.  
  8778. #ifndef NOSPL
  8779.     if (cx == XXOUT || cx == XXLNOUT) {    /* OUTPUT or LINEOUT */
  8780.     if ((x = cmtxt("Text to be output","",&s,NULL)) < 0)
  8781.       return(x);
  8782. #ifdef CK_APC
  8783.     if ((apcactive == APC_LOCAL) ||
  8784.         ((apcactive == APC_REMOTE) && (!(apcstatus & APC_UNCH))))
  8785.       return(success = 0);
  8786. #endif /* CK_APC */
  8787.     debug(F110,"OUTPUT 1",s,0);
  8788.     s = brstrip(s);            /* Strip enclosing braces, */
  8789.     debug(F110,"OUTPUT 2",s,0);
  8790. /*
  8791.   I don't think I could ever fully explain this in a million years...
  8792.   We have read the user's string without calling the variable-expander
  8793.   function.  Now, before we call it, we have to double backslashes that
  8794.   appear before \N, \B, \L, and \ itself, so the expander function will
  8795.   reduce them back to single backslashes, so when we call dooutput()...
  8796.   But it's more complicated than that.
  8797. */
  8798.     if (cmdgquo()) {        /* Only if COMMAND QUOTING ON ... */
  8799.         for (x = 0, y = 0; s[x]; x++, y++) {
  8800.         if (s[x] == CMDQ) {
  8801.             char c = s[x+1];
  8802.             if (c == 'n' || c == 'N' ||
  8803.             c == 'b' || c == 'B' ||
  8804.             c == 'l' || c == 'L' ||
  8805.             c == CMDQ)
  8806.               line[y++] = CMDQ;
  8807.         }
  8808.         line[y] = s[x];
  8809.         }
  8810.         line[y++] = '\0';        /* Now expand variables, etc. */
  8811.         debug(F110,"OUTPUT 3",line,0);
  8812.         s = line+y+1;
  8813.         x = LINBUFSIZ - (int) strlen(line) - 1;
  8814.         debug(F101,"OUTPUT size","",x);
  8815.         if (zzstring(line,&s,&x) < 0)
  8816.           return(success = 0);
  8817.         s = line+y+1;
  8818.         debug(F110,"OUTPUT 4",s,0);
  8819.     }
  8820.     success = dooutput(s,cx);
  8821.     return(success);
  8822.     }
  8823. #endif /* NOSPL */
  8824.  
  8825. #ifdef ANYX25
  8826. #ifndef IBMX25
  8827.     if (cx == XXPAD) {            /* PAD commands */
  8828.     x = cmkey(padtab,npadc,"PAD command","",xxstring);
  8829.     if (x == -3) {
  8830.         printf("?You must specify a PAD command to execute\n");
  8831.         return(-9);
  8832.     }
  8833.     if (x < 0) return(x);
  8834.  
  8835.     switch (x) {
  8836.       case XYPADL:
  8837.         if (x25stat() < 0)
  8838.           printf("Sorry, you must 'set network' & 'set host' first\r\n");
  8839.         else {
  8840.         x25clear();
  8841.         initpad();
  8842.         }
  8843.         break;
  8844.       case XYPADS:
  8845.         if (x25stat() < 0)
  8846.           printf("Not connected\r\n");
  8847.         else {
  8848.         extern int linkid, lcn;
  8849.         conol("Connected thru ");
  8850.         conol(ttname);
  8851.         printf(", Link id %d, Logical channel number %d\r\n",
  8852.                linkid,lcn);
  8853.         }
  8854.         break;
  8855.       case XYPADR:
  8856.         if (x25stat() < 0)
  8857.           printf("Sorry, you must 'set network' & 'set host' first\r\n");
  8858.         else
  8859.           x25reset(0,0);
  8860.         break;
  8861.       case XYPADI:
  8862.         if (x25stat() < 0)
  8863.           printf("Sorry, you must 'set network' & 'set host' first\r\n");
  8864.         else
  8865.           x25intr(0);
  8866.     }
  8867.     return(0);
  8868.     }
  8869. #endif /* IBMX25 */
  8870. #endif /* ANYX25 */
  8871.  
  8872. #ifndef NOSPL
  8873.     if (cx == XXPAU || cx == XXWAI || cx == XXMSL) /* PAUSE, WAIT, etc */
  8874.       return(dopaus(cx));
  8875. #endif /* NOSPL */
  8876.  
  8877. #ifndef NOFRILLS
  8878.     if (cx == XXPRI) {
  8879. #ifdef IKSD
  8880. #ifdef CK_LOGIN
  8881.     if (inserver && (isguest || !ENABLED(en_pri))) {
  8882.         printf("?Sorry, printing is disabled\n");
  8883.         return(-9);
  8884.     }
  8885. #endif /* CK_LOGIN */
  8886. #endif /* IKSD */
  8887.     if ((x = cmifi("File to print","",&s,&y,xxstring)) < 0) {
  8888.         if (x == -3) {
  8889.         printf("?A file specification is required\n");
  8890.         return(-9);
  8891.         } else return(x);
  8892.     }
  8893.     if (y != 0) {
  8894.         printf("?Wildcards not allowed\n");
  8895.         return(-9);
  8896.     }
  8897.     ckstrncpy(line,s,LINBUFSIZ);
  8898.     s = "";
  8899. #ifndef NT
  8900.     if ((x = cmtxt("Local print command options, or carriage return","",&s,
  8901.                xxstring)) < 0)
  8902.       return(x);
  8903. #endif /* NT */
  8904.     if ((x = cmcfm()) < 0)
  8905.       return(x);
  8906.     return(success = (zprint(s,line) == 0) ? 1 : 0);
  8907.     }
  8908. #endif /* NOFRILLS */
  8909.  
  8910. #ifdef TCPSOCKET
  8911. #ifndef NOPUSH
  8912.     if (cx == XXPNG)             /* PING an IP host */
  8913.       return(doping());
  8914. #endif /* NOPUSH */
  8915.  
  8916. #ifndef NOFTP
  8917.     if (cx == XXFTP)            /* FTP */
  8918. #ifdef SYSFTP
  8919. #ifndef NOPUSH
  8920.       return(doftp());            /* Just runs system's ftp program */
  8921. #else
  8922.       return(-2);
  8923. #endif /* NOPUSH */
  8924. #else
  8925.     return(doxftp());
  8926. #endif /* SYSFTP */
  8927. #endif /* NOFTP */
  8928. #endif /* TCPSOCKET */
  8929.  
  8930.     if (cx == XXPWD || cx == XXLPWD) {    /* PWD */
  8931. #ifdef OS2
  8932.     char *pwp;
  8933. #endif /* OS2 */
  8934.     if ((x = cmcfm()) < 0)
  8935.       return(x);
  8936. #ifdef LOCUS
  8937.     if (!locus && cx != XXLPWD) {
  8938. #ifdef NOXFER
  8939.         return(-2);
  8940. #else
  8941.         return(dormt(XZPWD));
  8942. #endif /* NOXFER */
  8943.         }
  8944. #endif /* LOCUS */
  8945.  
  8946. #ifndef MAC
  8947. #ifndef OS2
  8948. #ifdef UNIX
  8949.     printf("%s\n",zgtdir());
  8950. #else
  8951.     xsystem(PWDCMD);
  8952. #endif /* UNIX */
  8953.     return(success = 1);        /* Blind faith */
  8954. #else  /* OS2 */
  8955.     if (pwp = zgtdir()) {
  8956.         if (*pwp) {
  8957. #ifdef NT
  8958.         line[0] = NUL;
  8959.         ckGetLongPathName(pwp,line,LINBUFSIZ);
  8960.         line[LINBUFSIZ-1] = NUL;
  8961.         tmpbuf[0] = NUL;
  8962.         GetShortPathName(pwp,tmpbuf,TMPBUFSIZ);
  8963.         tmpbuf[TMPBUFSIZ-1] = NUL;
  8964.         pwp = line;
  8965.         if (!strcmp(line,tmpbuf)) {
  8966. #endif /* NT */
  8967.             printf("%s\n",pwp);
  8968. #ifdef NT
  8969.         } else {
  8970.             printf("  Long name:  %s\n",line);
  8971.             printf("  Short name: %s\n",tmpbuf);
  8972.         }            
  8973. #endif /* NT */
  8974.         }
  8975.         return(success = ((int)strlen(pwp) > 0));
  8976.     } else return(success = 0);
  8977. #endif /* OS2 */
  8978. #else  /* MAC */
  8979.     if (pwp = zgtdir()) {
  8980.         printf("%s\n",pwp);
  8981.         return(success = ((int)strlen(pwp) > 0));
  8982.     } else return(success = 0);
  8983. #endif /* MAC */
  8984.     }
  8985.  
  8986.     if (cx == XXQUI || cx == XXEXI) {    /* EXIT, QUIT */
  8987.     extern int quitting;
  8988.  
  8989.     if ((y = cmnum("exit status code",ckitoa(xitsta),10,&x,xxstring)) < 0)
  8990.       return(y);
  8991.     if ((y = cmtxt("Optional EXIT message","",&s,xxstring)) < 0)
  8992.       return(y);
  8993.     s = brstrip(s);
  8994.     ckstrncpy(line,s,LINBUFSIZ);
  8995.  
  8996.     if (!hupok(0))            /* Check if connection still open */
  8997.       return(success = 0);
  8998.  
  8999.     if (line[0])            /* Print EXIT message if given */
  9000.       printf("%s\n",(char *)line);
  9001.  
  9002.     quitting = 1;            /* Flag that we are quitting. */
  9003.  
  9004. #ifdef VMS
  9005.     doexit(GOOD_EXIT,x);
  9006. #else
  9007. #ifdef OSK
  9008. /* Returning any codes here makes the OS-9 shell print an error message. */
  9009.     doexit(GOOD_EXIT,-1);
  9010. #else
  9011. #ifdef datageneral
  9012.         doexit(GOOD_EXIT,x);
  9013. #else
  9014.     doexit(x,-1);
  9015. #endif /* datageneral */
  9016. #endif /* OSK */
  9017. #endif /* VMS */
  9018.     }
  9019.  
  9020. #ifndef NOXFER
  9021. #ifndef NOFRILLS
  9022.     if (cx == XXERR) {            /* ERROR */
  9023. #ifdef CK_XYZ
  9024.     if (protocol != PROTO_K) {
  9025.         printf("Sorry, E-PACKET only works with Kermit protocol\n");
  9026.         return(-9);
  9027.     }
  9028. #endif /* CK_XYZ */
  9029.     if ((x = cmcfm()) < 0) return(x);
  9030.     ttflui();
  9031.     epktflg = 1;
  9032.     sstate = 'a';
  9033.     return(0);
  9034.     }
  9035. #endif /* NOFRILLS */
  9036.  
  9037.     if (cx == XXFIN) {            /* FINISH */
  9038. #ifdef NEWFTP
  9039.     if ((ftpget == 1) || ((ftpget == 2) && ftpisopen()))
  9040.       return(ftpbye());
  9041. #endif /* NEWFTP */
  9042. #ifdef CK_XYZ
  9043.     if (protocol != PROTO_K) {
  9044.         printf("Sorry, FINISH only works with Kermit protocol\n");
  9045.         return(-9);
  9046.     }
  9047. #endif /* CK_XYZ */
  9048.     if ((x = cmcfm()) < 0) return(x);
  9049.  
  9050. #ifdef IKS_OPTION
  9051.         if (
  9052. #ifdef CK_XYZ
  9053.             protocol == PROTO_K &&
  9054. #endif /* CK_XYZ */
  9055.             !iks_wait(KERMIT_REQ_START,1)) {
  9056.         printf(
  9057.               "?A Kermit Server is not available to process this command\n");
  9058.         return(-9);            /* Correct the return code */
  9059.         }
  9060. #endif /* IKS_OPTION */
  9061.  
  9062.     sstate = setgen('F',"","","");
  9063.     if (local) ttflui();        /* If local, flush tty input buffer */
  9064.     return(0);
  9065.     }
  9066. #endif /* NOXFER */
  9067.  
  9068. #ifndef NOSPL
  9069.     if (cx == XXFOR)            /* FOR loop */
  9070.       return(dofor());
  9071. #endif /* NOSPL */
  9072.  
  9073. #ifndef NOXFER
  9074.     /* GET MGET REGET RETRIEVE etc */
  9075.     if (cx == XXGET || cx == XXMGET || cx == XXREGET || cx == XXRETR) {
  9076. #ifdef IKSD
  9077.     if (inserver && !ENABLED(en_sen)) {
  9078.         printf("?Sorry, reception of files is disabled\n");
  9079.         return(-9);
  9080.     }
  9081. #endif /* IKSD */
  9082.     return(doxget(cx));
  9083.     }
  9084. #endif /* NOXFER */
  9085.  
  9086. #ifndef NOSPL
  9087. #ifndef NOFRILLS
  9088.     if (cx == XXGOK) {            /* GETOK */
  9089.     return(success = doask(cx));
  9090.     }
  9091. #endif /* NOFRILLS */
  9092. #endif /* NOSPL */
  9093.  
  9094.     if (cx == XXHLP) {            /* HELP */
  9095. #ifdef NOHELP
  9096.     return(dohlp(XXHLP));
  9097. #else
  9098.     x = cmkey2(cmdtab,
  9099.            ncmd,"\nCommand or topic","help",toktab,xxstring,1+2+8);
  9100.     debug(F111,"HELP command x",cmdbuf,x);
  9101.     if (x == -5) {
  9102.         y = chktok(toktab);
  9103.         debug(F101,"HELP cmkey token","",y);
  9104.         /* ungword(); */
  9105.         switch (y) {
  9106. #ifndef NOPUSH
  9107.           case '!':
  9108.           case '@': x = XXSHE; break;
  9109.           case '<': x = XXFUN; break;
  9110. #endif /* NOPUSH */
  9111.           case '#': x = XXCOM; break;
  9112.           case ';': x = XXCOM; break;
  9113. #ifndef NOSPL
  9114.               case '.': x = XXDEF; break;
  9115.           case ':': x = XXLBL; break;
  9116. #ifndef NOSEXP
  9117.           case '(': x = XXSEXP; break;
  9118. #endif /* NOSEXP */
  9119. #endif /* NOSPL */
  9120. #ifdef CK_RECALL
  9121.           case '^': x = XXREDO; break;
  9122. #endif    /* CK_RECALL */
  9123.           case '&': x = XXECH; break; /* (what is this?) */
  9124.           default:
  9125.         printf("\n?Invalid - %s\n",cmdbuf);
  9126.         x = -2;
  9127.         }
  9128.     }
  9129.     makestr(&hlptok,atmbuf);
  9130.     debug(F111,"HELP token",hlptok,x);
  9131.     return(dohlp(x));
  9132. #endif /* NOHELP */
  9133.     }
  9134.  
  9135. #ifndef NOHELP
  9136.     if (cx == XXINT)            /* INTRO */
  9137.       return(hmsga(introtxt));
  9138.     if (cx == XXNEW) {            /* NEWS */
  9139.     int x;
  9140.     extern char * k_info_dir;
  9141.     x = hmsga(newstxt);
  9142.     return(x);
  9143.     }
  9144.  
  9145. #ifdef OS2ONLY
  9146.     if (cx == XXUPD) {            /* View UPDATE file */
  9147.         extern char exedir[];
  9148.         char * pTopic;
  9149.         char updstr[2048];
  9150.         if ((x = cmtxt("topic name","",&pTopic,xxstring)) < 0)
  9151.             return x;
  9152. #ifdef COMMENT
  9153.     sprintf(updstr,
  9154.         "start view %s\\docs\\k2.inf+%s\\docs\\using_ck.inf+\
  9155. %s\\docs\\dialing.inf+%s\\docs\\modems.inf %s",
  9156.         exedir,exedir,exedir,exedir,pTopic
  9157.         );
  9158. #else
  9159.     if (ckmakxmsg(updstr,
  9160.              2048,
  9161.              "start view ",
  9162.              exedir,
  9163.              "\\docs\\k2.inf+",
  9164.              exedir,
  9165.              "\\docs\\using_ck.inf+",
  9166.              exedir,
  9167.              "\\docs\\dialing.inf+",
  9168.              exedir,
  9169.              "\\docs\\modems.inf ",
  9170.              pTopic,
  9171.              NULL,
  9172.              NULL
  9173.              ) > 0)
  9174. #endif /* COMMENT */
  9175.       system(updstr);
  9176.         return(success = 1);
  9177.     }
  9178. #endif /* OS2ONLY */
  9179. #endif /* NOHELP */
  9180.  
  9181. #ifndef NOLOCAL
  9182.     if (cx == XXHAN) {            /* HANGUP */
  9183.     if ((x = cmcfm()) < 0) return(x);
  9184. #ifdef NEWFTP
  9185.     if ((ftpget == 1) || ((ftpget == 2) && !local && ftpisopen()))
  9186.       return(success = ftpbye());
  9187. #endif /* NEWFTP */
  9188. #ifndef NODIAL
  9189.     if ((x = mdmhup()) < 1) {
  9190.         debug(F101,"HANGUP mdmup","",x);
  9191. #endif /* NODIAL */
  9192.         x = tthang();
  9193.         debug(F101,"HANGUP tthang","",x);
  9194.         x = (x > -1);
  9195. #ifndef NODIAL
  9196.     }
  9197.     dialsta = DIA_UNK;
  9198. #endif /* NODIAL */
  9199.     whyclosed = WC_CLOS;
  9200.     ttchk();            /* In case of CLOSE-ON-DISCONNECT */
  9201.     dologend();
  9202. #ifdef OS2
  9203.     if (x)
  9204.       DialerSend(OPT_KERMIT_HANGUP, 0);
  9205. #endif /* OS2 */
  9206.     if (x) haveline = 0;
  9207.     return(success = x);
  9208.     }
  9209. #endif /* NOLOCAL */
  9210.  
  9211. #ifndef NOSPL
  9212.     /* INPUT, REINPUT, and MINPUT */
  9213.  
  9214.     if (cx == XXINP || cx == XXREI || cx == XXMINP) {
  9215.     long zz;
  9216.     int flags = 0, incount = 0;
  9217.     extern int itsapattern, isjoin, isinbuflen;
  9218.     int c, getval;
  9219.  
  9220.     struct FDB sw, nu, fl;
  9221.     int fc, havetime = 0;
  9222.     char * m;
  9223.  
  9224.     if (cx == XXREI) {
  9225.         m = "Timeout in seconds (ignored)";
  9226.     } else {
  9227.         m = "Seconds to wait for input,\n or time of day hh:mm:ss,\
  9228.  or switch";
  9229.     }
  9230.     cmfdbi(&sw,            /* First FDB - command switches */
  9231.            _CMKEY,            /* fcode */
  9232.            m,            /* helpmsg */
  9233.            ckitoa(indef),        /* default */
  9234.            "",            /* addtl string data */
  9235.            ninputsw,        /* addtl numeric data 1: tbl size */
  9236.            4,            /* addtl numeric data 2: 4 = cmswi */
  9237.            xxstring,        /* Processing function */
  9238.            inputsw,            /* Keyword table */
  9239.            &nu            /* Pointer to next FDB */
  9240.            );
  9241.     cmfdbi(&nu,
  9242.            _CMNUM,            /* Number */
  9243.            m,            /* Help message */
  9244.            ckitoa(indef),        /* default */
  9245.            "",            /* N/A */
  9246.            10,            /* Radix = 10 */
  9247.            0,            /* N/A */
  9248.            xxstring,        /* Processing function */
  9249.            NULL,            /* N/A */
  9250.            &fl            /* Next */
  9251.            );
  9252.     cmfdbi(&fl,            /* Time of day hh:mm:ss */
  9253.            _CMFLD,            /* fcode */
  9254.            "",            /* hlpmsg */
  9255.            "",
  9256.            "",            /* addtl string data */
  9257.            0,            /* addtl numeric data 1 */
  9258.            0,            /* addtl numeric data 2 */
  9259.            xxstring,
  9260.            NULL,
  9261.            NULL
  9262.            );
  9263.     fc = (cx == XXREI) ? cmfdb(&nu) : cmfdb(&sw); /* Parse something */
  9264.  
  9265.     for (y = 0; y < MINPMAX; y++) {    /* Initialize search strings */
  9266.         mp[y] = 0;            /* Assume it's not a pattern */
  9267.         if (!mpinited) {
  9268.         ms[y] = NULL;
  9269.         }
  9270.         if (ms[y]) {
  9271.         free(ms[y]);        /* Free old strings, if any */
  9272.         ms[y] = NULL;
  9273.         }
  9274.     }
  9275.     mpinited = 1;
  9276.     while (!havetime) {
  9277.         if (fc < 0) {        /* Error */
  9278.         if (fc == -3) {
  9279.             printf("?Syntax error in INPUT-class command\n");
  9280.             return(-9);
  9281.         } else
  9282.           return(fc);
  9283.         }
  9284.         switch (cmresult.fcode) {
  9285.           case _CMKEY:        /* Switch */
  9286.         c = cmgbrk();
  9287.         if ((getval = (c == ':' || c == '=')) &&
  9288.             !(cmgkwflgs() & CM_ARG)) {
  9289.             printf("?This switch does not take an argument\n");
  9290.             return(-9);
  9291.         }
  9292.         if (getval && cmresult.nresult == INPSW_COU) {
  9293.             if ((y = cmnum("Number of bytes to read",
  9294.                    "",10,&x,xxstring)) < 0)
  9295.               return(y);
  9296.             incount = x;
  9297.         }
  9298.         flags |= cmresult.nresult;
  9299.         fc = cmfdb(&sw);    /* Maybe parse more switches */
  9300.         continue;
  9301.  
  9302.           case _CMNUM:        /* Seconds to time out */
  9303.         x = cmresult.nresult;
  9304. #ifdef CKFLOAT
  9305.         if (inscale != 1.0)    /* Scale */
  9306.           x *= inscale;        
  9307. #endif    /* CKFLOAT */
  9308.         havetime++;
  9309.         break;
  9310.  
  9311.           case _CMFLD:
  9312.         zz = tod2sec(atmbuf);    /* Convert to secs since midnight */
  9313.         if (zz < 0L) {
  9314.             printf("?Number, expression, or time of day required\n");
  9315.             return(-9);
  9316.         } else {
  9317.             char now[32];    /* Current time */
  9318.             char *p;
  9319.             long tnow;
  9320.             p = now;
  9321.             ztime(&p);
  9322.             tnow = atol(p+11) * 3600L + atol(p+14) * 60L + atol(p+17);
  9323.             if (zz < tnow)    /* User's time before now */
  9324.               zz += 86400L;    /* So make it tomorrow */
  9325.             zz -= tnow;        /* Seconds from now. */
  9326.             if (zz > -1L) {
  9327.             x = zz;
  9328.             if (zz != (long) x) {
  9329.                 printf(
  9330. "Sorry, arithmetic overflow - hh:mm:ss not usable on this platform.\n"
  9331. );
  9332.                 return(-9);
  9333.             }
  9334.             }
  9335.             havetime++;
  9336.         }
  9337.         break;
  9338.           default:        
  9339.         printf("?Internal error\n");
  9340.         return(-9);
  9341.         }
  9342.     }
  9343.     /* Now parse the search text */
  9344.  
  9345. #ifdef CK_MINPUT
  9346.     if (cx == XXMINP) {        /* MINPUT */
  9347.         int i, k = 0, n = 0;
  9348.         struct stringarray * q;
  9349.         keepallchars = 1;
  9350.         while (k < MINPMAX) {
  9351.         if ((y = cmfld("String or pattern","",&s,xxstring)) < 0) {
  9352.             if (y == -3) {
  9353.             if ((y = cmcfm()) < 0)
  9354.               return(y);
  9355.             break;
  9356.             } else {
  9357.             return(y);
  9358.             }
  9359.         }
  9360.         debug(F111,"MINPUT field",s,k);
  9361.         if (isjoin) {
  9362.             if ((q = cksplit(1,0,s," ",(char *)c1chars,3,0,0))) {
  9363.             char ** ap = q->a_head;
  9364.             n = q->a_size;
  9365.             debug(F101,"minput cksplit size","",n);
  9366.             for (i = 1; i <= n && k < MINPMAX; i++) {
  9367.                 if (!ap[i]) /* Add non-empty elements */
  9368.                   continue;
  9369.                 if (!*(ap[i]))
  9370.                   continue;
  9371.                 makestr(&(ms[k]),ap[i]);
  9372.                 debug(F111,"MINPUT JOIN",ms[k],k);
  9373.                 k++;
  9374.             }
  9375.             }
  9376.         } else {
  9377.             if (s) if (*s) {
  9378.             makestr(&(ms[k]),brstrip(s));
  9379.             if (itsapattern) mp[k] = 1;
  9380.             debug(F111,"MINPUT",ms[k],itsapattern);
  9381.             k++;
  9382.             }
  9383.         }
  9384.         }
  9385.         keepallchars = 0;
  9386.     } else {
  9387. #endif /* CK_MINPUT */
  9388.  
  9389.         /* INPUT or REINPUT */
  9390.  
  9391.         if (flags & INPSW_COU) {
  9392.         if ((y = cmcfm()) < 0)
  9393.           return(y);
  9394.         } else {
  9395.         if ((y = cmtxt("Material to be input","",&s,xxstring)) < 0)
  9396.           return(y);
  9397.         }
  9398.         mp[0] = itsapattern ? 1 : 0;
  9399.         makestr(&(ms[0]),brstrip(s));
  9400.         ms[1] = NULL;
  9401.  
  9402. #ifdef CK_MINPUT
  9403.     }
  9404. #endif /* CK_MINPUT */
  9405.  
  9406.     if (incount > 0)        /* No searching if /COUNT: given */
  9407.       makestr(&(ms[0]),NULL);
  9408.  
  9409.     if (cx == XXINP || cx == XXMINP) { /* Not REINPUT... */
  9410.         i_active = 1;
  9411.         /* Go try to input the search string */
  9412.         success = doinput(x,ms,mp,flags,incount);
  9413.         i_active = 0;
  9414.     } else {            /* REINPUT */
  9415.         success = doreinp(x,ms[0],itsapattern);
  9416.     }
  9417.     if (intime[cmdlvl] && !success) { /* TIMEOUT-ACTION = QUIT? */
  9418.         popclvl();            /* If so, pop command level. */
  9419.         if (pflag && cmdlvl == 0) {
  9420.         if (cx == XXINP)  printf("?INPUT timed out\n");
  9421.         if (cx == XXMINP) printf("?MINPUT timed out\n");
  9422.         if (cx == XXREI)  printf("?REINPUT failed\n");
  9423.         }
  9424.     }
  9425.     return(success);        /* Return do(re)input's return code */
  9426.     }
  9427.  
  9428. #endif /* NOSPL */
  9429.  
  9430.     if (cx == XXLOG) {            /* LOG */
  9431.     x = cmkey(logtab,nlog,"What to log","",xxstring);
  9432.     if (x == -3) {
  9433.         printf("?Type of log required\n");
  9434.         return(-9);
  9435.     }
  9436.     if (x < 0) return(x);
  9437.     x = dolog(x);
  9438.     if (x < 0)
  9439.       return(x);
  9440.     else
  9441.       return(success = x);
  9442.     }
  9443.  
  9444.     if (cx == XXLOGIN) {        /* (REMOTE) LOGIN */
  9445. #ifdef NEWFTP
  9446.     if ((ftpget == 1) || ((ftpget == 2) && ftpisopen()))
  9447.       return(success = doftpusr());
  9448. #endif /* NEWFTP */
  9449. #ifdef IKSD
  9450.     if (inserver) {
  9451.         printf("?Already logged in\n");
  9452.         return(-9);
  9453.     } else
  9454. #endif /* IKSD */
  9455.     {
  9456. #ifdef NOXFER
  9457.         return(-2);
  9458. #else
  9459.         return(dormt(XZLGI));
  9460. #endif /* NOXFER */
  9461.     }
  9462.     }
  9463.     if (cx == XXLOGOUT) {        /* (REMOTE) LOGOUT */
  9464. #ifdef NEWFTP
  9465.     if ((ftpget == 1) || ((ftpget == 2) && ftpisopen()))
  9466.       return(success = doftpres());
  9467. #endif /* NEWFTP */
  9468.  
  9469. #ifdef IKSD
  9470.         if (inserver) {
  9471.         if ((x = cmcfm()) < 0)
  9472.           return(x);
  9473.         doexit(GOOD_EXIT,xitsta);
  9474.     } else
  9475. #endif /* IKSD */
  9476.     if (!local || (network && ttchk() < 0)) {
  9477.         printf("?No connection.\n");
  9478.         return(-9);
  9479.     } else {
  9480. #ifdef NOXFER
  9481.         return(-2);
  9482. #else
  9483.         return(dormt(XZLGO));
  9484. #endif /* NOXFER */
  9485.     }
  9486.     }
  9487.  
  9488. #ifndef NOSCRIPT
  9489.     if (cx == XXLOGI) {            /* UUCP-style script */
  9490.     if ((x = cmtxt("expect-send expect-send ...","",&s,xxstring)) < 0)
  9491.       return(x);
  9492. #ifdef CK_APC
  9493.     if ((apcactive == APC_LOCAL) ||
  9494.         ((apcactive == APC_REMOTE) && (!(apcstatus & APC_UNCH))))
  9495.       return(success = 0);
  9496. #endif /* CK_APC */
  9497. #ifdef VMS
  9498.     conres();            /* For Ctrl-C to work... */
  9499. #endif /* VMS */
  9500.     return(success = dologin(s));    /* Return 1=completed, 0=failed */
  9501.     }
  9502. #endif /* NOSCRIPT */
  9503.  
  9504. #ifndef NOXFER
  9505. #ifdef PIPESEND
  9506.     if (cx == XXCREC) {            /* CRECEIVE */
  9507.     if (protocol != PROTO_K) {
  9508.         printf("?Sorry, CRECEIVE works only with Kermit protocol\n");
  9509.         return(-9);
  9510.     } else
  9511.       return(doxget(cx));
  9512.     }
  9513.     if (cx == XXCGET) {            /* CGET */
  9514.     return(doxget(cx));
  9515.     }
  9516. #endif /* PIPESEND */
  9517.  
  9518.     if (cx == XXREC)            /* RECEIVE */
  9519.       return(doxget(cx));
  9520. #endif /* NOXFER */
  9521.  
  9522. #ifndef NOXFER
  9523.     if (cx == XXREM) {            /* REMOTE */
  9524. #ifdef NEWFTP
  9525.     if ((ftpget == 1) || ((ftpget == 2) && ftpisopen()))
  9526.       return(doftprmt(0,0));
  9527. #endif /* NEWFTP */
  9528. #ifdef CK_XYZ
  9529.     if (protocol != PROTO_K) {
  9530.         printf("Sorry, REMOTE commands only work with Kermit protocol\n");
  9531.         return(-9);
  9532.     }
  9533. #endif /* CK_XYZ */
  9534.     x = cmkey(remcmd,nrmt,"Remote Kermit server command","",xxstring);
  9535.     if (x == -3) {
  9536.         printf("?You must specify a command for the remote server\n");
  9537.         return(-9);
  9538.     }
  9539.     return(dormt(x));
  9540.     }
  9541. #endif /* NOXFER */
  9542.  
  9543. #ifndef NORENAME
  9544. #ifndef NOFRILLS
  9545.     if (cx == XXREN || cx == XXLREN) {    /* RENAME */
  9546. #ifdef LOCUS
  9547.     if (!locus && cx != XXLREN) {
  9548. #ifdef NOXFER
  9549.         return(-2);
  9550. #else
  9551.         return(dormt(XZREN));
  9552. #endif /* NOXFER */
  9553.         }
  9554. #endif /* LOCUS */
  9555. #ifdef IKSD
  9556.     if (inserver && (!ENABLED(en_ren)
  9557. #ifdef CK_LOGIN
  9558.              || isguest
  9559. #endif /* CK_LOGIN */
  9560.              )) {
  9561.         printf("?Sorry, renaming of files is disabled\n");
  9562.         return(-9);
  9563.     }
  9564. #endif /* IKSD */
  9565. #ifdef CK_APC
  9566.     if ((apcactive == APC_LOCAL) ||
  9567.         ((apcactive == APC_REMOTE) && (!(apcstatus & APC_UNCH))))
  9568.       return(success = 0);
  9569. #endif /* CK_APC */
  9570.     return(dorenam());
  9571.     }
  9572. #endif /* NOFRILLS */
  9573. #endif /* NORENAME */
  9574.  
  9575.     if (cx == XXEIGHT) {        /* EIGHTBIT */
  9576.     extern int parity, cmask, cmdmsk;
  9577.     if ((x = cmcfm()) < 0)
  9578.       return(x);
  9579.     parity = 0;
  9580.     cmask = 0xff;
  9581.     cmdmsk = 0xff;
  9582.     return(success = 1);
  9583.     }
  9584.  
  9585. #ifndef NOXFER
  9586. /* SEND, CSEND, MOVE, MAIL, and RESEND use the new common code */
  9587.  
  9588.     if (cx == XXSEN            /* SEND */
  9589. #ifdef PIPESEND
  9590.     || cx == XXCSEN            /* CSEND */
  9591. #endif /* PIPESEND */
  9592.     || cx == XXMOVE            /* MOVE */
  9593.     || cx == XXMAI            /* MAIL */
  9594. #ifdef CK_RESEND
  9595.     || cx == XXRSEN            /* RESEND */
  9596. #endif /* CK_RESEND */
  9597.     ) {
  9598. #ifdef IKSD
  9599.     if (inserver && !ENABLED(en_get)) {
  9600.         printf("?Sorry, sending files is disabled\n");
  9601.         return(-9);
  9602.     }
  9603. #endif /* IKSD */
  9604.     return(doxsend(cx));
  9605.     }
  9606.  
  9607. /* PSEND, ADD, and REMOVE use special parsing */
  9608.  
  9609. #ifdef ADDCMD
  9610.     /* ADD and REMOVE */
  9611.     if (cx == XXADD || cx == XXREMV) {
  9612.     char * m;
  9613.     m = (cx == XXADD) ? "Add to which list?" : "Remove from which list?";
  9614.     x = cmkey(addtab,naddtab,m,"",xxstring);
  9615.     if (x < 0)
  9616.       return(x);
  9617. #ifndef NOMSEND
  9618.     if (x == ADD_SND)
  9619.       return(addsend(cx));
  9620.     else
  9621. #endif /* NOMSEND */
  9622.       return(doadd(cx,x));
  9623.     }
  9624. #endif /* ADDCMD */
  9625.  
  9626. #ifdef CK_RESEND
  9627.     if (cx == XXPSEN) {            /* PSEND */
  9628.     int seekto = 0;            /* FIX THIS */
  9629.  
  9630.     cmarg = cmarg2 = "";
  9631.     x = cmifi("File to partially send", "", &s, &y, xxstring);
  9632.     if (x < 0) {
  9633.         if (x == -3) {
  9634.         printf("?A file specification is required\n");
  9635.         return(-9);
  9636.         } else return(x);
  9637.     }
  9638.     nfils = -1;            /* Files come from internal list. */
  9639. #ifndef NOMSEND
  9640.         addlist = 0;            /* Don't use SEND-LIST. */
  9641.         filenext = NULL;
  9642. #endif /* NOMSEND */
  9643.     ckstrncpy(line,s,LINBUFSIZ);    /* Save copy of string just parsed. */
  9644.     debug(F110,"PSEND line",line,0);
  9645.     if (y != 0) {
  9646.         printf("?Sorry, wildcards not permitted in this command\n");
  9647.         return(-9);
  9648.     }
  9649.     if (sizeof(int) < 4) {
  9650.         printf("?Sorry, this command needs 32-bit integers\n");
  9651.         return(-9);
  9652.     }
  9653.     x = cmnum("starting position (byte number)",
  9654.           "",10,&seekto,xxstring);
  9655.     if (x < 0)
  9656.       return(x);
  9657.     zfnqfp(s,fspeclen,fspec);    /* Get full path */
  9658.     if ((x = cmtxt("Name to send it with","",&s,NULL)) < 0)
  9659.       return(x);
  9660.     ckstrncpy(tmpbuf,s,TMPBUFSIZ);
  9661.  
  9662. #ifdef IKSD
  9663.     if (inserver && !ENABLED(en_get)) {
  9664.         printf("?Sorry, sending files is disabled\n");
  9665.         return(-9);
  9666.     }
  9667. #endif /* IKSD */
  9668. #ifdef PIPESEND
  9669.     if (sndfilter) {
  9670.         printf("?Sorry, no PSEND while SEND FILTER selected\n");
  9671.         return(-9);
  9672.     }
  9673. #endif /* PIPESEND */
  9674. #ifdef CK_XYZ
  9675.     if ((protocol == PROTO_X || protocol == PROTO_XC)) {
  9676.         printf("Sorry, PSEND works only with Kermit protocol\n");
  9677.         return(-9);
  9678.     }
  9679. #endif /* CK_XYZ */
  9680.  
  9681.     cmarg2 = brstrip(tmpbuf);    /* Strip braces */
  9682.     cmarg = line;            /* File to send */
  9683.     debug(F110,"PSEND filename",cmarg,0);
  9684.     debug(F110,"PSEND as-name",cmarg2,0);
  9685.     sendstart = seekto;
  9686.     sstate = 's';            /* Set start state to SEND */
  9687. #ifndef NOMSEND
  9688.     addlist = 0;
  9689.     filenext = NULL;
  9690. #endif /* NOMSEND */
  9691.     sendmode = SM_PSEND;
  9692. #ifdef MAC
  9693.     what = W_SEND;
  9694.     scrcreate();
  9695. #endif /* MAC */
  9696.     if (local) {            /* If in local mode, */
  9697.         displa = 1;            /* enable file transfer display */
  9698.     }
  9699.     return(0);
  9700.     }
  9701. #endif /* CK_RESEND */
  9702. #endif /* NOXFER */
  9703.  
  9704. #ifndef NOXFER
  9705. #ifndef NOMSEND
  9706.     if (cx == XXMSE || cx == XXMMOVE) {
  9707. #ifdef NEWFTP
  9708.     if ((ftpget == 1) || ((ftpget == 2) && ftpisopen()))
  9709.       return(doftpput(cx,0));
  9710. #endif /* NEWFTP */
  9711. #ifdef CK_XYZ
  9712.     if (protocol == PROTO_X || protocol == PROTO_XC) {
  9713.         printf(
  9714. "Sorry, you can only send one file at a time with XMODEM protocol\n"
  9715.            );
  9716.         return(-9);
  9717.     }
  9718. #endif /* CK_XYZ */
  9719.         return(doxsend(cx));
  9720.     }
  9721.  
  9722. #ifdef COMMENT                /* (moved to doxsend) */
  9723.     if (cx == XXMSE || cx == XXMMOVE) {    /* MSEND and MMOVE commands */
  9724.     nfils = 0;            /* Like getting a list of */
  9725.     lp = line;            /* files on the command line */
  9726.     addlist = 0;            /* Do not use SEND-LIST */
  9727.     filenext = NULL;        /* Ditto ! */
  9728.  
  9729.     while (1) {
  9730.         char *p;
  9731.         if ((x = cmifi("Names of files to send, separated by spaces","",
  9732.                &s,&y,xxstring)) < 0) {
  9733.         if (x == -3) {
  9734.             if (nfils <= 0) {
  9735.             printf("?A file specification is required\n");
  9736.             return(-9);
  9737.             } else break;
  9738.         }
  9739.         return(x);
  9740.         }
  9741.         msfiles[nfils++] = lp;    /* Got one, count it, point to it, */
  9742.         p = lp;            /* remember pointer, */
  9743.         while (*lp++ = *s++)    /* and copy it into buffer */
  9744.           if (lp > (line + LINBUFSIZ)) { /* Avoid memory leak */
  9745.           printf("?MSEND list too long\n");
  9746.           line[0] = NUL;
  9747.           return(-9);
  9748.           }
  9749.         debug(F111,"msfiles",msfiles[nfils-1],nfils-1);
  9750.         if (nfils == 1) *fspec = NUL; /* Take care of \v(filespec) */
  9751. #ifdef ZFNQFP
  9752.         zfnqfp(p,TMPBUFSIZ,tmpbuf);
  9753.         p = tmpbuf;
  9754. #endif /* ZFNQFP */
  9755.         if (((int)strlen(fspec) + (int)strlen(p) + 1) < fspeclen) {
  9756.         strcat(fspec,p);    /* safe */
  9757.         strcat(fspec," ");    /* safe */
  9758.         } else printf("WARNING - \\v(filespec) buffer overflow\n");
  9759.     }
  9760.     cmlist = msfiles;        /* Point cmlist to pointer array */
  9761.     cmarg2 = "";            /* No internal expansion list (yet) */
  9762.     sndsrc = nfils;            /* Filenames come from cmlist */
  9763.     sendmode = SM_MSEND;        /* Remember this kind of SENDing */
  9764.     sstate = 's';            /* Set start state for SEND */
  9765.     if (cx == XXMMOVE)        /* If MMOVE'ing, */
  9766.       moving = 1;            /*  set this flag. */
  9767. #ifdef MAC
  9768.     what = W_SEND;
  9769.     scrcreate();
  9770. #endif /* MAC */
  9771.     if (local) {            /* If in local mode, */
  9772.         displa = 1;            /* turn on file transfer display */
  9773.         ttflui();            /* and flush tty input buffer. */
  9774.     }
  9775.     return(0);
  9776.     }
  9777. #endif /* COMMENT */
  9778. #endif /* NOMSEND */
  9779. #endif /* NOXFER */
  9780.  
  9781. #ifndef NOSERVER
  9782.     if (cx == XXSER) {            /* SERVER */
  9783. #ifdef CK_XYZ
  9784.     if (protocol != PROTO_K) {
  9785.         printf("Sorry, SERVER only works with Kermit protocol\n");
  9786.         return(-9);
  9787.     }
  9788. #endif /* CK_XYZ */
  9789. #ifdef COMMENT
  9790. /*
  9791.   Parse for time limit, but since we don't use it yet,
  9792.   the parsing is commented out.
  9793. */
  9794.     x_ifnum = 1;            /* Turn off internal complaints */
  9795.     y = cmnum("optional time limit, seconds, or time of day as hh:mm:ss",
  9796.           "0", 10, &x, xxstring
  9797.           );
  9798.     x_ifnum = 0;
  9799.     if (y < 0) {
  9800.         if (y == -2) {        /* Invalid number or expression */
  9801.         zz = tod2sec(atmbuf);    /* Convert to secs since midnight */
  9802.         if (zz < 0L) {
  9803.             printf("?Number, expression, or time of day required\n");
  9804.             return(-9);
  9805.         } else {
  9806.             char now[32];    /* Current time */
  9807.             char *p;
  9808.             long tnow;
  9809.             p = now;
  9810.             ztime(&p);
  9811.             tnow = atol(p+11) * 3600L + atol(p+14) * 60L + atol(p+17);
  9812.             if (zz < tnow)    /* User's time before now */
  9813.               zz += 86400L;    /* So make it tomorrow */
  9814.             zz -= tnow;        /* Seconds from now. */
  9815.         }
  9816.         } else
  9817.           return(y);
  9818.     }
  9819.     if (zz > -1L) {
  9820.         x = zz;
  9821.         if (zz != (long) x) {
  9822.         printf(
  9823. "Sorry, arithmetic overflow - hh:mm:ss not usable on this platform.\n"
  9824.                );
  9825.         return(-9);
  9826.         }
  9827.     }
  9828.     if (x < 0)
  9829.       x = 0;
  9830. #endif /* COMMENT */
  9831.  
  9832.     if ((x = cmcfm()) < 0) return(x);
  9833.     sstate = 'x';
  9834. #ifdef MAC
  9835.     what = W_RECV;
  9836.     scrcreate();
  9837. #endif /* MAC */
  9838.     if (local) displa = 1;
  9839. #ifdef AMIGA
  9840.     reqoff();            /* No DOS requestors while server */
  9841. #endif /* AMIGA */
  9842.     return(0);
  9843.     }
  9844. #endif /* NOSERVER */
  9845.  
  9846.     if (cx == XXSAVE) {            /* SAVE command */
  9847.     x = cmkey(savtab,nsav,"option","keymap",xxstring);
  9848.     if (x == -3) {
  9849.         printf("?You must specify an option to save\n");
  9850.         return(-9);
  9851.     }
  9852.     if (x < 0) return(x);
  9853.     /* have to set success separately for each item in doprm()... */
  9854.     /* actually not really, could have just had doprm return 0 or 1 */
  9855.     /* and set success here... */
  9856.     y = dosave(x);
  9857.     if (y == -3) {
  9858.         printf("?More fields required\n");
  9859.         return(-9);
  9860.     } else return(y);
  9861.     }
  9862.  
  9863.     if (cx == XXSET) {            /* SET command */
  9864.     x = cmkey(prmtab,nprm,"Parameter","",xxstring);
  9865.     if (x == -3) {
  9866.         printf("?You must specify a parameter to set\n");
  9867.         return(-9);
  9868.     }
  9869.     if (x < 0) return(x);
  9870.     /* have to set success separately for each item in doprm()... */
  9871.     /* actually not really, could have just had doprm return 0 or 1 */
  9872.     /* and set success here... */
  9873.     y = doprm(x,0);
  9874.     if (y == -3) {
  9875.         printf("?More fields required\n");
  9876.         return(-9);
  9877.     } else return(y);
  9878.     }
  9879.  
  9880. #ifndef NOPUSH
  9881.     if (cx == XXSHE            /* SHELL (system) command */
  9882.     || cx == XXEXEC            /* exec() */
  9883.     ) {
  9884.     int rx = 0;
  9885.     char * p = NULL;
  9886.     int i /* ,n */ ;
  9887. #ifdef UNIXOROSK
  9888.     char * args[256];
  9889. #endif /* UNIXOROSK */
  9890.  
  9891. #ifdef IKSD
  9892.     if (inserver && (nopush || !ENABLED(en_hos))) {
  9893.         printf("?Sorry, host command access is disabled\n");
  9894.         return(-9);
  9895.     }
  9896. #endif /* IKSD */
  9897.  
  9898. #ifdef CKEXEC
  9899.     if (cx == XXEXEC) {        /* EXEC (overlay ourselves) */
  9900.         struct FDB sw, fl;
  9901.         cmfdbi(&sw,            /* First FDB - command switches */
  9902.            _CMKEY,        /* fcode */
  9903.            "Command to overlay C-Kermit\n or switch", /* hlpmsg */
  9904.            "",            /* default */
  9905.            "",            /* addtl string data */
  9906.            1,            /* addtl numeric data 1: tbl size */
  9907.            4,            /* addtl numeric data 2: 4 = cmswi */
  9908.            xxstring,        /* Processing function */
  9909.            redirsw,        /* Keyword table */
  9910.            &fl            /* Pointer to next FDB */
  9911.            );
  9912.         cmfdbi(&fl,            /* 2nd FDB - command to exec */
  9913.            _CMFLD,        /* fcode */
  9914.            "Command to overlay C-Kermit", /* hlpmsg */
  9915.            "",            /* default */
  9916.            "",            /* addtl string data */
  9917.            0,            /* addtl numeric data 1 */
  9918.            0,            /* addtl numeric data 2 */
  9919.            xxstring,
  9920.            NULL,
  9921.            NULL            /* No more after this */
  9922.            );
  9923.         while (1) {
  9924.         x = cmfdb(&sw);        /* Parse something */
  9925.         debug(F101,"exec cmfdb","",x);
  9926.         if (x < 0)
  9927.           return(x);
  9928.         /* Generalize this if we add more switches */
  9929.         if (cmresult.fcode == _CMKEY) {
  9930.             rx = 1;
  9931.             continue;
  9932.         }
  9933.         if (cmresult.fcode == _CMFLD)
  9934.           break;
  9935.         return(-2);
  9936.         }
  9937.         ckstrncpy(tmpbuf,cmresult.sresult,TMPBUFSIZ);
  9938.         if (!tmpbuf[0]) {
  9939.         printf("?Command required\n");
  9940.         return(-9);
  9941.         }
  9942.         p = brstrip(tmpbuf);
  9943.         args[0] = NULL;        /* Set argv[0] to it */
  9944.         makestr(&args[0],p);
  9945.         for (i = 1; i < 255; i++) {    /* Get arguments for command */
  9946.         if ((x = cmfld("Argument","",&s,xxstring)) < 0) {
  9947.             if (x == -3) {
  9948.             if ((x = cmcfm()) < 0)
  9949.               return(x);
  9950.             break;
  9951.             } else
  9952.               return(x);
  9953.         }
  9954.         args[i] = NULL;
  9955.         s = brstrip(s);
  9956.         makestr(&args[i],s);
  9957.         }
  9958.         args[i] = NULL;
  9959.     } else {
  9960. #endif /* CKEXEC */
  9961.         if ((x = cmtxt("System command to execute","",&s,xxstring)) < 0)
  9962.           return(x);
  9963. #ifdef CKEXEC
  9964.     }
  9965. #endif /* CKEXEC */
  9966.         if (nopush)
  9967.           return(success = 0);
  9968. #ifdef CK_APC
  9969.     if (apcactive == APC_REMOTE && !(apcstatus & APC_UNCH))
  9970.       return(success = 0);
  9971. #endif /* CK_APC */
  9972.     conres();            /* Make console normal  */
  9973. #ifdef OS2
  9974.     if (!(s && *s)) {
  9975.         os2push();
  9976.             return(success = 1);
  9977.     } else
  9978. #endif /* OS2 */
  9979.       if (cx == XXSHE) {
  9980.           x = zshcmd(s);
  9981.           debug(F101,"RUN zshcmd code","",x);
  9982.           concb((char)escape);
  9983.           return(success = x);
  9984. #ifdef CKEXEC
  9985.       } else {
  9986. #ifdef DEBUG
  9987.           if (deblog) {
  9988.           debug(F111,"EXEC cmd",p,0);
  9989.           for (i = 0; i < 256 && args[i]; i++)
  9990.             debug(F111,"EXEC arg",args[i],i);
  9991.           }
  9992. #endif /* DEBUG */
  9993.           if (p) {
  9994.           z_exec(p,args,rx);    /* Overlay ourself */
  9995.           debug(F100,"EXEC fails","",0);
  9996.           concb((char)escape);    /* In case it returns */
  9997.           }
  9998.           return(success = 0);
  9999. #endif /* CKEXEC */
  10000.       }
  10001.     }
  10002.  
  10003. #ifdef CK_REDIR
  10004.     if (cx == XXFUN) {            /* REDIRECT */
  10005. #ifdef CK_APC
  10006.     if ((apcactive == APC_LOCAL) ||
  10007.         ((apcactive == APC_REMOTE) && (!(apcstatus & APC_UNCH))))
  10008.       return(success = 0);
  10009. #endif /* CK_APC */
  10010.     ckmakmsg(tmpbuf,
  10011.          TMPBUFSIZ,
  10012.          "Local command to run,\n",
  10013.          "with its standard input/output redirected to ",
  10014.          local ? ttname : "the communications connection",
  10015.          "\n"
  10016.          );
  10017.     if ((x = cmtxt(tmpbuf,"",&s,xxstring)) < 0)
  10018.       return(x);
  10019.         if (nopush) {
  10020.             printf("?REDIRECT disabled\n");
  10021.             return(success=0);
  10022.         }
  10023.     if (!local) {
  10024.         printf("?SET LINE or SET HOST required first\n");
  10025.         return(-9);
  10026.     }
  10027.     if (!*s) {
  10028.         printf("?REDIRECT requires a command to redirect\n");
  10029.         return(-9);
  10030.     }
  10031.     return(success = ttruncmd(s));
  10032.     }
  10033. #endif /* CK_REDIR */
  10034. #endif /* NOPUSH */
  10035.  
  10036. #ifndef NOSHOW
  10037.     if (cx == XXSHO) {            /* SHOW */
  10038.     x = cmkey(shotab,nsho,"","parameters",xxstring);
  10039.     if (x < 0) return(x);
  10040.     return(doshow(x));
  10041.     }
  10042. #endif /* NOSHOW */
  10043.  
  10044. #ifndef MAC
  10045.     if (cx == XXSPA) {            /* SPACE */
  10046. #ifdef IKSD
  10047.     if (inserver && !ENABLED(en_spa)) {
  10048.         printf("?Sorry, SPACE command disabled\n");
  10049.         return(-9);
  10050.     }
  10051. #endif /* IKSD */
  10052. #ifdef datageneral
  10053.     /* AOS/VS can take an argument after its "space" command. */
  10054.     if ((x = cmtxt("Confirm, or local directory name","",&s,xxstring)) < 0)
  10055.       return(x);
  10056.     if (nopush) {
  10057.         printf("?Sorry, SPACE command disabled\n");
  10058.         return(-9);
  10059.     } else if (*s == NUL) {
  10060.         xsystem(SPACMD);
  10061.     } else {
  10062.         ckmakmsg(line,LINBUFSIZ,"space ",s,NULL,NULL);
  10063.         xsystem(line);
  10064.     }
  10065. #else
  10066. #ifdef OS2
  10067.     if ((x = cmtxt("Press Enter for current disk,\n\
  10068.  or specify a disk letter like A:","",&s,xxstring)) < 0)
  10069.       return(x);
  10070.     if (*s == NUL) {        /* Current disk */
  10071.             unsigned long space = zdskspace(0);
  10072.             if (space > 0 && space < 1024)
  10073.               printf(" Free space: unknown\n");
  10074.             else
  10075.           printf(" Free space: %ldK\n", space/1024L);
  10076.     } else {
  10077.         int drive = toupper(*s);
  10078.             unsigned long space = zdskspace(drive - 'A' + 1);
  10079.             if (space > 0 && space < 1024)
  10080.               printf(" Drive %c: unknown free\n");
  10081.             else
  10082.               printf(" Drive %c: %ldK free\n", drive,space / 1024L);
  10083.     }
  10084. #else
  10085. #ifdef UNIXOROSK
  10086.     x = cmdir("Confirm for current disk,\n\
  10087.  or specify a disk device or directory","",&s,xxstring);
  10088.     if (x == -3)
  10089.       s = "";
  10090.     else if (x < 0)
  10091.       return(x);
  10092.         ckstrncpy(tmpbuf,s,TMPBUFSIZ);
  10093.         s = tmpbuf;
  10094.     if ((x = cmcfm()) < 0) return(x);
  10095.     if (nopush) {
  10096.         printf("?Sorry, SPACE command disabled\n");
  10097.         return(-9);
  10098.     }
  10099.     if (!*s) {            /* Current disk */
  10100.         xsystem(SPACMD);
  10101.     } else {            /* Specified disk */
  10102.         ckmakmsg(line,LINBUFSIZ,SPACM2," ",s,NULL);
  10103.         xsystem(line);
  10104.     }
  10105. #else
  10106.     if ((x = cmcfm()) < 0) return(x);
  10107.     if (nopush) {
  10108.         printf("?Sorry, SPACE command disabled\n");
  10109.         return(-9);
  10110.     }
  10111.     xsystem(SPACMD);
  10112. #endif /* UNIXOROSK */
  10113. #endif /* OS2 */
  10114. #endif /* datageneral */
  10115.     return(success = 1);        /* Pretend it worked */
  10116.     }
  10117. #endif /* MAC */
  10118.  
  10119. #ifndef NOXFER
  10120.     if (cx == XXSTA) {            /* STATISTICS */
  10121.     if ((x = cmkey(stattab,2,"Carriage return, or option",
  10122.                "/brief",xxstring)) < 0)
  10123.       return(x);
  10124.     if ((y = cmcfm()) < 0) return(y);
  10125.     return(success = dostat(x));
  10126.     }
  10127. #endif /* NOXFER */
  10128.  
  10129.     if (cx == XXSTO || cx == XXEND) {    /* STOP, END, or POP */
  10130.     if ((y = cmnum("exit status code","0",10,&x,xxstring)) < 0)
  10131.       return(y);
  10132.     if ((y = cmtxt("Message to print","",&s,xxstring)) < 0)
  10133.       return(y);
  10134.     s = brstrip(s);
  10135.     if (*s) printf("%s\n",s);
  10136.     if (cx == XXSTO) {
  10137.         dostop();
  10138.     } else {
  10139.         doend(x);
  10140.     }
  10141.     return(success = (x == 0));
  10142.     }
  10143.     if (cx == XXSUS) {            /* SUSPEND */
  10144.     if ((y = cmcfm()) < 0) return(y);
  10145. #ifdef NOJC
  10146.     printf("Sorry, this version of Kermit cannot be suspended\n");
  10147. #else
  10148. #ifdef IKSD
  10149.     if (inserver) {
  10150.         printf("?Sorry, IKSD can not be suspended\n");
  10151.         return(-9);
  10152.     } else
  10153. #endif /* IKSD */
  10154.       if (nopush) {
  10155.         printf("?Sorry, access to system is disabled\n");
  10156.         return(-9);
  10157.     }
  10158.     stptrap(0);
  10159. #endif /* NOJC */
  10160.     return(0);
  10161.     }
  10162.  
  10163.     if (cx == XXTAK) {            /* TAKE */
  10164.     char * scriptenv = NULL;    
  10165. #ifdef OS2
  10166.         char * GetAppData(int);
  10167.     extern char startupdir[],exedir[],inidir[];
  10168.     char * keymapenv = NULL;
  10169.         char * appdata0 = NULL, *appdata1 = NULL;
  10170.     int xx;
  10171. #define TAKEPATHLEN 4096
  10172. #else /* OS2 */
  10173. #define TAKEPATHLEN 1024
  10174. #endif /* OS2 */
  10175.     char takepath[TAKEPATHLEN];
  10176.  
  10177.     if (tlevel >= MAXTAKE-1) {
  10178.         printf("?Take files nested too deeply\n");
  10179.         return(-9);
  10180.     }
  10181. #ifdef OS2
  10182. #ifdef NT
  10183.     scriptenv = getenv("K95SCRIPTS");
  10184.     keymapenv = getenv("K95KEYMAPS");
  10185.         makestr(&appdata0,(char *)GetAppData(0));
  10186.         makestr(&appdata1,(char *)GetAppData(1));
  10187. #else /* NT */
  10188.     scriptenv = getenv("K2SCRIPTS");
  10189.     keymapenv = getenv("K2KEYMAPS");
  10190. #endif /* NT */
  10191. #endif /* OS2 */
  10192.  
  10193.     if (!scriptenv)            /* Let this work for Unix etc too */
  10194.       scriptenv = getenv("CK_SCRIPTS"); /* Use this if defined */
  10195. #ifndef OS2
  10196.     if (!scriptenv)            /* Otherwise use home directory */
  10197.       scriptenv = homepath();
  10198. #endif /* OS2 */
  10199.     if (!scriptenv)
  10200.       scriptenv = "";
  10201.     ckstrncpy(takepath,scriptenv,TAKEPATHLEN);
  10202.     debug(F110,"TAKE initial takepath",takepath,0);
  10203.  
  10204. #ifdef OS2
  10205.     if (!keymapenv)
  10206.       keymapenv = getenv("CK_KEYMAPS");
  10207.     if (!keymapenv)
  10208.       keymapenv = "";
  10209.  
  10210.     ckstrncat(takepath,
  10211.           (scriptenv && scriptenv[strlen(scriptenv)-1]==';')?"":";",
  10212.           TAKEPATHLEN
  10213.           );
  10214.     ckstrncat(takepath,keymapenv?keymapenv:"",TAKEPATHLEN);
  10215.     ckstrncat(takepath,
  10216.           (keymapenv && keymapenv[strlen(keymapenv)-1]==';')?"":";",
  10217.           TAKEPATHLEN
  10218.           );
  10219.     ckstrncat(takepath,startupdir,TAKEPATHLEN);
  10220.     ckstrncat(takepath,";",TAKEPATHLEN);
  10221.     ckstrncat(takepath,startupdir,TAKEPATHLEN);
  10222.     ckstrncat(takepath,"SCRIPTS/;",TAKEPATHLEN);
  10223.     ckstrncat(takepath,startupdir,TAKEPATHLEN);
  10224.     ckstrncat(takepath,"KEYMAPS/;",TAKEPATHLEN);
  10225.  
  10226.     ckstrncat(takepath,appdata1,TAKEPATHLEN);
  10227.     ckstrncat(takepath,"Kermit 95/;",TAKEPATHLEN);
  10228.     ckstrncat(takepath,appdata1,TAKEPATHLEN);
  10229.     ckstrncat(takepath,"Kermit 95/SCRIPTS/;",TAKEPATHLEN);
  10230.     ckstrncat(takepath,appdata1,TAKEPATHLEN);
  10231.     ckstrncat(takepath,"Kermit 95/KEYMAPS/;",TAKEPATHLEN);
  10232.  
  10233.     ckstrncat(takepath,appdata0,TAKEPATHLEN);
  10234.     ckstrncat(takepath,"Kermit 95/;",TAKEPATHLEN);
  10235.     ckstrncat(takepath,appdata0,TAKEPATHLEN);
  10236.     ckstrncat(takepath,"Kermit 95/SCRIPTS/;",TAKEPATHLEN);
  10237.     ckstrncat(takepath,appdata0,TAKEPATHLEN);
  10238.     ckstrncat(takepath,"Kermit 95/KEYMAPS/;",TAKEPATHLEN);
  10239.  
  10240.     ckstrncat(takepath,inidir,TAKEPATHLEN);
  10241.     ckstrncat(takepath,";",TAKEPATHLEN);
  10242.     ckstrncat(takepath,inidir,TAKEPATHLEN);
  10243.     ckstrncat(takepath,"SCRIPTS/;",TAKEPATHLEN);
  10244.     ckstrncat(takepath,inidir,TAKEPATHLEN);
  10245.     ckstrncat(takepath,"KEYMAPS/;",TAKEPATHLEN);
  10246.  
  10247.     ckstrncat(takepath,zhome(),TAKEPATHLEN);
  10248.     ckstrncat(takepath,";",TAKEPATHLEN);
  10249.     ckstrncat(takepath,zhome(),TAKEPATHLEN);
  10250.     ckstrncat(takepath,"SCRIPTS/;",TAKEPATHLEN);
  10251.     ckstrncat(takepath,zhome(),TAKEPATHLEN);
  10252.     ckstrncat(takepath,"KEYMAPS/;",TAKEPATHLEN);
  10253.  
  10254.     ckstrncat(takepath,exedir,TAKEPATHLEN);
  10255.     ckstrncat(takepath,";",TAKEPATHLEN);
  10256.     ckstrncat(takepath,exedir,TAKEPATHLEN);
  10257.     ckstrncat(takepath,"SCRIPTS/;",TAKEPATHLEN);
  10258.     ckstrncat(takepath,exedir,TAKEPATHLEN);
  10259.     ckstrncat(takepath,"KEYMAPS/;",TAKEPATHLEN);
  10260. #endif /* OS2 */
  10261.     debug(F110,"TAKE final takepath",takepath,0);
  10262.  
  10263.     if ((y = cmifip("Commands from file",
  10264.             "",&s,&x,0,takepath,xxstring)) < 0) {
  10265.         if (y == -3) {
  10266.         printf("?A file name is required\n");
  10267.         return(-9);
  10268.         } else
  10269.           return(y);
  10270.     }
  10271.     if (x != 0) {
  10272.         printf("?Wildcards not allowed in command file name\n");
  10273.         return(-9);
  10274.     }
  10275.     ckstrncpy(line,s,LINBUFSIZ);
  10276.     debug(F110,"TAKE file",s,0);
  10277.     if (isdir(s)) {
  10278.         printf("?Can't execute a directory - \"%s\"\n", s);
  10279.         return(-9);
  10280.     }
  10281. #ifndef NOTAKEARGS
  10282.     {
  10283.         char * p;
  10284.         x = strlen(line);
  10285.         debug(F111,"TAKE args",line,x);
  10286.         p = line + x + 1;
  10287.         if ((y = cmtxt("Optional arguments","",&s,xxstring)) < 0)
  10288.           return(y);
  10289.         if (*s) {            /* Args given? */
  10290.         ckstrncpy(p,s,LINBUFSIZ-x-1);
  10291. #ifdef ZFNQFP
  10292.         zfnqfp(line,TMPBUFSIZ,tmpbuf);
  10293.         s = tmpbuf;
  10294. #else
  10295.         s = line;
  10296. #endif /* ZFNQFP */
  10297.         debug(F110,"TAKE filename",s,0);
  10298.         x = strlen(s);
  10299.         debug(F101,"TAKE new len",s,x);
  10300.  
  10301. #ifdef COMMENT
  10302. /*
  10303.   This was added in C-Kermit 7.0 to allow args to be passed from the TAKE
  10304.   command to the command file.  But it overwrites the current argument vector,
  10305.   which is at best surprising, and at worst unsafe.
  10306. */
  10307.         addmac("%0",s);        /* Define %0 = name of file */
  10308.         varnam[0] = '%';
  10309.         varnam[2] = '\0';
  10310.         debug(F110,"take arg 0",s,0);
  10311.         debug(F110,"take args",p,0);
  10312.         for (y = 1; y < 10; y++) { /* Clear current args %1..%9 */
  10313.             varnam[1] = (char) (y + '0');
  10314.             delmac(varnam,0);
  10315.         }
  10316.         xwords(p,MAXARGLIST,NULL,0); /* Assign new args */
  10317.         debug(F110,"take args",p,0);
  10318. #else
  10319. /*
  10320.   This method is used in 8.0.  If the TAKE command includes arguments, we
  10321.   insert an intermediate temporary macro between the current level; we pass
  10322.   the arguments to the macro and then the macro TAKEs the command file.
  10323.   If the user Ctrl-C's out of the TAKE file, some temporary macro definitions
  10324.   and other small malloc'd bits might be left behind.
  10325. */
  10326.         {
  10327.             char * q = NULL;
  10328.             char * r = NULL;
  10329.             int k, m;
  10330.             m = maclvl;
  10331.             q = (char *)malloc(x+24);
  10332.             if (q) {
  10333.             r = (char *)malloc(x+24);
  10334.             if (r) {
  10335.                 sprintf(q,"_file[%s](%d)",s,cmdlvl); /* safe */
  10336.                 sprintf(r,"take %s",s); /* safe */
  10337.                 k = addmac(q,r);
  10338.                 if (k > -1) {
  10339.                 dodo(k,p,0);
  10340.                 while (maclvl > m) {
  10341.                     sstate = (CHAR) parser(1);
  10342.                     if (sstate) proto();
  10343.                 }
  10344.                 }
  10345.                 k = delmac(q,0);
  10346.                 free(q);
  10347.                 free(r);
  10348.                 return(success);
  10349.             }
  10350.             }
  10351.         }
  10352.         return(success = 0);
  10353. #endif /* COMMENT */
  10354.         }
  10355.     }
  10356. #else
  10357.     if ((y = cmcfm()) < 0) return(y);
  10358. #endif /* NOTAKEARGS */
  10359.     return(success = dotake(line));
  10360.     }
  10361.  
  10362. #ifndef NOLOCAL
  10363. #ifdef OS2
  10364.     if (cx == XXVIEW) {            /* VIEW Only Terminal mode */
  10365.     viewonly = TRUE;
  10366.     success = doconect(0, 0);
  10367.     viewonly = FALSE;
  10368.     return success;
  10369.     }
  10370. #endif /* OS2 */
  10371.  
  10372. #ifdef NETCONN
  10373.     if (cx == XXTEL || cx == XXIKSD) {    /* TELNET */
  10374.     int x,z;
  10375. #ifdef OS2
  10376.     if (!tcp_avail) {
  10377.         printf("?Sorry, either TCP/IP is not available on this system or\n\
  10378. necessary DLLs did not load.  Use SHOW NETWORK to check network status.\n");
  10379.         success = 0;
  10380.         return(-9);
  10381.     } else
  10382. #endif /* OS2 */
  10383.       {
  10384.       x = nettype;            /* Save net type in case of failure */
  10385.       z = ttnproto;            /* Save protocol in case of failure */
  10386.       nettype = NET_TCPB;
  10387.       ttnproto = (cx == XXTEL) ? NP_TELNET : NP_KERMIT;
  10388.       if ((y = setlin(XYHOST,0,1)) <= 0) {
  10389.               nettype = x;        /* Failed, restore net type. */
  10390.               ttnproto = z;        /* and protocol */
  10391.               success = 0;
  10392.       }
  10393.       didsetlin++;
  10394.         }
  10395.     return(y);
  10396.     }
  10397.  
  10398. #ifndef PTYORPIPE
  10399. #ifdef NETCMD
  10400. #define PTYORPIPE
  10401. #else
  10402. #ifdef NETPTY
  10403. #define PTYORPIPE
  10404. #endif /* NETPTY */
  10405. #endif /* NETCMD */
  10406. #endif /* PTYORPIPE */
  10407.  
  10408. #ifdef PTYORPIPE
  10409.     if (cx == XXPIPE || cx == XXPTY) {    /* PIPE or PTY */
  10410.     int x;
  10411.     extern int netsave;
  10412.     x = nettype;            /* Save net type in case of failure */
  10413.     nettype = (cx == XXPIPE) ? NET_CMD : NET_PTY;
  10414.     if ((y = setlin(XYHOST,0,1)) < 0) {
  10415.         nettype = x;        /* Failed, restore net type. */
  10416.         ttnproto = z;        /* and protocol */
  10417.         success = 0;
  10418.     }
  10419.     didsetlin++;
  10420.     netsave = x;
  10421.     return(y);
  10422.     }
  10423. #endif /* PTYORPIPE */
  10424.  
  10425. #ifdef ANYSSH
  10426.     if (cx == XXSSH) {            /* SSH (Secure Shell) */
  10427.     extern int netsave;
  10428. #ifdef SSHBUILTIN
  10429.     int k, x, havehost = 0, trips = 0;
  10430.         int    tmpver = -1, tmpxfw = -1;
  10431. #ifndef SSHTEST
  10432.         extern int sl_ssh_xfw, sl_ssh_xfw_saved;
  10433.         extern int sl_ssh_ver, sl_ssh_ver_saved;
  10434. #endif /* SSHTEST */
  10435.         extern int mdmtyp, mdmsav, cxtype, sl_uid_saved;
  10436.         extern char * slmsg;
  10437.     extern char uidbuf[], sl_uidbuf[];
  10438.         extern char pwbuf[], * g_pswd;
  10439.         extern int pwflg, pwcrypt, g_pflg, g_pcpt, nolocal;
  10440.     struct FDB sw, kw, fl;
  10441.  
  10442.         if (ssh_tmpstr)
  10443.       memset(ssh_tmpstr,0,strlen(ssh_tmpstr));
  10444.         makestr(&ssh_tmpstr,NULL);
  10445.         makestr(&ssh_tmpuid,NULL);
  10446.         makestr(&ssh_tmpcmd,NULL);
  10447.         makestr(&ssh_tmpport,NULL);
  10448.  
  10449.     cmfdbi(&kw,            /* 1st FDB - commands */
  10450.            _CMKEY,            /* fcode */
  10451.            "host [ port ],\n or action",    /* hlpmsg */
  10452.            "",            /* default */
  10453.            "",            /* addtl string data */
  10454.            nsshcmd,            /* addtl numeric data 1: tbl size */
  10455.            0,            /* addtl numeric data 2: 0 = keyword */
  10456.            xxstring,        /* Processing function */
  10457.            sshkwtab,        /* Keyword table */
  10458.            &fl            /* Pointer to next FDB */
  10459.            );
  10460.     cmfdbi(&fl,            /* Host */
  10461.            _CMFLD,            /* fcode */
  10462.            "",            /* hlpmsg */
  10463.            "",            /* default */
  10464.            "",            /* addtl string data */
  10465.            0,            /* addtl numeric data 1 */
  10466.            0,            /* addtl numeric data 2 */
  10467.            xxstring,
  10468.            NULL,
  10469.            NULL
  10470.            );
  10471.  
  10472.     x = cmfdb(&kw);
  10473.     if (x == -3) {
  10474.         printf("?ssh what?\n");
  10475.         return(-9);
  10476.     }
  10477.     if (x < 0)
  10478.       return(x);
  10479.     havehost = 0;
  10480.     if (cmresult.fcode == _CMFLD) {
  10481.         havehost = 1;
  10482.         ckstrncpy(line,cmresult.sresult,LINBUFSIZ); /* Hostname */
  10483.         cmresult.nresult = XSSH_OPN;
  10484.     }
  10485.     switch (cmresult.nresult) {    /* SSH keyword */
  10486.       case XSSH_OPN:        /* SSH OPEN */
  10487.         if (!havehost) {
  10488.         if ((x = cmfld("Host","",&s,xxstring)) < 0)
  10489.           return(x);
  10490.         ckstrncpy(line,s,LINBUFSIZ);
  10491.         }
  10492.         /* Parse [ port ] [ switches ] */
  10493.         cmfdbi(&kw,            /* Switches */
  10494.            _CMKEY,
  10495.            "Port number or service name,\nor switch",
  10496.            "",
  10497.            "",
  10498.            nsshopnsw,
  10499.            4,
  10500.            xxstring,
  10501.            sshopnsw,
  10502.            &fl
  10503.            );
  10504.         cmfdbi(&fl,            /* Port number or service name */
  10505.            _CMFLD,
  10506.            "",
  10507.            "",
  10508.            "",
  10509.            0,
  10510.            0,
  10511.            xxstring,
  10512.            NULL,
  10513.            NULL
  10514.            );
  10515.         trips = 0;            /* Explained below */
  10516.         while (1) {            /* Parse port and switches */
  10517.         x = cmfdb(&kw);        /* Get a field */
  10518.         if (x == -3)        /* User typed CR so quit from loop */
  10519.           break;
  10520.         if (x < 0)        /* Other parse error, pass it back */
  10521.           return(x);
  10522.         switch (cmresult.fcode) { /* Field or Keyword? */
  10523.                   case _CMFLD:          /* Field */
  10524.                     makestr(&ssh_tmpport,cmresult.sresult);
  10525.             break;
  10526.           case _CMKEY:        /* Keyword */
  10527.             switch (cmresult.nresult) {    /* Which one? */
  10528.               case SSHSW_USR:            /* /USER: */
  10529.             if (!cmgbrk()) {
  10530.                 printf("?This switch requires an argument\n");
  10531.                 return(-9);
  10532.             }
  10533.             if ((y = cmfld("Username","",&s,xxstring)) < 0)
  10534.               return(y);
  10535.             s = brstrip(s);
  10536.             makestr(&ssh_tmpuid,s);
  10537.             break;
  10538.                       case SSHSW_PWD:
  10539.             if (!cmgbrk()) {
  10540.                 printf("?This switch requires an argument\n");
  10541.                 return(-9);
  10542.             }
  10543.             debok = 0;
  10544.             if ((x = cmfld("Password","",&s,xxstring)) < 0) {
  10545.                 if (x == -3) {
  10546.                 makestr(&ssh_tmpstr,"");
  10547.                 } else {
  10548.                 return(x);
  10549.                 }
  10550.             } else {
  10551.                 s = brstrip(s);
  10552.                 if ((x = (int)strlen(s)) > PWBUFL) {
  10553.                 makestr(&slmsg,"Internal error");
  10554.                 printf("?Sorry, too long - max = %d\n",PWBUFL);
  10555.                 return(-9);
  10556.                 }
  10557.                 makestr(&ssh_tmpstr,s);
  10558.             }
  10559.             break;
  10560.  
  10561.               case SSHSW_VER:
  10562.             if ((x = cmnum("Number","",10,&z,xxstring)) < 0)
  10563.               return(x);
  10564.             if (z < 1 || z > 2) {
  10565.                 printf("?Out of range: %d\n",z);
  10566.                 return(-9);
  10567.             }
  10568.                         tmpver = z;
  10569.             break;
  10570.               case SSHSW_CMD:
  10571.               case SSHSW_SUB:
  10572.             if ((x = cmfld("Text","",&s,xxstring)) < 0)
  10573.               return(x);
  10574.                         makestr(&ssh_tmpcmd,s);
  10575.             ssh_cas = (cmresult.nresult == SSHSW_SUB);
  10576.             break;
  10577.               case SSHSW_X11:
  10578.             if ((x = cmkey(onoff,2,"","on",xxstring)) < 0)
  10579.               return(x);
  10580.                         tmpxfw = x;
  10581.             break;
  10582.               default:
  10583.                 return(-2);
  10584.             }
  10585.         }
  10586.         if (trips++ == 0) {    /* After first time through */
  10587.             cmfdbi(&kw,        /* only parse switches, not port. */
  10588.                _CMKEY,
  10589.                "Switch",
  10590.                "",
  10591.                "",
  10592.                nsshopnsw,
  10593.                4,
  10594.                xxstring,
  10595.                sshopnsw,
  10596.                NULL
  10597.                );
  10598.         }
  10599.         }
  10600.         if ((x = cmcfm()) < 0)    /* Get confirmation */
  10601.           return(x);
  10602.             if (clskconnx(1) < 0) {    /* Close current Kermit connection */
  10603.               if ( ssh_tmpstr ) {
  10604.                   memset(ssh_tmpstr,0,strlen(ssh_tmpstr));
  10605.                   makestr(&ssh_tmpstr,NULL);
  10606.               }
  10607.               return(success = 0);
  10608.             }
  10609.         makestr(&ssh_hst,line);    /* Stash everything */
  10610.         if (ssh_tmpuid) {
  10611.                 if (!sl_uid_saved) {
  10612.                     ckstrncpy(sl_uidbuf,uidbuf,UIDBUFLEN);
  10613.                     sl_uid_saved = 1;
  10614.                 }
  10615.         ckstrncpy(uidbuf,ssh_tmpuid,UIDBUFLEN);
  10616.         makestr(&ssh_tmpuid,NULL);
  10617.         }
  10618.             if (ssh_tmpport) {
  10619.                 makestr(&ssh_prt,ssh_tmpport);
  10620.                 makestr(&ssh_tmpport,NULL);
  10621.             } else
  10622.                 makestr(&ssh_prt,NULL);
  10623.  
  10624.             if (ssh_tmpcmd) {
  10625.                 makestr(&ssh_cmd,brstrip(ssh_tmpcmd));
  10626.                 makestr(&ssh_tmpcmd,NULL);
  10627.             } else
  10628.                 makestr(&ssh_cmd,NULL);
  10629.  
  10630.             if (tmpver > -1) {
  10631. #ifndef SSHTEST
  10632.                 if (!sl_ssh_ver_saved) {
  10633.                     sl_ssh_ver = ssh_ver;
  10634.                     sl_ssh_ver_saved = 1;
  10635.                 }
  10636. #endif /* SSHTEST */
  10637.                 ssh_ver = tmpver;
  10638.             }
  10639.             if (tmpxfw > -1) {
  10640. #ifndef SSHTEST
  10641.                 if (!sl_ssh_xfw_saved) {
  10642.                     sl_ssh_xfw = ssh_xfw;
  10643.                     sl_ssh_xfw_saved = 1;
  10644.                 }
  10645. #endif /* SSHTEST */
  10646.                 ssh_xfw = tmpxfw;
  10647.             }
  10648.         if (ssh_tmpstr) {
  10649.         if (ssh_tmpstr[0]) {
  10650.             ckstrncpy(pwbuf,ssh_tmpstr,PWBUFL+1);
  10651.             pwflg = 1;
  10652.             pwcrypt = 0;
  10653.         } else
  10654.           pwflg = 0;
  10655.         makestr(&ssh_tmpstr,NULL);
  10656.         }
  10657.         nettype = NET_SSH;
  10658.         if (mdmsav < 0)
  10659.           mdmsav = mdmtyp;
  10660.         mdmtyp = -nettype;
  10661.         x = 1;
  10662.  
  10663. #ifndef NOSPL
  10664.             makestr(&g_pswd,pwbuf);             /* Save global pwbuf */
  10665.             g_pflg = pwflg;                     /* and flag */
  10666.             g_pcpt = pwcrypt;
  10667. #endif /* NOSPL */
  10668.  
  10669.         /* Line parameter to ttopen() is ignored */
  10670.         debug(F110,"SSH line",line,0);
  10671.         k = ttopen(line,&x,mdmtyp, 0);
  10672.         if (k < 0) {
  10673.         printf("?Unable to connect to %s\n",ssh_hst);
  10674.         mdmtyp = mdmsav;
  10675.                 slrestor();
  10676.         return(success = 0);
  10677.         }
  10678.         duplex = 0;             /* Remote echo */
  10679.         ckstrncpy(ttname,line,TTNAMLEN); /* Record the command */
  10680.         debug(F110,"ssh ttname",ttname,0);
  10681.         makestr(&slmsg,NULL);    /* No SET LINE error message */
  10682.         cxtype = CXT_SSH;
  10683. #ifndef NODIAL
  10684.         dialsta = DIA_UNK;
  10685. #endif /* NODIAL */
  10686.         success = 1;        /* SET LINE succeeded */
  10687.         network = 1;        /* Network connection (not serial) */
  10688.         local = 1;            /* Local mode (not remote) */
  10689.         if ((reliable != SET_OFF || !setreliable))
  10690.           reliable = SET_ON;    /* Transport is reliable end to end */
  10691. #ifdef OS2
  10692.             DialerSend(OPT_KERMIT_CONNECT, 0);
  10693. #endif /* OS2 */
  10694.         setflow();            /* Set appropriate flow control */
  10695.  
  10696.         haveline = 1;
  10697. #ifdef CKLOGDIAL
  10698. #ifdef NETCONN
  10699.         dolognet();
  10700. #endif /* NETCONN */
  10701. #endif /* CKLOGDIAL */
  10702.  
  10703. #ifndef NOSPL
  10704.         if (local) {
  10705.         if (nmac) {        /* Any macros defined? */
  10706.             int k;        /* Yes */
  10707.             k = mlook(mactab,"on_open",nmac); /* Look this up */
  10708.             if (k >= 0) {                  /* If found, */
  10709.             if (dodo(k,ssh_hst,0) > -1)   /* set it up, */
  10710.               parser(1);              /* and execute it */
  10711.             }
  10712.         }
  10713.         }
  10714. #endif /* NOSPL */
  10715. #ifdef LOCUS        
  10716.         if (autolocus)
  10717.         setlocus(1,1);
  10718. #endif /* LOCUS */
  10719.  
  10720.     /* Command was confirmed so we can pre-pop command level. */
  10721.     /* This is so CONNECT module won't think we're executing a */
  10722.     /* script if CONNECT was the final command in the script. */
  10723.         if (cmdlvl > 0)
  10724.           prepop();
  10725.         success = doconect(0,cmdlvl == 0 ? 1 : 0);
  10726.         if (ttchk() < 0)
  10727.           dologend();
  10728.         return(success);
  10729.  
  10730.       case XSSH_CLR:
  10731.         if ((y = cmkey(sshclr,nsshclr,"","", xxstring)) < 0) {
  10732.             if (y == -3) {
  10733.             printf("?clear what?\n");
  10734.             return(-9);
  10735.         }
  10736.             return(y);
  10737.         }
  10738.         if ((x = cmcfm()) < 0)
  10739.           return(x);
  10740.         switch (y) {
  10741.           case SSHC_LPF:
  10742.                 ssh_pf_lcl_n = 0;
  10743.         break;
  10744.           case SSHC_RPF:
  10745.         ssh_pf_rmt_n = 0;
  10746.         break;
  10747.           default:
  10748.         return(-2);
  10749.         }
  10750.             return(success = 1);    /* or whatever */
  10751.  
  10752.       case XSSH_AGT: {        /* SSH AGENT */
  10753.           int doeach = 0;
  10754.           if ((y = cmkey(sshagent,nsshagent,"","",xxstring)) < 0)
  10755.         return(y);
  10756.           switch (y) {
  10757.         case SSHA_ADD:        /* SSH AGENT ADD ... */
  10758.           if ((x = cmifi("Identity file","",&s,&y,xxstring)) < 0) {
  10759. #ifndef SSHTEST
  10760.               if (x == -3)    /* No name given */
  10761.             doeach = 1;    /* so do them all */
  10762.               else
  10763. #endif /* SSHTEST */
  10764.             return(x);
  10765.           }
  10766.           ckstrncpy(line,s,LINBUFSIZ);
  10767.           if ((x = cmcfm()) < 0)
  10768.             return(x);
  10769. #ifdef SSHTEST
  10770.           x = 0;
  10771. #else
  10772.           if (doeach) {
  10773.                       int i;
  10774.                       x = 0;
  10775.                       for (i = 0; i < ssh_idf_n; i++)
  10776.             x += ssh_agent_add_file(ssh_idf[i]);
  10777.           } else
  10778.             x = ssh_agent_add_file(line);
  10779. #endif /* SSHTEST */
  10780.           return(success = (x == 0));
  10781.  
  10782.         case SSHA_DEL: {    /* SSH AGENT DELETE ... */
  10783.             int doall = 0;
  10784.             if ((x = cmifi("Identity file","",&s,&y,xxstring)) < 0) {
  10785. #ifndef SSHTEST
  10786.             if (x == -3)    /* No name given */
  10787.               doall = 1;    /* so do them all */
  10788.             else
  10789. #endif /* SSHTEST */
  10790.               return(x);
  10791.             }
  10792.             ckstrncpy(line,s,LINBUFSIZ);
  10793.             if ((x = cmcfm()) < 0)
  10794.               return(x);
  10795. #ifdef SSHTEST
  10796.             x = 0;
  10797. #else
  10798.             if (doall)
  10799.               x = ssh_agent_delete_all();
  10800.             else
  10801.               x = ssh_agent_delete_file(line);
  10802. #endif /* SSHTEST */
  10803.             return(success = (x == 0));
  10804.         }
  10805.         case SSHA_LST: {
  10806.             int fingerprint = 0;
  10807.             if ((y = cmswi(sshagtsw,nsshagtsw,"","",xxstring)) < 0) {
  10808.             if (y != -3)
  10809.               return(y);
  10810.             } else if (cmgbrk() > SP) {
  10811.             printf("?This switch does not take an argument\n");
  10812.             return(-9);
  10813.             } else if (y == SSHASW_FP) {
  10814.             fingerprint = 1;
  10815.             }
  10816.             if ((x = cmcfm()) < 0)
  10817.               return(x);
  10818. #ifdef SSHTEST
  10819.             return(success = 1);
  10820. #else
  10821.             return(success =
  10822.                (ssh_agent_list_identities(fingerprint) == 0));
  10823. #endif /* SSHTEST */
  10824.         }
  10825.         default:
  10826.           return(-2);
  10827.           }
  10828.       }
  10829.       case XSSH_ADD: {        /* SSH ADD */
  10830.           /* ssh add { local, remote } port host port */
  10831.           int cx, i, j, k;
  10832.           char * h;
  10833.           if ((cx = cmkey(addfwd,naddfwd,"","", xxstring)) < 0)
  10834.         return(cx);
  10835.           if ((x = cmnum((cx == SSHF_LCL) ?
  10836.                  "Local port number" : "Remote port number",
  10837.                  "",10,&j,xxstring)) < 0)
  10838.         return(x);
  10839.           if ((x = cmfld("Host","",&s,xxstring)) < 0)
  10840.         return(x);
  10841.           makestr(&h,s);
  10842.           if ((x = cmnum("Port","",10,&k,xxstring)) < 0)
  10843.         return(x);
  10844.           if ((x = cmcfm()) < 0)
  10845.         return(x);
  10846.  
  10847.           switch(cx) {
  10848.         case SSHF_LCL:
  10849.            if (ssh_pf_lcl_n == 32) {
  10850.                printf(
  10851. "?Maximum number of local port forwardings already specified\n"
  10852.                  );
  10853.                free(h);
  10854.                return(success = 0);
  10855.           }
  10856.           ssh_pf_lcl[ssh_pf_lcl_n].p1 = j;
  10857.           makestr(&(ssh_pf_lcl[ssh_pf_lcl_n].host),h);
  10858.           makestr(&h,NULL);
  10859.           ssh_pf_lcl[ssh_pf_lcl_n].p2 = k;
  10860.           ssh_pf_lcl_n++;
  10861.           break;
  10862.         case SSHF_RMT:
  10863.           if (ssh_pf_rmt_n == 32) {
  10864.               printf(
  10865. "?Maximum number of remote port forwardings already specified\n"
  10866.                 );
  10867.               free(h);
  10868.               return(success = 0);
  10869.           }
  10870.           ssh_pf_rmt[ssh_pf_rmt_n].p1 = j;
  10871.           makestr(&(ssh_pf_rmt[ssh_pf_rmt_n].host),h);
  10872.           makestr(&h,NULL);
  10873.           ssh_pf_rmt[ssh_pf_rmt_n].p2 = k;
  10874.           ssh_pf_rmt_n++;
  10875.           }
  10876.           return(success = 1);
  10877.       }
  10878.       /* Not supporting arbitrary forwarding yet */
  10879.       case XSSH_FLP:        /* SSH FORWARD-LOCAL-PORT */
  10880.       case XSSH_FRP: {        /* SSH FORWARD-REMOTE-PORT */
  10881.           int li_port = 0;
  10882.           int to_port = 0;
  10883.           char * fw_host = NULL;
  10884.           int n;
  10885.               if ((x = cmnum(cmresult.nresult == XSSH_FLP ?
  10886.                               "local-port":"remote-port",
  10887.                               "",10,&li_port,xxstring)) < 0)
  10888.                   return(x);
  10889.               if (li_port < 1 || li_port > 65535) {
  10890.                   printf("?Out range - min: 1, max: 65535\n");
  10891.                   return(-9);
  10892.               }
  10893.           if ((x = cmfld("host",ssh_hst?ssh_hst:"",&s,xxstring)) < 0)
  10894.         return(x);
  10895.               n = ckstrncpy(tmpbuf,s,TMPBUFSIZ);
  10896.               fw_host = tmpbuf;
  10897.               if ((x = cmnum("host-port",ckuitoa(li_port),10,
  10898.                               &to_port,xxstring)) < 0)
  10899.                   return(x);
  10900.               if (to_port < 1 || to_port > 65535) {
  10901.                   printf("?Out range - min: 1, max: 65535\n");
  10902.                   return(-9);
  10903.               }
  10904.           if ((x = cmcfm()) < 0)
  10905.         return(x);
  10906.           switch (cmresult.nresult) {
  10907.                 case XSSH_FLP:    /* SSH FORWARD-LOCAL-PORT */
  10908. #ifndef SSHTEST
  10909.                   ssh_fwd_local_port(li_port,fw_host,to_port);
  10910. #endif /* SSHTEST */
  10911.           return(success = 1);
  10912.         case XSSH_FRP:    /* SSH FORWARD-REMOTE-PORT */
  10913. #ifndef SSHTEST
  10914.                   ssh_fwd_remote_port(li_port,fw_host,to_port);
  10915. #endif /* SSHTEST */
  10916.           return(success = 1);
  10917.           }
  10918.           return(success = 1);
  10919.       }
  10920.     case XSSH_V2:        /* SSH V2 */
  10921.       if ((cx = cmkey(ssh2tab,nssh2tab,"","", xxstring)) < 0)
  10922.         return(cx);
  10923.       switch (cx) {
  10924.         case XSSH2_RKE:
  10925.           if ((x = cmcfm()) < 0)
  10926.         return(x);
  10927. #ifndef SSHTEST
  10928.           ssh_v2_rekey();
  10929. #endif /* SSHTEST */
  10930.           return(success = 1);
  10931.         default:
  10932.           return(-2);
  10933.       }
  10934.     case XSSH_KEY:
  10935.       if ((cx = cmkey(sshkey,nsshkey,"","", xxstring)) < 0)
  10936.         return(cx);
  10937.       switch (cx) {
  10938.         case SSHK_PASS: {    /* Change passphrase */
  10939.           char * oldp = NULL, * newp = NULL;
  10940.           struct FDB df, sw;
  10941.           cmfdbi(&sw,
  10942.              _CMKEY,        /* fcode */
  10943.              "Filename, or switch", /* hlpmsg */
  10944.              "",        /* default */
  10945.              "",        /* addtl string data */
  10946.              2,            /* addtl numeric data 1: tbl size */
  10947.              4,            /* addtl numeric data 2: 4 = cmswi */
  10948.              xxstring,        /* Processing function */
  10949.              sshkpsw,        /* Keyword table */
  10950.              &df        /* Pointer to next FDB */
  10951.              );
  10952.           cmfdbi(&df,        /* 2nd FDB - file for display */
  10953.              _CMIFI,        /* output file */
  10954.              "",        /* hlpmsg */
  10955.              "",        /* default */
  10956.              "",        /* addtl string data */
  10957.              0,            /* addtl numeric data 1 */
  10958.              0,            /* addtl numeric data 2 */
  10959.              xxstring,
  10960.              NULL,
  10961.              NULL
  10962.              );
  10963.           line[0] = NUL;
  10964.  
  10965.           while (1) {
  10966.           x = cmfdb(&sw);
  10967.           if (x == -3) break;
  10968.           if (x < 0)
  10969.             return(x);
  10970.           if (cmresult.fcode != _CMKEY)
  10971.             break;
  10972.           if (!cmgbrk()) {
  10973.               printf("?This switch requires an argument\n");
  10974.               return(-9);
  10975.           }
  10976.           if ((y = cmfld("Passphrase","",&s,xxstring)) < 0)
  10977.             return(y);
  10978.           switch (cmresult.nresult) {
  10979.             case 1:        /* Old */
  10980.               makestr(&oldp,s);
  10981.               break;
  10982.             case 2:        /* New */
  10983.               makestr(&newp,s);
  10984.           }
  10985.           }
  10986.           if (cmresult.fcode == _CMIFI) { /* Filename */
  10987.           ckstrncpy(line,cmresult.sresult,LINBUFSIZ);
  10988.           if (zfnqfp(line,TMPBUFSIZ,tmpbuf))
  10989.             ckstrncpy(line,tmpbuf,LINBUFSIZ);
  10990.           }
  10991.           if ((x = cmcfm()) < 0) return(x);
  10992.  
  10993. #ifndef SSHTEST
  10994.           x = sshkey_change_passphrase(line[0] ? line : NULL,
  10995.                          oldp, newp);
  10996. #endif /* SSHTEST */
  10997.           makestr(&oldp,NULL);
  10998.           makestr(&newp,NULL);
  10999.           success = (x == 0);
  11000.           return(success);
  11001.         }
  11002.         case SSHK_CREA: {    /* SSH KEY CREATE /switches... */
  11003.           int bits = 1024, keytype = SSHKT_2R;
  11004.           char * pass = NULL, * comment = NULL;
  11005.           struct FDB df, sw;
  11006.  
  11007.               /*
  11008.                * char * sshkey_default_file(int keytype) 
  11009.                * will provide the default filename for a given keytype
  11010.                * is it possible to have the default value for the 2nd
  11011.                * FDB set and changed when a /TYPE switch is provided?
  11012.                * Would this allow for tab completion of the filename?
  11013.                */
  11014.           cmfdbi(&sw,
  11015.              _CMKEY,        /* fcode */
  11016.              "Filename, or switch", /* hlpmsg */
  11017.              "",        /* default */
  11018.              "",        /* addtl string data */
  11019.              nsshkcrea,        /* addtl numeric data 1: tbl size */
  11020.              4,            /* addtl numeric data 2: 4 = cmswi */
  11021.              xxstring,        /* Processing function */
  11022.              sshkcrea,        /* Keyword table */
  11023.              &df        /* Pointer to next FDB */
  11024.              );
  11025.           cmfdbi(&df,        /* 2nd FDB - file for display */
  11026.              _CMOFI,        /* output file */
  11027.              "",        /* hlpmsg */
  11028.              "",        /* default */
  11029.              "",        /* addtl string data */
  11030.              0,            /* addtl numeric data 1 */
  11031.              0,            /* addtl numeric data 2 */
  11032.              xxstring,
  11033.              NULL,
  11034.              NULL
  11035.              );
  11036.           line[0] = NUL;
  11037.  
  11038.           while (1) {
  11039.           x = cmfdb(&sw);
  11040.           if (x == -3) break;
  11041.           if (x < 0)
  11042.             return(x);
  11043.           if (cmresult.fcode != _CMKEY)
  11044.             break;
  11045.           if (!cmgbrk()) {
  11046.               printf("?This switch requires an argument\n");
  11047.               return(-9);
  11048.           }
  11049.           switch (cmresult.nresult) {
  11050.             case SSHKC_BI:    /* /BITS:n */
  11051.               if ((y = cmnum("","1024",10,&z,xxstring)) < 0)
  11052.             return(y);
  11053.               if (z < 512 || z > 4096) {
  11054.               printf("?Out range - min: 512, max: 4096\n");
  11055.               return(-9);
  11056.               }
  11057.               bits = z;
  11058.               break;
  11059.             case SSHKC_PP:    /* /PASSPHRASE:blah */
  11060.               if ((y = cmfld("Passphrase","",&s,xxstring)) < 0)
  11061.             return(y);
  11062.               makestr(&pass,s);
  11063.               break;
  11064.             case SSHKC_TY:    /* /TYPE:keyword */
  11065.               if ((y = cmkey(sshkcty,nsshkcty,"",
  11066.                      "v2-rsa",xxstring)) < 0)
  11067.             return(y);
  11068.               keytype = y;
  11069.               break;
  11070.             case SSHKC_1R:    /* /COMMENT */
  11071.               if ((y = cmfld("Text","",&s,xxstring)) < 0)
  11072.             return(y);
  11073.               makestr(&comment,s);
  11074.               break;
  11075.           }
  11076.           }
  11077.           if (cmresult.fcode == _CMOFI) { /* Filename */
  11078.                   if (cmresult.sresult) {
  11079.                       ckstrncpy(line,cmresult.sresult,LINBUFSIZ);
  11080.                       if (zfnqfp(line,TMPBUFSIZ,tmpbuf))
  11081.                           ckstrncpy(line,tmpbuf,LINBUFSIZ);
  11082.           }
  11083.           }
  11084.           if ((y = cmcfm()) < 0) /* Confirm */
  11085.         return(y);
  11086. #ifndef SSHTEST
  11087.           x = sshkey_create(line[0] ? line : NULL,
  11088.                 bits, pass, keytype, comment);
  11089.           if (pass)
  11090.         memset(pass,0,strlen(pass));
  11091. #endif /* SSHTEST */
  11092.           makestr(&pass,NULL);
  11093.           makestr(&comment,NULL);
  11094.           return(success = (x == 0));
  11095.         }
  11096.         case SSHK_DISP: {    /* SSH KEY DISPLAY /switches... */
  11097.           char c;
  11098.           int infmt = 0, outfmt = 0;
  11099.           struct FDB df, sw;
  11100.           cmfdbi(&sw,
  11101.              _CMKEY,        /* fcode */
  11102.              "Filename, or switch", /* hlpmsg */
  11103.              "",        /* default */
  11104.              "",        /* addtl string data */
  11105.              nsshdswi,        /* addtl numeric data 1: tbl size */
  11106.              4,            /* addtl numeric data 2: 4 = cmswi */
  11107.              xxstring,        /* Processing function */
  11108.              sshdswi,        /* Keyword table */
  11109.              &df        /* Pointer to next FDB */
  11110.              );
  11111.           cmfdbi(&df,        /* 2nd FDB - file for display */
  11112.              _CMIFI,        /* fcode */
  11113.              "",        /* hlpmsg */
  11114.              "",        /* default */
  11115.              "",        /* addtl string data */
  11116.              0,            /* addtl numeric data 1 */
  11117.              0,            /* addtl numeric data 2 */
  11118.              xxstring,
  11119.              NULL,
  11120.              NULL
  11121.              );
  11122.           line[0] = NUL;
  11123.  
  11124.           while (1) {
  11125.           x = cmfdb(&sw);
  11126.           if (x == -3) break;
  11127.           if (x < 0)
  11128.             return(x);
  11129.           if (cmresult.fcode != _CMKEY)
  11130.             break;
  11131.           if (!cmgbrk()) {
  11132.               printf("?This switch requires an argument\n");
  11133.               return(-9);
  11134.           }
  11135.           switch (cmresult.nresult) {
  11136. #ifdef COMMENT
  11137.             case SSHKD_IN:    /* /IN-FORMAT: */
  11138.               if ((y = cmkey(sshdifmt,nsshdifmt,
  11139.                      "","",xxstring)) < 0)
  11140.             return(y);
  11141.               infmt = y;
  11142.               break;
  11143. #endif /* COMMENT */
  11144.             case SSHKD_OUT:    /* /FORMAT: */
  11145.               if ((y = cmkey(sshdofmt,nsshdofmt,
  11146.                      "","",xxstring)) < 0)
  11147.             return(y);
  11148.               outfmt = y;
  11149.               break;
  11150.           }
  11151.           }
  11152.           if (cmresult.fcode == _CMIFI) { /* Filename */
  11153.           ckstrncpy(line,cmresult.sresult,LINBUFSIZ);
  11154.           if (zfnqfp(line,TMPBUFSIZ,tmpbuf))
  11155.             ckstrncpy(line,tmpbuf,LINBUFSIZ);
  11156.           }
  11157. #ifdef COMMENT
  11158.           if (!line[0]) {
  11159.           printf("?Key filename required\n");
  11160.           return(-9);
  11161.           }
  11162. #endif /* COMMENT */
  11163.           if ((y = cmcfm()) < 0) /* Confirm */
  11164.         return(y);
  11165. #ifndef SSHTEST
  11166.           switch (outfmt) {
  11167.         case SKDF_OSSH:
  11168.                   /* 2nd param is optional passphrase */
  11169.           x = sshkey_display_public(line[0] ? line : NULL, NULL);
  11170.           break;
  11171.         case SKDF_SSHC:
  11172.                   /* 2nd param is optional passphrase */
  11173.           x = sshkey_display_public_as_ssh2(line[0] ? line : NULL,
  11174.                             NULL);
  11175.           break;
  11176.         case SKDF_IETF:
  11177.           x = sshkey_display_fingerprint(line[0] ? line : NULL, 1);
  11178.           break;
  11179.         case SKDF_FING:
  11180.           x = sshkey_display_fingerprint(line[0] ? line : NULL, 0);
  11181.           break;
  11182.           }
  11183. #endif /* SSHTEST */
  11184.           return(success = (x == 0));
  11185.         }
  11186.         case SSHK_V1:        /* SSH KEY V1 SET-COMMENT */
  11187.           if ((x = cmkey(sshkv1,1,"","set-comment", xxstring)) < 0)
  11188.         return(x);
  11189.           if (x != 1) return(-2);
  11190.           if ((x = cmifi("Key file name","",&s,&y,xxstring)) < 0) {
  11191.           if (x == -3) {
  11192.               printf("?Name of key file required\n");
  11193.               return(-9);
  11194.           }
  11195.           }
  11196.           ckstrncpy(line,s,LINBUFSIZ);
  11197.           if ((x = cmtxt("Comment text","",&s,xxstring)) < 0)
  11198.         return(x);
  11199. #ifndef SSHTEST
  11200.           x = sshkey_v1_change_comment(line,  /* filename */
  11201.                        s,     /* new comment */
  11202.                        NULL   /* passphrase */
  11203.                        );
  11204. #endif /* SSHTEST */
  11205.           success = (x == 0);
  11206.           return(success);
  11207.       }
  11208.       default:
  11209.         return(-2);
  11210.     }
  11211. #else  /* SSHBUILTIN */
  11212. #ifdef SSHCMD
  11213.     x = nettype;
  11214.     if ((y = setlin(XXSSH,0,1)) < 0) {
  11215.         if (errno)
  11216.           printf("?%s\n",ck_errstr());
  11217.             else
  11218. #ifdef COMMENT
  11219.         /* This isn't right either because it catches command editing */
  11220.           printf("?Sorry, pseudoterminal open failed\n");
  11221.             if (hints)
  11222.           printf("Hint: Try \"ssh -t %s\"\n",line);
  11223. #else
  11224.           return(y);
  11225. #endif /* COMMENT */
  11226.         nettype = x;        /* Failed, restore net type. */
  11227.         ttnproto = z;        /* and protocol */
  11228.         success = 0;
  11229.     }
  11230.     didsetlin++;
  11231.     netsave = x;
  11232.     return(y);
  11233. #endif /* SSHCMD */
  11234. #endif /* SSHBUILTIN */
  11235.     }
  11236. #endif /* ANYSSH */
  11237.  
  11238. #ifdef SSHBUILTIN
  11239.     if (cx == XXSKRM) {            /* SKERMIT (Secure Shell Kermit) */
  11240.     extern int netsave;
  11241.     int k, x, havehost = 0, trips = 0;
  11242.         int    tmpver = -1, tmpxfw = -1;
  11243. #ifndef SSHTEST
  11244.         extern int sl_ssh_xfw, sl_ssh_xfw_saved;
  11245.         extern int sl_ssh_ver, sl_ssh_ver_saved;
  11246. #endif /* SSHTEST */
  11247.         extern int mdmtyp, mdmsav, cxtype, sl_uid_saved;
  11248.         extern char * slmsg;
  11249.     extern char uidbuf[], sl_uidbuf[];
  11250.         extern char pwbuf[], * g_pswd;
  11251.         extern int pwflg, pwcrypt, g_pflg, g_pcpt, nolocal;
  11252.     struct FDB sw, kw, fl;
  11253.  
  11254.         if (ssh_tmpstr)
  11255.       memset(ssh_tmpstr,0,strlen(ssh_tmpstr));
  11256.         makestr(&ssh_tmpstr,NULL);
  11257.         makestr(&ssh_tmpuid,NULL);
  11258.         makestr(&ssh_tmpcmd,NULL);
  11259.         makestr(&ssh_tmpport,NULL);
  11260.  
  11261.     cmfdbi(&kw,            /* 1st FDB - commands */
  11262.            _CMKEY,            /* fcode */
  11263.            "host [ port ],\n or action", /* hlpmsg */
  11264.            "",            /* default */
  11265.            "",            /* addtl string data */
  11266.            nsshkermit,        /* addtl numeric data 1: tbl size */
  11267.            0,            /* addtl numeric data 2: 0 = keyword */
  11268.            xxstring,        /* Processing function */
  11269.            sshkermit,        /* Keyword table */
  11270.            &fl            /* Pointer to next FDB */
  11271.            );
  11272.     cmfdbi(&fl,            /* Host */
  11273.            _CMFLD,            /* fcode */
  11274.            "",            /* hlpmsg */
  11275.            "",            /* default */
  11276.            "",            /* addtl string data */
  11277.            0,            /* addtl numeric data 1 */
  11278.            0,            /* addtl numeric data 2 */
  11279.            xxstring,
  11280.            NULL,
  11281.            NULL
  11282.            );
  11283.  
  11284.     x = cmfdb(&kw);
  11285.     if (x == -3) {
  11286.         printf("?skermit what?\n");
  11287.         return(-9);
  11288.     }
  11289.     if (x < 0)
  11290.       return(x);
  11291.     havehost = 0;
  11292.     if (cmresult.fcode == _CMFLD) {
  11293.         havehost = 1;
  11294.         ckstrncpy(line,cmresult.sresult,LINBUFSIZ); /* Hostname */
  11295.         cmresult.nresult = SKRM_OPN;
  11296.     }
  11297.     switch (cmresult.nresult) {    /* SSH keyword */
  11298.       case SKRM_OPN:        /* SSH OPEN */
  11299.         if (!havehost) {
  11300.         if ((x = cmfld("Host","",&s,xxstring)) < 0)
  11301.           return(x);
  11302.         ckstrncpy(line,s,LINBUFSIZ);
  11303.         }
  11304.         /* Parse [ port ] [ switches ] */
  11305.         cmfdbi(&kw,            /* Switches */
  11306.            _CMKEY,
  11307.            "Port number or service name,\nor switch",
  11308.            "",
  11309.            "",
  11310.            nsshkrmopnsw,
  11311.            4,
  11312.            xxstring,
  11313.            sshkrmopnsw,
  11314.            &fl
  11315.            );
  11316.         cmfdbi(&fl,            /* Port number or service name */
  11317.            _CMFLD,
  11318.            "",
  11319.            "",
  11320.            "",
  11321.            0,
  11322.            0,
  11323.            xxstring,
  11324.            NULL,
  11325.            NULL
  11326.            );
  11327.         trips = 0;            /* Explained below */
  11328.         while (1) {            /* Parse port and switches */
  11329.         x = cmfdb(&kw);        /* Get a field */
  11330.         if (x == -3)        /* User typed CR so quit from loop */
  11331.           break;
  11332.         if (x < 0)        /* Other parse error, pass it back */
  11333.           return(x);
  11334.         switch (cmresult.fcode) { /* Field or Keyword? */
  11335.                   case _CMFLD:          /* Field */
  11336.                     makestr(&ssh_tmpport,cmresult.sresult);
  11337.             break;
  11338.           case _CMKEY:        /* Keyword */
  11339.             switch (cmresult.nresult) {    /* Which one? */
  11340.               case SSHSW_USR:            /* /USER: */
  11341.             if (!cmgbrk()) {
  11342.                 printf("?This switch requires an argument\n");
  11343.                 return(-9);
  11344.             }
  11345.             if ((y = cmfld("Username","",&s,xxstring)) < 0)
  11346.               return(y);
  11347.             s = brstrip(s);
  11348.             makestr(&ssh_tmpuid,s);
  11349.             break;
  11350.                       case SSHSW_PWD:
  11351.             if (!cmgbrk()) {
  11352.                 printf("?This switch requires an argument\n");
  11353.                 return(-9);
  11354.             }
  11355.             debok = 0;
  11356.             if ((x = cmfld("Password","",&s,xxstring)) < 0) {
  11357.                 if (x == -3) {
  11358.                 makestr(&ssh_tmpstr,"");
  11359.                 } else {
  11360.                 return(x);
  11361.                 }
  11362.             } else {
  11363.                 s = brstrip(s);
  11364.                 if ((x = (int)strlen(s)) > PWBUFL) {
  11365.                 makestr(&slmsg,"Internal error");
  11366.                 printf("?Sorry, too long - max = %d\n",PWBUFL);
  11367.                 return(-9);
  11368.                 }
  11369.                 makestr(&ssh_tmpstr,s);
  11370.             }
  11371.             break;
  11372.  
  11373.                     case SSHSW_VER:
  11374.             if ((x = cmnum("Number","",10,&z,xxstring)) < 0)
  11375.               return(x);
  11376.             if (z < 1 || z > 2) {
  11377.                 printf("?Out of range: %d\n",z);
  11378.                 return(-9);
  11379.             }
  11380.                         tmpver = z;
  11381.             break;
  11382.                     default:
  11383.                         return(-2);
  11384.             }
  11385.                   }
  11386.         if (trips++ == 0) {    /* After first time through */
  11387.             cmfdbi(&kw,        /* only parse switches, not port. */
  11388.                _CMKEY,
  11389.                "Switch",
  11390.                "",
  11391.                "",
  11392.                nsshkrmopnsw,
  11393.                4,
  11394.                xxstring,
  11395.                sshkrmopnsw,
  11396.                NULL
  11397.                );
  11398.         }
  11399.         }
  11400.         if ((x = cmcfm()) < 0)    /* Get confirmation */
  11401.           return(x);
  11402.               if (clskconnx(1) < 0) {    /* Close current Kermit connection */
  11403.                   if ( ssh_tmpstr ) {
  11404.                       memset(ssh_tmpstr,0,strlen(ssh_tmpstr));
  11405.                       makestr(&ssh_tmpstr,NULL);
  11406.                   }
  11407.                   return(success = 0);
  11408.               }
  11409.               makestr(&ssh_hst,line);    /* Stash everything */
  11410.               if (ssh_tmpuid) {
  11411.                   if (!sl_uid_saved) {
  11412.                       ckstrncpy(sl_uidbuf,uidbuf,UIDBUFLEN);
  11413.                       sl_uid_saved = 1;
  11414.                   }
  11415.                   ckstrncpy(uidbuf,ssh_tmpuid,UIDBUFLEN);
  11416.                   makestr(&ssh_tmpuid,NULL);
  11417.               }
  11418.               if (ssh_tmpport) {
  11419.                   makestr(&ssh_prt,ssh_tmpport);
  11420.                   makestr(&ssh_tmpport,NULL);
  11421.               } else
  11422.                   makestr(&ssh_prt,NULL);
  11423.  
  11424.               /* Set the Subsystem to Kermit */
  11425.               ssh_cas = 1;
  11426.               makestr(&ssh_cmd,"kermit");
  11427.  
  11428.               if (tmpver > -1) {
  11429. #ifndef SSHTEST
  11430.                   if (!sl_ssh_ver_saved) {
  11431.                       sl_ssh_ver = ssh_ver;
  11432.                       sl_ssh_ver_saved = 1;
  11433.                   }
  11434. #endif /* SSHTEST */
  11435.                   ssh_ver = tmpver;
  11436.               }
  11437.               /* Disable X11 Forwarding */
  11438. #ifndef SSHTEST
  11439.               if (!sl_ssh_xfw_saved) {
  11440.                   sl_ssh_xfw = ssh_xfw;
  11441.                   sl_ssh_xfw_saved = 1;
  11442.               }
  11443. #endif /* SSHTEST */
  11444.               ssh_xfw = 0;
  11445.  
  11446.               if (ssh_tmpstr) {
  11447.                   if (ssh_tmpstr[0]) {
  11448.                       ckstrncpy(pwbuf,ssh_tmpstr,PWBUFL+1);
  11449.                       pwflg = 1;
  11450.                       pwcrypt = 0;
  11451.                   } else
  11452.                       pwflg = 0;
  11453.                   makestr(&ssh_tmpstr,NULL);
  11454.               }
  11455.               nettype = NET_SSH;
  11456.               if (mdmsav < 0)
  11457.                   mdmsav = mdmtyp;
  11458.               mdmtyp = -nettype;
  11459.               x = 1;
  11460.  
  11461. #ifndef NOSPL
  11462.             makestr(&g_pswd,pwbuf);    /* Save global pwbuf */
  11463.             g_pflg = pwflg;        /* and flag */
  11464.             g_pcpt = pwcrypt;
  11465. #endif /* NOSPL */
  11466.  
  11467.         /* Line parameter to ttopen() is ignored */
  11468.         k = ttopen(line,&x,mdmtyp, 0);
  11469.         if (k < 0) {
  11470.         printf("?Unable to connect to %s\n",ssh_hst);
  11471.         mdmtyp = mdmsav;
  11472.                 slrestor();
  11473.         return(success = 0);
  11474.         }
  11475.         duplex = 0;             /* Remote echo */
  11476.         ckstrncpy(ttname,line,TTNAMLEN); /* Record the command */
  11477.         debug(F110,"ssh ttname",ttname,0);
  11478.         makestr(&slmsg,NULL);    /* No SET LINE error message */
  11479.         cxtype = CXT_SSH;
  11480. #ifndef NODIAL
  11481.         dialsta = DIA_UNK;
  11482. #endif /* NODIAL */
  11483.         success = 1;        /* SET LINE succeeded */
  11484.         network = 1;        /* Network connection (not serial) */
  11485.         local = 1;            /* Local mode (not remote) */
  11486.         if ((reliable != SET_OFF || !setreliable))
  11487.           reliable = SET_ON;    /* Transport is reliable end to end */
  11488. #ifdef OS2
  11489.             DialerSend(OPT_KERMIT_CONNECT, 0);
  11490. #endif /* OS2 */
  11491.         setflow();            /* Set appropriate flow control */
  11492.  
  11493.         haveline = 1;
  11494. #ifdef CKLOGDIAL
  11495. #ifdef NETCONN
  11496.         dolognet();
  11497. #endif /* NETCONN */
  11498. #endif /* CKLOGDIAL */
  11499.  
  11500. #ifndef NOSPL
  11501.         if (local) {
  11502.         if (nmac) {        /* Any macros defined? */
  11503.             int k;        /* Yes */
  11504.             k = mlook(mactab,"on_open",nmac); /* Look this up */
  11505.             if (k >= 0) {                  /* If found, */
  11506.             if (dodo(k,ssh_hst,0) > -1)   /* set it up, */
  11507.               parser(1);              /* and execute it */
  11508.             }
  11509.         }
  11510.         }
  11511. #endif /* NOSPL */
  11512. #ifdef LOCUS        
  11513.         if (autolocus)
  11514.         setlocus(1,1);
  11515. #endif /* LOCUS */
  11516.  
  11517.     /* Command was confirmed so we can pre-pop command level. */
  11518.     /* This is so CONNECT module won't think we're executing a */
  11519.     /* script if CONNECT was the final command in the script. */
  11520.         if (cmdlvl > 0)
  11521.           prepop();
  11522.         return(success = 1);
  11523.  
  11524.       default:
  11525.         return(-2);
  11526.     }
  11527.     }
  11528. #endif /* SSHBUILTIN */
  11529.  
  11530. #ifdef SFTP_BUILTIN
  11531.     if (cx == XXSFTP) {            /* SFTP (Secure Shell File Transfer) */
  11532.     extern int netsave;
  11533.     int k, x, havehost = 0, trips = 0;
  11534.         int    tmpver = -1, tmpxfw = -1;
  11535. #ifndef SSHTEST
  11536.         extern int sl_ssh_xfw, sl_ssh_xfw_saved;
  11537.         extern int sl_ssh_ver, sl_ssh_ver_saved;
  11538. #endif /* SSHTEST */
  11539.         extern int mdmtyp, mdmsav, cxtype, sl_uid_saved;
  11540.         extern char * slmsg;
  11541.     extern char uidbuf[], sl_uidbuf[];
  11542.         extern char pwbuf[], * g_pswd;
  11543.         extern int pwflg, pwcrypt, g_pflg, g_pcpt, nolocal;
  11544.     struct FDB sw, kw, fl;
  11545.  
  11546.         if (ssh_tmpstr)
  11547.       memset(ssh_tmpstr,0,strlen(ssh_tmpstr));
  11548.         makestr(&ssh_tmpstr,NULL);
  11549.         makestr(&ssh_tmpuid,NULL);
  11550.         makestr(&ssh_tmpcmd,NULL);
  11551.         makestr(&ssh_tmpport,NULL);
  11552.  
  11553.     cmfdbi(&kw,            /* 1st FDB - commands */
  11554.            _CMKEY,            /* fcode */
  11555.            "host [ port ],\n or action", /* hlpmsg */
  11556.            "",            /* default */
  11557.            "",            /* addtl string data */
  11558.            nsftpkwtab,        /* addtl numeric data 1: tbl size */
  11559.            0,            /* addtl numeric data 2: 0 = keyword */
  11560.            xxstring,        /* Processing function */
  11561.            sftpkwtab,        /* Keyword table */
  11562.            &fl            /* Pointer to next FDB */
  11563.            );
  11564.     cmfdbi(&fl,            /* Host */
  11565.            _CMFLD,            /* fcode */
  11566.            "",            /* hlpmsg */
  11567.            "",            /* default */
  11568.            "",            /* addtl string data */
  11569.            0,            /* addtl numeric data 1 */
  11570.            0,            /* addtl numeric data 2 */
  11571.            xxstring,
  11572.            NULL,
  11573.            NULL
  11574.            );
  11575.  
  11576.     x = cmfdb(&kw);
  11577.     if (x == -3) {
  11578.         printf("?sftp what?\n");
  11579.         return(-9);
  11580.     }
  11581.     if (x < 0)
  11582.       return(x);
  11583.     havehost = 0;
  11584.     if (cmresult.fcode == _CMFLD) {
  11585.         havehost = 1;
  11586.         ckstrncpy(line,cmresult.sresult,LINBUFSIZ); /* Hostname */
  11587.         cmresult.nresult = SFTP_OPN;
  11588.     }
  11589.     switch (cmresult.nresult) {    /* SFTP keyword */
  11590.       case SFTP_OPN:        /* SFTP OPEN */
  11591.         if (!havehost) {
  11592.         if ((x = cmfld("Host","",&s,xxstring)) < 0)
  11593.           return(x);
  11594.         ckstrncpy(line,s,LINBUFSIZ);
  11595.         }
  11596.         /* Parse [ port ] [ switches ] */
  11597.         cmfdbi(&kw,            /* Switches */
  11598.            _CMKEY,
  11599.            "Port number or service name,\nor switch",
  11600.            "",
  11601.            "",
  11602.            nsshkrmopnsw,
  11603.            4,
  11604.            xxstring,
  11605.            sshkrmopnsw,
  11606.            &fl
  11607.            );
  11608.         cmfdbi(&fl,            /* Port number or service name */
  11609.            _CMFLD,
  11610.            "",
  11611.            "",
  11612.            "",
  11613.            0,
  11614.            0,
  11615.            xxstring,
  11616.            NULL,
  11617.            NULL
  11618.            );
  11619.         trips = 0;            /* Explained below */
  11620.         while (1) {            /* Parse port and switches */
  11621.         x = cmfdb(&kw);        /* Get a field */
  11622.         if (x == -3)        /* User typed CR so quit from loop */
  11623.           break;
  11624.         if (x < 0)        /* Other parse error, pass it back */
  11625.           return(x);
  11626.         switch (cmresult.fcode) { /* Field or Keyword? */
  11627.                   case _CMFLD:          /* Field */
  11628.                     makestr(&ssh_tmpport,cmresult.sresult);
  11629.             break;
  11630.           case _CMKEY:        /* Keyword */
  11631.             switch (cmresult.nresult) {    /* Which one? */
  11632.               case SSHSW_USR:            /* /USER: */
  11633.             if (!cmgbrk()) {
  11634.                 printf("?This switch requires an argument\n");
  11635.                 return(-9);
  11636.             }
  11637.             if ((y = cmfld("Username","",&s,xxstring)) < 0)
  11638.               return(y);
  11639.             s = brstrip(s);
  11640.             makestr(&ssh_tmpuid,s);
  11641.             break;
  11642.                       case SSHSW_PWD:
  11643.             if (!cmgbrk()) {
  11644.                 printf("?This switch requires an argument\n");
  11645.                 return(-9);
  11646.             }
  11647.             debok = 0;
  11648.             if ((x = cmfld("Password","",&s,xxstring)) < 0) {
  11649.                 if (x == -3) {
  11650.                 makestr(&ssh_tmpstr,"");
  11651.                 } else {
  11652.                 return(x);
  11653.                 }
  11654.             } else {
  11655.                 s = brstrip(s);
  11656.                 if ((x = (int)strlen(s)) > PWBUFL) {
  11657.                 makestr(&slmsg,"Internal error");
  11658.                 printf("?Sorry, too long - max = %d\n",PWBUFL);
  11659.                 return(-9);
  11660.                 }
  11661.                 makestr(&ssh_tmpstr,s);
  11662.             }
  11663.             break;
  11664.  
  11665.                     case SSHSW_VER:
  11666.             if ((x = cmnum("Number","",10,&z,xxstring)) < 0)
  11667.               return(x);
  11668.             if (z < 1 || z > 2) {
  11669.                 printf("?Out of range: %d\n",z);
  11670.                 return(-9);
  11671.             }
  11672.                         tmpver = z;
  11673.             break;
  11674.                     default:
  11675.                         return(-2);
  11676.             }
  11677.         }
  11678.         if (trips++ == 0) {    /* After first time through */
  11679.             cmfdbi(&kw,        /* only parse switches, not port. */
  11680.                _CMKEY,
  11681.                "Switch",
  11682.                "",
  11683.                "",
  11684.                nsshkrmopnsw,
  11685.                4,
  11686.                xxstring,
  11687.                sshkrmopnsw,
  11688.                NULL
  11689.                );
  11690.         }
  11691.         }
  11692.         if ((x = cmcfm()) < 0)    /* Get confirmation */
  11693.           return(x);
  11694.               if (clskconnx(1) < 0) {    /* Close current Kermit connection */
  11695.                   if ( ssh_tmpstr ) {
  11696.                       memset(ssh_tmpstr,0,strlen(ssh_tmpstr));
  11697.                       makestr(&ssh_tmpstr,NULL);
  11698.                   }
  11699.                   return(success = 0);
  11700.               }
  11701.               makestr(&ssh_hst,line);    /* Stash everything */
  11702.               if (ssh_tmpuid) {
  11703.                   if (!sl_uid_saved) {
  11704.                       ckstrncpy(sl_uidbuf,uidbuf,UIDBUFLEN);
  11705.                       sl_uid_saved = 1;
  11706.                   }
  11707.                   ckstrncpy(uidbuf,ssh_tmpuid,UIDBUFLEN);
  11708.                   makestr(&ssh_tmpuid,NULL);
  11709.               }
  11710.               if (ssh_tmpport) {
  11711.                   makestr(&ssh_prt,ssh_tmpport);
  11712.                   makestr(&ssh_tmpport,NULL);
  11713.               } else
  11714.                   makestr(&ssh_prt,NULL);
  11715.  
  11716.               /* Set the Subsystem to Kermit */
  11717.               ssh_cas = 1;
  11718.               makestr(&ssh_cmd,"sftp");
  11719.  
  11720.               if (tmpver > -1) {
  11721. #ifndef SSHTEST
  11722.                   if (!sl_ssh_ver_saved) {
  11723.                       sl_ssh_ver = ssh_ver;
  11724.                       sl_ssh_ver_saved = 1;
  11725.                   }
  11726. #endif /* SSHTEST */
  11727.                   ssh_ver = tmpver;
  11728.               }
  11729.               /* Disable X11 Forwarding */
  11730. #ifndef SSHTEST
  11731.               if (!sl_ssh_xfw_saved) {
  11732.                   sl_ssh_xfw = ssh_xfw;
  11733.                   sl_ssh_xfw_saved = 1;
  11734.               }
  11735. #endif /* SSHTEST */
  11736.               ssh_xfw = 0;
  11737.  
  11738.               if (ssh_tmpstr) {
  11739.                   if (ssh_tmpstr[0]) {
  11740.                       ckstrncpy(pwbuf,ssh_tmpstr,PWBUFL+1);
  11741.                       pwflg = 1;
  11742.                       pwcrypt = 0;
  11743.                   } else
  11744.                       pwflg = 0;
  11745.                   makestr(&ssh_tmpstr,NULL);
  11746.               }
  11747.               nettype = NET_SSH;
  11748.               if (mdmsav < 0)
  11749.                   mdmsav = mdmtyp;
  11750.               mdmtyp = -nettype;
  11751.               x = 1;
  11752.  
  11753. #ifndef NOSPL
  11754.             makestr(&g_pswd,pwbuf);             /* Save global pwbuf */
  11755.             g_pflg = pwflg;                     /* and flag */
  11756.             g_pcpt = pwcrypt;
  11757. #endif /* NOSPL */
  11758.  
  11759.         /* Line parameter to ttopen() is ignored */
  11760.         k = ttopen(line,&x,mdmtyp, 0);
  11761.         if (k < 0) {
  11762.         printf("?Unable to connect to %s\n",ssh_hst);
  11763.         mdmtyp = mdmsav;
  11764.                 slrestor();
  11765.         return(success = 0);
  11766.         }
  11767.         duplex = 0;             /* Remote echo */
  11768.         ckstrncpy(ttname,line,TTNAMLEN); /* Record the command */
  11769.         debug(F110,"ssh ttname",ttname,0);
  11770.         makestr(&slmsg,NULL);    /* No SET LINE error message */
  11771.         cxtype = CXT_SSH;
  11772. #ifndef NODIAL
  11773.         dialsta = DIA_UNK;
  11774. #endif /* NODIAL */
  11775.         success = 1;        /* SET LINE succeeded */
  11776.         network = 1;        /* Network connection (not serial) */
  11777.         local = 1;            /* Local mode (not remote) */
  11778.         if ((reliable != SET_OFF || !setreliable))
  11779.           reliable = SET_ON;    /* Transport is reliable end to end */
  11780. #ifdef OS2
  11781.             DialerSend(OPT_KERMIT_CONNECT, 0);
  11782. #endif /* OS2 */
  11783.         setflow();            /* Set appropriate flow control */
  11784.  
  11785.         haveline = 1;
  11786. #ifdef CKLOGDIAL
  11787. #ifdef NETCONN
  11788.         dolognet();
  11789. #endif /* NETCONN */
  11790. #endif /* CKLOGDIAL */
  11791.  
  11792. #ifndef NOSPL
  11793.         if (local) {
  11794.         if (nmac) {        /* Any macros defined? */
  11795.             int k;        /* Yes */
  11796.             k = mlook(mactab,"on_open",nmac); /* Look this up */
  11797.             if (k >= 0) {                  /* If found, */
  11798.             if (dodo(k,ssh_hst,0) > -1)   /* set it up, */
  11799.               parser(1);              /* and execute it */
  11800.             }
  11801.         }
  11802.         }
  11803. #endif /* NOSPL */
  11804. #ifdef LOCUS        
  11805.         if (autolocus)
  11806.         setlocus(1,1);
  11807. #endif /* LOCUS */
  11808.  
  11809.     /* Command was confirmed so we can pre-pop command level. */
  11810.     /* This is so CONNECT module won't think we're executing a */
  11811.     /* script if CONNECT was the final command in the script. */
  11812.         if (cmdlvl > 0)
  11813.           prepop();
  11814.  
  11815.             success = sftp_do_init();
  11816.         return(success = 1);
  11817.  
  11818.       case SFTP_CD:
  11819.       case SFTP_CHGRP:
  11820.       case SFTP_CHMOD:
  11821.       case SFTP_CHOWN:
  11822.       case SFTP_RM:
  11823.       case SFTP_DIR:
  11824.       case SFTP_GET:
  11825.       case SFTP_MKDIR:
  11826.       case SFTP_PUT:
  11827.       case SFTP_PWD:
  11828.       case SFTP_REN:
  11829.       case SFTP_RMDIR:
  11830.       case SFTP_LINK:
  11831.       case SFTP_VER:
  11832.         if ((y = cmtxt("command parameters","",&s,xxstring)) < 0) 
  11833.           return(y);
  11834.         if (ssh_tchk() < 0 || !ssh_cas || strcmp(ssh_cmd,"sftp")) {
  11835.         printf("?Not connected to SFTP Service\n");
  11836.         return(success = 0);
  11837.         }
  11838.         success = sftp_do_cmd(cmresult.nresult,s);
  11839.         return(success);
  11840.       default:
  11841.         return(-2);
  11842.     }
  11843.     }
  11844. #endif /* SFTP_BUILTIN */
  11845.  
  11846.     if (cx == XXRLOG) {            /* RLOGIN */
  11847. #ifdef RLOGCODE
  11848.     int x,z;
  11849. #ifdef OS2
  11850.     if (!tcp_avail) {
  11851.         printf("?Sorry, either TCP/IP is not available on this system or\n\
  11852. necessary DLLs did not load.  Use SHOW NETWORK to check network status.\n"
  11853.            );
  11854.         success = 0;
  11855.         return(-9);
  11856.     } else {
  11857. #endif /* OS2 */
  11858.         x = nettype;        /* Save net type in case of failure */
  11859.         z = ttnproto;        /* Save protocol in case of failure */
  11860.         nettype = NET_TCPB;
  11861.         ttnproto = NP_RLOGIN;
  11862.         if ((y = setlin(XYHOST,0,1)) <= 0) {
  11863.         nettype = x;        /* Failed, restore net type. */
  11864.         ttnproto = z;        /* and protocol */
  11865.         success = 0;
  11866.         }
  11867.         didsetlin++;
  11868. #ifdef OS2
  11869.     }
  11870. #endif /* OS2 */
  11871.     return(y);
  11872. #else
  11873.     printf("?Sorry, RLOGIN is not configured in this copy of C-Kermit.\n");
  11874.     return(-9);
  11875. #endif /* RLOGCODE */
  11876.     }
  11877. #endif /* NETCONN */
  11878. #endif /* NOLOCAL */
  11879.  
  11880. #ifndef NOXMIT
  11881.     if (cx == XXTRA) {            /* TRANSMIT */
  11882.     extern int xfrxla;
  11883.     int i, n, xpipe = 0, xbinary = 0, xxlate = 1, xxnowait = 0, getval;
  11884.     int xxecho = 0;
  11885.     int scan = 1;
  11886.     char c;
  11887.     struct FDB sf, sw, tx;        /* FDBs for parse functions */
  11888. #ifndef NOCSETS
  11889.     extern int tcs_transp;        /* Term charset is transparent */
  11890. #else
  11891.     int tcs_transp = 1;
  11892. #endif /* NOCSETS */
  11893.  
  11894. #ifdef COMMENT
  11895.     xbinary = binary;        /* Default text/binary mode */
  11896. #else
  11897.     xbinary = 0;            /* Default is text */
  11898. #endif /* COMMENT */
  11899.     xxecho = xmitx;
  11900.  
  11901.     cmfdbi(&sw,            /* First FDB - command switches */
  11902.            _CMKEY,            /* fcode */
  11903.            "Filename, or switch",    /* hlpmsg */
  11904.            "",            /* default */
  11905.            "",            /* addtl string data */
  11906.            nxmitsw,            /* addtl numeric data 1: tbl size */
  11907.            4,            /* addtl numeric data 2: 4 = cmswi */
  11908.            xxstring,        /* Processing function */
  11909.            xmitsw,            /* Keyword table */
  11910.            &sf            /* Pointer to next FDB */
  11911.            );
  11912.     cmfdbi(&sf,            /* 2nd FDB - file to send */
  11913.            _CMIFI,            /* fcode */
  11914.            "File to transmit",    /* hlpmsg */
  11915.            "",            /* default */
  11916.            "",            /* addtl string data */
  11917.            0,            /* addtl numeric data 1 */
  11918.            0,            /* addtl numeric data 2 */
  11919.            xxstring,
  11920.            NULL,
  11921. #ifdef PIPESEND
  11922.            &tx
  11923. #else
  11924.            NULL
  11925. #endif /* PIPESEND */
  11926.            );
  11927. #ifdef PIPESEND
  11928.         cmfdbi(&tx,
  11929.            _CMTXT,            /* fcode */
  11930.            "Command",        /* hlpmsg */
  11931.            "",            /* default */
  11932.            "",            /* addtl string data */
  11933.            0,            /* addtl numeric data 1 */
  11934.            0,            /* addtl numeric data 2 */
  11935.            xxstring,
  11936.            NULL,
  11937.            NULL
  11938.            );
  11939. #endif /* PIPESEND */
  11940.  
  11941.     while (1) {
  11942.         x = cmfdb(&sw);
  11943.         if (x < 0)
  11944.           return(x);
  11945.         if (cmresult.fcode != _CMKEY)
  11946.           break;
  11947.         c = cmgbrk();        /* Have switch, get break character */
  11948.         if ((getval = (c == ':' || c == '=')) && !(cmgkwflgs() & CM_ARG)) {
  11949.         printf("?This switch does not take an argument\n");
  11950.         return(-9);
  11951.         }
  11952.         if (!getval && (cmgkwflgs() & CM_ARG)) {
  11953.         printf("?This switch requires an argument\n");
  11954.         return(-9);
  11955.         }
  11956.         n = cmresult.nresult;    /* Numeric result = switch ID */
  11957.         switch (n) {        /* Process the switch */
  11958. #ifdef PIPESEND
  11959.           case XMI_CMD:        /* Transmit from a command */
  11960.         if (nopush) {
  11961.             printf("?Sorry, system command access is disabled\n");
  11962.             return(-9);
  11963.         }
  11964.         sw.hlpmsg = "Command, or switch"; /* Change help message */
  11965.         xpipe = 1;        /* (No way to undo this one) */
  11966.         break;
  11967. #endif /* PIPESEND */
  11968.  
  11969.           case XMI_BIN:        /* Binary */
  11970.         xbinary = 1;
  11971.         xxlate = 0;        /* Don't translate charsets */
  11972.         scan = 0;
  11973.         break;
  11974.  
  11975.           case XMI_TXT:        /* Text */
  11976.         xbinary = 0;
  11977.         xxlate = !tcs_transp;    /* Translate if TERM CHAR not TRANSP */
  11978.         scan = 0;
  11979.         break;
  11980.  
  11981.           case XMI_TRA:        /* Transparent text */
  11982.         xbinary = 0;
  11983.         xxlate = 0;        /* But don't translate charsets */
  11984.         scan = 0;
  11985.         break;
  11986.  
  11987. #ifdef COMMENT
  11988.           case XMI_VRB:        /* /VERBOSE */
  11989.           case XMI_QUI:        /* /QUIET */
  11990.         break;            /* (not implemented yet) */
  11991. #endif /* COMMENT */
  11992.  
  11993.           case XMI_NOW:        /* /NOWAIT */
  11994.         xxnowait = 1;
  11995.         break;
  11996.  
  11997.           case XMI_NOE:        /* /NOWAIT */
  11998.         xxecho = 0;
  11999.         break;
  12000.  
  12001.           default:
  12002.         return(-2);
  12003.         }
  12004.  
  12005.     }
  12006.     if (cmresult.fcode != _CMIFI && cmresult.fcode != _CMTXT)
  12007.       return(-2);
  12008.     ckstrncpy(line,cmresult.sresult,LINBUFSIZ); /* Filename */
  12009.     if (zfnqfp(line,TMPBUFSIZ,tmpbuf))
  12010.       ckstrncpy(line,tmpbuf,LINBUFSIZ);
  12011.     s = line;
  12012.     if ((y = cmcfm()) < 0)        /* Confirm */
  12013.       return(y);
  12014. #ifdef CK_APC
  12015.     if ((apcactive == APC_LOCAL) ||
  12016.         ((apcactive == APC_REMOTE) && (!(apcstatus & APC_UNCH))))
  12017.       return(success = 0);
  12018. #endif /* CK_APC */
  12019.     if (cmresult.nresult != 0) {
  12020.         printf("?Only a single file may be transmitted\n");
  12021.         return(-9);
  12022.     }
  12023. #ifdef PIPESEND
  12024.     if (xpipe) {
  12025.         s = brstrip(s);
  12026.         if (!*s) {
  12027.         printf("?Sorry, a command to send from is required\n");
  12028.         return(-9);
  12029.         }
  12030.         pipesend = 1;
  12031.     }
  12032. #endif /* PIPESEND */
  12033.  
  12034.     if (scan && (filepeek
  12035. #ifndef NOXFER
  12036.              || patterns
  12037. #endif /* NOXFER */
  12038.              )) {        /* If user didn't specify type */
  12039.         int k, x;                  /* scan the file to see */
  12040.         x = -1;
  12041.         k = scanfile(s,&x,nscanfile);
  12042.         if (k > 0) xbinary = (k == FT_BIN) ? XYFT_B : XYFT_T;
  12043.     }
  12044.     if (!xfrxla) xxlate = 0;
  12045.     success = transmit(s,
  12046.                (char) (xxnowait ? '\0' : (char)xmitp),
  12047.                xxlate,
  12048.                xbinary,
  12049.                xxecho
  12050.                );
  12051.     return(success);
  12052.     }
  12053. #endif /* NOXMIT */
  12054.  
  12055. #ifndef NOFRILLS
  12056.     if (cx == XXTYP  || cx == XXCAT || cx == XXMORE ||
  12057.     cx == XXHEAD || cx == XXTAIL) {
  12058.     int paging = 0, havename = 0, head = 0, width = 0;
  12059.     int height = 0, count = 0;
  12060.     char pfxbuf[64], * prefix = NULL;
  12061.     char outfile[CKMAXPATH+1];
  12062.     struct FDB sf, sw;
  12063.     char * pat = NULL;
  12064.     int incs = 0, outcs = 0, cset = -1, number = 0;
  12065. #ifdef UNICODE
  12066.         char * tocs = "";
  12067.     extern int fileorder;
  12068. #ifdef OS2
  12069. #ifdef NT
  12070.     char guibuf[128], * gui_title = NULL;
  12071.     int  gui = 0;
  12072. #endif /* NT */
  12073. #ifndef NOCSETS
  12074.     extern int tcsr, tcsl;
  12075. #endif /* NOCSETS */
  12076. #endif /* OS2 */
  12077. #endif /* UNICODE */
  12078.  
  12079.     outfile[0] = NUL;
  12080.  
  12081.     if (cx == XXMORE)
  12082.       paging = 1;
  12083.     else if (cx == XXCAT)
  12084.       paging = 0;
  12085.     else
  12086.       paging = (typ_page < 0) ? xaskmore : typ_page;
  12087.     if (paging < 0)
  12088.       paging = saveask;
  12089.  
  12090.     if (cx == XXHEAD) {
  12091.         head = 10;
  12092.         cx = XXTYP;
  12093.     } else if (cx == XXTAIL) {
  12094.         head = -10;
  12095.         cx = XXTYP;
  12096.     }
  12097.  
  12098. #ifdef IKSD
  12099.     if (inserver && !ENABLED(en_typ)) {
  12100.         printf("?Sorry, TYPE command disabled\n");
  12101.         return(-9);
  12102.     }
  12103. #endif /* IKSD */
  12104.  
  12105.     cmfdbi(&sw,            /* 2nd FDB - optional /PAGE switch */
  12106.            _CMKEY,            /* fcode */
  12107.            "Filename or switch",    /* hlpmsg */
  12108.            "",            /* default */
  12109.            "",            /* addtl string data */
  12110.            ntypetab,        /* addtl numeric data 1: tbl size */
  12111.            4,            /* addtl numeric data 2: 4 = cmswi */
  12112.            xxstring,        /* Processing function */
  12113.            typetab,            /* Keyword table */
  12114.            &sf            /* Pointer to next FDB */
  12115.            );
  12116.     cmfdbi(&sf,            /* 1st FDB - file to type */
  12117.            _CMIFI,            /* fcode */
  12118.            "",            /* hlpmsg */
  12119.            "",            /* default */
  12120.            "",            /* addtl string data */
  12121.            0,            /* addtl numeric data 1 */
  12122.            0,            /* addtl numeric data 2 */
  12123.            xxstring,
  12124.            NULL,
  12125.            NULL
  12126.            );
  12127.  
  12128.     while (!havename) {
  12129.         x = cmfdb(&sw);        /* Parse something */
  12130.         debug(F101,"type cmfdb","",x);
  12131.         debug(F101,"type cmresult.fcode","",cmresult.fcode);
  12132.         debug(F101,"type cmresult.nresult","",cmresult.nresult);
  12133.         if (x < 0) {            /* Error */
  12134.         if (x == -3) {
  12135.             x = -9;
  12136.             printf("?Filename required\n");
  12137.         }
  12138.         return(x);
  12139.         } else if (cmresult.fcode == _CMKEY) {
  12140.         char c; int getval;
  12141.         c = cmgbrk();
  12142.         getval = (c == ':' || c == '=');
  12143.         if (getval && !(cmgkwflgs() & CM_ARG)) {
  12144.             printf("?This switch does not take an argument\n");
  12145.             return(-9);
  12146.         }
  12147. #ifdef COMMENT
  12148.         if (!getval && (cmgkwflgs() & CM_ARG)) {
  12149.             printf("?This switch requires an argument\n");
  12150.             /* Not if it has a default! */
  12151.             return(-9);
  12152.         }
  12153. #endif /* COMMENT */
  12154.         switch (cmresult.nresult) {
  12155. #ifdef CK_TTGWSIZ
  12156.           case TYP_PAG:
  12157.             paging = 1;
  12158.             break;
  12159.  
  12160.           case TYP_NOP:
  12161.             paging = 0;
  12162.             break;
  12163. #endif /* CK_TTGWSIZ */
  12164.  
  12165.           case TYP_COU:
  12166.             paging = 0;
  12167.             count = 1;
  12168.             break;
  12169.  
  12170.           case TYP_HEA:
  12171.           case TYP_TAI:
  12172.             y = 10;
  12173.             if (getval)
  12174.               if ((x = cmnum("Number of lines",
  12175.                      "10",10,&y,xxstring)) < 0)
  12176.             return(x);
  12177.             head = (cmresult.nresult == TYP_TAI) ? -y : y;
  12178.             break;
  12179.  
  12180.           case TYP_WID:
  12181.             y = typ_wid > -1 ? typ_wid : cmd_cols;
  12182.             if (getval)
  12183.               if ((x = cmnum("Column at which to truncate",
  12184.                      ckitoa(y),10,&y,xxstring)) < 0)
  12185.             return(x);
  12186.             width = y;
  12187.             break;
  12188.  
  12189. #ifdef KUI
  12190.           case TYP_HIG:
  12191.             if (getval)
  12192.               if ((x = cmnum("Height of GUI dialog",
  12193.                      ckitoa(y),10,&y,xxstring)) < 0)
  12194.             return(x);
  12195.             height = y;
  12196.             break;
  12197. #endif /* KUI */
  12198.  
  12199.           case TYP_PAT:
  12200.             if (!getval && (cmgkwflgs() & CM_ARG)) {
  12201.             printf("?This switch requires an argument\n");
  12202.             return(-9);
  12203.             }
  12204.             if ((x = cmfld("pattern","",&s,xxstring)) < 0)
  12205.               return(x);
  12206.             ckstrncpy(tmpbuf,s,TMPBUFSIZ);
  12207.             pat = tmpbuf;
  12208.             break;
  12209.  
  12210.           case TYP_PFX:
  12211.             if (!getval && (cmgkwflgs() & CM_ARG)) {
  12212.             printf("?This switch requires an argument\n");
  12213.             return(-9);
  12214.             }
  12215.             if ((x = cmfld("prefix for each line","",&s,xxstring)) < 0)
  12216.               return(x);
  12217.             if ((int)strlen(s) > 63) {
  12218.             printf("?Too long - 63 max\n");
  12219.             return(-9);
  12220.             }
  12221.             ckstrncpy(pfxbuf,s,64);
  12222.             prefix = brstrip(pfxbuf);
  12223.             number = 0;
  12224.             break;
  12225.  
  12226. #ifdef KUI
  12227.           case TYP_GUI:
  12228.             if (!getval && (cmgkwflgs() & CM_ARG)) {
  12229.             printf("?This switch requires an argument\n");
  12230.             return(-9);
  12231.             }
  12232.             if ((x = cmfld("Dialog box title","",&s,xxstring)) < 0) {
  12233.             if (x != -3)
  12234.               return(x);
  12235.             } else {
  12236.             if ((int)strlen(s) > 127) {
  12237.                 printf("?Too long - 127 max\n");
  12238.                 return(-9);
  12239.             }
  12240.             ckstrncpy(guibuf,s,128);
  12241.             gui_title = brstrip(guibuf);
  12242.             }
  12243.             gui = 1;
  12244.             break;
  12245. #endif /* KUI */
  12246.  
  12247.           case TYP_NUM:        /* /NUMBER */
  12248.             number = 1;
  12249.             prefix = NULL;
  12250.             break;
  12251.  
  12252. #ifdef UNICODE
  12253.           case TYP_XPA:        /* /TRANSPARENT */
  12254.             incs = 0;
  12255.             cset = 0;
  12256.             outcs = -1;
  12257.             break;
  12258.  
  12259.           case TYP_XIN:        /* /CHARACTER-SET: */
  12260.             if (!getval && (cmgkwflgs() & CM_ARG)) {
  12261.             printf("?This switch requires an argument\n");
  12262.             return(-9);
  12263.             }
  12264.             if ((incs = cmkey(fcstab,nfilc,
  12265.                       "character-set name","",xxstring)) < 0) {
  12266.             if (incs == -3)    /* Note: No default */
  12267.               incs = -2;
  12268.             return(incs);
  12269.             }
  12270.             cset = incs;
  12271.             break;
  12272.  
  12273.           case TYP_XUT:        /* /TRANSLATE-TO: */
  12274.             if (!getval && (cmgkwflgs() & CM_ARG)) {
  12275.             printf("?This switch requires an argument\n");
  12276.             return(-9);
  12277.             }
  12278. #ifdef OS2
  12279.             if (!inserver && !k95stdout) {
  12280.             tocs = "ucs2";
  12281.             } else {
  12282. #ifdef CKOUNI
  12283.             tocs = rlookup(txrtab,ntxrtab,tcsl);
  12284. #else /* CKOUNI */
  12285.             extern struct keytab ttcstab[];
  12286.             extern int ntxrtab;
  12287.             tocs = rlookup(ttcstab,ntermc,tocs);
  12288.             if (!tocs)
  12289.               tocs = getdcset();
  12290. #endif /* CKOUNI */
  12291.                     }
  12292. #else /* OS2 */
  12293.             tocs = getdcset();
  12294. #endif /* OS2 */
  12295.             if ((outcs = cmkey(fcstab,nfilc,
  12296.                        "character-set",tocs,xxstring)) < 0)
  12297.               return(outcs);
  12298.             break;
  12299. #endif /* UNICODE */
  12300.           case TYP_OUT:
  12301.             if ((x = cmofi("File for result lines","",
  12302.                    &s,xxstring)) < 0)
  12303.               return(x);
  12304.             ckstrncpy(outfile,s,CKMAXPATH);
  12305.             break;
  12306.         }
  12307.         } else if (cmresult.fcode == _CMIFI)
  12308.           havename = 1;
  12309.         else
  12310.           return(-2);
  12311.     }
  12312.     if (havename) {
  12313.         ckstrncpy(line,cmresult.sresult,LINBUFSIZ);
  12314.         y = cmresult.nresult;
  12315.     } else {
  12316.         if ((x = cmifi("Filename","",&s,&y,xxstring)) < 0) {
  12317.         if (x == -3) {
  12318.             printf("?Name of an existing file required\n");
  12319.             return(-9);
  12320.         } else return(x);
  12321.         }
  12322.         ckstrncpy(line,s,LINBUFSIZ);
  12323.     }
  12324.     if (y != 0) {
  12325.         printf("?A single file please\n");
  12326.         return(-9);
  12327.     }
  12328. #ifdef KUI
  12329.     if ( outfile[0] && gui ) {
  12330.         printf("?/GUI and /OUTPUT are incompatible\n");
  12331.         return(-9);
  12332.     }
  12333. #endif /* KUI */
  12334.  
  12335.     if ((y = cmcfm()) < 0)        /* Confirm the command */
  12336.       return(y);
  12337.  
  12338. #ifdef UNICODE
  12339.     fileorder = -1;
  12340.     if (cset < 0 && filepeek) {    /* If no charset switches given */
  12341.         int k, x = -1;
  12342.         k = scanfile(line,&x,nscanfile); /* Call file analyzer */
  12343.         debug(F111,"type scanfile",line,k);
  12344.         debug(F101,"type scanfile flag","",x);
  12345.         switch(k) {
  12346.           case FT_UTF8:        /* which can detect UTF-8... */
  12347.         cset = 0;
  12348.         incs = FC_UTF8;
  12349.         break;
  12350.           case FT_UCS2:        /* and UCS-2... */
  12351.         cset = 0;
  12352.         incs = FC_UCS2;
  12353.         fileorder = x;        /* even if there is no BOM. */
  12354.         debug(F101,"type fileorder","",fileorder);
  12355.         break;
  12356.         }
  12357.     }
  12358. #ifdef OS2
  12359.         if (cset < 0) {            /* If input charset still not known */
  12360. #ifdef CKOUNI
  12361.             tocs = rlookup(txrtab,ntxrtab,tcsl);
  12362. #else /* CKOUNI */
  12363.             extern struct keytab ttcstab[];
  12364.             extern int ntxrtab;
  12365.             tocs = rlookup(ttcstab,ntermc,incs);
  12366.             if (!tocs)
  12367.           tocs = getdcset();
  12368. #endif /* CKOUNI */
  12369.             incs = lookup(fcstab,tocs,nfilc,&x);
  12370.         }
  12371. #endif /* OS2 */
  12372.  
  12373.         if (outcs == 0 && incs != 0) {    /* Supply default target charset */
  12374.         int x = 0;            /* if switch not given. */
  12375.         tocs = getdcset();
  12376.         outcs = lookup(fcstab,tocs,nfilc,&x);
  12377.     }
  12378. #else  /* !UNICODE */
  12379.     if (cset < 0) incs = outcs = 0;
  12380. #endif /* UNICODE */
  12381.  
  12382.     if (outfile[0] && paging)    /* This combination makes no sense */
  12383.       paging = 0;            /* so turn off paging */
  12384.  
  12385. #ifdef KUI
  12386.     /* No paging when dialog is used */
  12387.     if ( gui && paging )
  12388.       paging = 0;
  12389.  
  12390.     if ( !gui && height ) {
  12391.         printf("?The /HEIGHT switch is not supported without /GUI\n");
  12392.         return(-9);
  12393.     }
  12394. #endif /* KUI */
  12395.  
  12396.     if (count) paging = -1;
  12397.     debug(F111,"type",line,paging);
  12398. #ifdef KUI
  12399.     if ( gui ) {
  12400.         s = (char *)1;    /* ok, its an ugly hack */
  12401.         if (gui_text_popup_create(gui_title ?
  12402.                       gui_title : line, height,width) < 0) {
  12403.         printf("?/GUI not supported on this system\n");
  12404.         gui = 0;
  12405.         return(-9);
  12406.         }
  12407.         width = 0;
  12408.     } else
  12409. #endif /* KUI */
  12410.       s = outfile;
  12411.     success =
  12412.       dotype(line,paging,0,head,pat,width,prefix,incs,outcs,s,number);
  12413.     return(success);
  12414.     }
  12415. #endif /* NOFRILLS */
  12416.  
  12417. #ifndef NOCSETS
  12418.     if (cx == XXXLA) {            /* TRANSLATE file's charset */
  12419.     _PROTOTYP (int doxlate, ( void ) );
  12420.     return(doxlate());
  12421.     }
  12422. #endif /* NOCSETS */
  12423.  
  12424.     if (cx == XXVER) {            /* VERSION */
  12425.     int n = 0;
  12426.     extern char * ck_patch, * ck_s_test;
  12427. #ifdef COMMENT
  12428.     extern int hmtopline;
  12429. #endif /* COMMENT */
  12430.     if ((y = cmcfm()) < 0)
  12431.           return(y);
  12432.  
  12433. #ifdef CK_64BIT
  12434.     printf("\n%s, for%s (64-bit)\n Numeric: %ld",versio,ckxsys,vernum);
  12435. #else
  12436.     printf("\n%s, for%s\n Numeric: %ld",versio,ckxsys,vernum);
  12437. #endif    /* CK_64BIT */
  12438.     printf("\n\n");
  12439.         printf("Authors:\n");
  12440.     printf(" Frank da Cruz, Columbia University\n");
  12441.         printf(" Jeffrey Eric Altman, Secure Endpoints, Inc. %s\n",
  12442.            "<jaltman@secure-endpoints.com>"
  12443.            );
  12444.     printf(" Contributions from many others.\n");
  12445.     n = 7;
  12446.     if (*ck_s_test) {
  12447.         printf("\nTHIS IS A TEST VERSION, NOT FOR PRODUCTION USE.\n");
  12448.         n += 2;
  12449.     }
  12450.     if (*ck_patch) {
  12451.         printf(" Patches: %s\n", ck_patch);
  12452.         n++;
  12453.     }
  12454.     printf(" Type COPYRIGHT for copyright and license.\n\n");
  12455. #ifdef OS2
  12456.     shoreg();
  12457. #else
  12458. #ifdef COMMENT
  12459.     hmtopline = n+1;
  12460.     hmsga(copyright);
  12461.     hmtopline = 0;
  12462. #endif /* COMMENT */
  12463. #endif /* OS2 */
  12464.     return(success = 1);
  12465.     }
  12466.  
  12467.     if (cx == XXCPR) {            /* COPYRIGHT or LICENSE */
  12468.         _PROTOTYP( int hmsgaa, (char * [], char *) );
  12469.         extern char * ck_cryear;
  12470.     if ((y = cmcfm()) < 0)
  12471.           return(y);
  12472.     hmsgaa(copyright,ck_cryear);
  12473.     return(success = 1);
  12474.     }
  12475.  
  12476. #ifndef MAC                /* Only for multiuser systems */
  12477. #ifndef OS2
  12478. #ifndef NOFRILLS
  12479.     if (cx == XXWHO) {            /* WHO */
  12480.     char *wc;
  12481. #ifdef IKSD
  12482.     if (inserver && !ENABLED(en_who)) {
  12483.         printf("?Sorry, WHO command disabled\n");
  12484.         return(-9);
  12485.     }
  12486. #endif /* IKSD */
  12487. #ifdef datageneral
  12488.     if ((z = cmcfm()) < 0) return(z);
  12489.     if (nopush) {
  12490.         printf("?Sorry, who not allowed\n");
  12491.         return(success = 0);
  12492.     }
  12493.         xsystem(WHOCMD);
  12494. #else
  12495.     if ((y = cmtxt("user name","",&s,xxstring)) < 0) return(y);
  12496.         if (nopush) {
  12497.         printf("?Sorry, WHO command disabled\n");
  12498.         return(success = 0);
  12499.     }
  12500.     if (!(wc = getenv("CK_WHO"))) wc = WHOCMD;
  12501.     if (wc)
  12502.       if ((int) strlen(wc) > 0) {
  12503.           ckmakmsg(line,LINBUFSIZ,wc," ",s,NULL);
  12504.           xsystem(line);
  12505.       }
  12506. #endif /* datageneral */
  12507.     return(success = 1);
  12508.     }
  12509. #endif /* NOFRILLS */
  12510. #endif /* OS2 */
  12511. #endif /* MAC */
  12512.  
  12513. #ifndef NOFRILLS
  12514.     if (cx == XXWRI || cx == XXWRL || cx == XXWRBL) { /* WRITE */
  12515.     int x,y;            /* On stack in case of \fexec() */
  12516.     if ((x = cmkey(writab,nwri,"to file or log","",xxstring)) < 0) {
  12517.         if (x == -3) printf("?Write to what?\n");
  12518.         return(x);
  12519.     }
  12520.     if ((y = cmtxt("text","",&s,xxstring)) < 0) return(y);
  12521.     s = brstrip(s);
  12522.     switch (x) {
  12523.       case LOGD: y = ZDFILE; break;
  12524.       case LOGP: y = ZPFILE; break;
  12525. #ifndef NOLOCAL
  12526.       case LOGS: y = ZSFILE; break;
  12527. #endif /* NOLOCAL */
  12528.       case LOGT: y = ZTFILE; break;
  12529. #ifndef NOSPL
  12530.       case LOGW: y = ZWFILE; break;
  12531. #endif /* NOSPL */
  12532.       case LOGX:            /* SCREEN (stdout) */
  12533.       case LOGE:            /* ERROR  (stderr) */
  12534.         if (x == LOGE) {
  12535.         debug(F110,
  12536.               (cx == XXWRL) ? "WRITELN ERROR" : "WRITE ERROR", s,0);
  12537.         fprintf(stderr,"%s%s",s,(cx == XXWRL) ? "\n" : "");
  12538.         } else {
  12539.         debug(F110,
  12540.               (cx == XXWRL) ? "WRITELN SCREEN" : "WRITE SCREEN", s,0);
  12541.         printf("%s%s",s,(cx == XXWRL) ? "\n" : "");
  12542.         }
  12543.         return(success = 1);
  12544.       default: return(-2);
  12545.     }
  12546.     if (chkfn(y) > 0) {
  12547.         x = (cx == XXWRI) ? zsout(y,s) : zsoutl(y,s);
  12548.         debug(F111,"WRITE",
  12549.           (cx == XXWRI) ? "zsout" : "zsoutl",
  12550.           x);
  12551.         if (x < 0) printf("?Write error\n");
  12552.     } else {
  12553.         x = -1;
  12554.         printf("?File or log not open\n");
  12555.     }
  12556.     debug(F101,"WRITE x","",x);
  12557.     return(success = (x == 0) ? 1 : 0);
  12558.     }
  12559. #endif /* NOFRILLS */
  12560.  
  12561. #ifndef NOXFER
  12562.     if (cx == XXASC || cx == XXBIN) {
  12563.     if ((x = cmcfm()) < 0) return(x);
  12564. #ifdef NEWFTP
  12565. /*
  12566.   Make C-Kermit work like other ftp clients, where
  12567.   the ASCII (TEXT) and BINARY commands are global settings.
  12568. */
  12569.     if (ftpisopen()) {
  12570.         doftpglobaltype((cx == XXASC) ? XYFT_T : XYFT_B);
  12571.         /* Fall thru--the command it should apply to both FTP and Kermit */
  12572.         /* return(success = 1); */
  12573.     }
  12574. #endif /* NEWFTP */
  12575.  
  12576.     xfermode = XMODE_M;        /* Set manual Kermit transfer mode */
  12577.     binary = (cx == XXASC) ? XYFT_T : XYFT_B;
  12578.     return(success = 1);
  12579.     }
  12580. #endif /* NOXFER */
  12581.  
  12582.     if (cx == XXCLS) {
  12583.     if ((x = cmcfm()) < 0) return(x);
  12584.     y = ck_cls();
  12585.     return(success = (y > -1) ? 1 : 0);
  12586.     }
  12587.  
  12588. #ifdef CK_MKDIR
  12589.     if (cx == XXMKDIR || cx == XXLMKD) {
  12590.     char *p;
  12591. #ifdef LOCUS
  12592.     if (!locus && cx != XXLMKD) {
  12593. #ifdef NOXFER
  12594.         return(-2);
  12595. #else
  12596.         return(dormt(XZMKD));
  12597. #endif /* NOXFER */
  12598.         }
  12599. #endif /* LOCUS */
  12600. #ifdef IKSD
  12601.     if (inserver && !ENABLED(en_mkd)) {
  12602.         printf("?Sorry, directory creation is disabled\n");
  12603.         return(-9);
  12604.     }
  12605. #endif /* IKSD */
  12606.     if ((x = cmfld("Name for new directory","",&s,xxstring)) < 0) {
  12607.         if (x != -3) {
  12608.         return(x);
  12609.         } else {
  12610.         printf("?Directory name required\n");
  12611.         return(-9);
  12612.         }
  12613.     }
  12614.     ckstrncpy(line,s,LINBUFSIZ);
  12615.     s = line;
  12616.     if ((x = cmcfm()) < 0) return(x);
  12617.     s = brstrip(s);
  12618.     bgchk();            /* Set msgflg */
  12619.     x = ckmkdir(0,s,&p,msgflg,0);
  12620. #ifdef COMMENT
  12621.     if (msgflg && x == 0)
  12622.       printf("?Directory already exists\n");
  12623. #endif /* COMMENT */
  12624.     return(success = (x < 0) ? 0 : 1);
  12625.     }
  12626.     if (cx == XXRMDIR || cx == XXLRMD) { /* RMDIR */
  12627.     char *p;
  12628. #ifdef LOCUS
  12629.     if (!locus && cx != XXLRMD) {
  12630. #ifdef NOXFER
  12631.         return(-2);
  12632. #else
  12633.         return(dormt(XZRMD));
  12634. #endif /* NOXFER */
  12635.         }
  12636. #endif /* LOCUS */
  12637. #ifdef IKSD
  12638.     if (inserver && !ENABLED(en_rmd)) {
  12639.         printf("?Sorry, directory removal is disabled\n");
  12640.         return(-9);
  12641.     }
  12642. #endif /* IKSD */
  12643.     if ((x = cmdir("Name of directory to be removed","",&s,xxstring)) < 0)
  12644.       return(x);
  12645.     ckstrncpy(line,s,LINBUFSIZ);
  12646.     s = line;
  12647.     if ((x = cmcfm()) < 0) return(x);
  12648.     s = brstrip(s);
  12649.     x = ckmkdir(1,s,&p,msgflg,0);
  12650.     return(success = (x < 0) ? 0 : 1);
  12651.     }
  12652. #endif /* CK_MKDIR */
  12653.  
  12654. #ifdef TNCODE
  12655.     if (cx == XXTELOP)
  12656.       return(dotelopt());
  12657. #endif /* TNCODE */
  12658.  
  12659. #ifndef NOPUSH
  12660.     if (cx == XXNPSH) {
  12661.     if ((z = cmcfm()) < 0) return(z);
  12662.         nopush = 1;
  12663. #ifndef NOSERVER
  12664.         en_hos = 0;
  12665. #endif /* NOSERVER */
  12666. #ifdef PIPESEND
  12667.     usepipes = 0;
  12668. #endif /* PIPESEND */
  12669.         return(success = 1);
  12670.     }
  12671. #endif /* NOPUSH */
  12672.  
  12673. #ifdef OS2
  12674.     if (cx == XXNSCR) {
  12675.     if ((z = cmcfm()) < 0) return(z);
  12676.         tt_scroll = 0;
  12677.         return(success = 1);
  12678.     }
  12679. #endif /* OS2 */
  12680.  
  12681. #ifndef NOSPL
  12682.     if (cx == XXLOCAL)            /* LOCAL variable declarations */
  12683.       return(success = dolocal());
  12684. #endif /* NOSPL */
  12685.  
  12686.     if (cx == XXKERMI) {        /* The KERMIT command */
  12687.     char * list[65];
  12688.     extern char **xargv;
  12689.     extern int xargc;
  12690.     int i;
  12691.     if ((y = cmtxt("kermit command-line arguments, -h for help",
  12692.                "",&s,xxstring)) < 0)
  12693.       return(y);
  12694.     ckstrncpy(line,"kermit ",LINBUFSIZ);
  12695.     ckstrncat(line,s,LINBUFSIZ-8);
  12696.     xwords(line,64,list,0);
  12697.     for (i = 1; i < 64; i++) {
  12698.         if (!list[i])
  12699.           break;
  12700.     }
  12701.     i--;
  12702.     xargc = i;
  12703.     xargv = list;
  12704.     xargv++;
  12705.     sstate = cmdlin();
  12706.     if (sstate) {
  12707.         extern int justone;
  12708.         debug(F000,"KERMIT sstate","",sstate);
  12709.         justone = 1;        /* Force return to command mode */
  12710.         proto();            /* after protocol */
  12711.         return(success);
  12712.     } else {
  12713.         debug(F101,"KERMIT sstate","",sstate);
  12714.         return(success = 1);    /* Not exactly right, but... */
  12715.     }
  12716.     }
  12717.     if (cx == XXDATE) {            /* DATE command */
  12718.     extern char cmdatebuf[], * cmdatemsg;
  12719.  
  12720. #ifndef COMMENT
  12721.     char * dp;
  12722.     if ((y = cmtxt("date and/or time, or carriage return for current",
  12723.                "",&s,xxstring)) < 0)
  12724.       return(y);
  12725.     s = brstrip(s);
  12726.     dp = cmcvtdate(s,1);
  12727.     if (!dp) {
  12728.         printf("?%s\n",cmdatemsg ? cmdatemsg : "Date conversion error");
  12729.         success = 0;
  12730.     } else {
  12731.         printf("%s\n",dp);
  12732.         success = 1;
  12733.     }
  12734. #else
  12735.     /* This works fine but messes up my "dates" torture-test script */
  12736.  
  12737.     if ((x = cmdate("Date and/or time, or carriage return for current",
  12738.             "",&s,0,xxstring)) < 0) {
  12739.         return(x);
  12740.     } else {
  12741.         printf("%s\n",cmdatebuf);
  12742.         success = 1;
  12743.     }
  12744. #endif /* COMMENT */
  12745.     return(success);
  12746.     }
  12747. #ifndef NOPUSH
  12748. #ifndef NOFRILLS
  12749.     if (cx == XXEDIT)
  12750.       return(doedit());
  12751. #endif /* NOFRILLS */
  12752. #endif /* NOPUSH */
  12753.  
  12754. #ifdef BROWSER                /* Defined only ifndef NOPUSH */
  12755.     if (cx == XXBROWS)
  12756.       return(dobrowse());
  12757. #endif /* BROWSER */
  12758.  
  12759. #ifdef CK_TAPI
  12760.     if (cx == XXTAPI) {            /* Microsoft TAPI */
  12761.     return (success = dotapi());
  12762.     }
  12763. #endif /* CK_TAPI */
  12764.  
  12765. #ifndef NOXFER
  12766.     if (cx == XXWHERE) {
  12767.     extern char * rfspec, * sfspec, * srfspec, * rrfspec;
  12768.     if ((x = cmcfm()) < 0) return(x);
  12769.     printf("\nFile most recently...\n\n");
  12770.     printf("  Sent:       %s\n",   sfspec ? sfspec : "(none)");
  12771.     if (sfspec && srfspec) {
  12772.         printf("  Stored as:  %s\n",   srfspec);
  12773.         printf("\n");
  12774.     }
  12775.     printf("  Received:   %s\n",   rrfspec ? rrfspec : "(none)");
  12776.     if (rfspec && rrfspec)
  12777.     printf("  Stored as:  %s\n",   rfspec);
  12778.     printf(
  12779. "\nIf the full path is not shown, then the file is probably in your current\n"
  12780.            );
  12781.     printf(
  12782. "directory or your download directory (if any - SHOW FILE to find out).\n\n"
  12783.            );
  12784.     return(success = 1);
  12785.     }
  12786. #endif /* NOXFER */
  12787.  
  12788. #ifdef CK_RECALL
  12789.     if (cx == XXREDO)
  12790.       return(doredo());
  12791. #endif /* CK_RECALL */
  12792.  
  12793. #ifdef CKROOT
  12794.     if (cx == XXCHRT)            /* Change Kermit's root directory */
  12795.       return(dochroot());
  12796. #endif /* CKROOT */
  12797.  
  12798. #ifdef CK_KERBEROS
  12799.     if (cx == XXAUTH) {            /* KERBEROS */
  12800.     x = cp_auth();            /* Parse it */
  12801. #ifdef IKSD
  12802.         if (inserver) {
  12803.             printf("?Command disabled in IKSD.\r\n");
  12804.             return(success = 0);
  12805.         }
  12806. #endif /* IKSD */
  12807.     if (x < 0)            /* Pass parse errors back */
  12808.       return(x);
  12809.     return(success = doauth(cx));
  12810.     }
  12811. #endif /* CK_KERBEROS */
  12812.  
  12813. #ifndef NOLOCAL
  12814.     if (cx == XXTERM) {
  12815.     return(settrmtyp());
  12816.     }
  12817. #endif /* NOLOCAL */
  12818.  
  12819.     if (cx == XXSTATUS) {
  12820.     if ((x = cmcfm()) < 0) return(x);
  12821.     printf( " %s\n", success ? "SUCCESS" : "FAILURE" );
  12822.     return(0);            /* Don't change it */
  12823.     }
  12824.  
  12825.     if (cx == XXFAIL) {
  12826.     if ((x = cmcfm()) < 0) return(x);
  12827.     return(success = 0);
  12828.     }
  12829.  
  12830.     if (cx == XXSUCC) {
  12831.     if ((x = cmcfm()) < 0) return(x);
  12832.     return(success = 1);
  12833.     }
  12834.  
  12835.     if (cx == XXNLCL) {
  12836.     extern int nolocal;
  12837.     if ((x = cmcfm()) < 0) return(x);
  12838.     nolocal = 1;
  12839.     return(success = 1);
  12840.     }
  12841.  
  12842. #ifndef NOXFER
  12843.     if (cx == XXRASG)            /* Shortcuts for REMOTE commands */
  12844.       return(dormt(XZASG));
  12845.     if (cx == XXRCWD)
  12846.       return(dormt(XZCWD));
  12847.     if (cx == XXRCPY)
  12848.       return(dormt(XZCPY));
  12849.     if (cx == XXRDEL)
  12850.       return(dormt(XZDEL));
  12851.     if (cx == XXRDIR)
  12852.       return(dormt(XZDIR));
  12853.     if (cx == XXRXIT)
  12854.       return(dormt(XZXIT));
  12855.     if (cx == XXRHLP)
  12856.       return(dormt(XZHLP));
  12857.     if (cx == XXRHOS)
  12858.       return(dormt(XZHOS));
  12859.     if (cx == XXRKER)
  12860.       return(dormt(XZKER));
  12861.     if (cx == XXRPWD)
  12862.       return(dormt(XZPWD));
  12863.     if (cx == XXRQUE)
  12864.       return(dormt(XZQUE));
  12865.     if (cx == XXRREN)
  12866.       return(dormt(XZREN));
  12867.     if (cx == XXRMKD)
  12868.       return(dormt(XZMKD));
  12869.     if (cx == XXRMSG)
  12870.       return(dormt(XZMSG));
  12871.     if (cx == XXRRMD)
  12872.       return(dormt(XZRMD));
  12873.     if (cx == XXRSET)
  12874.       return(dormt(XZSET));
  12875.     if (cx == XXRSPA)
  12876.       return(dormt(XZSPA));
  12877.     if (cx == XXRTYP)
  12878.       return(dormt(XZTYP));
  12879.     if (cx == XXRWHO)
  12880.       return(dormt(XZWHO));
  12881.     if (cx == XXRCDUP)
  12882.       return(dormt(XZCDU));
  12883.     if (cx == XXRPRI)
  12884.       return(dormt(XZPRI));
  12885. #endif /* NOXFER */
  12886.  
  12887.     if (cx == XXRESET) {        /* RESET */
  12888.     if ((x = cmcfm()) < 0)
  12889.       return(x);
  12890.     concb((char)escape);        /* Make command echoing to normal */
  12891.     doclean(0);            /* Close all files */
  12892.     return(success = 1);
  12893.     }
  12894.  
  12895. #ifndef NOXFER
  12896. #ifndef NOCSETS
  12897.     if (cx == XXASSOC)            /* ASSOCIATE */
  12898.       return(doassoc());
  12899. #endif /* NOCSETS */
  12900. #endif /* NOXFER */
  12901.  
  12902. #ifndef NOSPL
  12903.     if (cx == XXSHIFT) {        /* SHIFT */
  12904.     if ((y = cmnum("Number of arguments to shift","1",10,&x,xxstring)) < 0)
  12905.       return(y);
  12906.     if ((z = cmcfm()) < 0)
  12907.       return(z);
  12908.     return(success = doshift(x));
  12909.     }
  12910. #endif /* NOSPL */
  12911.  
  12912. #ifndef NOHELP
  12913.     if (cx == XXMAN)
  12914.       return(domanual());
  12915. #endif /* NOHELP */
  12916.  
  12917. #ifndef NOSPL
  12918.     if (cx == XXSORT)            /* SORT an array */
  12919.       return(dosort());
  12920. #endif /* NOSPL */
  12921.  
  12922.     if (cx == XXPURGE) {
  12923. #ifdef IKSD
  12924.     if (inserver && (!ENABLED(en_del)
  12925. #ifdef CK_LOGIN
  12926.                           || isguest
  12927. #endif /* CK_LOGIN */
  12928.              )) {
  12929.         printf("?Sorry, DELETE is disabled\n");
  12930.         return(-9);
  12931.     }
  12932. #endif /* IKSD */
  12933. #ifdef CK_APC
  12934.     if ((apcactive == APC_LOCAL) ||
  12935.         ((apcactive == APC_REMOTE) && (!(apcstatus & APC_UNCH))))
  12936.       return(success = 0);
  12937. #endif /* CK_APC */
  12938. #ifdef CKPURGE
  12939.         return(dopurge());
  12940. #else
  12941. #ifdef VMS
  12942.     if ((x = cmtxt("optional switches followed by filespec",
  12943.                "",&s,xxstring)) < 0)
  12944.       return(x);
  12945.     if (nopush) {
  12946.         printf("?Sorry, DCL access is disabled\n");
  12947.         return(-9);
  12948.     }
  12949.     ckstrncpy(line,s,LINBUFSIZ);
  12950.     s = line;
  12951.     x = mlook(mactab,"purge",nmac);
  12952.     return(success = dodo(x,s,cmdstk[cmdlvl].ccflgs));
  12953. #else
  12954.     return(-2);
  12955. #endif /* VMS */
  12956. #endif /* CKPURGE */
  12957.     }
  12958.  
  12959. #ifndef NOSPL
  12960.     if (cx == XXFAST) {
  12961.     if ((x = cmcfm()) < 0) return(x);
  12962.     x = mlook(mactab,"fast",nmac);
  12963.     return(success = dodo(x,NULL,cmdstk[cmdlvl].ccflgs));
  12964.     }
  12965.     if (cx == XXCAU) {
  12966.     if ((x = cmcfm()) < 0) return(x);
  12967.     x = mlook(mactab,"cautious",nmac);
  12968.     return(success = dodo(x,NULL,cmdstk[cmdlvl].ccflgs));
  12969.     }
  12970.     if (cx == XXROB) {
  12971.     if ((x = cmcfm()) < 0) return(x);
  12972.     x = mlook(mactab,"robust",nmac);
  12973.     return(success = dodo(x,NULL,cmdstk[cmdlvl].ccflgs));
  12974.     }
  12975. #endif /* NOSPL */
  12976.  
  12977.     if (cx == XXSCRN) {            /* SCREEN */
  12978.     int row, col;
  12979.     if ((x = cmkey(scntab, nscntab,"screen action","", xxstring)) < 0)
  12980.       return(x);
  12981.     switch (x) {            /* MOVE-TO (cursor position) */
  12982.       case SCN_MOV:
  12983.         if ((y = cmnum("Row (1-based)","",10,&z,xxstring)) < 0)
  12984.           return(y);
  12985.         row = z;
  12986.         y = cmnum("Column (1-based)","1",10,&z,xxstring);
  12987.         if (y < 0)
  12988.           return(y);
  12989.         col = z;
  12990.         if ((y = cmcfm()) < 0)
  12991.           return(y);
  12992.         if (row < 0 || col < 0) {
  12993.         printf("?Row and Column must be 1 or greater\n");
  12994.         return(-9);
  12995.         }
  12996.         if (cmd_rows > 0 && row > cmd_rows)
  12997.           row = cmd_rows;
  12998.         if (cmd_cols > 0 && col > cmd_cols)
  12999.           col = cmd_cols;
  13000.         y = ck_curpos(row,col);
  13001.         return(success = (y > -1) ? 1 : 0);
  13002.  
  13003.       case SCN_CLR:            /* CLEAR */
  13004.         if ((y = cmcfm()) < 0)
  13005.           return(y);
  13006.         debug(F100,"screen calling ck_cls()","",0);
  13007.         y = ck_cls();
  13008.         return(success = (y > -1) ? 1 : 0);
  13009.  
  13010.       case SCN_CLE:            /* CLEOL */
  13011.         if ((y = cmcfm()) < 0)
  13012.           return(y);
  13013.         y = ck_cleol();
  13014.         return(success = (y > -1) ? 1 : 0);
  13015.     }
  13016.     }
  13017.  
  13018. #ifndef NOHTTP
  13019. #ifdef TCPSOCKET
  13020.     if (cx == XXHTTP)
  13021.       return(dohttp());
  13022. #endif /* TCPSOCKET */
  13023. #endif /* NOHTTP */
  13024.  
  13025. #ifndef NOSPL
  13026.     if (cx == XXARRAY) {        /* ARRAY */
  13027. #ifndef NOSHOW
  13028.     extern int showarray();
  13029. #endif /* NOSHOW */
  13030.     if ((x = cmkey(arraytab, narraytab,"Array operation","",xxstring)) < 0)
  13031.       return(x);
  13032.     switch (x) {
  13033.       case ARR_DCL:
  13034.         return(dodcl(XXDCL));
  13035.       case ARR_SRT:
  13036.         return(dosort());
  13037. #ifndef NOSHOW
  13038.       case ARR_SHO:
  13039.         return(showarray());
  13040. #endif /* NOSHOW */
  13041.       case ARR_CPY:
  13042.         return(copyarray());
  13043.       case ARR_SET:
  13044.       case ARR_CLR:
  13045.         return(clrarray(x));
  13046.       case ARR_DST:
  13047.         return(unarray());
  13048.       case ARR_RSZ:
  13049.         return(rszarray());
  13050.       case ARR_EQU:
  13051.         return(linkarray());
  13052.  
  13053.       default:
  13054.         printf("?Sorry, not implemented yet - \"%s\"\n",cmdbuf);
  13055.         return(-9);
  13056.     }
  13057.     }
  13058.     if (cx == XXTRACE)            /* TRACE */
  13059.       return(dotrace());
  13060. #endif /* NOSPL */
  13061.  
  13062. #ifdef CK_PERMS
  13063. #ifdef UNIX
  13064.     if (cx == XXCHMOD)
  13065.       return(douchmod());        /* Do Unix chmod */
  13066. #endif /* UNIX */
  13067. #endif /* CK_PERMS */
  13068.  
  13069.     if (cx == XXPROMP)
  13070.       return(doprompt());
  13071.  
  13072.     if (cx == XXGREP)
  13073.       return(dogrep());
  13074.  
  13075.     if (cx == XXDEBUG) {        /* DEBUG */
  13076. #ifndef DEBUG
  13077.     int dummy = 0;
  13078.     return(seton(&dummy));
  13079. #else
  13080.     return(seton(&deblog));
  13081. #endif /* DEBUG */
  13082.     }
  13083.     if (cx == XXMSG || cx == XXXMSG) {    /* MESSAGE */
  13084.     extern int debmsg;        /* Script debugging messages */
  13085.     if ((x = cmtxt("Message to print if SET DEBUG MESSAGE is ON or STDERR",
  13086.          "",&s,xxstring)) < 0)
  13087.       return(x);
  13088.     if (!s)                /* Watch out for null result */
  13089.       s = "";            /* Make it an empty string */
  13090.     else                 /* Not null */
  13091.       s = brstrip(s);        /* Strip braces and doublequotes */
  13092.     switch (debmsg) {        /* Not debugging - don't print */
  13093.       case 0:
  13094.         break;
  13095.       case 1:
  13096.         printf("%s",s);        /* Print to stdout */
  13097.         if (cx == XXMSG) printf("\n");
  13098.         break;
  13099.       case 2:
  13100.         fprintf(stderr,"%s",s);    /* Ditto but print to stderr */
  13101.         if (cx == XXMSG) fprintf(stderr,"\n");
  13102.         break;
  13103.     }
  13104.     return(0);            /* Return without affecting SUCCESS */
  13105.     }
  13106.  
  13107. #ifdef CKLEARN
  13108.     if (cx == XXLEARN) {        /* LEARN */
  13109.     struct FDB of, sw, cm;
  13110.     int closing = 0, off = 0, on = 0, confirmed = 0;
  13111.     char c;
  13112.  
  13113.     cmfdbi(&sw,            /* 2nd FDB - optional /PAGE switch */
  13114.            _CMKEY,            /* fcode */
  13115.            "Script file name, or switch", /* hlpmsg */
  13116.            "",            /* default */
  13117.            "",            /* addtl string data */
  13118.            3,            /* addtl numeric data 1: tbl size */
  13119.            4,            /* addtl numeric data 2: 4 = cmswi */
  13120.            xxstring,        /* Processing function */
  13121.            learnswi,        /* Keyword table */
  13122.            &of            /* Pointer to next FDB */
  13123.            );
  13124.     cmfdbi(&of,_CMOFI,"","","",0,0,xxstring,NULL,&cm);
  13125.     cmfdbi(&cm,_CMCFM,"","","",0,0,NULL,NULL,NULL);
  13126.     line[0] = NUL;
  13127.  
  13128.     while (!confirmed) {
  13129.         x = cmfdb(&sw);        /* Parse something */
  13130.         if (x < 0)
  13131.           return(x);
  13132.         switch (cmresult.fcode) {    /* What was it? */
  13133.           case _CMOFI:        /* Output file name */
  13134.         ckstrncpy(line,cmresult.sresult,LINBUFSIZ);
  13135.         break;
  13136.           case _CMKEY:        /* Switch */
  13137.         c = cmgbrk();
  13138.         if ((c == ':' || c == '=') && !(cmgkwflgs() & CM_ARG)) {
  13139.             printf("?This switch does not take an argument\n");
  13140.             return(-9);
  13141.         }
  13142.         switch (cmresult.nresult) {
  13143.           case 2:        /* /CLOSE */
  13144.             closing = 1;    /* Fall thru on purpose */
  13145.           case 0:        /* /OFF */
  13146.             off = 1;
  13147.             on = 0;
  13148.             break;
  13149.           case 1:        /* /ON */
  13150.             on = 1;
  13151.             off = 0;
  13152.             break;
  13153.         }
  13154.         break;
  13155.           case _CMCFM:        /* Confirmation */
  13156.         confirmed++;
  13157.         break;
  13158.         }
  13159.     }
  13160.     if (closing) {
  13161.         if (learnfp) {
  13162.         fclose(learnfp);
  13163.         learnfp = NULL;
  13164.         }
  13165.         makestr(&learnfile,NULL);
  13166.     }
  13167.     if (line[0]) {
  13168.         if (!on && !off)
  13169.           on = 1;
  13170.         if (learnfp) {
  13171.         fclose(learnfp);
  13172.         learnfp = NULL;
  13173.         }
  13174.         makestr(&learnfile,line);
  13175.         if (learnfile) {
  13176.         char * modes = "w";
  13177.         learnfp = fopen(learnfile,modes);
  13178.         if (!learnfp) {
  13179.             debug(F110,"LEARN file open error",learnfile,0);
  13180.             perror(learnfile);
  13181.             return(-9);
  13182.         } else {
  13183. #ifdef ZFNQFP
  13184.             if (zfnqfp(learnfile,TMPBUFSIZ,tmpbuf))
  13185.               makestr(&learnfile,tmpbuf);
  13186. #endif /* ZFNQFP */
  13187.             debug(F110,"LEARN file open ok",learnfile,0);
  13188.             if (!quiet) {
  13189.             printf("Recording to %s...\n\n",learnfile);
  13190.             printf(
  13191. " WARNING: If you type your password during script recording, it will appear\n\
  13192.  in the file.  Be sure to edit it or take other appropriate precautions.\n\n"
  13193.                    );
  13194.             }
  13195.             fputs(  "; Scriptfile: ",learnfp);
  13196.             fputs(learnfile,learnfp);
  13197.             fputs("\n; Directory:  ",learnfp);
  13198.             fputs(zgtdir(),learnfp);
  13199.             fputs("\n; Recorded:   ",learnfp);
  13200.             fputs(ckdate(),learnfp);
  13201.             fputs("\n",learnfp);
  13202.         }
  13203.         }
  13204.     }
  13205.     if (on) {
  13206.         learning = 1;
  13207.     } else if (off) {
  13208.         learning = 0;
  13209.     }
  13210.     debug(F101,"LEARN learning","",learning);
  13211.     return(success = 1);
  13212.     }
  13213. #endif /* CKLEARN */
  13214.  
  13215. #ifdef NEWFTP
  13216.     if (cx == XXUSER || cx == XXACCT) {
  13217.     if (!ftpisopen()) {
  13218.         printf("?FTP connection is not open\n");
  13219.         return(-9);
  13220.     }
  13221.     return(success = (cx == XXUSER) ? doftpusr() : doftpacct());
  13222.     }
  13223.     if (cx == XXSITE || cx == XXPASV) {
  13224.     if (!ftpisopen()) {
  13225.         printf("?FTP connection is not open\n");
  13226.         return(-9);
  13227.     }
  13228.     return(success = (cx == XXSITE) ? doftpsite() : dosetftppsv());
  13229.     }
  13230. #endif /* NEWFTP */
  13231.  
  13232.     if (cx == XXORIE) {            /* ORIENTATION */
  13233.     extern char * myname;
  13234.     int i, y, n = 0;
  13235.         char * s, *p, vbuf[32];
  13236.     char * vars[16];       char * legend[16];
  13237.  
  13238.     if ((y = cmcfm()) < 0)
  13239.       return(y);
  13240.  
  13241.     printf("\nProgram name:\n  %s\n\n",myname);
  13242.     n += 4;
  13243.  
  13244. #ifdef NT
  13245.     vars[0] = "home";      legend[0] = "Your home directory";
  13246.     vars[1] = "directory"; legend[1] = "K95's current directory";
  13247.     vars[2] = "exedir";    legend[2] = "K95 Program directory";
  13248.     vars[3] = "inidir";    legend[3] = "K95 Initialization file directory";
  13249.     vars[4] = "startup";   legend[4] = "Current directory when started";
  13250.     
  13251.         vars[5] = "common";
  13252.         legend[5] = "K95 data for all users and K95SITE.INI file";
  13253.     
  13254.         vars[6] = "personal";  legend[6] = "Your personal data directory tree";
  13255.         vars[7] = "desktop";   legend[7] = "Your deskop directory tree";
  13256.     
  13257.         vars[8] = "appdata";
  13258.         legend[8] = "Your personal K95 data tree and K95CUSTOM.INI file";
  13259.     
  13260.         vars[9] = "download";  legend[9] = "Your K95 download directory";
  13261.         vars[10] = "tmpdir";   legend[10] = "Your TEMP directory";
  13262.     vars[11] = NULL;       legend[11] = NULL;
  13263.  
  13264.     for (i = 0; i < 16 && vars[i]; i++) {
  13265.         printf("%s:\n",legend[i]);
  13266.         if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  13267.         ckmakmsg(vbuf,32,"\\v(",vars[i],")",NULL);
  13268.         printf("  Variable:   %s\n",vbuf);
  13269.         if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  13270.         y = TMPBUFSIZ;
  13271.         s = tmpbuf;
  13272.         zzstring(vbuf,&s,&y);
  13273.         line[0] = NUL;
  13274.         ckGetLongPathName(tmpbuf,line,LINBUFSIZ);
  13275.         printf("  Long name:  %s\n",line);
  13276.         if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  13277.         line[0] = NUL;
  13278.         GetShortPathName(tmpbuf,line,LINBUFSIZ);
  13279.         printf("  Short name: %s\n",line);
  13280.         if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  13281.             printf("\n");
  13282.         if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  13283.     }
  13284. #else  /* NT */
  13285.  
  13286.     vars[0] = "home";      legend[0] = "Your home directory";
  13287.     vars[1] = "directory"; legend[1] = "Kermit's current directory";
  13288.     vars[2] = "exedir";    legend[2] = "Kermit's program directory";
  13289.     vars[3] = "inidir";    legend[3] = "Initialization file directory";
  13290.     vars[4] = "startup";   legend[4] = "Current directory when started";
  13291.     vars[5] = "download";  legend[5] = "Kermit download directory";
  13292.     vars[6] = NULL;           legend[6] = NULL;
  13293.  
  13294.     for (i = 0; i < 16 && vars[i]; i++) {
  13295.         printf("%s:\n",legend[i]);
  13296.         if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  13297.         ckmakmsg(vbuf,32,"\\v(",vars[i],")",NULL);
  13298.         printf("  Variable: %s\n",vbuf);
  13299.         if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  13300.         y = TMPBUFSIZ;
  13301.         s = tmpbuf;
  13302.         zzstring(vbuf,&s,&y);
  13303.             printf("  Value:    %s\n",tmpbuf);
  13304.         if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  13305.             printf("\n");
  13306.         if (++n > cmd_rows - 3) if (!askmore()) return(0); else n = 0;
  13307.     }
  13308. #endif /* NT */
  13309.     return(success = 1);
  13310.     }
  13311.  
  13312. #ifdef NT
  13313.     if (cx == XXDIALER) {
  13314.         StartDialer();
  13315.         return(success = 1);
  13316.     }
  13317. #endif /* NT */
  13318.  
  13319.     if (cx == XXCONT) {            /* CONTINUE */
  13320.     if ((x = cmcfm()) < 0)
  13321.       return(x);
  13322.     if (!xcmdsrc) {            /* At prompt: continue script */
  13323.         if (cmdlvl > 0)
  13324.           popclvl();        /* Pop command level */
  13325.         return(success = 1);    /* always succeeds */
  13326. #ifndef NOSPL
  13327.     } else {            /* In script: whatever... */
  13328.         x = mlook(mactab,"continue",nmac);
  13329.         /* Don't set success */
  13330.         return(dodo(x,NULL,cmdstk[cmdlvl].ccflgs));
  13331. #endif /* NOSPL */
  13332.     }
  13333.     }
  13334. #ifdef UNIX
  13335. #ifndef NOPUTENV
  13336. /*
  13337.   NOTE: Syntax is PUTENV name value, not PUTENV name=value.
  13338.   I could check for this but it would be too much magic.
  13339. */
  13340.     if (cx == XXPUTE) {            /* PUTENV */
  13341.         char * t = tmpbuf;        /* Create or alter environment var */
  13342.     char * s1 = NULL, * s2 = NULL;
  13343.     if ((x = cmfld("Variable name","",&s,xxstring)) < 0)
  13344.           return(x);
  13345.     if (s) if (s == "") s = NULL;
  13346.     (VOID) makestr(&s1,s);
  13347.     if (s && !s1) {
  13348.         printf("?PUTENV - memory allocation failure\n");
  13349.         return(-9);
  13350.     }
  13351.     if ((x = cmtxt("Value","",&s,xxstring)) < 0)
  13352.       return(x);
  13353.     if (s) if (s == "") s = NULL;
  13354.     (VOID) makestr(&s2,s);
  13355.     success = doputenv(s1,s2);
  13356.     (VOID) makestr(&s1,NULL);
  13357.     (VOID) makestr(&s2,NULL);
  13358.     return(success);
  13359.     }
  13360. #endif    /* NOPUTENV */
  13361. #endif    /* UNIX */
  13362.  
  13363.     if (cx == XXNOTAV) {        /* Command in table not available */
  13364.     ckstrncpy(tmpbuf,atmbuf,TMPBUFSIZ);
  13365.     if ((x = cmtxt("Rest of command","",&s,NULL)) < 0)
  13366.       return(x);
  13367.     printf("Sorry, \"%s\" not configured in this version of Kermit.\n",
  13368.            tmpbuf
  13369.            );
  13370.     return(success = 0);
  13371.     }
  13372.     return(-2);                /* None of the above */
  13373.  
  13374. } /* end of docmd() */
  13375.  
  13376. #endif /* NOICP */
  13377.