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

   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

Defined variables