# 2.11BSD#431 - /usr/src/new/kermit5.188/ckuus3.c

##### Functions

    dochk             X
    doprm             X
    set_key           X

##### Variables

    autotab           X
    byttab            X
    chktab            X
    crrtab            X
    dbgtab            X
    dpxtab            X
    filtab            X
    flotab            X
    ftrtab            X
    fttab             X
    hshtab            X
    lstab             X
    nbytt             X
    ncrr              X
    ndbg              X
    nfilp             X
    nflo              X
    nftr              X
    nfttyp            X
    nhsh              X
    nls               X
    npadx3            X
    npar              X
    nrlt              X
    nspd              X
    ntn               X
    nts               X
    nx25              X
    onoff             X
    padx3tab          X
    partab            X
    rltab             X
    spdtab            X
    srvtab            X
    tntab             X
    tstab             X
    vms_msgs          X
    wideresult        X
    wildtab           X
    x25tab            X

       1: #ifndef NOICP
       2:
       3: /*  C K U U S 3 --  "User Interface" for Unix Kermit, part 3  */
       4:
       5: /*
       6:   Author: Frank da Cruz (fdc@columbia.edu, FDCCU@CUVMA.BITNET),
       7:   Columbia University Center for Computing Activities.
       8:   First released January 1985.
       9:   Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
      10:   York.  Permission is granted to any individual or institution to use this
      11:   software as long as it is not sold for profit.  This copyright notice must be
      12:   retained.  This software may not be included in commercial products without
      13:   written permission of Columbia University.
      14: */
      15:
      16: /*  SET command (but much material has been split off into ckuus7.c). */
      17:
      18: /*
      19:   Kermit-specific includes.
      20:   Definitions here supersede those from system include files.
      21: */
      22: #include "ckcdeb.h"         /* Debugging & compiler things */
      23: #include "ckcasc.h"         /* ASCII character symbols */
      24: #include "ckcker.h"         /* Kermit application definitions */
      25: #include "ckcxla.h"         /* Character set translation */
      26: #include "ckcnet.h"         /* Network symbols */
      27: #include "ckuusr.h"         /* User interface symbols */
      28:
      29: /* Variables */
      30:
      31: extern int size, spsiz, spmax, urpsiz, srvtim,
      32:   local, server, success,
      33:   flow, binary, delay, parity, escape, what, srvdis,
      34:   turn, duplex, backgrd,
      35:   turnch, bctr, mdmtyp, keep, maxtry, unkcs, network,
      36:   ebqflg, quiet, swcapr, nettype,
      37:   wslotr, lscapr, lscapu,
      38:   carrier, debses,
      39:   cdtimo, nlangs, bgset, pflag, msgflg, dblchar,
      40:   cmdmsk, spsizr, wildxpand, suspend,
      41:   techo, terror;
      42:
      43: extern char *ccntab[];
      44:
      45: #ifndef NOSCRIPT
      46: extern int secho;           /* Whether SCRIPT cmd should echo */
      47: #endif /* NOSCRIPT */
      48:
      49: #ifndef NOSPL
      50: #ifdef DCMDBUF
      51: extern int *count;
      52: #else
      53: extern int count[];
      54: #endif /* DCMDBUF */
      55: extern int mecho, merror;       /* Macro echo, error */
      56: extern int incase;          /* INPUT case */
      57: #endif /* NOSPL */
      58:
      59: extern int bigsbsiz, bigrbsiz;      /* Packet buffers */
      60:
      61: extern long speed;          /* Terminal speed */
      62:
      63: extern CHAR sstate;         /* Protocol start state */
      64: extern char ttname[];           /* Communication device name */
      65: #ifndef MAC
      66: #ifndef NOSETKEY
      67: extern KEY *keymap;         /* Character map for SET KEY (1:1)  */
      68: extern MACRO *macrotab;         /* Macro map for SET KEY (1:string) */
      69: #ifdef OS2
      70: int wideresult;                         /* for SET KEY, wide OS/2 scan codes */
      71: #endif /* OS2 */
      72: #endif /* NOSETKEY */
      73: #endif /* MAC */
      74:
      75: #ifndef NOCSETS
      76: /* system-independent character sets, defined in ckcxla.[ch] */
      77: extern struct csinfo tcsinfo[];
      78: extern struct langinfo langs[];
      79:
      80: /* Other character-set related variables */
      81: extern int tcharset, tslevel, language;
      82: #endif /* NOCSETS */
      83:
      84: /* Declarations from cmd package */
      85:
      86: #ifdef DCMDBUF
      87: extern char *cmdbuf;            /* Command buffer */
      88: extern char *line;
      89: #else
      90: extern char cmdbuf[];           /* Command buffer */
      91: extern char line[];         /* Character buffer for anything */
      92: #endif /* DCMDBUF */
      93:
      94: /* From main ckuser module... */
      95:
      96: extern char tmpbuf[], *tp, *lp;     /* Temporary buffer */
      97:
      98: extern int tlevel;          /* Take Command file level */
      99:
     100: #ifndef NOSPL
     101: extern int cmdlvl;          /* Overall command level */
     102: #endif /* NOSPL */
     103:
     104: #ifdef UNIX
     105: extern int sessft;          /* Session-log file type */
     106: #endif /* UNIX */
     107:
     108:
     109: #ifdef VMS
     110: int vms_msgs = 1;           /* SET MESSAGES */
     111: #endif /* VMS */
     112:
     113: /* Keyword tables for SET commands */
     114:
     115: struct keytab chktab[] = {
     116:     "1", 1, 0,
     117:     "2", 2, 0,
     118:     "3", 3, 0,
     119:     "blank-free-2", 4, 0
     120: };
     121:
     122: /* For SET MODEM */
     123:
     124: struct keytab autotab[] = {
     125:     "changes-speed", 1, 0,
     126:     "matches-speed", 0, 0
     127: };
     128:
     129: /* For SET CARRIER */
     130:
     131: struct keytab crrtab[] = {
     132:     "auto", CAR_AUT, 0,
     133:     "off",  CAR_OFF, 0,
     134:     "on",   CAR_ON, 0
     135: };
     136: int ncrr = 3;
     137:
     138: /* For SET DEBUG */
     139:
     140: struct keytab dbgtab[] = {
     141:     "off",     0,  0,
     142:     "on",      1,  0,
     143:     "session", 2,  0
     144: };
     145: int ndbg = 3;
     146:
     147: /* Transmission speeds */
     148:
     149: /* Note, the values are encoded in cps rather than bps because 19200 and */
     150: /* 38400 are too big for some ints.  All but 75bps are multiples of ten. */
     151: /* Result of lookup in this table must be multiplied by 10 to get actual */
     152: /* speed in bps.  If this number is 70, it must be changed to 75. */
     153: /* If it is 888, this means 75/1200 split speed.  134.5 (IBM 2741) is not */
     154: /* supported, and split speed is not possible in AT&T UNIX. */
     155:
     156: /* The values are generic, rather than specific to UNIX.  We can't use */
     157: /* B75, B1200, B9600, etc, because non-UNIX versions of C-Kermit will not */
     158: /* necessarily have these symbols defined. */
     159:
     160: /* Like all other keytabs, this one must be in "alphabetical" order, */
     161: /* rather than numeric order. */
     162:
     163: struct keytab spdtab[] = {
     164:     "0",      0,  CM_INV,
     165:     "110",   11,  0,
     166: #ifdef OS2
     167: #ifdef __32BIT__
     168:  "115200",11520,  0,
     169: #endif /* __32BIT__ */
     170: #endif /* OS2 */
     171:   "1200",   120,  0,
     172: #ifdef OS2
     173:   "14400", 1440,  0,
     174: #endif /* OS2 */
     175:   "150",     15,  0,
     176:   "19200", 1920,  0,
     177:   "200",     20,  0,
     178:   "2400",   240,  0,
     179:   "300",     30,  0,
     180:   "3600",   360,  0,
     181:   "38400", 3840,  0,
     182:   "4800",   480,  0,
     183:   "50",       5,  0,
     184: #ifdef OS2
     185:   "57600", 5760,  0,
     186: #endif /* OS2 */
     187:   "600",     60,  0,
     188: #ifdef OS2
     189:   "7200",   720,  0,
     190: #endif /* OS2 */
     191:   "75",       7,  0,
     192: #ifdef ANYBSD
     193:   "75/1200",888,  0,        /* Special code "888" for split speed */
     194: #endif /* ANYBSD */
     195: #ifdef OS2
     196: #ifdef __32BIT__
     197:   "76800", 7680,  0,
     198: #endif /* __32BIT__ */
     199: #endif /* OS2 */
     200:   "9600",   960,  0
     201: };
     202: int nspd = (sizeof(spdtab) / sizeof(struct keytab)); /* how many speeds */
     203:
     204: #ifndef NOCSETS
     205: extern struct keytab lngtab[];      /* Languages for SET LANGUAGE */
     206: extern int nlng;
     207: #endif /* NOCSETS */
     208:
     209: /* Duplex keyword table */
     210:
     211: struct keytab dpxtab[] = {
     212:     "full",      0, 0,
     213:     "half",      1, 0
     214: };
     215:
     216: /* SET FILE parameters */
     217:
     218: struct keytab filtab[] = {
     219:     "bytesize",         XYFILS, 0,
     220: #ifndef NOCSETS
     221:     "character-set",    XYFILC, 0,
     222: #endif /* NOCSETS */
     223:     "collision",        XYFILX, 0,
     224:     "display",          XYFILD, 0,
     225:     "incomplete",       XYFILI, 0,
     226: #ifdef VMS
     227:     "label",            XYFILL, 0,
     228: #endif /* VMS */
     229:     "names",            XYFILN, 0,
     230: #ifdef VMS
     231:     "record-length",    XYFILR, 0,
     232: #endif /* VMS */
     233:     "type",             XYFILT, 0,
     234:     "warning",          XYFILW, CM_INV
     235: };
     236: int nfilp = (sizeof(filtab) / sizeof(struct keytab));
     237:
     238: /* Flow Control */
     239:
     240: struct keytab flotab[] = {      /* SET FLOW-CONTROL keyword table */
     241: #ifdef CK_DTRCD
     242:     "dtr/cd",   FLO_DTRC, 0,
     243: #endif /* CK_DTRCD */
     244: #ifdef CK_DTRCTS
     245:     "dtr/cts",FLO_DTRT, 0,
     246: #endif /* CK_DTRCTS */
     247:     "keep",     FLO_KEEP, 0,
     248:     "none",     FLO_NONE, 0,
     249: #ifdef CK_RTSCTS
     250:     "rts/cts",  FLO_RTSC, 0,
     251: #endif /* CK_RTSCTS */
     252:     "xon/xoff", FLO_XONX, 0
     253: };
     254: int nflo = (sizeof(flotab) / sizeof(struct keytab));
     255:
     256: /*  Handshake characters  */
     257:
     258: struct keytab hshtab[] = {
     259:     "bell", 007, 0,
     260:     "code", 998, 0,
     261:     "cr",   015, 0,
     262:     "esc",  033, 0,
     263:     "lf",   012, 0,
     264:     "none", 999, 0,         /* (can't use negative numbers) */
     265:     "xoff", 023, 0,
     266:     "xon",  021, 0
     267: };
     268: int nhsh = (sizeof(hshtab) / sizeof(struct keytab));
     269:
     270: struct keytab fttab[] = {       /* File types */
     271: #ifdef VMS
     272:     "b",         XYFT_B, CM_INV|CM_ABR,
     273: #endif /* VMS */
     274:     "binary",    XYFT_B, 0,
     275: #ifdef VMS
     276:     "block",     XYFT_I, CM_INV,
     277:     "image",     XYFT_I, 0,
     278:     "labeled",   XYFT_L, 0,
     279: #endif /* VMS */
     280:     "text",      XYFT_T, 0
     281: };
     282: int nfttyp = (sizeof(fttab) / sizeof(struct keytab));
     283:
     284: #ifndef NODIAL
     285: extern struct keytab mdmtab[] ;     /* Modem types (in module ckudia.c) */
     286: extern int nmdm;            /* Number of them */
     287: #ifndef MINIDIAL
     288: extern int tbmodel;         /* Telebit model ID */
     289: #endif /* MINIDIAL */
     290: #endif /* NODIAL */
     291:
     292: #ifdef UNIX
     293: struct keytab wildtab[] = {     /* SET WILDCARD-EXPANSION */
     294:     "kermit",  0, 0,
     295:     "shell",   1, 0
     296: };
     297: #endif /* UNIX */
     298:
     299: #ifdef NETCONN
     300: extern struct keytab netcmd[];
     301: extern int nnets;
     302: #endif /* NETCONN */
     303:
     304: #ifdef SUNX25
     305: struct keytab x25tab[] = {
     306:     "call-user-data",    XYUDAT, 0,
     307:     "closed-user-group", XYCLOS, 0,
     308:     "reverse-charge",    XYREVC, 0
     309: };
     310: int nx25 = (sizeof(x25tab) / sizeof(struct keytab));
     311:
     312: struct keytab padx3tab[] = {
     313:     "break-action",         PAD_BREAK_ACTION,           0,
     314:     "break-character",      PAD_BREAK_CHARACTER,        0,
     315:     "character-delete",     PAD_CHAR_DELETE_CHAR,       0,
     316:     "cr-padding",           PAD_PADDING_AFTER_CR,       0,
     317:     "discard-output",       PAD_SUPPRESSION_OF_DATA,    0,
     318:     "echo",                 PAD_ECHO,                   0,
     319:     "editing",              PAD_EDITING,                0,
     320:     "escape",               PAD_ESCAPE,                 0,
     321:     "forward",              PAD_DATA_FORWARD_CHAR,      0,
     322:     "lf-padding",           PAD_PADDING_AFTER_LF,       0,
     323:     "lf-insert",            PAD_LF_AFTER_CR,            0,
     324:     "line-delete",          PAD_BUFFER_DELETE_CHAR,     0,
     325:     "line-display",         PAD_BUFFER_DISPLAY_CHAR,    0,
     326:     "line-fold",            PAD_LINE_FOLDING,           0,
     327:     "pad-flow-control",     PAD_FLOW_CONTROL_BY_PAD,    0,
     328:     "service-signals",      PAD_SUPPRESSION_OF_SIGNALS, 0,
     329:     "timeout",              PAD_DATA_FORWARD_TIMEOUT,   0,
     330: /* Speed is read-only */
     331:     "transmission-rate",    PAD_LINE_SPEED,             0,
     332:     "user-flow-control",    PAD_FLOW_CONTROL_BY_USER,   0
     333: };
     334: int npadx3 = (sizeof(padx3tab) / sizeof(struct keytab));
     335: #endif /* SUNX25 */
     336:
     337: /* Parity keyword table */
     338:
     339: struct keytab partab[] = {
     340:     "even",    'e', 0,
     341:     "mark",    'm', 0,
     342:     "none",     0 , 0,
     343:     "odd",     'o', 0,
     344:     "space",   's', 0
     345: };
     346: int npar = (sizeof(partab) / sizeof(struct keytab));
     347:
     348: /* On/Off table */
     349:
     350: struct keytab onoff[] = {
     351:     "off",       0, 0,
     352:     "on",        1, 0
     353: };
     354:
     355: struct keytab rltab[] = {
     356:     "local",     1, 0,
     357:     "off",       0, CM_INV,
     358:     "on",        1, CM_INV,
     359:     "remote",    0, 0
     360: };
     361: int nrlt = (sizeof(rltab) / sizeof(struct keytab));
     362:
     363: /* Incomplete File Disposition table */
     364: static
     365: struct keytab ifdtab[] = {
     366:     "discard",   0, 0,
     367:     "keep",      1, 0
     368: };
     369:
     370: /* SET TAKE parameters table */
     371: static
     372: struct keytab taktab[] = {
     373:     "echo",  0, 0,
     374:     "error", 1, 0,
     375:     "off",   2, CM_INV,         /* For compatibility */
     376:     "on",    3, CM_INV          /* with MS-DOS Kermit... */
     377: };
     378:
     379: /* SET MACRO parameters table */
     380: static
     381: struct keytab smactab[] = {
     382:     "echo",  0, 0,
     383:     "error", 1, 0
     384: };
     385:
     386: #ifndef NOSCRIPT
     387: static
     388: struct keytab scrtab[] = {
     389:     "echo",  0, 0
     390: };
     391: #endif /* NOSCRIPT */
     392:
     393: /* Bytesize table */
     394: struct keytab byttab[] = {
     395:     "bytesize",  0, 0
     396: };
     397: int nbytt = 1;
     398:
     399: #ifndef NOSERVER
     400: /* Server parameters table */
     401: struct keytab srvtab[] = {
     402:     "display", XYSERD, 0,
     403:     "timeout", XYSERT, 0
     404: };
     405: #endif /* NOSERVER */
     406:
     407: /* SET TRANSFER/XFER table */
     408:
     409: struct keytab tstab[] = {
     410: #ifndef NOCSETS
     411:     "character-set", 1,   0,
     412: #endif /* NOCSETS */
     413:     "locking-shift", 2,   0
     414: };
     415: int nts = (sizeof(tstab) / sizeof(struct keytab));
     416:
     417: #ifndef NOCSETS
     418: /* SET TRANSFER CHARACTER-SET table */
     419:
     420: extern struct keytab tcstab[];
     421: extern int ntcs;
     422: #endif /* NOCSETS */
     423:
     424: /* SET TRANSFER LOCKING-SHIFT table */
     425: struct keytab lstab[] = {
     426:     "forced", 2,   0,
     427:     "off",    0,   0,
     428:     "on",     1,   0
     429: };
     430: int nls = (sizeof(lstab) / sizeof(struct keytab));
     431:
     432: /* SET TELNET table */
     433: #ifdef TNCODE
     434: extern int tn_duplex, tn_nlm;
     435: extern char *tn_term;
     436: struct keytab tntab[] = {
     437:     "echo",          CK_TN_EC,   0,
     438:     "newline-mode",  CK_TN_NL,   0,
     439:     "terminal-type", CK_TN_TT,   0
     440: };
     441: int ntn = (sizeof(tntab) / sizeof(struct keytab));
     442: #endif /* TNCODE */
     443:
     444: struct keytab ftrtab[] = {      /* Feature table */
     445: #ifndef NOCSETS             /* 0 = we have it, 1 = we don't */
     446: "character-sets",   0, 0,
     447: #else
     448: "character-sets",   1, 0,
     449: #endif /* NOCSETS */
     450: #ifndef NOCYRIL
     451: "cyrillic",     0, 0,
     452: #else
     453: "cyrillic",     1, 0,
     454: #endif /* NOCYRIL */
     455:
     456: #ifndef NODEBUG
     457: "debug",        0, 0,
     458: #else
     459: "debug",        1, 0,
     460: #endif /* NODEBUG */
     461:
     462: #ifndef NODIAL
     463: "dial",         0, 0,
     464: #else
     465: "dial",         1, 0,
     466: #endif /* NODIAL */
     467:
     468: #ifdef DYNAMIC
     469: "dynamic-memory",       0, 0,
     470: #else
     471: "dynamic-memory",       1, 0,
     472: #endif /* DYNAMIC */
     473:
     474: #ifdef CK_CURSES
     475: "fullscreen-display",   0, 0,
     476: #else
     477: "fullscreen-display",   1, 0,
     478: #endif /* CK_CURSES */
     479: #ifndef NOHELP
     480: "help",         0, 0,
     481: #else
     482: "help",         1, 0,
     483: #endif /* NOHELP */
     484: #ifndef NOSPL
     485: "if-command",       0, 0,
     486: #else
     487: "if-command",       1, 0,
     488: #endif /* NOSPL */
     489: #ifndef NOJC
     490: #ifdef UNIX
     491: "job-control",      0, 0,
     492: #else
     493: "job-control",      1, 0,
     494: #endif /* UNIX */
     495: #else
     496: "job-control",      1, 0,
     497: #endif /* NOJC */
     498: #ifdef KANJI
     499: "kanji",        0, 0,
     500: #else
     501: "kanji",        1, 0,
     502: #endif /* KANJI */
     503: #ifndef NOCSETS
     504: "latin1",       0, 0,
     505: #else
     506: "latin1",       1, 0,
     507: #endif /* NOCSETS */
     508: #ifdef LATIN2
     509: "latin2",       0, 0,
     510: #else
     511: "latin2",       1, 0,
     512: #endif /* LATIN2 */
     513: #ifdef NETCONN
     514: "network",      0, 0,
     515: #else
     516: "network",      1, 0,
     517: #endif /* NETCONN */
     518: #ifndef NOPUSH
     519: "push",         0, 0,
     520: #else
     521: "push",         1, 0,
     522: #endif /* PUSH */
     523: #ifndef NOSCRIPT
     524: "script-command",   0, 0,
     525: #else
     526: "script-command",   1, 0,
     527: #endif /* NOSCRIPT */
     528: #ifndef NOSERVER
     529: "server-mode",      0, 0,
     530: #else
     531: "server-mode",      1, 0,
     532: #endif /* NOSERVER */
     533: #ifndef NOSHOW
     534: "show-command",     0, 0,
     535: #else
     536: "show-command",     1, 0,
     537: #endif /* NOSHOW */
     538: #ifndef NOXMIT
     539: "transmit",     0, 0,
     540: #else
     541: "transmit",     1, 0
     542: #endif /* NOXMIT */
     543: };
     544: int nftr = (sizeof(ftrtab) / sizeof(struct keytab));
     545:
     546: int                 /* CHECK command */
     547: dochk() {
     548:     int x, y;
     549:     if ((y = cmkey(ftrtab,nftr,"","",xxstring)) < 0) return(y);
     550:     if ((x = cmcfm()) < 0) return(x);
     551:     if (msgflg)             /* If at top level... */
     552:       printf(" %svailable\n", y ? "Not a" : "A"); /* Print a message */
     553:     else if (y && !backgrd)     /* Or if not available and in */
     554:       printf(" CHECK: feature not available\n"); /* command file or macro */
     555:     return(success = 1 - y);
     556: }
     557:
     558: #ifndef MAC
     559: #ifndef NOSETKEY
     560: int
     561: set_key() {             /* SET KEY */
     562:     int y;
     563:     int kc;             /* Key code */
     564:     char *bind;             /* Key binding */
     565:
     566:     if ((y = cmnum("numeric key code","",10,&kc,xxstring)) < 0)
     567:       return(y);
     568:     if (kc < 0 || kc >= KMSIZE) {
     569:     printf("?key code must be between 0 and %d\n", KMSIZE - 1);
     570:     return(-9);
     571:     }
     572: #ifdef OS2
     573:     wideresult = -1;
     574: #endif /* OS2 */
     575:     if ((y = cmtxt("key definition","",&bind,xxstring)) < 0)
     576:       return(y);
     577:     if (macrotab[kc]) {         /* Possibly free old macro from key */
     578:     free(macrotab[kc]);
     579:     macrotab[kc] = NULL;
     580:     }
     581:     switch (strlen(bind)) {     /* Action depends on length */
     582: #ifdef OS2
     583:       case 0:               /* Reset to default binding */
     584:         keymap[kc] = wideresult == -1 ? kc : 0;   /* or bind to NUL */
     585:     break;
     586:       case 1:               /* Single character */
     587:     keymap[kc] = wideresult == -1 ? (CHAR) *bind : wideresult;
     588:     break;
     589: #else /* Not OS/2 */
     590:       case 0:               /* Reset to default binding */
     591:     keymap[kc] = kc;
     592:     break;
     593:       case 1:               /* Single character */
     594:     keymap[kc] = (CHAR) *bind;
     595:     break;
     596: #endif /* OS2 */
     597:
     598:       default:              /* Character string */
     599:     keymap[kc] = kc;
     600:     macrotab[kc] = (MACRO) malloc(strlen(bind)+1);
     601:     if (macrotab[kc])
     602:       strcpy((char *) macrotab[kc], bind);
     603:     break;
     604:     }
     605:     return(1);
     606: }
     607: #endif /* NOSETKEY */
     608: #endif /* MAC */
     609:
     610: /*  D O P R M  --  Set a parameter.  */
     611: /*
     612:  Returns:
     613:   -2: illegal input
     614:   -1: reparse needed
     615:    0: success
     616: */
     617: int
     618: doprm(xx,rmsflg) int xx, rmsflg; {
     619:     int i, x, y = 0, z;
     620:     long zz;
     621:     char *s;
     622:
     623: switch (xx) {
     624:
     625: #ifdef SUNX25               /* SET X25 ... */
     626: case XYX25:
     627:     return(setx25());
     628:
     629: case XYPAD:             /* SET PAD ... */
     630:     return(setpadp());
     631: #endif /* SUNX25 */
     632:
     633: case XYEOL: /* These have all been moved to set send/receive... */
     634: case XYLEN:     /* Let the user know what to do. */
     635: case XYMARK:
     636: case XYNPAD:
     637: case XYPADC:
     638: case XYTIMO:
     639:     printf("...Use SET SEND or SET RECEIVE instead.\n");
     640:     printf("Type HELP SET SEND or HELP SET RECEIVE for more info.\n");
     641:     return(success = 0);
     642:
     643: case XYATTR:                /* File Attribute packets */
     644:     return(setat(rmsflg));
     645:
     646: case XYIFD:             /* Incomplete file disposition */
     647:     if ((y = cmkey(ifdtab,2,"","discard",xxstring)) < 0) return(y);
     648:     if ((x = cmcfm()) < 0) return(x);
     649:     if (rmsflg) {
     650:     sstate = setgen('S', "310", y ? "1" : "0", "");
     651:     return((int) sstate);
     652:     } else {
     653:     keep = y;
     654:     return(success = 1);
     655:     }
     656:
     657: #ifndef NOSPL
     658: case XYINPU:                /* SET INPUT */
     659:     return(setinp());
     660: #endif /* NOSPL */
     661:
     662: #ifdef NETCONN
     663: case XYNET:             /* SET NETWORK */
     664:     if ((z = cmkey(netcmd,nnets,"","tcp/ip",xxstring)) < 0)
     665:       return(z);
     666:     if ((x = cmcfm()) < 0) return(x);
     667:     nettype = z;
     668:     if (
     669:     (nettype != NET_DEC) &&
     670:     (nettype != NET_SX25) &&
     671:         (nettype != NET_TCPB)) {
     672:     printf("?Network type not supported\n");
     673:     return(success = 0);
     674:     } else {
     675:     return(success = 1);
     676:     }
     677: #endif /* NETCONN */
     678:
     679: case XYHOST:                /* SET HOST or SET LINE */
     680: case XYLINE:
     681:     return(setlin(xx,1));
     682:
     683: #ifndef MAC
     684: #ifndef NOSETKEY
     685: case XYKEY:             /* SET KEY */
     686:     return(set_key());
     687: #endif /* NOSETKEY */
     688: #endif /* MAC */
     689:
     690: #ifndef NOCSETS
     691: case XYLANG:                /* Language */
     692:     if ((y = cmkey(lngtab,nlng,"","none",xxstring)) < 0) /* language code */
     693:       return(y);
     694:     if ((x = cmcfm()) < 0) return(x);   /* And confirmation of command */
     695:
     696:     /* Look up language and get associated character sets */
     697:     for (i = 0; (i < nlangs) && (langs[i].id != y); i++) ;
     698:     if (i >= nlangs) {
     699:     printf("?internal error, sorry\n");
     700:     return(success = 0);
     701:     }
     702:     language = i;           /* All good, set the language, */
     703:     return(success = 1);
     704: #endif /* NOCSETS */
     705:
     706: #ifndef MAC
     707: case XYBACK:                /* BACKGROUND */
     708:     if ((z = cmkey(onoff,2,"","",xxstring)) < 0) return(z);
     709:     if ((y = cmcfm()) < 0) return(y);
     710:     bgset = z;
     711:     success = 1;
     712:     bgchk();
     713:     return(success);
     714: #endif /* MAC */
     715:
     716: case XYQUIE:                /* QUIET */
     717:     return(success = seton(&quiet));
     718:
     719: case XYBUF: {               /* BUFFERS */
     720: #ifdef DYNAMIC
     721:     int sb, rb;
     722:     if ((y = cmnum("send buffer size","",10,&sb,xxstring)) < 0) {
     723:     if (y == -3) printf("?two numbers required\n");
     724:     return(y);
     725:     }
     726:     if (sb < 80) {
     727:     printf("?too small");
     728:     return(-2);
     729:     }
     730:     if ((y = cmnum("receive buffer size","",10,&rb,xxstring)) < 0)  {
     731:     if (y == -3) printf("?receive buffer size required\n");
     732:     return(y);
     733:     }
     734:     if (rb < 80) {
     735:     printf("?too small");
     736:     return(-2);
     737:     }
     738:     if ((y = cmcfm()) < 0) return(y);
     739:     if ((y = inibufs(sb,rb)) < 0) return(y);
     740:     y = adjpkl(urpsiz,wslotr,bigrbsiz); /* Maybe adjust packet sizes */
     741:     if (y != urpsiz) urpsiz = y;
     742:     y = adjpkl(spsiz,wslotr,bigsbsiz);
     743:     if (y != spsiz) spsiz = spmax = spsizr = y;
     744:     return(success = 1);
     745: #else
     746:     printf("?Sorry, not available\n");
     747:     return(success = 0);
     748: #endif /* DYNAMIC */
     749: }
     750:
     751: case XYCHKT:                /* BLOCK-CHECK */
     752:     if ((x = cmkey(chktab,4,"","1",xxstring)) < 0) return(x);
     753:     if ((y = cmcfm()) < 0) return(y);
     754:     bctr = x;                /* Set locally too, even if REMOTE SET */
     755:     if (rmsflg) {
     756:     if (x == 4) {
     757:         tmpbuf[0] = 'B';
     758:         tmpbuf[1] = '\0';
     759:     } else sprintf(tmpbuf,"%d",x);
     760:     sstate = setgen('S', "400", tmpbuf, "");
     761:     return((int) sstate);
     762:     } else {
     763:     return(success = 1);
     764:     }
     765:
     766: #ifndef MAC
     767: /*
     768:   The Mac has no carrier...
     769: */
     770: case XYCARR:                /* CARRIER */
     771:     if ((y = cmkey(crrtab,ncrr,"","auto",xxstring)) < 0) return(y);
     772:     if (y == CAR_ON) {
     773:     x = cmnum("Carrier wait timeout, seconds","0",10,&z,xxstring);
     774:     if (x < 0) return(z);
     775:     }
     776:     if ((x = cmcfm()) < 0) return(x);
     777:     carrier = ttscarr(y);
     778:     cdtimo = z;
     779:     return(success = 1);
     780: #endif /* MAC */
     781:
     782: #ifdef TNCODE
     783: case XYTEL:             /* TELNET */
     784:     if ((z = cmkey(tntab,ntn,"parameter for TELNET negotiations", "",
     785:            xxstring)) < 0) return(z);
     786:     switch (z) {
     787:       case CK_TN_EC:            /* ECHO */
     788:     if ((x = cmkey(rltab,nrlt,
     789:                "initial TELNET echoing state","local",xxstring)) < 0)
     790:       return(x);
     791:     if ((y = cmcfm()) < 0) return(y);
     792:     tn_duplex = x;
     793:     return(success = 1);
     794:
     795:       case CK_TN_TT:            /* TERMINAL TYPE */
     796:     if ((y = cmtxt("terminal type for TELNET connections","",
     797:                &s,xxstring)) < 0)
     798:       return(y);
     799:     if (tn_term) free(tn_term); /* Free any previous storage */
     800:     if (s == NULL || *s == NUL) {   /* If none given */
     801:         tn_term = NULL;     /* remove the override string */
     802:         return(success = 1);
     803:     } else if (tn_term = malloc(strlen(s)+1)) { /* Make storage for new */
     804:         strcpy(tn_term,s);      /* Copy string into new storage */
     805:         return(success = 1);
     806:     } else return(success = 0);
     807:
     808:       case CK_TN_NL:            /* NEWLINE-MODE */
     809:     return(success = seton(&tn_nlm));
     810:
     811:       default:
     812:     return(-2);
     813:     }
     814: #endif /* TNCODE */
     815:
     816: default:
     817:     break;
     818: }
     819:
     820: switch (xx) {
     821: #ifndef NOSPL
     822: case XYCOUN:                /* SET COUNT */
     823:     x = cmnum("Positive number","0",10,&z,xxstring);
     824:     if (x < 0) return(x);
     825:     if ((x = cmcfm()) < 0) return(x);
     826:     if (z < 0) {
     827:     printf("?A positive number, please\n");
     828:     return(0);
     829:     }
     830:     debug(F101,"XYCOUN: z","",z);
     831:     return(success = setnum(&count[cmdlvl],z,0,10000));
     832: #endif /* NOSPL */
     833:
     834: #ifndef NOSPL
     835: case XYCASE:
     836:     return(success = seton(&incase));
     837: #endif /* NOSPL */
     838:
     839: case XYCMD:             /* COMMAND ... */
     840:     if ((y = cmkey(byttab,nbytt,"","bytesize",xxstring)) < 0) return(y);
     841:     if ((y = cmnum("bytesize for command characters, 7 or 8","7",10,&x,
     842:            xxstring)) < 0)
     843:       return(y);
     844:     if (x != 7 && x != 8) {
     845:     printf("\n?The choices are 7 and 8\n");
     846:     return(success = 0);
     847:     }
     848:     if ((y = cmcfm()) < 0) return(y);
     849:     if (x == 7) cmdmsk = 0177;
     850:     else if (x == 8) cmdmsk = 0377;
     851:     return(success = 1);
     852:
     853: case XYDFLT:                /* SET DEFAULT = CD */
     854:     return(success = docd());
     855:
     856: case XYDEBU:                /* SET DEBUG { on, off, session } */
     857:     if ((y = cmkey(dbgtab,ndbg,"","",xxstring)) < 0) return(y);
     858:     if ((x = cmcfm()) < 0) return(x);
     859:     switch (y) {
     860:       case 0:               /* 0 = all debugging off. */
     861:     debses = 0;
     862: #ifdef DEBUG
     863:     if (deblog) doclslog(LOGD);
     864: #endif /* DEBUG */
     865:         return(success = 1);
     866:
     867:       case 1:               /* 1 = log debugging to debug.log */
     868: #ifdef DEBUG
     869:     deblog = debopn("debug.log", 0);
     870:     return(success = deblog ? 1 : 0);
     871: #else
     872:     printf("?Sorry, debug log feature not enabled\n");
     873:     return(success = 0);
     874: #endif /* DEBUG */
     875:
     876:       case 2:               /* 2 = session. */
     877:     return(success = debses = 1);
     878:     }
     879:
     880: case XYDELA:                /* SET DELAY */
     881:     y = cmnum("Number of seconds before starting to send","5",10,&x,xxstring);
     882:     if (x < 0) x = 0;
     883:     return(success = setnum(&delay,x,y,999));
     884:
     885: default:
     886:     break;
     887: }
     888:
     889: switch (xx) {
     890:
     891: #ifndef NODIAL
     892: case XYDIAL:                /* SET DIAL */
     893:     return(setdial());
     894: #endif /* NODIAL */
     895:
     896: #ifdef COMMENT              /* Unused at present */
     897: case XYDOUB:
     898:     if ((x = cmfld("Character to double","none",&s,xxstring)) < 0) {
     899:     if (x == -3) {
     900:         dblchar = -1;
     901:         if (msgflg) printf("Doubling Off\n");
     902:         return(success = 1);
     903:     } else return(x);
     904:     }
     905:     strcpy(line,s);
     906:     lp = line;
     907:     if ((x = cmcfm()) < 0) return(x);
     908:     if (!xxstrcmp(lp,"none",4)) {
     909:     dblchar = -1;
     910:     if (msgflg) printf("Doubling Off\n");
     911:     return(success = 1);
     912:     }
     913:     if ((int)strlen(lp) != 1) return(-2);
     914:     dblchar = *lp & 0xFF;
     915:     if (msgflg) printf("Doubled: %d\n",dblchar);
     916:     return(success = 1);
     917: #endif /* COMMENT */
     918:
     919: case XYDUPL:                /* SET DUPLEX */
     920:     if ((y = cmkey(dpxtab,2,"","full",xxstring)) < 0) return(y);
     921:     if ((x = cmcfm()) < 0) return(x);
     922:     duplex = y;
     923:     return(success = 1);
     924:
     925: case XYLCLE:                /* LOCAL-ECHO (= DUPLEX) */
     926:     return(success = seton(&duplex));
     927:
     928: case XYESC:             /* SET ESCAPE */
     929:     sprintf(tmpbuf,"%d",DFESC);
     930:     y = cmnum("Decimal ASCII code for CONNECT-mode escape character",
     931:           tmpbuf, 10,&x,xxstring);
     932:     success = setcc(&escape,x,y);
     933: #ifdef COMMENT
     934: /* This is what SHOW ESCAPE is for. */
     935:     if (success && msgflg)
     936:       printf(" CONNECT-mode escape character: %d (Ctrl-%c, %s)\n",
     937:          escape,ctl(escape),(escape == 127 ? "DEL" : ccntab[escape]));
     938: #endif /* COMMENT */
     939:     return(success);
     940:
     941: default:
     942:     break;
     943: }
     944:
     945: switch (xx) {
     946: case XYFILE:                /* SET FILE */
     947:     return(setfil(rmsflg));
     948:
     949: case XYFLOW:                /* FLOW-CONTROL */
     950: /*
     951:   Note: flotab[] keyword table (defined above) only includes the legal
     952:   flow-control options for each implementation, controlled by symbols
     953:   defined in ckcdeb.h.
     954: */
     955:     if ((y = cmkey(flotab,nflo,"","xon/xoff",xxstring)) < 0) return(y);
     956:     if ((x = cmcfm()) < 0) return(x);
     957:     flow = y;
     958:     debug(F101,"set flow","",flow);
     959:     return(success = 1);
     960:
     961: case XYHAND:                /* HANDSHAKE */
     962:     if ((y = cmkey(hshtab,nhsh,"","none",xxstring)) < 0) return(y);
     963:     if (y == 998) {
     964:     if ((x = cmnum("ASCII value","",10,&y,xxstring)) < 0)
     965:       return(x);
     966:     if ((y < 1) || ((y > 31) && (y != 127))) {
     967:         printf("?Character must be in ASCII control range\n");
     968:         return(-9);
     969:     }
     970:     }
     971:     if ((x = cmcfm()) < 0) return(x);
     972:     turn = (y > 0127) ? 0 : 1 ;
     973:     turnch = y;
     974:     return(success = 1);
     975:
     976: #ifndef NOSPL
     977: case XYMACR:                /* SET MACRO */
     978:     if ((y = cmkey(smactab,2,"","",xxstring)) < 0) return(y);
     979:     switch (y) {
     980:       case 0: return(success = seton(&mecho));
     981:       case 1: return(success = seton(&merror));
     982:       default: return(-2);
     983:     }
     984: #endif /* NOSPL */
     985:
     986: #ifndef NODIAL
     987: case XYMODM:                /* SET MODEM */
     988:     if ((x = cmkey(mdmtab,nmdm,"type of modem","none", xxstring)) < 0)
     989:     return(x);
     990:     if ((z = cmcfm()) < 0) return(z);
     991:     mdmtyp = x;
     992: #ifndef MINIDIAL
     993:     tbmodel = 0;          /* If it's a Telebit, we don't know the model yet */
     994: #endif /* MINIDIAL */
     995:     return(success = 1);
     996: #endif /* NODIAL */
     997:
     998:   case XYMSGS:
     999: #ifdef VMS
    1000:     if ((z = cmkey(onoff,2,"","",xxstring)) < 0) return(z);
    1001:     if ((y = cmcfm()) < 0) return(y);
    1002:     vms_msgs = z;
    1003:     printf("Sorry, SET MESSAGES not implemented yet\n");
    1004:     return(success = 0);
    1005: #endif /* VMS */
    1006: default:
    1007:     break;
    1008: }
    1009:
    1010: switch (xx) {
    1011:
    1012: case XYPARI:                /* PARITY */
    1013:     if ((y = cmkey(partab,npar,"","none",xxstring)) < 0) return(y);
    1014:     if ((x = cmcfm()) < 0) return(x);
    1015:
    1016: /* If parity not none, then we also want 8th-bit prefixing */
    1017:
    1018:     if (parity = y) ebqflg = 1; else ebqflg = 0;
    1019:     return(success = 1);
    1020:
    1021: #ifndef NOFRILLS
    1022: case XYPROM:                /* SET PROMPT */
    1023: /*
    1024:   Note: xxstring not invoked here.  Instead, it is invoked every time the
    1025:   prompt is issued.  This allows the prompt string to contain variables
    1026:   that can change, like \v(dir), \v(time), etc.
    1027: */
    1028: #ifdef MAC
    1029:     if ((x = cmtxt("Program's command prompt","Mac-Kermit>",&s,NULL)) < 0)
    1030: #else
    1031:     if ((x = cmtxt("Program's command prompt","C-Kermit>",&s,NULL)) < 0)
    1032: #endif /* MAC */
    1033:       return(x);
    1034:     if (*s == '{') {            /* Remove enclosing braces, if any */
    1035:     x = (int)strlen(s);
    1036:     if (s[x-1] == '}') {
    1037:         s[x-1] = NUL;
    1038:         s++;
    1039:     }
    1040:     }
    1041: #ifdef COMMENT
    1042: /*
    1043:   Let's not do this any more -- we don't do it anywhere else.
    1044: */
    1045:     else if (*s == '"') {       /* For compatibility with pre-5A */
    1046:     x = (int)strlen(s);
    1047:     if (s[x-1] == '"') {
    1048:         s[x-1] = NUL;
    1049:         s++;
    1050:     }
    1051:     }
    1052: #endif /* COMMENT */
    1053:     cmsetp(s);              /* Set the prompt */
    1054:     return(success = 1);
    1055: #endif /* NOFRILLS */
    1056:
    1057: case XYRETR:                /* RETRY: per-packet retry limit */
    1058:     y = cmnum("Maximum retries per packet","10",10,&x,xxstring);
    1059:     if (x < 0) x = 0;
    1060:     if ((x = setnum(&maxtry,x,y,999)) < 0) return(x);
    1061:     if (maxtry <= wslotr) {
    1062:     printf("?Retry limit must be greater than window size\n");
    1063:     return(success = 0);
    1064:     }
    1065:     sprintf(tmpbuf,"%d",maxtry);
    1066:     if (rmsflg) {
    1067:     sstate = setgen('S', "403", tmpbuf, "");
    1068:     return((int) sstate);
    1069:     } else return(success = x);
    1070:
    1071: #ifndef NOSERVER
    1072: case XYSERV:                /* SET SERVER items */
    1073:     if ((y = cmkey(srvtab,2,"","",xxstring)) < 0) return(y);
    1074:     switch (y) {
    1075:       case XYSERT:
    1076:     tp = tmpbuf;
    1077:         sprintf(tp,"%d",DSRVTIM);
    1078:     if ((y = cmnum("interval for server NAKs, 0 = none",tp,10,&x,
    1079:                xxstring)) < 0)
    1080:       return(y);
    1081:     if (x < 0) {
    1082:         printf("\n?Specify a positive number, or 0 for no server NAKs\n");
    1083:         return(0);
    1084:     }
    1085:     if ((y = cmcfm()) < 0) return(y);
    1086:     sprintf(tp,"%d",x);
    1087:     if (rmsflg) {
    1088:         sstate = setgen('S', "404", tp, "");
    1089:         return((int) sstate);
    1090:     } else {
    1091:         srvtim = x;         /* Set the server timeout variable */
    1092:         return(success = 1);
    1093:     }
    1094:       case XYSERD:          /* SERVER DISPLAY */
    1095:     return(success = seton(&srvdis)); /* ON or OFF... */
    1096:       default:
    1097:     return(-2);
    1098:     }
    1099: #endif /* NOSERVER */
    1100:
    1101: #ifdef UNIX
    1102: #ifndef NOJC
    1103: case XYSUSP:                /* SET SUSPEND */
    1104:     seton(&suspend);            /* on or off... */
    1105:     return(success = 1);
    1106: #endif /* NOJC */
    1107: #endif /* UNIX */
    1108:
    1109: case XYTAKE:                /* SET TAKE */
    1110:     if ((y = cmkey(taktab,4,"","",xxstring)) < 0) return(y);
    1111:     switch (y) {
    1112:       case 0: return(success = seton(&techo));
    1113:       case 1: return(success = seton(&terror));
    1114:       case 2: techo = 0; return(success = 1); /* For compatibility with */
    1115:       case 3: techo = 1; return(success = 1); /* MS-DOS Kermit */
    1116:       default: return(-2);
    1117:     }
    1118:
    1119: #ifndef NOSCRIPT
    1120: case XYSCRI:                /* SET SCRIPT */
    1121:     if ((y = cmkey(scrtab,1,"","echo",xxstring)) < 0) return(y);
    1122:     switch (y) {
    1123:       case 0: return(success = seton(&secho));
    1124:       default: return(-2);
    1125:     }
    1126: #endif /* NOSCRIPT */
    1127:
    1128: default:
    1129:     break;
    1130: }
    1131:
    1132: switch (xx) {
    1133: case XYTERM:                /* SET TERMINAL */
    1134:     return(settrm());
    1135:
    1136: default:
    1137:     break;
    1138: }
    1139:
    1140: switch (xx) {
    1141:
    1142: /* SET SEND/RECEIVE protocol parameters. */
    1143:
    1144: case XYRECV:
    1145: case XYSEND:
    1146:     return(setsr(xx,rmsflg));
    1147:
    1148: #ifdef UNIX
    1149: case XYSESS:                /* SESSION-LOG */
    1150:     if ((x = cmkey(fttab,2,"type of file","text",xxstring)) < 0)
    1151:       return(x);
    1152:     if ((y = cmcfm()) < 0) return(y);
    1153:     sessft = x;
    1154:     return(success = 1);
    1155: #endif /* UNIX */
    1156:
    1157: case XYSPEE:                /* SET SPEED */
    1158:     if (network) {
    1159:     printf("\n?Speed cannot be set for network connections\n");
    1160:     return(success = 0);
    1161:     }
    1162:     lp = line;
    1163:     sprintf(lp,"Transmission rate for %s in bits per second",ttname);
    1164:
    1165:     if ((x = cmkey(spdtab,nspd,line,"",xxstring)) < 0) {
    1166:     if (x == -3) printf("?value required\n");
    1167:     return(x);
    1168:     }
    1169:     if ((y = cmcfm()) < 0) return(y);
    1170:     if (!local) {
    1171:     printf("?Sorry, you must SET LINE first\n");
    1172:     return(success = 0);
    1173:     }
    1174:     zz = (long) x * 10L;
    1175:     if (zz == 70) zz = 75;      /* (see spdtab[] def) */
    1176:     if (ttsspd(x) < 0)  {       /* Call ttsspd with cps, not bps! */
    1177:     printf("?Unsupported line speed - %ld\n",zz);
    1178:     return(success = 0);
    1179:     } else {
    1180:     speed = zz;
    1181:     if (pflag &&
    1182: #ifndef NOSPL
    1183:         cmdlvl == 0
    1184: #else
    1185:         tlevel < 0
    1186: #endif /* NOSPL */
    1187:         ) {
    1188:         if (speed == 8880)
    1189:           printf("%s, 75/1200 bps\n",ttname);
    1190:         else
    1191:           printf("%s, %ld bps\n",ttname,speed);
    1192:     }
    1193:     return(success = 1);
    1194:     }
    1195:
    1196:   case XYXFER:              /* SET TRANSFER */
    1197:     if ((y = cmkey(tstab,nts,"","character-set",xxstring)) < 0) return(y);
    1198: #ifndef NOCSETS
    1199:     if (y == 1) {           /* character-set */
    1200:     if ((y = cmkey(tcstab,ntcs,"","transparent",xxstring)) < 0) return(y);
    1201:     if ((x = cmcfm()) < 0) return(x);
    1202:     if (rmsflg) {
    1203:         sstate = setgen('S', "405", tcsinfo[y].designator, "");
    1204:         return((int) sstate);
    1205:     } else {
    1206:         tslevel = (y == TC_TRANSP) ? 0 : 1; /* transfer syntax level */
    1207:         tcharset = y;       /* transfer character set */
    1208:         return(success = 1);
    1209:     }
    1210:     } else
    1211: #endif /* NOCSETS */
    1212:       if (y == 2) {         /* LOCKING-SHIFT options */
    1213:       if ((y = cmkey(lstab,nls,"","on",xxstring)) < 0)
    1214:         return(y);
    1215:       if ((x = cmcfm()) < 0) return(x);
    1216:       lscapr = (y == 1) ? 1 : 0;    /* ON: requested = 1 */
    1217:       lscapu = (y == 2) ? 2 : 0;    /* FORCED:  used = 1 */
    1218:       return(success = 1);
    1219:       } else return(-2);
    1220:
    1221: #ifndef NOXMIT
    1222:   case XYXMIT:              /* SET TRANSMIT */
    1223:     return(setxmit());
    1224: #endif /* NOXMIT */
    1225:
    1226: #ifndef NOCSETS
    1227:   case XYUNCS:              /* UNKNOWN-CHARACTER-SET */
    1228:     if ((y = cmkey(ifdtab,2,"","discard",xxstring)) < 0) return(y);
    1229:     if ((x = cmcfm()) < 0) return(x);
    1230:     unkcs = y;
    1231:     return(success = 1);
    1232: #endif /* NOCSETS */
    1233:
    1234: #ifdef UNIX
    1235:   case XYWILD:              /* WILDCARD-EXPANSION */
    1236:     if ((y = cmkey(wildtab,2,"who expands wildcards","kermit",xxstring)) < 0)
    1237:       return(y);
    1238:     if ((x = cmcfm()) < 0) return(x);
    1239:     wildxpand = y;
    1240:     return(success = 1);
    1241: #endif /* UNIX */
    1242:
    1243:   case XYWIND:              /* WINDOW-SLOTS */
    1244:     y = cmnum("Number of sliding-window slots, 1 to 31","1",10,&x,xxstring);
    1245:     y = setnum(&z,x,y,31);
    1246:     if (y < 0) return(y);
    1247:     if (z < 1) z = 1;
    1248: #ifdef COMMENT
    1249:     /* This is unreasonable */
    1250:     if (maxtry < z) {
    1251:     printf("?Window slots must be less than retry limit\n");
    1252:     return(success = 0);
    1253:     }
    1254: #endif /* COMMENT */
    1255:     if (rmsflg) {           /* Set remote window size */
    1256:     tp = tmpbuf;
    1257:     sprintf(tp,"%d",z);
    1258:     sstate = setgen('S', "406", tp, "");
    1259:     return((int) sstate);
    1260:     }
    1261:     wslotr = z;             /* Set local window size */
    1262:     swcapr = (wslotr > 1) ? 1 : 0;  /* Set window bit in capas word? */
    1263:     if (wslotr > 1) {           /* Window size > 1? */
    1264:     y = adjpkl(urpsiz,wslotr,bigrbsiz); /* Maybe adjust packet size */
    1265:     if (y != urpsiz) {      /* Did it change? */
    1266:         urpsiz = y;
    1267:         if (msgflg)
    1268:         printf(
    1269: " Adjusting receive packet-length to %d for %d window slots\n",
    1270:            urpsiz, wslotr);
    1271:     }
    1272:     }
    1273:     return(success = 1);
    1274:
    1275: default:
    1276:     if ((x = cmcfm()) < 0) return(x);
    1277:     printf("Not working yet - %s\n",cmdbuf);
    1278:     return(success = 0);
    1279:     }
    1280: }
    1281: #endif /* NOICP */

#### Defined functions

dochk defined in line 546; used 1 times

- in /usr/src/new/kermit5.188/ckuusr.c line 1049

doprm defined in line 617; used 3 times

- in /usr/src/new/kermit5.188/ckuus7.c line 880, 1294
- in /usr/src/new/kermit5.188/ckuusr.c line 1694

set_key defined in line 560; used 1 times

- in line 686

#### Defined variables

autotab defined in line 124; never used
byttab defined in line 394; used 1 times

- in line 840

chktab defined in line 115; used 1 times

- in line 752

crrtab defined in line 131; used 1 times

- in line 771

dbgtab defined in line 140; used 1 times

- in line 857

dpxtab defined in line 211; used 1 times

- in line 920

filtab defined in line 218; used 2 times

- in line 236
- in /usr/src/new/kermit5.188/ckuus7.c line 668

flotab defined in line 240; used 2 times

- in line 254, 955

ftrtab defined in line 444; used 2 times

- in line 544-549(2)

fttab defined in line 270; used 3 times

- in line 282, 1150
- in /usr/src/new/kermit5.188/ckuus7.c line 809

hshtab defined in line 258; used 2 times

- in line 268, 962

ifdtab defined in line 365; used 2 times

- in line 647, 1228

lstab defined in line 425; used 2 times

- in line 430, 1213

nbytt defined in line 397; used 1 times

- in line 840

ncrr defined in line 136; used 1 times

- in line 771

ndbg defined in line 145; used 1 times

- in line 857

nfilp defined in line 236; used 1 times

- in /usr/src/new/kermit5.188/ckuus7.c line 668

nflo defined in line 254; used 1 times

- in line 955

nftr defined in line 544; used 1 times

- in line 549

nfttyp defined in line 282; used 1 times

- in /usr/src/new/kermit5.188/ckuus7.c line 809

nhsh defined in line 268; used 1 times

- in line 962

nls defined in line 430; used 1 times

- in line 1213

npadx3 defined in line 334; used 2 times

- in /usr/src/new/kermit5.188/ckuus4.c line 1245
- in /usr/src/new/kermit5.188/ckuus7.c line 1588

npar defined in line 346; used 1 times

- in line 1013

nrlt defined in line 361; used 2 times

- in line 788
- in /usr/src/new/kermit5.188/ckuus7.c line 1016

nspd defined in line 202; used 1 times

- in line 1165

ntn defined in line 441; used 1 times

- in line 784

nts defined in line 415; used 1 times

- in line 1197

nx25 defined in line 310; used 1 times

- in /usr/src/new/kermit5.188/ckuus7.c line 1536

onoff defined in line 350; used 7 times

- in line 708, 1000
- in /usr/src/new/kermit5.188/ckuus7.c line 466, 1540, 1560, 1578, 1805

padx3tab defined in line 312; used 5 times

- in line 334
- in /usr/src/new/kermit5.188/ckuus4.c line 1246-1247(3)
- in /usr/src/new/kermit5.188/ckuus7.c line 1588

partab defined in line 339; used 3 times

- in line 346, 1013
- in /usr/src/new/kermit5.188/ckuus6.c line 540

rltab defined in line 355; used 3 times

- in line 361, 788
- in /usr/src/new/kermit5.188/ckuus7.c line 1016

scrtab defined in line 388; used 1 times

- in line 1121

smactab defined in line 381; used 1 times

- in line 978

spdtab defined in line 163; used 2 times

- in line 202, 1165

srvtab defined in line 401; used 1 times

- in line 1073

taktab defined in line 372; used 1 times

- in line 1110

tntab defined in line 436; used 2 times

- in line 441, 784

tstab defined in line 409; used 2 times

- in line 415, 1197

vms_msgs defined in line 110; used 1 times

- in line 1002

wideresult defined in line 70; used 13 times

- in line 573, 584-587(3)
- in /usr/src/new/kermit5.188/ckucmd.c line 578, 2083, 2095-2099(3)
- in /usr/src/new/kermit5.188/ckuus3.c line 573, 584-587(3)

wildtab defined in line 293; used 1 times

- in line 1236

x25tab defined in line 305; used 2 times

- in line 310
- in /usr/src/new/kermit5.188/ckuus7.c line 1536

Last modified: 1992-11-24 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 3457 |