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

##### Functions

    dormt             X
    rfilop            X
    rmsg              X
    setat             X
    setcc             X
    setdial           X
    setfil            X
    setinp            X
    setlin            X
    setnum            X
    seton             X
    setpadp           X
    setsr             X
    settrm            X
    setx25            X
    setxmit           X

##### Variables

    VOID              X
    akmtab            X
    attrtab           X
    colxtab           X
    crdtab            X
    dialtab           X
    fbtab             X
    fdtab             X
    fntab             X
    incast            X
    inptab            X
    intimt            X
    kpmtab            X
    lbltab            X
    natr              X
    nclrs             X
    ncolors           X
    ncolx             X
    ncursors          X
    ndial             X
    nfbtyp            X
    nfdtab            X
    ninp              X
    nlblp             X
    nos2dev           X
    nrfilp            X
    nrms              X
    nrsrtab           X
    nsrtab            X
    ntrm              X
    nttyp             X
    nxmit             X
    os2devtab         X
    rmstab            X
    rsrtab            X
    srtab             X
    trmtab            X
    tt_arrow          X
    tt_cursor         X
    tt_keypad         X
    tt_type           X
    tt_wrap           X
    ttyclrtab         X
    ttycoltab         X
    ttycurtab         X
    ttyptab           X
    xmitab            X
    xmitbuf           X

##### Macros

    CK_NEED_SIG       X
    XMBUFL            X
    XMITE             X
    XMITF             X
    XMITL             X
    XMITP             X
    XMITS             X
    XMITW             X
    XMITX             X

       1: #ifndef NOICP
       2:
       3: /*  C K U U S 7 --  "User Interface" for Unix Kermit, part 7  */
       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: /*
      17:   This file created from parts of ckuus3.c, which became to big for
      18:   Mark Williams Coherent compiler to handle.
      19: */
      20:
      21: /*
      22:   Definitions here supersede those from system include files.
      23: */
      24: #include "ckcdeb.h"         /* Debugging & compiler things */
      25: #include "ckcasc.h"         /* ASCII character symbols */
      26: #include "ckcker.h"         /* Kermit application definitions */
      27: #include "ckcxla.h"         /* Character set translation */
      28: #include "ckcnet.h"         /* Network symbols */
      29: #include "ckuusr.h"         /* User interface symbols */
      30:
      31: static int x, y = 0, z;
      32: static char *s;
      33:
      34: static int mdmsav = -1;         /* Save modem type around network */
      35: static int oldplex = -1;        /* Duplex holder around network */
      36:
      37: extern int success, nfilp, fmask, fncnv, frecl, nfttyp, binary, warn, msgflg;
      38: extern int cmask, maxrps, wslotr, bigsbsiz, bigrbsiz, urpsiz, rpsiz, spsiz;
      39: extern int spsizr, spsizf, maxsps, spmax, pflag, bctr, npad, timef, timint;
      40: extern int pkttim, rtimo, local, nfils, displa, atcapr, nettype, escape;
      41: extern int mdmtyp, duplex, dfloc, network, cdtimo, fncact, mypadn;
      42: extern int tnlm, sosi, tlevel, lf_opts, backgrd, flow, fdispla;
      43: extern int
      44:   atenci, atenco, atdati, atdato, atleni, atleno, atblki, atblko,
      45:   attypi, attypo, atsidi, atsido, atsysi, atsyso, atdisi, atdiso;
      46:
      47: extern long speed;
      48:
      49: extern CHAR sstate, eol, seol, stchr, mystch, mypadc, padch;
      50:
      51: extern char *cmarg, *cmarg2, *dftty;
      52:
      53: extern char tmpbuf[], *tp, *lp;     /* Temporary buffer & pointers */
      54: #ifndef NOFRILLS
      55: extern char optbuf[];           /* Buffer for MAIL or PRINT options */
      56: extern int rprintf;         /* REMOTE PRINT flag */
      57: #endif /* NOFRILLS */
      58: extern char ttname[];
      59:
      60: extern struct keytab onoff[], filtab[], fttab[], rltab[];
      61: extern int nrlt;
      62:
      63: #ifdef DCMDBUF
      64: extern char *atxbuf;            /* Atom buffer */
      65: extern char *cmdbuf;            /* Command buffer */
      66: extern char *line;          /* Character buffer for anything */
      67: #ifdef CK_CURSES
      68: /* This needs cleaning up... */
      69: #ifdef UNIX
      70: extern char *trmbuf;            /* Termcap buffer */
      71: #endif /* UNIX */
      72: #ifdef OS2
      73: extern char *trmbuf;            /* Termcap buffer */
      74: #endif /* OS2 */
      75: #ifdef OSK
      76: extern char *trmbuf;            /* Termcap buffer */
      77: #endif /* OSK */
      78: #ifdef AMIGA
      79: extern char *trmbuf;            /* Termcap buffer */
      80: #endif /* AMIGA */
      81: #endif /* CK_CURSES */
      82: #else
      83: extern char atxbuf[];           /* Atom buffer */
      84: extern char cmdbuf[];           /* Command buffer */
      85: extern char line[];         /* Character buffer for anything */
      86: #ifdef CK_CURSES
      87: #ifdef UNIX
      88: extern char trmbuf[];           /* Termcap buffer */
      89: #endif /* UNIX */
      90: #endif /* CK_CURSES */
      91: #endif /* DCMDBUF */
      92:
      93: #ifndef NOCSETS
      94: extern struct keytab fcstab[];      /* For 'set file character-set' */
      95: extern struct keytab ttcstab[];
      96: extern int nfilc, fcharset, ntermc, tcsr, tcsl;
      97: #endif /* NOCSETS */
      98:
      99: #ifndef NOSPL
     100: extern int cmdlvl;          /* Overall command level */
     101: #endif /* NOSPL */
     102:
     103: #ifdef TNCODE
     104: extern int tn_init;
     105: #endif /* TNCODE */
     106:
     107: #ifdef SUNX25
     108: extern int revcall, closgr, cudata, nx25, npadx3;
     109: extern char udata[MAXCUDATA];
     110: extern CHAR padparms[MAXPADPARMS+1];
     111: extern struct keytab x25tab[], padx3tab[];
     112: #endif /* SUNX25 */
     113:
     114: #ifdef CK_CURSES
     115: #ifndef VMS
     116: _PROTOTYP(int tgetent,(char *, char *));
     117: #endif /* VMS */
     118: #endif /* CK_CURSES */
     119:
     120: #ifndef NODIAL
     121: extern int dialhng, dialtmo, dialksp, dialdpy, dialmnp, dialmhu;
     122: extern int mdmspd;
     123: extern char *dialini, *dialdir, *dialcmd, *dialnpr;
     124: extern FILE * dialfd;
     125:
     126:
     127: struct keytab dialtab[] = {
     128:     "dial-command", XYDDIA, 0,
     129:     "directory", XYDDIR, 0,
     130:     "display", XYDDPY, 0,
     131:     "hangup",  XYDHUP, 0,
     132:     "init-string", XYDINI, 0,
     133:     "kermit-spoof", XYDKSP, 0,
     134:     "mnp-enable", XYDMNP, 0,
     135: #ifdef MDMHUP
     136:     "modem-hangup", XYDMHU, 0,
     137: #endif /* MDMHUP */
     138:     "prefix", XYDNPR, 0,
     139:     "speed-matching", XYDSPD, 0,
     140:     "timeout", XYDTMO, 0
     141: };
     142: int ndial = (sizeof(dialtab) / sizeof(struct keytab));
     143: #endif /* NODIAL */
     144:
     145: #ifndef NOXMIT
     146: /* set transmit */
     147: #define XMITF 0
     148: #define XMITL 1
     149: #define XMITP 2
     150: #define XMITE 3
     151: #define XMITX 4
     152: #define XMITS 5
     153: #define XMITW 6
     154:
     155: #ifndef NOXMIT
     156: #define XMBUFL 50
     157: extern int xmitf, xmitl, xmitp, xmitx, xmits, xmitw;
     158: char xmitbuf[XMBUFL+1] = { NUL };   /* TRANSMIT eof string */
     159: #endif /* NOXMIT */
     160:
     161: struct keytab xmitab[] = {
     162:     "echo",     XMITX, 0,
     163:     "eof",      XMITE, 0,
     164:     "fill",     XMITF, 0,
     165:     "linefeed", XMITL, 0,
     166:     "locking-shift", XMITS, 0,
     167:     "pause",    XMITW, 0,
     168:     "prompt",   XMITP, 0
     169: };
     170: int nxmit = (sizeof(xmitab) / sizeof(struct keytab));
     171: #endif /* NOXMIT */
     172:
     173: /* For SET FILE COLLISION */
     174: /* Some of the following may be possible for some C-Kermit implementations */
     175: /* but not others.  Those that are not possible for your implementation */
     176: /* should be ifdef'd out. */
     177:
     178: struct keytab colxtab[] = { /* SET FILE COLLISION options */
     179:     "append",    XYFX_A, 0,  /* append to old file */
     180: #ifdef COMMENT
     181:     "ask",       XYFX_Q, 0,  /* ask what to do (not implemented) */
     182: #endif
     183:     "backup",    XYFX_B, 0,  /* rename old file */
     184:     "discard",   XYFX_D, 0,  /* don't accept new file */
     185:     "no-supersede", XYFX_D, CM_INV, /* ditto (MSK compatibility) */
     186:     "overwrite", XYFX_X, 0,  /* overwrite the old file == file warning off */
     187:     "rename",    XYFX_R, 0,  /* rename the incoming file == file warning on */
     188:     "update",    XYFX_U, 0,  /* replace if newer */
     189: };
     190: int ncolx = (sizeof(colxtab) / sizeof(struct keytab));
     191:
     192: static struct keytab rfiltab[] = {  /* for REMOTE SET FILE */
     193:     "collision",     XYFILX, 0,
     194:     "record-length", XYFILR, 0,
     195:     "type",          XYFILT, 0
     196: };
     197: int nrfilp = (sizeof(rfiltab) / sizeof(struct keytab));
     198:
     199: struct keytab fntab[] = {           /* File naming */
     200:     "converted", 1, 0,
     201:     "literal",   0, 0
     202: };
     203:
     204: /* Terminal parameters table */
     205: struct keytab trmtab[] = {
     206: #ifdef OS2
     207:     "arrow-keys",    XYTARR, 0,
     208: #endif /* OS2 */
     209:     "bytesize",      XYTBYT, 0,
     210: #ifndef NOCSETS
     211:     "character-set", XYTCS,  0,
     212: #endif /* NOCSETS */
     213: #ifdef OS2
     214:     "color",         XYTCOL, 0,
     215: #endif /* OS2 */
     216:     "cr-display",    XYTCRD, 0,
     217: #ifdef OS2
     218:     "cursor",        XYTCUR, 0,
     219: #endif /* OS2 */
     220:     "echo",          XYTEC,  0,
     221: #ifdef OS2
     222:     "keypad-mode",   XYTKPD, 0,
     223: #endif /* OS2 */
     224:     "locking-shift", XYTSO,  0,
     225:     "newline-mode",  XYTNL,  0
     226: #ifdef OS2
     227: ,   "type",          XYTTYP, 0,
     228:     "wrap",          XYTWRP, 0
     229: #endif /* OS2 */
     230: };
     231: int ntrm = (sizeof(trmtab) / sizeof(struct keytab));
     232:
     233: struct keytab crdtab[] = {      /* Carriage-return display */
     234:     "crlf",        1, 0,
     235:     "normal",      0, 0
     236: };
     237: extern int tt_crd;          /* Carriage-return display variable */
     238:
     239: #ifdef OS2
     240: /*
     241:   OS/2 serial communication devices.
     242: */
     243: struct keytab os2devtab[] = {
     244:     "1",    1, CM_INV,          /* Invisible synonyms, like */
     245:     "2",    2, CM_INV,          /* "set port 1" */
     246:     "3",    3, CM_INV,
     247:     "4",    4, CM_INV,
     248:     "5",    5, CM_INV,
     249:     "6",    6, CM_INV,
     250:     "7",    7, CM_INV,
     251:     "8",    8, CM_INV,
     252:     "com1", 1, 0,           /* Real device names */
     253:     "com2", 2, 0,
     254:     "com3", 3, 0,
     255:     "com4", 4, 0,
     256:     "com5", 5, 0,
     257:     "com6", 6, 0,
     258:     "com7", 7, 0,
     259:     "com8", 7, 0
     260: };
     261: int nos2dev = (sizeof(os2devtab) / sizeof(struct keytab));
     262:
     263: /*
     264:   Terminal parameters that can be set by SET commands.
     265:   Used by the ck?con.c terminal emulator code.
     266:   For now, only use for OS/2.  Should add these for Macintosh.
     267: */
     268: int tt_arrow = 1;           /* Arrow key mode */
     269: int tt_keypad = 0;          /* Keypad mode */
     270: int tt_wrap = 1;            /* Autowrap */
     271: int tt_type = TT_VT102;         /* Terminal type */
     272: int tt_cursor = 0;          /* Cursor type */
     273: #endif /* OS2 */
     274:
     275: #ifdef OS2
     276: struct keytab akmtab[] = {      /* Arrow key mode */
     277:     "application", 1, 0,
     278:     "cursor",      0, 0
     279: };
     280: struct keytab kpmtab[] = {      /* Keypad mode */
     281:     "application", 0, 0,
     282:     "numeric",     1, 0
     283: };
     284:
     285: struct keytab ttycoltab[] = {       /* Items to be colored */
     286:     "help",        4, 0,        /* Help screen */
     287:     "normal",      0, 0,        /* Normal screen text */
     288:     "reverse",     1, 0,        /* Reverse video */
     289:     "status",      3, 0,        /* Status line */
     290:     "underlined",  2, 0         /* Underlined text */
     291: };
     292: int ncolors = 5;
     293:
     294: struct keytab ttyclrtab[] = {       /* Colors */
     295:     "black",       0, 0,
     296:     "blue",        1, 0,
     297:     "brown",       6, 0,
     298:     "cyan",        3, 0,
     299:     "dgray",       8, 0,
     300:     "green",       2, 0,
     301:     "lblue",       9, 0,
     302:     "lcyan",      11, 0,
     303:     "lgray",       7, 0,
     304:     "lgreen",     10, 0,
     305:     "lmagenta",   13, 0,
     306:     "lred",       12, 0,
     307:     "magenta",     5, 0,
     308:     "red",         4, 0,
     309:     "white",      15, 0,
     310:     "yellow",     14, 0
     311: };
     312: int nclrs = 16;
     313:
     314: struct keytab ttycurtab[] = {
     315:     "full",        2, 0,
     316:     "half",        1, 0,
     317:     "underline",   0, 0
     318: };
     319: int ncursors = 3;
     320: #endif /* OS2 */
     321:
     322: #ifdef OS2
     323: struct keytab ttyptab[] = {
     324: #ifdef COMMENT
     325: /*
     326:   Not supported yet...
     327:   The idea is to let the console driver handle the escape sequences.
     328: */
     329:     "none",    TT_NONE,  0,
     330: #endif /* COMMENT */
     331: #ifdef OS2PM
     332:     "tek4014", TT_TEK40, 0,
     333: #endif /* OS2PM */
     334:     "vt102",   TT_VT102, 0,
     335:     "vt52",    TT_VT52,  0
     336: };
     337: int nttyp = 2;
     338: #endif /* OS2 */
     339:
     340: /* #ifdef VMS */
     341: struct keytab fbtab[] = {       /* Binary record types for VMS */
     342:     "fixed",     XYFT_B, 0,     /* Fixed is normal for binary */
     343:     "undefined", XYFT_U, 0      /* Undefined if they ask for it */
     344: };
     345: int nfbtyp = (sizeof(fbtab) / sizeof(struct keytab));
     346: /* #endif */
     347:
     348: #ifdef VMS
     349: struct keytab lbltab[] = {      /* Labeled File info */
     350:     "acl",         LBL_ACL, 0,
     351:     "backup-date", LBL_BCK, 0,
     352:     "name",        LBL_NAM, 0,
     353:     "owner",       LBL_OWN, 0,
     354:     "path",        LBL_PTH, 0
     355: };
     356: int nlblp = (sizeof(lbltab) / sizeof(struct keytab));
     357: #endif /* VMS */
     358:
     359: struct keytab fdtab[] = {       /* SET FILE DISPLAY options */
     360: #ifdef MAC              /* Macintosh */
     361:     "fullscreen", XYFD_R, 0,        /* Full-screen but not curses */
     362:     "none",   XYFD_N, 0,
     363:     "off",    XYFD_N, CM_INV,
     364:     "on",     XYFD_R, CM_INV,
     365:     "quiet",  XYFD_N, CM_INV
     366:
     367: #else                   /* Not Mac */
     368:     "crt", XYFD_S, 0,           /* CRT display */
     369: #ifdef CK_CURSES
     370: #ifdef COMMENT
     371:     "curses",     XYFD_C, CM_INV,   /* Full-screen, curses */
     372: #endif /* COMMENT */
     373:     "fullscreen", XYFD_C, 0,        /* Full-screen, whatever the method */
     374: #endif /* CK_CURSES */
     375:     "none",   XYFD_N, 0,        /* No display */
     376:     "off",    XYFD_N, CM_INV,       /* Ditto */
     377:     "on",     XYFD_R, CM_INV,       /* On = Serial */
     378:     "quiet",  XYFD_N, CM_INV,       /* No display */
     379:     "serial", XYFD_R, 0         /* Serial */
     380: #endif /* MAC */
     381: };
     382: int nfdtab = (sizeof(fdtab) / sizeof(struct keytab));
     383:
     384: struct keytab rsrtab[] = {      /* For REMOTE SET RECEIVE */
     385:     "packet-length", XYLEN, 0,
     386:     "timeout", XYTIMO, 0
     387: };
     388: int nrsrtab = (sizeof(rsrtab) / sizeof(struct keytab));
     389:
     390: /* Send/Receive Parameters */
     391:
     392: struct keytab srtab[] = {
     393:     "end-of-packet", XYEOL, 0,
     394:     "packet-length", XYLEN, 0,
     395:     "pad-character", XYPADC, 0,
     396:     "padding", XYNPAD, 0,
     397:     "start-of-packet", XYMARK, 0,
     398:     "timeout", XYTIMO, 0
     399: };
     400: int nsrtab = (sizeof(srtab) / sizeof(struct keytab));
     401:
     402: /* REMOTE SET */
     403:
     404: struct keytab rmstab[] = {
     405:     "attributes",  XYATTR, 0,
     406:     "block-check", XYCHKT, 0,
     407:     "file",        XYFILE, 0,
     408:     "incomplete",  XYIFD,  0,
     409:     "receive",     XYRECV, 0,
     410:     "retry",       XYRETR, 0,
     411:     "server",      XYSERV, 0,
     412:     "transfer",    XYXFER, 0,
     413:     "window",      XYWIND, 0
     414: };
     415: int nrms = (sizeof(rmstab) / sizeof(struct keytab));
     416:
     417: struct keytab attrtab[] = {
     418:     "all",           AT_XALL, 0,
     419: #ifdef COMMENT
     420:     "blocksize",     AT_BLKS, 0,    /* not used */
     421: #endif /* COMMENT */
     422:     "character-set", AT_ENCO, 0,
     423:     "date",          AT_DATE, 0,
     424:     "disposition",   AT_DISP, 0,
     425:     "encoding",      AT_ENCO, CM_INV,
     426:     "length",        AT_LENK, 0,
     427:     "off",           AT_ALLN, 0,
     428:     "on",            AT_ALLY, 0,
     429: #ifdef COMMENT
     430:     "os-specific",   AT_SYSP, 0,    /* not used by UNIX or VMS */
     431: #endif /* COMMENT */
     432:     "system-id",     AT_SYSI, 0,
     433:     "type",          AT_FTYP, 0,
     434: };
     435: int natr = (sizeof(attrtab) / sizeof(struct keytab)); /* how many attributes */
     436:
     437: #ifndef NOSPL
     438: extern int indef, intime, incase, inecho, insilence;
     439: struct keytab inptab [] = {     /* SET INPUT parameters */
     440:     "case",            IN_CAS, 0,
     441:     "default-timeout", IN_DEF, CM_INV,
     442:     "echo",            IN_ECH, 0,
     443:     "silence",         IN_SIL, 0,
     444:     "timeout-action",  IN_TIM, 0
     445: };
     446: int ninp = (sizeof(inptab) / sizeof(struct keytab));
     447:
     448: struct keytab intimt[] = {      /* SET INPUT TIMEOUT parameters */
     449:     "proceed", 0, 0,            /* 0 = proceed */
     450:     "quit",    1, 0         /* 1 = quit */
     451: };
     452:
     453: struct keytab incast[] = {      /* SET INPUT CASE parameters */
     454:     "ignore",  0, 0,            /* 0 = ignore */
     455:     "observe", 1, 0         /* 1 = observe */
     456: };
     457: #endif /* NOSPL */
     458:
     459: /* The following routines broken out of doprm() to give compilers a break. */
     460:
     461: /*  S E T O N  --  Parse on/off (default on), set parameter to result  */
     462:
     463: int
     464: seton(prm) int *prm; {
     465:     int x, y;
     466:     if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
     467:     if ((x = cmcfm()) < 0) return(x);
     468:     *prm = y;
     469:     return(1);
     470: }
     471:
     472: /*  S E T N U M  --  Set parameter to result of cmnum() parse.  */
     473: /*
     474:  Call with pointer to integer variable to be set,
     475:    x = number from cnum parse, y = return code from cmnum,
     476:    max = maximum value to accept, -1 if no maximum.
     477:  Returns -9 on failure, after printing a message, or 1 on success.
     478: */
     479: int
     480: setnum(prm,x,y,max) int x, y, *prm, max; {
     481:     extern int cmflgs;
     482:     debug(F101,"setnum","",y);
     483:     if (y == -3) {
     484:     printf("\n?Value required\n");
     485:     return(-9);
     486:     }
     487:     if (y == -2) {
     488:     printf("%s?Not a number: %s\n",cmflgs == 1 ? "" : "\n", atxbuf);
     489:     return(-9);
     490:     }
     491:     if (y < 0) return(y);
     492:     if (max > -1 && x > max) {
     493:     printf("?Sorry, %d is the maximum\n",max);
     494:     return(-9);
     495:     }
     496:     if ((y = cmcfm()) < 0) return(y);
     497:     *prm = x;
     498:     return(1);
     499: }
     500:
     501: /*  S E T C C  --  Set parameter to an ASCII control character value.  */
     502:
     503: int
     504: setcc(prm,x,y) int x, y, *prm; {
     505:     if (y == -3) {
     506:     printf("\n?Value required\n");
     507:     return(-3);
     508:     }
     509:     if (y < 0) return(y);
     510:     if ((x > 037) && (x != 0177)) {
     511:     printf("\n?Not in ASCII control range - %d\n",x);
     512:     return(-2);
     513:     }
     514:     if ((y = cmcfm()) < 0) return(y);
     515:     *prm = x;
     516:     return(1);
     517: }
     518:
     519: #ifndef NODIAL
     520: _PROTOTYP(static int dialstr,(char **, char *));
     521: /*
     522:   Parse a DIAL-related string, stripping enclosing braces, if any.
     523: */
     524: static int
     525: dialstr(p,msg) char **p; char *msg; {
     526:     int x;
     527:     if ((x = cmtxt(msg, "", &s, xxstring)) < 0)
     528:       return(x);
     529:     if (*s == '{') {            /* Strip enclosing braces, if any */
     530:     x = strlen(s);
     531:     if (s[x-1] == '}') {
     532:         s[x-1] = NUL;
     533:         s++;
     534:     }
     535:     }
     536:     if (*p) {               /* Free any previous string. */
     537:     free(*p);
     538:     *p = (char *) 0;
     539:     }
     540:     if ((x = strlen(s)) > 0) {
     541:     *p = malloc(x + 1);     /* Allocate space for it */
     542:     strcpy(*p,s);           /* and make a safe copy. */
     543:     } else *p = (char *) 0;
     544:     return(success = 1);
     545: }
     546:
     547: int                 /* Set DIAL command options */
     548: setdial() {
     549:     if ((y = cmkey(dialtab,ndial,"","",xxstring)) < 0) return(y);
     550:     switch (y) {
     551:       case XYDHUP:          /* DIAL HANGUP */
     552:     return(success = seton(&dialhng));
     553:       case XYDINI:          /* DIAL INIT-STRING */
     554:     return(dialstr(&dialini,"Modem dialer initialization string"));
     555:       case XYDNPR:          /* DIAL NUMBER-PREFIX */
     556:     return(dialstr(&dialnpr,"Modem dialer telephone number prefix"));
     557:       case XYDDIA:          /* DIAL DIAL-COMMAND */
     558:     x = cmtxt("Dialing command for modem,\n\
     559:  include \"%s\" to stand for phone number,\n\
     560:  for example, \"set dial dial-command ATDT%s\\13\"",
     561:           "",
     562:           &s,
     563:           xxstring);
     564:     if (x < 0 && x != -3)       /* Handle parse errors */
     565:       return(x);
     566:     y = x = strlen(s);      /* Get length of text */
     567:     if (x > 0 && *s == '{') {   /* Strip enclosing braces, */
     568:         if (s[x-1] == '}') {    /* if any. */
     569:         s[x-1] = NUL;
     570:         s++;
     571:         y -= 2;
     572:         }
     573:     }
     574:     if (y > 0) {            /* If there is any text (left), */
     575:         for (x = 0; x < y; x++) {   /* make sure they included "%s" */
     576:         if (s[x] != '%') continue;
     577:         if (s[x+1] == 's') break;
     578:         }
     579:         if (x == y) {
     580:         printf(
     581: "?Dial-command must contain \"%cs\" for phone number.\n",'%');
     582:         return(-9);
     583:         }
     584:     }
     585:     if (dialcmd) {          /* Free any previous string. */
     586:         free(dialcmd);
     587:         dialcmd = (char *) 0;
     588:     }
     589:     if (y > 0) {
     590:         dialcmd = malloc(y + 1);    /* Allocate space for it */
     591:         strcpy(dialcmd,s);      /* and make a safe copy. */
     592:     }
     593:     return(success = 1);
     594:       case XYDKSP:          /* DIAL KERMIT-SPOOF */
     595:     return(success = seton(&dialksp));
     596:       case XYDTMO:          /* DIAL TIMEOUT */
     597:     y = cmnum("Seconds to wait for call completion","0",10,&x,xxstring);
     598:     return(success = setnum(&dialtmo,x,y,10000));
     599:       case XYDDPY:          /* DIAL DISPLAY */
     600:     return(success = seton(&dialdpy));
     601:       case XYDSPD:          /* DIAL SPEED-MATCHING */
     602:                     /* used to be speed-changing */
     603:     if ((y = seton(&mdmspd)) < 0) return(y);
     604: #ifdef COMMENT
     605:     mdmspd = 1 - mdmspd;        /* so here we reverse the meaning */
     606: #endif /* COMMENT */
     607:     return(success = 1);
     608:       case XYDMNP:          /* DIAL MNP-ENABLE */
     609:     return(success = seton(&dialmnp));
     610: #ifdef MDMHUP
     611:       case XYDMHU:          /* DIAL MODEM-HANGUP */
     612:     return(success = seton(&dialmhu));
     613: #endif /* MDMHUP */
     614:       case XYDDIR:          /* DIAL DIRECTORY */
     615:     if ((y = cmifi("Name of dialing directory file","",&s,&y,
     616:                xxstring)) < 0) {
     617:         if (y == -3) {
     618:         if (dialdir) free(dialdir); /* Free any previous storage */
     619:         dialdir = NULL;
     620:         return(success = 1);
     621:         } else return(y);
     622:     }
     623:     if (y) {
     624:         printf("?Wildcards not allowed\n");
     625:         return(-9);
     626:     }
     627:     strcpy(line,s);         /* Make safe copy of dial string */
     628:     if ((y = cmcfm()) < 0) return(y); /* Confirm the command */
     629:     if (dialdir) free(dialdir); /* Free previous filename storage */
     630:     if (dialfd) {           /* Close previous file, if any */
     631:         fclose(dialfd);
     632:         dialfd = NULL;
     633:     }
     634:     s = line;           /* Point back to dial string */
     635:     if (s == NULL || *s == NUL) {   /* If no name given */
     636:         dialdir = NULL;     /* remove the name string */
     637:         return(success = 1);
     638:     } else if ((dialdir = malloc(strlen(s)+1)) == NULL) {
     639:         return(success = 0);    /* Can't malloc storage for name */
     640:     } else {            /* Have storage for name */
     641:         strcpy(dialdir,s);      /* Copy string into new storage */
     642:         if ((dialfd = fopen(dialdir,"r")) == NULL) { /* Open the file */
     643:         perror(dialdir);    /* Can't, print message saying why */
     644:         success = 0;        /* We didn't succeed */
     645:         return(-9);     /* Fail, message already printed */
     646:         }
     647:         return(success = 1);    /* Everything is OK */
     648:     }
     649:
     650:       default:
     651:     printf("?Unexpected SET DIAL parameter\n");
     652:     return(-2);
     653:     }
     654: }
     655: #endif /* NODIAL */
     656:
     657: int
     658: setfil(rmsflg) int rmsflg; {
     659:     if (rmsflg) {
     660:     if ((y = cmkey(rfiltab,nrfilp,"Remote file parameter","",
     661:                xxstring)) < 0) {
     662:         if (y == -3) {
     663:         printf("?Remote file parameter required\n");
     664:         return(-9);
     665:         } else return(y);
     666:     }
     667:     } else {
     668:     if ((y = cmkey(filtab,nfilp,"File parameter","",xxstring)) < 0)
     669:       return(y);
     670:     }
     671:     switch (y) {
     672: #ifdef COMMENT              /* Not needed */
     673:       case XYFILB:          /* Blocksize */
     674:     sprintf(tmpbuf,"%d",DBLKSIZ);
     675:     if ((y = cmnum("file block size",tmpbuf,10,&z,xxstring)) < 0)
     676:       return(y);
     677:     if ((x = cmcfm()) < 0) return(x);
     678:     if (rmsflg) {
     679:         sprintf(tmpbuf,"%d",z);
     680:         sstate = setgen('S', "311", tmpbuf, "");
     681:         return((int) sstate);
     682:     } else {
     683:         fblksiz = z;
     684:         return(success = 1);
     685:     }
     686: #endif /* COMMENT */
     687:
     688:       case XYFILS:          /* Byte size */
     689:     if ((y = cmnum("file byte size (7 or 8)","8",10,&z,xxstring)) < 0)
     690:       return(y);
     691:     if (z != 7 && z != 8) {
     692:         printf("\n?The choices are 7 and 8\n");
     693:         return(0);
     694:     }
     695:     if ((y = cmcfm()) < 0) return(y);
     696:     if (z == 7) fmask = 0177;
     697:     else if (z == 8) fmask = 0377;
     698:     return(success = 1);
     699:
     700: #ifndef NOCSETS
     701:       case XYFILC:          /* Character set */
     702:     if ((x = cmkey(fcstab,nfilc,"local file code","ascii", xxstring)) < 0)
     703:       return(x);
     704:     if ((z = cmcfm()) < 0) return(z);
     705:     fcharset = x;
     706:     return(success = 1);
     707: #endif /* NOCSETS */
     708:
     709:       case XYFILD:          /* Display */
     710:     if ((x = cmkey(fdtab,nfdtab,"file transfer display style","",
     711:                xxstring)) < 0)
     712:       return(x);
     713:     if ((z = cmcfm()) < 0) return(z);
     714: #ifdef CK_CURSES
     715:     if (x == XYFD_C) {
     716: #ifdef VMS
     717:         lp = line;
     718: #else
     719:         lp = trmbuf;
     720: #endif /* VMS */
     721: #ifndef MYCURSES
     722:         s = getenv("TERM");
     723:         if (tgetent(lp,s) < 1) {
     724: #ifdef VMS
     725:         printf("Sorry, terminal type not supported: %s\n",s);
     726: #else
     727:         printf("Sorry, terminal type unknown: %s\n",s);
     728: #endif /* VMS */
     729:         return(success = 0);
     730:         }
     731: #endif /* MYCURSES */
     732:         line[0] = '\0';
     733:     }
     734: #endif /* CK_CURSES */
     735:     fdispla = x;            /* It's OK. */
     736:     return(success = 1);
     737:
     738:       case XYFILN:          /* Names */
     739:     if ((x = cmkey(fntab,2,"how to handle filenames","converted",
     740:                xxstring)) < 0)
     741:       return(x);
     742:     if ((z = cmcfm()) < 0) return(z);
     743:     fncnv = x;
     744:     return(success = 1);
     745:
     746:       case XYFILR:          /* Record length */
     747:     sprintf(tmpbuf,"%d",DLRECL);
     748:     if ((y = cmnum("file record length",tmpbuf,10,&z,xxstring)) < 0)
     749:       return(y);
     750:     if ((x = cmcfm()) < 0) return(x);
     751:     if (rmsflg) {
     752:         sprintf(tmpbuf,"%d",z);
     753:         sstate = setgen('S', "312", tmpbuf, "");
     754:         return((int) sstate);
     755:     } else {
     756:         frecl = z;
     757:         return(success = 1);
     758:     }
     759:
     760: #ifdef COMMENT
     761:       case XYFILO:          /* Organization */
     762:     if ((x = cmkey(forgtab,nforg,"file organization","sequential",
     763:                xxstring)) < 0)
     764:       return(x);
     765:     if ((y = cmcfm()) < 0) return(y);
     766:     if (rmsflg) {
     767:         sprintf(tmpbuf,"%d",x);
     768:         sstate = setgen('S', "314", tmpbuf, "");
     769:         return((int) sstate);
     770:     } else {
     771:         forg = x;
     772:         return(success = 1);
     773:     }
     774: #endif /* COMMENT */
     775:
     776: #ifdef COMMENT              /* Not needed */
     777:       case XYFILF:          /* Format */
     778:     if ((x = cmkey(frectab,nfrec,"file record format","stream",
     779:                xxstring)) < 0)
     780:       return(x);
     781:     if ((y = cmcfm()) < 0) return(y);
     782:     if (rmsflg) {
     783:         sprintf(tmpbuf,"%d",x);
     784:         sstate = setgen('S', "313", tmpbuf, "");
     785:         return((int) sstate);
     786:     } else {
     787:         frecfm = x;
     788:         return(success = 1);
     789:     }
     790: #endif /* COMMENT */
     791:
     792: #ifdef COMMENT
     793:       case XYFILP:          /* Printer carriage control */
     794:     if ((x = cmkey(fcctab,nfcc,"file carriage control","newline",
     795:                xxstring)) < 0)
     796:       return(x);
     797:     if ((y = cmcfm()) < 0) return(y);
     798:     if (rmsflg) {
     799:         sprintf(tmpbuf,"%d",x);
     800:         sstate = setgen('S', "315", tmpbuf, "");
     801:         return((int) sstate);
     802:     } else {
     803:         fcctrl = x;
     804:         return(success = 1);
     805:     }
     806: #endif /* COMMENT */
     807:
     808:       case XYFILT:          /* Type */
     809:     if ((x = cmkey(fttab,nfttyp,"type of file","text",xxstring)) < 0)
     810:       return(x);
     811: #ifdef COMMENT
     812:     if ((y = cmnum("file byte size (7 or 8)","8",10,&z,xxstring)) < 0)
     813:       return(y);
     814:     if (z != 7 && z != 8) {
     815:         printf("\n?The choices are 7 and 8\n");
     816:         return(0);
     817:     }
     818: #endif /* COMMENT */
     819:
     820: #ifdef VMS
     821:         /* Allow VMS users to choose record format for binary files */
     822:         if ((x == XYFT_B) && (rmsflg == 0)) {
     823:         if ((x = cmkey(fbtab,nfbtyp,"VMS record format","fixed",
     824:                xxstring)) < 0)
     825:           return(x);
     826:     }
     827: #endif /* VMS */
     828:     if ((y = cmcfm()) < 0) return(y);
     829:     if (rmsflg) {
     830:         sstate = setgen('S', "300", x ? "1" : "0", "");
     831:         return((int) sstate);
     832:     } else {
     833:         binary = x;
     834: #ifdef COMMENT
     835:         if (z == 7) fmask = 0177;
     836:         else if (z == 8) fmask = 0377;
     837: #endif /* COMMENT */
     838:         return(success = 1);
     839:     }
     840:
     841:       case XYFILX:          /* Collision Action */
     842:     if ((x = cmkey(colxtab,ncolx,"Filename collision action","backup",
     843:                xxstring)) < 0)
     844:       return(x);
     845:     if ((y = cmcfm()) < 0) return(y);
     846:     fncact = x;
     847:     if (rmsflg) {
     848:         sprintf(tmpbuf,"%d",fncact);
     849:         sstate = setgen('S', "302", tmpbuf, "");
     850:         return((int) sstate);
     851:     } else {
     852:         if (fncact == XYFX_R) warn = 1; /* SET FILE WARNING implications */
     853:         if (fncact == XYFX_X) warn = 0; /* ... */
     854:         return(success = 1);
     855:     }
     856:
     857:       case XYFILW:          /* Warning/Write-Protect */
     858:     seton(&warn);
     859:     if (warn)
     860:       fncact = XYFX_R;
     861:     else
     862:       fncact = XYFX_X;
     863:     return(success = 1);
     864:
     865: #ifdef VMS
     866:       case XYFILL:          /* LABELED FILE parameters */
     867:     if ((x = cmkey(lbltab,nlblp,"VMS labeled file feature","",
     868:                xxstring)) < 0)
     869:       return(x);
     870:     if ((success = seton(&y)) < 0)
     871:       return(success);
     872:     if (y)              /* Set or reset the selected bit */
     873:       lf_opts |= x;         /* in the options bitmask. */
     874:     else
     875:       lf_opts &= ~x;
     876:     return(success);
     877: #endif /* VMS */
     878:
     879:       case XYFILI:          /* INCOMPLETE */
     880:     return(doprm(XYIFD,rmsflg));
     881:
     882:       default:
     883:     printf("?unexpected file parameter\n");
     884:     return(-2);
     885:     }
     886: }
     887:
     888: int
     889: settrm() {
     890:     if ((y = cmkey(trmtab,ntrm,"","",xxstring)) < 0) return(y);
     891: #ifdef MAC
     892:     printf("\n?Sorry, not implemented yet.  Please use the Settings menu.\n");
     893:     return(-9);
     894: #else
     895:     switch (y) {
     896:       case XYTBYT:          /* SET TERMINAL BYTESIZE */
     897:     if ((y = cmnum("bytesize for terminal connection","8",10,&x,
     898:                xxstring)) < 0)
     899:       return(y);
     900:     if (x != 7 && x != 8) {
     901:         printf("\n?The choices are 7 and 8\n");
     902:         return(success = 0);
     903:     }
     904:     if ((y = cmcfm()) < 0) return(y);
     905:     if (x == 7) cmask = 0177;
     906:     else if (x == 8) cmask = 0377;
     907:         return(success = 1);
     908:
     909:       case XYTSO:           /* SET TERMINAL LOCKING-SHIFT */
     910:     return(success = seton(&sosi));
     911:
     912:       case XYTNL:           /* SET TERMINAL NEWLINE-MODE */
     913:     return(success = seton(&tnlm));
     914:
     915: #ifdef OS2
     916:       case XYTCOL:          /* SET TERMINAL COLOR */
     917:     if ((x = cmkey(ttycoltab,ncolors,"","normal",xxstring)) < 0) {
     918:         return(x);
     919:         } else {
     920:         extern int colornormal, colorreverse, colorunderline,
     921:           colorstatus, colorhelp, scrninitialised;
     922:         int fg, bg;
     923:         if ((fg = cmkey(ttyclrtab,nclrs,
     924:                 "foreground color","black",xxstring)) < 0)
     925:           return(fg);
     926:         if ((bg = cmkey(ttyclrtab,nclrs,
     927:                 "background color","cyan",xxstring)) < 0)
     928:           return(bg);
     929:         if ((y = cmcfm()) < 0)
     930:           return(y);
     931:         switch (x) {
     932:           case 0:
     933:         colornormal = fg | bg << 4;
     934:         break;
     935:           case 1:
     936:         colorreverse = fg | bg << 4;
     937:         break;
     938:           case 2:
     939:         colorunderline = fg | bg << 4;
     940:         break;
     941:           case 3:
     942:         colorstatus = fg | bg << 4;
     943:         break;
     944:           case 4:
     945:         colorhelp = fg | bg << 4;
     946:         break;
     947:           default:
     948:         printf("%s - invalid\n",cmdbuf);
     949:         return(-9);
     950:         break;
     951:         }
     952:         scrninitialised = 0;
     953:         }
     954:     return(success = 1);
     955:
     956:       case XYTCUR:          /* SET TERMINAL CURSOR */
     957:     if ((x = cmkey(ttycurtab,ncursors,"","underline",xxstring)) < 0)
     958:       return(x);
     959:     if ((y = cmcfm()) < 0) return(y);
     960:         tt_cursor = x;
     961:     return(success = 1);
     962:
     963:       case XYTTYP:          /* SET TERMINAL TYPE */
     964:     if ((x = cmkey(ttyptab,nttyp,"","vt102",xxstring)) < 0) return(x);
     965:     if ((y = cmcfm()) < 0) return(y);
     966:     tt_type = x;
     967:     return(success = 1);
     968:
     969:       case XYTARR:          /* SET TERMINAL ARROW-KEYS */
     970:     if ((x = cmkey(akmtab,2,"","",xxstring)) < 0) return(x);
     971:     if ((y = cmcfm()) < 0) return(y);
     972:     tt_arrow = x;           /* 0 = application, 1 = cursor */
     973:     return(success = 1);
     974:
     975:       case XYTKPD:          /* SET TERMINAL KEYPAD-MODE */
     976:     if ((x = cmkey(kpmtab,2,"","",xxstring)) < 0) return(x);
     977:     if ((y = cmcfm()) < 0) return(y);
     978:     tt_keypad = x;          /* 0 = application, 1 = numeric */
     979:     return(success = 1);
     980:
     981:       case XYTWRP:          /* SET TERMINAL WRAP */
     982:     seton(&tt_wrap);
     983:     return(success = 1);
     984: #endif /* OS2 */
     985:
     986: #ifndef NOCSETS
     987:       case XYTCS:           /* SET TERMINAL CHARACTER-SET */
     988:     /* set terminal character-set <remote> <local> */
     989:     if ((x = cmkey(ttcstab,ntermc,
     990:                "remote terminal character-set","",xxstring)) < 0)
     991:       return(x);
     992:     if (x == FC_TRANSP) {       /* TRANSPARENT? */
     993:         if ((x = cmcfm()) < 0) return(x); /* Confirm the command */
     994:         tcsr = tcsl = FC_USASCII;   /* Make them both the same */
     995:         return(success = 1);
     996:     }
     997:
     998: /* Not transparent, so get local set to translate it into */
     999:
    1000:     s = "";             /* Make current file char set */
    1001:     for (y = 0; y <= nfilc; y++)    /* be the default... */
    1002:       if (fcstab[y].kwval == fcharset) {
    1003:           s = fcstab[y].kwd;
    1004:           break;
    1005:         }
    1006:     if ((y = cmkey(fcstab,nfilc,
    1007:                "local character-set",s,xxstring)) < 0)
    1008:       return(y);
    1009:     if ((z = cmcfm()) < 0) return(z); /* Confirm the command */
    1010:     tcsr = x;           /* Remote character set */
    1011:     tcsl = y;           /* Local character set */
    1012:     return(success = 1);
    1013: #endif /* NOCSETS */
    1014:
    1015:       case XYTEC:           /* SET TERMINAL ECHO */
    1016:     if ((x = cmkey(rltab,nrlt,"which side echos during CONNECT",
    1017:                "remote", xxstring)) < 0) return(x);
    1018:     if ((y = cmcfm()) < 0) return(y);
    1019:     duplex = x;
    1020:     return(success = 1);
    1021:
    1022:       case XYTCRD:          /* SET TERMINAL CR-DISPLAY */
    1023:     if ((x = cmkey(crdtab,2,"", "normal", xxstring)) < 0) return(x);
    1024:     if ((y = cmcfm()) < 0) return(y);
    1025:     tt_crd = x;
    1026:     return(success = 1);
    1027:
    1028:       default:              /* Shouldn't get here. */
    1029:     return(-2);
    1030:     }
    1031: #endif /* MAC */
    1032: }
    1033:
    1034: int                 /* SET SEND/RECEIVE */
    1035: setsr(xx, rmsflg) int xx; int rmsflg; {
    1036:     if (xx == XYRECV)
    1037:         strcpy(line,"Parameter for inbound packets");
    1038:     else
    1039:         strcpy(line,"Parameter for outbound packets");
    1040:
    1041:     if (rmsflg) {
    1042:     if ((y = cmkey(rsrtab,nrsrtab,line,"",xxstring)) < 0) {
    1043:         if (y == -3) {
    1044:         printf("?Remote receive parameter required\n");
    1045:         return(-9);
    1046:         } else return(y);
    1047:     }
    1048:     } else {
    1049:     if ((y = cmkey(srtab,nsrtab,line,"",xxstring)) < 0) return(y);
    1050:     }
    1051:     switch (y) {
    1052:
    1053:       case XYEOL:
    1054:     y = cmnum("Decimal ASCII code for packet terminator","13",10,&x,
    1055:           xxstring);
    1056:     if ((y = setcc(&z,x,y)) < 0) return(y);
    1057:     if (xx == XYRECV) eol = z; else seol = z;
    1058:     return(success = y);
    1059:
    1060:       case XYLEN:
    1061:     y = cmnum("Maximum number of characters in a packet","90",10,&x,
    1062:           xxstring);
    1063:     if (xx == XYRECV) {     /* Receive... */
    1064:         if ((y = setnum(&z,x,y,maxrps)) < 0)
    1065:           return(y);
    1066:         if (z < 10) {
    1067:         printf("Sorry, 10 is the minimum\n");
    1068:         return(-9);
    1069:         }
    1070:         if (rmsflg) {
    1071:         tp = tmpbuf;
    1072:         sprintf(tp,"%d",z);
    1073:         sstate = setgen('S', "401", tp, "");
    1074:         return((int) sstate);
    1075:         } else {
    1076:         if (z > MAXRP) z = MAXRP;
    1077:         y = adjpkl(z,wslotr,bigrbsiz);
    1078:         if (y != z) {
    1079:             urpsiz = y;
    1080:             if (
    1081: #ifndef NOSPL
    1082:             cmdlvl == 0
    1083: #else
    1084:             tlevel < 0
    1085: #endif /* NOSPL */
    1086:             )
    1087:               if (msgflg) printf(
    1088: " Adjusting receive packet-length to %d for %d window slots\n",
    1089:              y, wslotr);
    1090:         }
    1091:         urpsiz = y;
    1092:         rpsiz =  (y > 94) ? 94 : y;
    1093:         }
    1094:     } else {            /* Send... */
    1095:         if ((y = setnum(&z,x,y,maxsps)) < 0)
    1096:           return(y);
    1097:         if (z < 10) {
    1098:         printf("Sorry, 10 is the minimum\n");
    1099:         return(-9);
    1100:         }
    1101:         if (z > MAXSP) z = MAXSP;
    1102:         spsiz = z;          /* Set it */
    1103:         y = adjpkl(spsiz,wslotr,bigsbsiz);
    1104:         if (y != spsiz &&
    1105: #ifndef NOSPL
    1106:         cmdlvl == 0
    1107: #else
    1108:         tlevel < 0
    1109: #endif /* NOSPL */
    1110:         )
    1111:           if (msgflg)
    1112:         printf("Adjusting packet size to %d for %d window slots\n",
    1113:              y,wslotr);
    1114:         spsiz = spmax = spsizr = y; /* Set it and flag that it was set */
    1115:         spsizf = 1;         /* to allow overriding Send-Init. */
    1116:     }
    1117:     if (pflag &&
    1118: #ifndef NOSPL
    1119:         cmdlvl == 0
    1120: #else
    1121:         tlevel < 0
    1122: #endif /* NOSPL */
    1123:         ) {
    1124:         if (z > 94 && msgflg) {
    1125:         printf("Extended-length packets requested.\n");
    1126:         if (bctr < 2 && z > 200) printf("\
    1127: Remember to SET BLOCK 2 or 3 for long packets.\n");
    1128:         }
    1129:         if (speed <= 0L) speed = ttgspd();
    1130: #ifdef COMMENT
    1131: /*
    1132:   Kermit does this now itself.
    1133: */
    1134:         if (speed <= 0L && z > 200 && msgflg) {
    1135:         printf("\
    1136: Make sure your timeout interval is long enough for %d-byte packets.\n",z);
    1137:         }
    1138: #endif /* COMMENT */
    1139:     }
    1140:     return(success = y);
    1141:
    1142:       case XYMARK:
    1143:     y = cmnum("Code for packet-start character","1",10,&x,xxstring);
    1144: #ifdef UNIX
    1145: /*
    1146:   Printable start-of-packet works for UNIX and VMS only!
    1147: */
    1148:     if ((y = setnum(&z,x,y,126)) < 0) return(y);
    1149: #else
    1150: #ifdef VMS
    1151:     if ((y = setnum(&z,x,y,126)) < 0) return(y);
    1152: #else
    1153:     if ((y = setcc(&z,x,y)) < 0) return(y);
    1154: #endif /* VMS */
    1155: #endif /* UNIX */
    1156:     if (xx == XYRECV) stchr = z; else mystch = z;
    1157:     return(success = y);
    1158:
    1159:
    1160:       case XYNPAD:          /* PADDING */
    1161:     y = cmnum("How many padding characters for inbound packets","0",10,&x,
    1162:           xxstring);
    1163:     if ((y = setnum(&z,x,y,94)) < 0) return(y);
    1164:     if (xx == XYRECV) mypadn = z; else npad = z;
    1165:     return(success = y);
    1166:
    1167:       case XYPADC:          /* PAD-CHARACTER */
    1168:     y = cmnum("Decimal ASCII code for packet padding character","0",10,&x,
    1169:           xxstring);
    1170:     if ((y = setcc(&z,x,y)) < 0) return(y);
    1171:     if (xx == XYRECV) mypadc = z; else padch = z;
    1172:     return(success = y);
    1173:
    1174:       case XYTIMO:          /* TIMEOUT */
    1175:     if (xx == XYRECV) {
    1176:         char buf[16];       /* Construct default */
    1177:         sprintf(buf,"%d",URTIME);
    1178:         y = cmnum("Packet timeout interval",buf,10,&x,xxstring);
    1179:         if ((y = setnum(&z,x,y,94)) < 0) return(y);
    1180:
    1181:         if (rmsflg) {       /* REMOTE SET RECEIVE TIMEOUT */
    1182:         tp = tmpbuf;        /*   Tell Kermit server what */
    1183:         sprintf(tp,"%d",z); /*   timeout to ask me to use. */
    1184:         sstate = setgen('S', "402", tp, "");
    1185:         return((int) sstate);
    1186:         } else {            /* SET RECEIVE TIMEOUT */
    1187:         pkttim = z;     /*   Value to put in my negotiation */
    1188:         }               /*   packet for other Kermit to use */
    1189:
    1190:     } else {            /* SET SEND TIMEOUT */
    1191:         y = cmnum("Packet timeout interval","",10,&x,xxstring);
    1192:         if (y == -3) {      /* They cancelled a previous */
    1193:         x = DMYTIM;     /* SET SEND command, so restore */
    1194:         y = 0;          /* the default */
    1195:         timef = 0;      /* and turn off the override flag */
    1196:         } else {            /* They gave a number */
    1197:         timef = 1;      /* so turn on the override flag */
    1198:         }
    1199:         if ((y = setnum(&z,x,y,94)) < 0)
    1200:           return(y);
    1201:         timint = rtimo = z;     /* Override value for me to use */
    1202:     }
    1203:     return(success = 1);
    1204:
    1205:       default:
    1206:     return(-2);
    1207:     }                   /* End of SET SEND/RECEIVE... */
    1208: }
    1209:
    1210: #ifndef NOXMIT
    1211: int
    1212: setxmit() {
    1213:     if ((y = cmkey(xmitab,nxmit,"","",xxstring)) < 0) return(y);
    1214:     switch (y) {
    1215:       case XMITE:           /* EOF */
    1216:     y = cmtxt("Characters to send at end of file,\n\
    1217:  Use backslash codes for control characters","",&s,xxstring);
    1218:     if (y < 0) return(y);
    1219:     if ((int)strlen(s) > XMBUFL) {
    1220:         printf("?Too many characters, %d maximum\n",XMBUFL);
    1221:         return(-2);
    1222:     }
    1223:     strcpy(xmitbuf,s);
    1224:     return(success = 1);
    1225:
    1226:       case XMITF:           /* Fill */
    1227:     y = cmnum("Numeric code for blank-line fill character","0",10,&x,
    1228:           xxstring);
    1229:     if ((y = setnum(&z,x,y,127)) < 0) return(y);
    1230:     xmitf = z;
    1231:     return(success = 1);
    1232:       case XMITL:           /* Linefeed */
    1233:         return(success = seton(&xmitl));
    1234:       case XMITS:           /* Locking-Shift */
    1235:         return(success = seton(&xmits));
    1236:       case XMITP:           /* Prompt */
    1237:     y = cmnum("Numeric code for host's prompt character, 0 for none",
    1238:           "10",10,&x,xxstring);
    1239:     if ((y = setnum(&z,x,y,127)) < 0) return(y);
    1240:     xmitp = z;
    1241:     return(success = 1);
    1242:       case XMITX:           /* Echo */
    1243:         return(success = seton(&xmitx));
    1244:       case XMITW:           /* Pause */
    1245:     y = cmnum("Number of milliseconds to pause between binary characters\n\
    1246: or text lines during transmission","0",10,&x,xxstring);
    1247:     if ((y = setnum(&z,x,y,1000)) < 0) return(y);
    1248:     xmitw = z;
    1249:     return(success = 1);
    1250:       default:
    1251:     return(-2);
    1252:     }
    1253: }
    1254: #endif /* NOXMIT */
    1255:
    1256: /*  D O R M T  --  Do a remote command  */
    1257:
    1258: #ifdef ATTSV
    1259: #ifndef aegis
    1260: #ifndef datageneral
    1261: #define CK_NEED_SIG
    1262: #endif /* datageneral */
    1263: #endif /* aegis */
    1264: #endif /* ATTSV */
    1265:
    1266: VOID rmsg() {
    1267:     if (pflag)
    1268:       printf(
    1269: #ifdef CK_NEEDSIG
    1270:
    1271:        " Type your escape character, %s, followed by X or E to cancel.\n",
    1272:        dbchr(escape)
    1273: #else
    1274:        " Press the X or E key to cancel.\n"
    1275: #endif /* CK_NEEDSIG */
    1276:       );
    1277: }
    1278:
    1279: int
    1280: dormt(xx) int xx; {
    1281:     int x, y, retcode;
    1282:     char *s, sbuf[50], *s2;
    1283:
    1284:
    1285:     if (xx < 0) return(xx);
    1286:
    1287:     if (xx == XZSET) {          /* REMOTE SET */
    1288:     if ((y = cmkey(rmstab,nrms,"","",xxstring)) < 0) {
    1289:         if (y == -3) {
    1290:         printf("?Parameter name required\n");
    1291:         return(-9);
    1292:         } else return(y);
    1293:     }
    1294:     return(doprm(y,1));
    1295:     }
    1296:
    1297:     switch (xx) {           /* Others... */
    1298:
    1299: case XZCWD:             /* CWD */
    1300:     if ((x = cmtxt("Remote directory name","",&s,xxstring)) < 0) return(x);
    1301:     debug(F111,"XZCWD: ",s,x);
    1302:     *sbuf = NUL;
    1303:     s2 = sbuf;
    1304:
    1305: /* The following is commented out, because there is practically no */
    1306: /* computer in the world that requires a password for directory changing. */
    1307: /* (The DEC-20 was the only one, and they're mostly all gone.) */
    1308: #ifdef DIRPWDPR
    1309:     if (*s != NUL) {            /* If directory name given, */
    1310:                     /* get password on separate line. */
    1311:         if (tlevel > -1) {      /* From take file... */
    1312:
    1313:         if (fgets(sbuf,50,tfile[tlevel]) == NULL)
    1314:             fatal("take file ends prematurely in 'remote cwd'");
    1315:         debug(F110," pswd from take file",s2,0);
    1316:         for (x = (int)strlen(sbuf);
    1317:              x > 0 && (sbuf[x-1] == NL || sbuf[x-1] == CR);
    1318:          x--)
    1319:         sbuf[x-1] = '\0';
    1320:
    1321:         } else {            /* From terminal... */
    1322:
    1323:         printf(" Password: ");      /* get a password */
    1324: #ifdef OS2
    1325:         while (((x = isatty(0) ? coninc(0) :
    1326:              getchar()) != NL) && (x != CR)) {     /* with no echo */
    1327: #else
    1328:         while (((x = getchar()) != NL) && (x != CR)) { /* with no echo */
    1329: #endif /* OS2 */
    1330:             if ((x &= 0177) == '?') {
    1331:                 printf("? Password of remote directory\n Password: ");
    1332:             s2 = sbuf;
    1333:             *sbuf = NUL;
    1334:             }
    1335:             else if (x == ESC)  /* Mini command line editor... */
    1336:                 putchar(BEL);
    1337:         else if (x == BS || x == 0177)
    1338:             s2--;
    1339:         else if (x == 025) {    /* Ctrl-U */
    1340:             s2 = sbuf;
    1341:             *sbuf = NUL;
    1342:         }
    1343:             else
    1344:             *s2++ = x;
    1345:             }
    1346:         *s2 = NUL;
    1347:         putchar('\n');
    1348:         }
    1349:         s2 = sbuf;
    1350:     } else s2 = "";
    1351: #endif /* DIRPWDPR */
    1352:
    1353:     debug(F110," password",s2,0);
    1354:     sstate = setgen('C',s,s2,"");
    1355:     retcode = 0;
    1356:     break;
    1357:
    1358: case XZDEL:             /* Delete */
    1359:     if ((x = cmtxt("Name of remote file(s) to delete","",&s,xxstring)) < 0) {
    1360:     if (x == -3) {
    1361:         printf("?Name of remote file(s) required\n");
    1362:         return(-9);
    1363:     } else return(x);
    1364:     }
    1365:     if (local) ttflui();        /* If local, flush tty input buffer */
    1366:     retcode = sstate = rfilop(s,'E');
    1367:     break;
    1368:
    1369: case XZDIR:             /* Directory */
    1370:     if ((x = cmtxt("Remote directory or file specification","",&s,
    1371:            xxstring)) < 0)
    1372:         return(x);
    1373:     if (local) ttflui();        /* If local, flush tty input buffer */
    1374:     rmsg();
    1375:     retcode = sstate = setgen('D',s,"","");
    1376:     break;
    1377:
    1378: case XZHLP:             /* Help */
    1379:     if ((x = cmcfm()) < 0) return(x);
    1380:     sstate = setgen('H',"","","");
    1381:     retcode = 0;
    1382:     break;
    1383:
    1384: #ifndef NOPUSH
    1385: case XZHOS:             /* Host */
    1386:     if ((x = cmtxt("Command for remote system","",&cmarg,xxstring)) < 0)
    1387:       return(x);
    1388:     if ((int)strlen(cmarg) < 1)  {
    1389:     if (x == -3) {
    1390:         printf("?Remote host command required\n");
    1391:         return(-9);
    1392:     } else return(x);
    1393:     }
    1394:     rmsg();
    1395:     retcode = sstate = 'c';
    1396:     break;
    1397: #endif /* NOPUSH */
    1398:
    1399: #ifndef NOFRILLS
    1400: case XZKER:
    1401:     if ((x = cmtxt("Command for remote Kermit","",&cmarg,xxstring)) < 0)
    1402:       return(x);
    1403:     if ((int)strlen(cmarg) < 1)  {
    1404:     if (x == -3) {
    1405:         printf("?Remote Kermit command required\n");
    1406:         return(-9);
    1407:     } else return(x);
    1408:     }
    1409:     retcode = sstate = 'k';
    1410:     rmsg();
    1411:     break;
    1412:
    1413: case XZLGI: {               /* Login */
    1414:     char *p1, *p2, *p3;
    1415:     if ((x = cmfld("User ID","",&s,xxstring)) < 0) return(x);
    1416:     if ((p1 = malloc((int)strlen(s) + 1)) == NULL) {
    1417:     printf("Internal error: malloc\n");
    1418:     return(-2);
    1419:     } else strcpy(p1,s);
    1420:     if ((x = cmfld("Password","",&s,xxstring)) < 0) return(x);
    1421:     if ((p2 = malloc((int)strlen(s) + 1)) == NULL) {
    1422:     printf("Internal error: malloc\n");
    1423:     return(-2);
    1424:     } else strcpy(p2,s);
    1425:     if ((x = cmtxt("Account or carriage return","",
    1426:            &s,xxstring)) < 0 && x != -3)
    1427:     return(x);
    1428:     if ((p3 = malloc((int)strlen(s) + 1)) == NULL) {
    1429:     printf("Internal error: malloc\n");
    1430:     return(-2);
    1431:     } else strcpy(p3,s);
    1432:     sstate = setgen('I',p1,p2,p3);
    1433:     if (p3) free(p3);
    1434:     if (p2) free(p2);
    1435:     if (p1) free(p1);
    1436:     retcode = 0;
    1437:     break;
    1438: }
    1439:
    1440: case XZLGO:             /* Logout */
    1441:     if ((x = cmcfm()) < 0) return(x);
    1442:     sstate = setgen('I',"","","");
    1443:     retcode = 0;
    1444:     break;
    1445:
    1446: case XZPRI:             /* Print */
    1447:     if (!atdiso || !atcapr) {       /* Disposition attribute off? */
    1448:     printf("?Disposition Attribute is Off\n");
    1449:     return(-2);
    1450:     }
    1451:     cmarg = "";
    1452:     cmarg2 = "";
    1453:     if ((x = cmifi("Local file(s) to print on remote printer","",&s,&y,
    1454:            xxstring)) < 0) {
    1455:     if (x == -3) {
    1456:         printf("?Name of local file(s) required\n");
    1457:         return(-9);
    1458:     }
    1459:     return(x);
    1460:     }
    1461:     strcpy(line,s);         /* Make a safe copy of filename */
    1462:     *optbuf = NUL;          /* Wipe out any old options */
    1463:     if ((x = cmtxt("Options for remote print command","",&s,xxstring)) < 0)
    1464:       return(x);
    1465:     strcpy(optbuf,s);           /* Make a safe copy of options */
    1466:     if ((int)strlen(optbuf) > 94) { /* Make sure this is legal */
    1467:     printf("?Option string too long\n");
    1468:     return(-9);
    1469:     }
    1470:     nfils = -1;             /* Expand file list internally */
    1471:     cmarg = line;           /* Point to file list. */
    1472:     rprintf = 1;            /* REMOTE PRINT modifier for SEND */
    1473:     sstate = 's';           /* Set start state to SEND */
    1474:     if (local) displa = 1;
    1475:     retcode = 0;
    1476:     break;
    1477: #endif /* NOFRILLS */
    1478:
    1479: case XZSPA:             /* Space */
    1480:     if ((x = cmtxt("Confirm, or remote directory name","",&s,xxstring)) < 0)
    1481:       return(x);
    1482:     retcode = sstate = setgen('U',s,"","");
    1483:     break;
    1484:
    1485: #ifndef NOFRILLS
    1486: case XZTYP:             /* Type */
    1487:     if ((x = cmtxt("Remote file specification","",&s,xxstring)) < 0)
    1488:       return(x);
    1489:     if ((int)strlen(s) < 1) {
    1490:     printf("?Remote filename required\n");
    1491:         return(-9);
    1492:     }
    1493:     rmsg();
    1494:     retcode = sstate = rfilop(s,'T');
    1495:     break;
    1496: #endif /* NOFRILLS */
    1497:
    1498: #ifndef NOFRILLS
    1499: case XZWHO:
    1500:     if ((x = cmtxt("Remote user name, or carriage return","",&s,xxstring)) < 0)
    1501:         return(x);
    1502:     retcode = sstate = setgen('W',s,"","");
    1503:     break;
    1504: #endif /* NOFRILLS */
    1505:
    1506: default:
    1507:         if ((x = cmcfm()) < 0) return(x);
    1508:         printf("?Not implemented - %s\n",cmdbuf);
    1509:         return(-2);
    1510:     }
    1511:     if (local) ttflui();        /* If local, flush tty input buffer */
    1512:     return(retcode);
    1513: }
    1514:
    1515:
    1516: /*  R F I L O P  --  Remote File Operation  */
    1517:
    1518: CHAR
    1519: #ifdef CK_ANSIC
    1520: rfilop(char * s, char t)
    1521: #else
    1522: rfilop(s,t) char *s, t;
    1523: #endif /* CK_ANSIC */
    1524: /* rfilop */ {
    1525:     if (*s == NUL) {
    1526:     printf("?File specification required\n");
    1527:     return((CHAR) 0);
    1528:     }
    1529:     debug(F111,"rfilop",s,t);
    1530:     return(setgen(t,s,"",""));
    1531: }
    1532:
    1533: #ifdef SUNX25
    1534: int
    1535: setx25() {
    1536:     if ((y = cmkey(x25tab,nx25,"X.25 call options","",xxstring)) < 0)
    1537:       return(y);
    1538:     switch (y) {
    1539:       case XYUDAT:
    1540:     if ((z = cmkey(onoff,2,"X.25 call user data","",xxstring))
    1541:         < 0) return(z);
    1542:     if (z == 0) {
    1543:         if ((z = cmcfm()) < 0) return(z);
    1544:         cudata = 0;             /* disable call user data */
    1545:         return (success = 1);
    1546:     }
    1547:     if ((x = cmtxt("X.25 call user data string","",&s,xxstring)) < 0)
    1548:       return(x);
    1549:     if ((int)strlen(s) == 0) {
    1550:         return (-3);
    1551:     } else if ((int)strlen(s) > MAXCUDATA) {
    1552:         printf("?The length must be > 0 and <= %d\n",MAXCUDATA);
    1553:         return(-2);
    1554:     }
    1555:     if ((y = cmcfm()) < 0) return(y);
    1556:     strcpy(udata,s);
    1557:     cudata = 1;         /* X.25 call user data specified */
    1558:     return (success = 1);
    1559:       case XYCLOS:
    1560:     if ((z = cmkey(onoff,2,"X.25 closed user group call","",xxstring))
    1561:         < 0) return(z);
    1562:     if (z == 0) {
    1563:         if ((z = cmcfm()) < 0) return(z);
    1564:         closgr = -1;        /* disable closed user group */
    1565:         return (success = 1);
    1566:     }
    1567:     if ((y = cmnum("0 <= cug index >= 99","",10,&x,xxstring)) < 0)
    1568:       return(y);
    1569:     if (x < 0 || x > 99) {
    1570:         printf("?The choices are 0 <= cug index >= 99\n");
    1571:         return(-2);
    1572:     }
    1573:     if ((y = cmcfm()) < 0) return(y);
    1574:     closgr = x;         /* closed user group selected */
    1575:     return (success = 1);
    1576:
    1577:       case XYREVC:
    1578:     if((z = cmkey(onoff,2,"X.25 reverse charge call","",xxstring)) < 0)
    1579:       return(z);
    1580:     if ((x = cmcfm()) < 0) return(x);
    1581:     revcall = z;
    1582:     return (success = 1);
    1583:     }
    1584: }
    1585:
    1586: int
    1587: setpadp() {
    1588:     if ((y = cmkey(padx3tab,npadx3,"PAD X.3 parameter name","",xxstring)) < 0)
    1589:       return(y);
    1590:     x = y;
    1591:     switch (x) {
    1592:       case PAD_BREAK_CHARACTER:
    1593:     if ((y = cmnum("PAD break character value","",10,&z,xxstring)) < 0)
    1594:       return(y);
    1595:     if ((y = cmcfm()) < 0) return(y);
    1596:     break;
    1597:       case PAD_ESCAPE:
    1598:     if ((y = cmnum("PAD escape","",10,&z,xxstring)) < 0) return(y);
    1599:     if (z != 0 && z != 1) {
    1600:         printf("?The choices are 0 or 1\n");
    1601:         return(-2);
    1602:     }
    1603:     if ((y = cmcfm()) < 0) return(y);
    1604:     break;
    1605:       case PAD_ECHO:
    1606:     if ((y = cmnum("PAD echo","",10,&z,xxstring)) < 0) return(y);
    1607:     if (z != 0 && z != 1) {
    1608:         printf("?The choices are 0 or 1\n");
    1609:         return(-2);
    1610:     }
    1611:     if ((y = cmcfm()) < 0) return(y);
    1612:     break;
    1613:       case PAD_DATA_FORWARD_CHAR:
    1614:     if ((y = cmnum("PAD data forward char","",10,&z,xxstring)) < 0)
    1615:       return(y);
    1616:     if (z != 0 && z != 2) {
    1617:         printf("?The choices are 0 or 2\n");
    1618:         return(-2);
    1619:     }
    1620:     if ((y = cmcfm()) < 0) return(y);
    1621:     break;
    1622:       case PAD_DATA_FORWARD_TIMEOUT:
    1623:     if ((y = cmnum("PAD data forward timeout","",10,&z,xxstring)) < 0)
    1624:         return(y);
    1625:     if (z < 0 || z > 255) {
    1626:         printf("?The choices are 0 or 1 <= timeout <= 255\n");
    1627:         return(-2);
    1628:     }
    1629:     if ((y = cmcfm()) < 0) return(y);
    1630:     break;
    1631:       case PAD_FLOW_CONTROL_BY_PAD:
    1632:     if ((y = cmnum("PAD pad flow control","",10,&z,xxstring)) < 0)
    1633:       return(y);
    1634:     if (z != 0 && z != 1) {
    1635:         printf("?The choices are 0 or 1\n");
    1636:         return(-2);
    1637:     }
    1638:     if ((y = cmcfm()) < 0) return(y);
    1639:     break;
    1640:       case PAD_SUPPRESSION_OF_SIGNALS:
    1641:     if ((y = cmnum("PAD service","",10,&z,xxstring)) < 0) return(y);
    1642:     if (z != 0 && z != 1) {
    1643:         printf("?The choices are 0 or 1\n");
    1644:         return(-2);
    1645:     }
    1646:     if ((y = cmcfm()) < 0) return(y);
    1647:     break;
    1648:
    1649:       case PAD_BREAK_ACTION:
    1650:     if ((y = cmnum("PAD break action","",10,&z,xxstring)) < 0) return(y);
    1651:     if (z != 0 && z != 1 && z != 2 && z != 5 && z != 8 && z != 21) {
    1652:         printf("?The choices are 0, 1, 2, 5, 8 or 21\n");
    1653:         return(-2);
    1654:     }
    1655:     if ((y = cmcfm()) < 0) return(y);
    1656:     break;
    1657:
    1658:       case PAD_SUPPRESSION_OF_DATA:
    1659:     if ((y = cmnum("PAD data delivery","",10,&z,xxstring)) < 0) return(y);
    1660:     if (z != 0 && z != 1) {
    1661:         printf("?The choices are 0 or 1\n");
    1662:         return(-2);
    1663:     }
    1664:     if ((y = cmcfm()) < 0) return(y);
    1665:     break;
    1666:
    1667:       case PAD_PADDING_AFTER_CR:
    1668:     if ((y = cmnum("PAD crpad","",10,&z,xxstring)) < 0) return(y);
    1669:     if (z < 0 || z > 7) {
    1670:         printf("?The choices are 0 or 1 <= crpad <= 7\n");
    1671:         return(-2);
    1672:     }
    1673:     if ((y = cmcfm()) < 0) return(y);
    1674:     break;
    1675:
    1676:       case PAD_LINE_FOLDING:
    1677:     if ((y = cmnum("PAD linefold","",10,&z,xxstring)) < 0) return(y);
    1678:     if (z < 0 || z > 255) {
    1679:         printf("?The choices are 0 or 1 <= linefold <= 255\n");
    1680:         return(-2);
    1681:     }
    1682:     if ((y = cmcfm()) < 0) return(y);
    1683:     break;
    1684:
    1685:       case PAD_LINE_SPEED:
    1686:     if ((y = cmnum("PAD baudrate","",10,&z,xxstring)) < 0) return(y);
    1687:     if (z < 0 || z > 18) {
    1688:         printf("?The choices are 0 <= baudrate <= 18\n");
    1689:         return(-2);
    1690:     }
    1691:     if ((y = cmcfm()) < 0) return(y);
    1692:     break;
    1693:
    1694:       case PAD_FLOW_CONTROL_BY_USER:
    1695:     if ((y = cmnum("PAD terminal flow control","",10,&z,xxstring)) < 0)
    1696:         return(y);
    1697:     if (z != 0 && z != 1) {
    1698:         printf("?The choices are 0 or 1\n");
    1699:         return(-2);
    1700:     }
    1701:     if ((y = cmcfm()) < 0) return(y);
    1702:     break;
    1703:
    1704:       case PAD_LF_AFTER_CR:
    1705:     if ((y = cmnum("PAD crpad","",10,&z,xxstring)) < 0) return(y);
    1706:     if (z < 0 || z == 3 || z > 7) {
    1707:         printf("?The choices are 0, 1, 2, 4, 5, 6 or 7\n");
    1708:         return(-2);
    1709:     }
    1710:     if ((y = cmcfm()) < 0) return(y);
    1711:     break;
    1712:
    1713:       case PAD_PADDING_AFTER_LF:
    1714:     if ((y = cmnum("PAD lfpad","",10,&z,xxstring)) < 0) return(y);
    1715:     if (z < 0 || z > 7) {
    1716:         printf("?The choices are 0 or 1 <= lfpad <= 7\n");
    1717:         return(-2);
    1718:     }
    1719:     if ((y = cmcfm()) < 0) return(y);
    1720:     break;
    1721:
    1722:       case PAD_EDITING:
    1723:     if ((y = cmnum("PAD edit control","",10,&z,xxstring)) < 0) return(y);
    1724:     if (z != 0 && z != 1) {
    1725:         printf("?The choices are 0 or 1\n");
    1726:         return(-2);
    1727:     }
    1728:     if ((y = cmcfm()) < 0) return(y);
    1729:     break;
    1730:
    1731:       case PAD_CHAR_DELETE_CHAR:
    1732:     if ((y = cmnum("PAD char delete char","",10,&z,xxstring)) < 0)
    1733:         return(y);
    1734:     if (z < 0 || z > 127) {
    1735:         printf("?The choices are 0 or 1 <= chardelete <= 127\n");
    1736:         return(-2);
    1737:     }
    1738:     if ((y = cmcfm()) < 0) return(y);
    1739:     break;
    1740:
    1741:       case PAD_BUFFER_DELETE_CHAR:
    1742:     if ((y = cmnum("PAD buffer delete char","",10,&z,xxstring)) < 0)
    1743:         return(y);
    1744:     if (z < 0 || z > 127) {
    1745:         printf("?The choices are 0 or 1 <= bufferdelte <= 127\n");
    1746:         return(-2);
    1747:     }
    1748:     if ((y = cmcfm()) < 0) return(y);
    1749:     break;
    1750:
    1751:       case PAD_BUFFER_DISPLAY_CHAR:
    1752:     if ((y = cmnum("PAD display line char","",10,&z,xxstring)) < 0)
    1753:         return(y);
    1754:     if (z < 0 || z > 127) {
    1755:         printf("?The choices are 0 or 1 <= displayline <= 127\n");
    1756:         return(-2);
    1757:     }
    1758:     if ((y = cmcfm()) < 0) return(y);
    1759:     break;
    1760:     }
    1761:     padparms[x] = z;
    1762:     return(success = 1);
    1763: }
    1764: #endif /* SUNX25 */
    1765:
    1766: int
    1767: setat(rmsflg) int rmsflg; {
    1768:     int xx;
    1769:     if ((y = cmkey(attrtab,natr,"File Attribute packets","",xxstring)) < 0)
    1770:       return(y);
    1771:     if (y == AT_XALL) {         /* ATTRIBUTES ALL ON or ALL OFF */
    1772:     if ((z = seton(&xx)) < 0) return(z);
    1773:     if (rmsflg) {
    1774:         printf("Sorry, command not available\n");
    1775:         return(-9);
    1776:     } else {
    1777:         atenci = xx;        /* Encoding in */
    1778:         atenco = xx;        /* Encoding out */
    1779:         atdati = xx;        /* Date in */
    1780:         atdato = xx;        /* Date out */
    1781:         atdisi = xx;        /* Disposition in/out */
    1782:         atdiso = xx;
    1783:         atleni = xx;        /* Length in/out (both kinds) */
    1784:         atleno = xx;
    1785:         atblki = xx;        /* Blocksize in/out */
    1786:         atblko = xx;
    1787:         attypi = xx;        /* File type in/out */
    1788:         attypo = xx;
    1789:         atsidi = xx;        /* System ID in/out */
    1790:         atsido = xx;
    1791:         atsysi = xx;        /* System-dependent params in/out */
    1792:         atsyso = xx;
    1793:     }
    1794:     return(z);
    1795:     } else if (y == AT_ALLY || y == AT_ALLN) { /* ATTRIBUTES ON or OFF */
    1796:     if ((x = cmcfm()) < 0) return(x);
    1797:     atcapr = (y == AT_ALLY) ? 1 : 0;
    1798:     if (rmsflg) {
    1799:         sstate = setgen('S', "132", atcapr ? "1" : "0", "");
    1800:         return((int) sstate);
    1801:     } else return(success = 1);
    1802:     }
    1803:     /* Otherwise, it's an individual attribute that wants turning off/on */
    1804:
    1805:     if ((z = cmkey(onoff,2,"","",xxstring)) < 0) return(z);
    1806:     if ((x = cmcfm()) < 0) return(x);
    1807:
    1808: /* There are better ways to do this... */
    1809: /* The real problem is that we're not separating the in and out cases */
    1810: /* and so we have to arbitrarily pick the "in" case, i.e tell the remote */
    1811: /* server to ignore incoming attributes of the specified type, rather */
    1812: /* than telling it not to send them.  The protocol does not (yet) define */
    1813: /* codes for "in-and-out-at-the-same-time". */
    1814:
    1815:     switch(y) {
    1816:       case AT_DISP:
    1817:     if (rmsflg) {
    1818:         sstate = setgen('S', "142", z ? "1" : "0", "");
    1819:         return((int) sstate);
    1820:     }
    1821:     atdisi = atdiso = z; break;
    1822:       case AT_ENCO:
    1823:     if (rmsflg) {
    1824:         sstate = setgen('S', "141", z ? "1" : "0", "");
    1825:         return((int) sstate);
    1826:     }
    1827:     atenci = atenco = z; break;
    1828:       case AT_DATE:
    1829:     if (rmsflg) {
    1830:         sstate = setgen('S', "135", z ? "1" : "0", "");
    1831:         return((int) sstate);
    1832:     }
    1833:     atdati = atdato = z; break;
    1834:       case AT_LENB:
    1835:       case AT_LENK:
    1836:     if (rmsflg) {
    1837:         sstate = setgen('S', "133", z ? "1" : "0", "");
    1838:         return((int) sstate);
    1839:     }
    1840:     atleni = atleno = z; break;
    1841:       case AT_BLKS:
    1842:     if (rmsflg) {
    1843:         sstate = setgen('S', "139", z ? "1" : "0", "");
    1844:         return((int) sstate);
    1845:     }
    1846:     atblki = atblko = z; break;
    1847:       case AT_FTYP:
    1848:     if (rmsflg) {
    1849:         sstate = setgen('S', "134", z ? "1" : "0", "");
    1850:         return((int) sstate);
    1851:     }
    1852:     attypi = attypo = z; break;
    1853:       case AT_SYSI:
    1854:     if (rmsflg) {
    1855:         sstate = setgen('S', "145", z ? "1" : "0", "");
    1856:         return((int) sstate);
    1857:     }
    1858:     atsidi = atsido = z; break;
    1859:       case AT_SYSP:
    1860:     if (rmsflg) {
    1861:         sstate = setgen('S', "147", z ? "1" : "0", "");
    1862:         return((int) sstate);
    1863:     }
    1864:     atsysi = atsyso = z; break;
    1865:       default:
    1866:     printf("?Not available\n");
    1867:     return(-2);
    1868:     }
    1869:     return(1);
    1870: }
    1871:
    1872: #ifndef NOSPL
    1873: int
    1874: setinp() {
    1875:     if ((y = cmkey(inptab,ninp,"","",xxstring)) < 0) return(y);
    1876:     switch (y) {
    1877:       case IN_DEF:          /* SET INPUT DEFAULT-TIMEOUT */
    1878:     z = cmnum("Positive number","",10,&x,xxstring);
    1879:     return(success = setnum(&indef,x,z,94));
    1880:       case IN_TIM:          /* SET INPUT TIMEOUT-ACTION */
    1881:     if ((z = cmkey(intimt,2,"","",xxstring)) < 0) return(z);
    1882:     if ((x = cmcfm()) < 0) return(x);
    1883:     intime = z;
    1884:     return(success = 1);
    1885:       case IN_CAS:          /* SET INPUT CASE */
    1886:     if ((z = cmkey(incast,2,"","",xxstring)) < 0) return(z);
    1887:     if ((x = cmcfm()) < 0) return(x);
    1888:     incase = z;
    1889:     return(success = 1);
    1890:       case IN_ECH:          /* SET INPUT ECHO */
    1891:     return(success = seton(&inecho));
    1892:       case IN_SIL:          /* SET INPUT SILENCE */
    1893:     z = cmnum("Positive number","",10,&x,xxstring);
    1894:     return(success = setnum(&insilence,x,z,-1));
    1895:     }
    1896:     return(0);
    1897: }
    1898: #endif /* NOSPL */
    1899:
    1900: /*
    1901:   setlin -- parse name of and then open a communication device.
    1902:   Call with:
    1903:     xx == XXLINE for a serial (tty) line, XXHOST for a network host,
    1904:     zz == 0 means if user doesn't give a device name, continue current
    1905:             active connection (if any);
    1906:     zz != 0 means if user doesn't give a device name, then close the
    1907:             current connection and restore the default communication device.
    1908: */
    1909: int
    1910: setlin(xx, zz) int xx, zz; {
    1911:     if (xx == XYHOST) {         /* SET HOST <hostname> */
    1912: #ifndef NETCONN
    1913:         printf("?Network connections not supported\n");
    1914:     return(-9);
    1915: #else
    1916:     if (
    1917:         (nettype != NET_DEC) &&
    1918:         (nettype != NET_SX25) &&
    1919:             (nettype != NET_TCPB)) {
    1920:         printf("?Network type not supported\n");
    1921:         return(-9);
    1922:       }
    1923:     if (nettype != NET_TCPB) {  /* Not a TCP/IP connection */
    1924:                     /* Just get a text string */
    1925:         if ((x = cmtxt( zz ?
    1926:    "Network host name,\n or carriage return to close an open connection" :
    1927:    "Network host name,\n or carriage return to resume an open connection",
    1928:                "",&s,xxstring)) < 0)
    1929:           return(x);
    1930:
    1931:     } else {            /* TCP/IP connection... */
    1932:
    1933:         /* Parse for host and service separately. */
    1934:
    1935:         if ((x = cmfld( zz ?
    1936:    "IP host name or number,\n or carriage return to close an open connection" :
    1937:    "IP host name or number,\n or carriage return to resume an open connection",
    1938:                "",&s,xxstring)) < 0) {
    1939:         if (x != -3)        /* Parse error */
    1940:           return(x);        /* return it */
    1941:         else if (!zz)       /* No hostname given */
    1942:           return(1);        /* and none required, */
    1943:         }               /* continue current connection. */
    1944:         if (*s) {           /* If they gave a host name... */
    1945:         strcpy(line,s);     /* make a copy */
    1946:         /* Check for "host:service" */
    1947:         for ( ; (*s != '\0') && (*s != ':'); s++) ;
    1948:
    1949:         /* If no service given, let them type one now. */
    1950:
    1951:         if (!*s) {
    1952:             if ((x = cmfld(
    1953:     "TCP service name or number,\n or carriage return for telnet (23)",
    1954:                    "23",&s,xxstring)) < 0 && x != -3)
    1955:               return(x);
    1956:             if (*s) {       /* If they gave a service, */
    1957:             strcat(line,":"); /* concatenate it to the hostname */
    1958:             strcat(line,s); /* separated by a colon, because */
    1959:             }           /* this is how ttopen() wants it. */
    1960:         }
    1961:         if ((x = cmcfm()) < 0) return(x); /* Confirm the command */
    1962:         s = line;
    1963:         }
    1964:     }
    1965:
    1966:     /* New connection wanted. */
    1967:
    1968:     ttflui();           /* Clear away buffered up junk */
    1969:     ttclos(0);          /* Close old connection, if any */
    1970:     if (oldplex > -1)       /* Restore duplex setting. */
    1971:       duplex = oldplex;
    1972:     if (*s) {           /* They gave a hostname */
    1973:         x = 1;          /* Network connection always local */
    1974:         mdmsav = mdmtyp;        /* Remember old modem type */
    1975:         mdmtyp = -nettype;      /* Special code for network */
    1976:         if (nettype == NET_TCPB) {  /* For TCP/IP telnet connections */
    1977:         oldplex = duplex;   /* Remember previous duplex */
    1978:         duplex = 0;     /* Set full duplex and let */
    1979:       }             /* negotiations change if necessary. */
    1980:     } else {            /* They just said "set host" */
    1981:         if (network && msgflg)
    1982:           printf(" Closing connection\n");
    1983:         s = dftty;          /* So go back to normal */
    1984:         x = dfloc;          /* default tty, location, */
    1985:         network = 0;        /* No more network connection. */
    1986:         duplex = oldplex;       /* Restore old duplex setting. */
    1987:         if (mdmtyp < 0) {       /* Switching from net to async? */
    1988:         if (mdmsav > -1)    /* Restore modem type from last */
    1989:           mdmtyp = mdmsav;  /* SET MODEM command, if any. */
    1990:         else
    1991:           mdmtyp = 0;
    1992:         }
    1993:     }
    1994: #endif /* NETCONN */
    1995:     }
    1996:
    1997: /* Serial tty device, possibly modem, connection... */
    1998:
    1999:     if (xx == XYLINE) {         /* SET LINE */
    2000: #ifdef OS2              /* or SET PORT */
    2001:     if ((x = cmkey(os2devtab,nos2dev,"serial communication device name",
    2002:                "com1", xxstring)) < 0) {
    2003:         debug(F101,"OS2 SET PORT x","",x);
    2004:         if (x != -9) return(x);
    2005:         s = atxbuf;         /* Doesn't match keyword */
    2006:         if (*s == '_') s++;     /* Secret notation for file handle */
    2007:         else return(-9);
    2008:     } else if (x >= 1 && x <= 8) {  /* Regular COM port */
    2009:         s = os2devtab[x+7].kwd; /* Use its real name */
    2010:     } else s = atxbuf;      /* Something else, believe it */
    2011: #else
    2012:     if ((x = cmtxt("Communication device name",dftty,&s,xxstring)) < 0)
    2013:       return(x);
    2014: #endif /* OS2 */
    2015:
    2016:     if (local) ttflui();        /* Clear away buffered up junk */
    2017:     ttclos(0);          /* Close old line, if any was open */
    2018:     if (*s) {           /* They gave a device name */
    2019:         x = -1;         /* Let ttopen decide about it */
    2020:     } else {            /* They just said "set line" */
    2021:         s = dftty;          /* so go back to normal tty */
    2022:         x = dfloc;          /* and mode. */
    2023:     }
    2024:     if (mdmtyp < 0) {       /* Switching from net to async? */
    2025:         if (mdmsav > -1)        /* Restore modem type from last */
    2026:           mdmtyp = mdmsav;      /* SET MODEM command, if any. */
    2027:         else
    2028:           mdmtyp = 0;
    2029:         mdmsav = -1;
    2030:     }
    2031:     if (oldplex > -1) {     /* Restore previous duplex setting. */
    2032:         duplex = oldplex;
    2033:         oldplex = -1;
    2034:     }
    2035:     network = 0;            /* No more network. */
    2036:     }
    2037: #ifdef COMMENT
    2038: /*
    2039:   The following is removed, not so much because it's a horrible hack, but
    2040:   because it only works if the SET FLOW command was given *before* the SET
    2041:   LINE command, whereas normally these commands can be given in any order.
    2042: */
    2043: #ifdef NEXT
    2044: /*
    2045:   This is a horrible hack, but it's nice for users.  On the NeXT, you select
    2046:   RTS/CTS hardware flow control not by system calls, but by referring to the
    2047:   device with a different name.  If the user has asked for RTS/CTS flow
    2048:   control on a NeXT, but used the non-RTS/CTS device name in the SET LINE
    2049:   command, we make the appropriate substitute here.  I wonder how much bigger
    2050:   this section of code will grow as the years go by...
    2051: */
    2052:     if ((flow == FLO_RTSC) &&       /* RTS/CTS flow control selected */
    2053:     strcmp(s,dftty)) {      /*  ...on external port? */
    2054:     y = strlen(s);          /* Yes, insert "f" as next-to-last */
    2055:     if (s[y-2] != 'f') {        /* character in device name if not */
    2056:         strcpy(line,s);     /* already there... */
    2057:         line[y] = line[y-1];    /* So /dev/cua => /dev/cufa, etc. */
    2058:         line[y-1] = 'f';
    2059:         line[y+1] = '\0';
    2060:         s = line;
    2061:     }
    2062:     }
    2063: #endif /* NEXT */
    2064: #endif /* COMMENT */
    2065:
    2066:     if ((y = ttopen(s,&x,mdmtyp,cdtimo)) < 0 ) { /* Open the new line */
    2067:     if (y == -2) {
    2068:         printf("?Timed out, no carrier.\n");
    2069:         printf("Try SET CARRIER OFF and SET LINE again, or else\n");
    2070:         printf("SET MODEM, SET LINE, and then DIAL.\n");
    2071:     } else if (y == -3) {
    2072:         printf("Sorry, access to lock denied: %s\n",s);
    2073:     } else if (y == -4) {
    2074:         printf("Sorry, access to device denied: %s\n",s);
    2075:     } else if (y == -5) {
    2076: #ifdef VMS
    2077:         printf("Sorry, device is in use or otherwise unavailable: %s\n",s);
    2078: #else
    2079:         printf("Sorry, device is in use: %s\n",s);
    2080: #endif /* VMS */
    2081:         } else {            /* Other error. */
    2082: #ifndef VMS
    2083:         if (errno) {
    2084:         tp = tmpbuf;
    2085:         sprintf(tp,"Sorry, can't open connection: %s",s);
    2086:         perror(tp);
    2087:         } else
    2088: #endif /* VMS */
    2089:           printf("Sorry, can't open connection: %s\n",s);
    2090:     }
    2091:     local = dfloc;          /* Go back to normal */
    2092: #ifndef MAC
    2093:     strcpy(ttname,dftty);       /* Restore default tty name */
    2094: #endif /* MAC */
    2095:     speed = ttgspd();
    2096:     network = 0;            /* No network connection active */
    2097:     return(success = 0);        /* Return failure */
    2098:     }
    2099:     if (x > -1) local = x;      /* Opened ok, set local/remote. */
    2100:     network = (mdmtyp < 0);     /* Remember connection type. */
    2101: #ifdef TNCODE
    2102:     if (network) tn_init = 0;       /* Say telnet not init'd yet. */
    2103: #endif /* TNCODE */
    2104:     strcpy(ttname,s);           /* Copy name into real place. */
    2105:     speed = ttgspd();           /* Get the current speed. */
    2106:     debug(F111,"set line ",ttname,local);
    2107: #ifdef NETCONN
    2108: #ifdef SUNX25
    2109:     if (nettype == NET_SX25) duplex = 1; /* Duplex half */
    2110: #endif /* SUNX25 */
    2111: #endif /* NETCONN */
    2112:     return(success = 1);
    2113: }
    2114: #endif /* NOICP */

#### Defined functions

dialstr defined in line 524; used 3 times

- in line 520, 554-556(2)

dormt defined in line 1279; used 1 times

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

rfilop defined in line 1518; used 2 times

- in line 1366, 1494

rmsg defined in line 1266; used 4 times

- in line 1374, 1394, 1410, 1493

setat defined in line 1766; used 1 times

- in /usr/src/new/kermit5.188/ckuus3.c line 644

setcc defined in line 503; used 4 times

- in line 1056, 1153, 1170
- in /usr/src/new/kermit5.188/ckuus3.c line 932

setdial defined in line 547; used 1 times

- in /usr/src/new/kermit5.188/ckuus3.c line 893

setfil defined in line 657; used 1 times

- in /usr/src/new/kermit5.188/ckuus3.c line 947

setinp defined in line 1873; used 1 times

- in /usr/src/new/kermit5.188/ckuus3.c line 659

setlin defined in line 1909; used 2 times

- in /usr/src/new/kermit5.188/ckuus3.c line 681
- in /usr/src/new/kermit5.188/ckuusr.c line 1828

setnum defined in line 479; used 17 times

- in line 598, 1064, 1095, 1148-1151(2), 1163, 1179, 1199, 1229, 1239, 1247, 1879, 1894
- in /usr/src/new/kermit5.188/ckuus3.c line 831, 883, 1060, 1245

seton defined in line 463; used 27 times

- in line 552, 595-603(3), 609-612(2), 858, 870, 910-913(2), 982, 1233-1235(2), 1243, 1772, 1891
- in /usr/src/new/kermit5.188/ckuus3.c line 717, 809, 836, 926, 980-981(2), 1095, 1104, 1112-1113(2), 1123

setpadp defined in line 1586; used 1 times

- in /usr/src/new/kermit5.188/ckuus3.c line 630

setsr defined in line 1034; used 1 times

- in /usr/src/new/kermit5.188/ckuus3.c line 1146

settrm defined in line 888; used 1 times

- in /usr/src/new/kermit5.188/ckuus3.c line 1134

setx25 defined in line 1534; used 1 times

- in /usr/src/new/kermit5.188/ckuus3.c line 627

setxmit defined in line 1211; used 1 times

- in /usr/src/new/kermit5.188/ckuus3.c line 1223

#### Defined variables

VOID defined in line 1266; never used
akmtab defined in line 276; used 1 times

- in line 970

attrtab defined in line 417; used 2 times

- in line 435, 1769

colxtab defined in line 178; used 4 times

- in line 190, 842
- in /usr/src/new/kermit5.188/ckuus4.c line 1305-1306(2)

crdtab defined in line 233; used 1 times

- in line 1023

dialtab defined in line 127; used 2 times

- in line 142, 549

fbtab defined in line 341; used 2 times

- in line 345, 823

fdtab defined in line 359; used 2 times

- in line 382, 710

fntab defined in line 199; used 1 times

- in line 739

incast defined in line 453; used 1 times

- in line 1886

inptab defined in line 439; used 2 times

- in line 446, 1875

intimt defined in line 448; used 1 times

- in line 1881

kpmtab defined in line 280; used 1 times

- in line 976

lbltab defined in line 349; used 2 times

- in line 356, 867

mdmsav defined in line 34; used 6 times

- in line 1974, 1988-1989(2), 2025-2029(3)

natr defined in line 435; used 1 times

- in line 1769

nclrs defined in line 312; used 2 times

- in line 923-926(2)

ncolors defined in line 292; used 1 times

- in line 917

ncolx defined in line 190; used 3 times

- in line 842
- in /usr/src/new/kermit5.188/ckuus4.c line 1304-1306(2)

ncursors defined in line 319; used 1 times

- in line 957

ndial defined in line 142; used 1 times

- in line 549

nfbtyp defined in line 345; used 1 times

- in line 823

nfdtab defined in line 382; used 1 times

- in line 710

ninp defined in line 446; used 1 times

- in line 1875

nlblp defined in line 356; used 1 times

- in line 867

nos2dev defined in line 261; used 1 times

- in line 2001

nrfilp defined in line 197; used 1 times

- in line 660

nrms defined in line 415; used 1 times

- in line 1288

nrsrtab defined in line 388; used 1 times

- in line 1042

nsrtab defined in line 400; used 1 times

- in line 1049

ntrm defined in line 231; used 1 times

- in line 890

nttyp defined in line 337; used 1 times

- in line 964

nxmit defined in line 170; used 1 times

- in line 1213

oldplex defined in line 35; used 7 times

- in line 1970-1971(2), 1977, 1986, 2031-2033(3)

os2devtab defined in line 243; used 3 times

- in line 261, 2001, 2009

rfiltab defined in line 192; used 2 times

- in line 197, 660

rmstab defined in line 404; used 2 times

- in line 415, 1288

rsrtab defined in line 384; used 2 times

- in line 388, 1042

s defined in line 32; used 108 times

- in line 527-533(6), 540-542(2), 562-570(6), 576-577(2), 591, 615, 627, 634-641(5), 722-727(4), 1000-1007(3), 1217-1223(3), 1282, 1300-1301(2), 1309, 1354-1359(2), 1366-1375(3), 1415-1431(9), 1453, 1461-1465(3), 1480-1494(5), 1500-1502(2), 1520-1530(6), 1547-1556(4), 1928, 1938, 1944-1962(10), 1972, 1983, 2005-2012(6), 2018-2021(2), 2053-2060(5), 2066, 2072-2079(4), 2085-2089(2), 2104

srtab defined in line 392; used 2 times

- in line 400, 1049

trmtab defined in line 205; used 2 times

- in line 231, 890

tt_arrow defined in line 268; used 2 times

- in line 972
- in /usr/src/new/kermit5.188/ckuus5.c line 2538

tt_cursor defined in line 272; used 1 times

- in line 960

tt_keypad defined in line 269; used 2 times

- in line 978
- in /usr/src/new/kermit5.188/ckuus5.c line 2540

tt_type defined in line 271; used 2 times

- in line 966
- in /usr/src/new/kermit5.188/ckuus5.c line 2527

tt_wrap defined in line 270; used 2 times

- in line 982
- in /usr/src/new/kermit5.188/ckuus5.c line 2541

ttyclrtab defined in line 294; used 2 times

- in line 923-926(2)

ttycoltab defined in line 285; used 1 times

- in line 917

ttycurtab defined in line 314; used 1 times

- in line 957

ttyptab defined in line 323; used 1 times

- in line 964

x defined in line 31; used 239 times

- in line 465-467(3), 480(2), 492-497(2), 504(2), 510-515(4), 526-532(6), 540-541(2), 558, 564-569(7), 575-579(6), 597-598(2), 677(2), 702-715(6), 735-743(4), 750(2), 762-771(4), 778-787(4), 794-803(4), 809-810(2), 822-833(5), 842-846(3), 867-875(4), 897-906(5), 917-918(2), 931, 957-978(12), 989-993(5), 1010, 1016-1025(6), 1054-1064(4), 1095, 1143-1153(4), 1161-1170(4), 1178-1179(2), 1191-1193(2), 1199, 1227-1229(2), 1238-1239(2), 1246-1247(2), 1281, 1300-1301(3), 1316-1319(6), 1325-1344(10), 1359-1363(3), 1370-1372(2), 1379(2), 1386-1392(4), 1401-1407(4), 1415-1427(7), 1441(2), 1453-1464(5), 1480-1481(2), 1487-1488(2), 1500-1501(2), 1507(2), 1547-1548(2), 1567-1574(4), 1580(2), 1590-1591(2), 1761, 1796(2), 1806(2), 1878-1887(6), 1893-1894(2), 1925-1929(2), 1935-1940(3), 1952-1955(3), 1961(2), 1973, 1984, 2001-2013(9), 2019-2022(2), 2066, 2099(2)

xmitab defined in line 161; used 2 times

- in line 170, 1213

xmitbuf defined in line 158; used 5 times

- in line 1223
- in /usr/src/new/kermit5.188/ckuus4.c line 622-623(2)
- in /usr/src/new/kermit5.188/ckuus5.c line 2669-2673(2)

y defined in line 31; used 292 times

- in line 465-468(4), 480-496(9), 504-514(7), 549-550(3), 566-579(5), 589-590(2), 597-603(4), 615-628(7), 660-676(8), 689-695(4), 748-749(2), 765(2), 781(2), 797(2), 812-813(2), 828(2), 845(2), 870-872(2), 890-904(7), 929-930(2), 959(2), 965(2), 971(2), 977(2), 1001-1011(8), 1018(2), 1024(2), 1042-1065(15), 1077-1079(3), 1089-1096(7), 1103-1104(2), 1113-1114(2), 1140-1172(22), 1178-1179(4), 1191-1200(6), 1213-1218(6), 1227-1229(4), 1237-1239(4), 1245-1247(4), 1281, 1288-1294(4), 1453, 1536-1538(3), 1555(2), 1567-1573(4), 1588-1758(79), 1769-1771(3), 1795-1797(3), 1815, 1875-1876(3), 2054-2059(6), 2066-2075(5)

#### Defined macros

CK_NEED_SIG defined in line 1261; never used
XMBUFL defined in line 156; used 3 times

- in line 158, 1219-1220(2)

XMITE defined in line 150; used 1 times

- in line 163

XMITF defined in line 147; used 1 times

- in line 164

XMITL defined in line 148; used 1 times

- in line 165

XMITP defined in line 149; used 1 times

- in line 168

XMITS defined in line 152; used 1 times

- in line 166

XMITW defined in line 153; used 1 times

- in line 167

XMITX defined in line 151; used 1 times

- in line 162

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