ckuus7.c

早期freebsd实现

#ifndef NOICP

/*  C K U U S 7 --  "User Interface" for Unix Kermit, part 7  */
 
/*
  Author: Frank da Cruz ([e-mail], [e-mail]),
  Columbia University Center for Computing Activities.
  First released January 1985.
  Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
  York.  Permission is granted to any individual or institution to use this
  software as long as it is not sold for profit.  This copyright notice must be
  retained.  This software may not be included in commercial products without
  written permission of Columbia University.
*/
 
/*
  This file created from parts of ckuus3.c, which became to big for
  Mark Williams Coherent compiler to handle.
*/

/*
  Definitions here supersede those from system include files.
*/
#include "ckcdeb.h"			/* Debugging & compiler things */
#include "ckcasc.h"			/* ASCII character symbols */
#include "ckcker.h"			/* Kermit application definitions */
#include "ckcxla.h"			/* Character set translation */
#include "ckcnet.h"			/* Network symbols */
#include "ckuusr.h"			/* User interface symbols */

static int x, y = 0, z;
static char *s;

static int mdmsav = -1;			/* Save modem type around network */
static int oldplex = -1;		/* Duplex holder around network */

extern int success, nfilp, fmask, fncnv, frecl, nfttyp, binary, warn, msgflg;
extern int cmask, maxrps, wslotr, bigsbsiz, bigrbsiz, urpsiz, rpsiz, spsiz;
extern int spsizr, spsizf, maxsps, spmax, pflag, bctr, npad, timef, timint;
extern int pkttim, rtimo, local, nfils, displa, atcapr, nettype, escape;
extern int mdmtyp, duplex, dfloc, network, cdtimo, fncact, mypadn;
extern int tnlm, sosi, tlevel, lf_opts, backgrd, flow, fdispla;
extern int
  atenci, atenco, atdati, atdato, atleni, atleno, atblki, atblko,
  attypi, attypo, atsidi, atsido, atsysi, atsyso, atdisi, atdiso; 

extern long speed;

extern CHAR sstate, eol, seol, stchr, mystch, mypadc, padch;

extern char *cmarg, *cmarg2, *dftty;

extern char tmpbuf[], *tp, *lp;		/* Temporary buffer & pointers */
#ifndef NOFRILLS
extern char optbuf[];			/* Buffer for MAIL or PRINT options */
extern int rprintf;			/* REMOTE PRINT flag */
#endif /* NOFRILLS */
extern char ttname[];

extern struct keytab onoff[], filtab[], fttab[], rltab[];
extern int nrlt;

#ifdef DCMDBUF
extern char *atxbuf;			/* Atom buffer */
extern char *cmdbuf;			/* Command buffer */
extern char *line;			/* Character buffer for anything */
#ifdef CK_CURSES
/* This needs cleaning up... */
#ifdef UNIX
extern char *trmbuf;			/* Termcap buffer */
#endif /* UNIX */
#ifdef OS2
extern char *trmbuf;			/* Termcap buffer */
#endif /* OS2 */
#ifdef OSK
extern char *trmbuf;			/* Termcap buffer */
#endif /* OSK */
#ifdef AMIGA
extern char *trmbuf;			/* Termcap buffer */
#endif /* AMIGA */
#endif /* CK_CURSES */
#else
extern char atxbuf[];			/* Atom buffer */
extern char cmdbuf[];			/* Command buffer */
extern char line[];			/* Character buffer for anything */
#ifdef CK_CURSES
#ifdef UNIX
extern char trmbuf[];			/* Termcap buffer */
#endif /* UNIX */
#endif /* CK_CURSES */
#endif /* DCMDBUF */

#ifndef NOCSETS
extern struct keytab fcstab[];		/* For 'set file character-set' */
extern struct keytab ttcstab[];
extern int nfilc, fcharset, ntermc, tcsr, tcsl;
#endif /* NOCSETS */

#ifndef NOSPL
extern int cmdlvl;			/* Overall command level */
#endif /* NOSPL */

#ifdef TNCODE
extern int tn_init;
#endif /* TNCODE */

#ifdef SUNX25
extern int revcall, closgr, cudata, nx25, npadx3;
extern char udata[MAXCUDATA];
extern CHAR padparms[MAXPADPARMS+1];
extern struct keytab x25tab[], padx3tab[];
#endif /* SUNX25 */

#ifdef CK_CURSES
#ifndef VMS
_PROTOTYP(int tgetent,(char *, char *));
#endif /* VMS */
#endif /* CK_CURSES */

#ifndef NODIAL
extern int dialhng, dialtmo, dialksp, dialdpy, dialmnp, dialmhu;
extern int mdmspd;
extern char *dialini, *dialdir, *dialcmd, *dialnpr;
extern FILE * dialfd;


struct keytab dialtab[] = {
    "dial-command", XYDDIA, 0,
    "directory", XYDDIR, 0,
    "display", XYDDPY, 0,
    "hangup",  XYDHUP, 0,
    "init-string", XYDINI, 0,
    "kermit-spoof", XYDKSP, 0,
    "mnp-enable", XYDMNP, 0,
#ifdef MDMHUP
    "modem-hangup", XYDMHU, 0,
#endif /* MDMHUP */
    "prefix", XYDNPR, 0,
    "speed-matching", XYDSPD, 0,
    "timeout", XYDTMO, 0
};
int ndial = (sizeof(dialtab) / sizeof(struct keytab));
#endif /* NODIAL */

#ifndef NOXMIT
/* set transmit */
#define XMITF 0
#define XMITL 1
#define XMITP 2
#define XMITE 3
#define XMITX 4
#define XMITS 5
#define XMITW 6

#ifndef NOXMIT
#define XMBUFL 50
extern int xmitf, xmitl, xmitp, xmitx, xmits, xmitw;
char xmitbuf[XMBUFL+1] = { NUL };	/* TRANSMIT eof string */
#endif /* NOXMIT */

struct keytab xmitab[] = {
    "echo",     XMITX, 0,
    "eof",      XMITE, 0,
    "fill",     XMITF, 0,
    "linefeed", XMITL, 0,
    "locking-shift", XMITS, 0,
    "pause",    XMITW, 0,
    "prompt",   XMITP, 0
};
int nxmit = (sizeof(xmitab) / sizeof(struct keytab));
#endif /* NOXMIT */

/* For SET FILE COLLISION */
/* Some of the following may be possible for some C-Kermit implementations */
/* but not others.  Those that are not possible for your implementation */
/* should be ifdef'd out. */

struct keytab colxtab[] = { /* SET FILE COLLISION options */
    "append",    XYFX_A, 0,  /* append to old file */
#ifdef COMMENT
    "ask",       XYFX_Q, 0,  /* ask what to do (not implemented) */
#endif
    "backup",    XYFX_B, 0,  /* rename old file */
    "discard",   XYFX_D, 0,  /* don't accept new file */
    "no-supersede", XYFX_D, CM_INV, /* ditto (MSK compatibility) */
    "overwrite", XYFX_X, 0,  /* overwrite the old file == file warning off */
    "rename",    XYFX_R, 0,  /* rename the incoming file == file warning on */
    "update",    XYFX_U, 0,  /* replace if newer */
};
int ncolx = (sizeof(colxtab) / sizeof(struct keytab));

static struct keytab rfiltab[] = {	/* for REMOTE SET FILE */
    "collision",     XYFILX, 0,
    "record-length", XYFILR, 0,
    "type",          XYFILT, 0
};
int nrfilp = (sizeof(rfiltab) / sizeof(struct keytab));

struct keytab fntab[] = {   		/* File naming */
    "converted", 1, 0,
    "literal",   0, 0
};

/* Terminal parameters table */
struct keytab trmtab[] = {
#ifdef OS2
    "arrow-keys",    XYTARR, 0,
#endif /* OS2 */
    "bytesize",      XYTBYT, 0,
#ifndef NOCSETS
    "character-set", XYTCS,  0,
#endif /* NOCSETS */
#ifdef OS2
    "color",         XYTCOL, 0,
#endif /* OS2 */
    "cr-display",    XYTCRD, 0,
#ifdef OS2
    "cursor",        XYTCUR, 0,
#endif /* OS2 */
    "echo",          XYTEC,  0,
#ifdef OS2
    "keypad-mode",   XYTKPD, 0,
#endif /* OS2 */
    "locking-shift", XYTSO,  0,
    "newline-mode",  XYTNL,  0
#ifdef OS2
,   "type",          XYTTYP, 0,
    "wrap",          XYTWRP, 0
#endif /* OS2 */
};
int ntrm = (sizeof(trmtab) / sizeof(struct keytab));

struct keytab crdtab[] = {		/* Carriage-return display */
    "crlf",        1, 0,
    "normal",      0, 0
};
extern int tt_crd;			/* Carriage-return display variable */

#ifdef OS2
/*
  OS/2 serial communication devices.
*/
struct keytab os2devtab[] = {
    "1",    1, CM_INV,			/* Invisible synonyms, like */
    "2",    2, CM_INV,			/* "set port 1" */
    "3",    3, CM_INV,
    "4",    4, CM_INV,
    "5",    5, CM_INV,
    "6",    6, CM_INV,
    "7",    7, CM_INV,
    "8",    8, CM_INV,
    "com1", 1, 0,			/* Real device names */
    "com2", 2, 0,
    "com3", 3, 0,
    "com4", 4, 0,
    "com5", 5, 0,
    "com6", 6, 0,
    "com7", 7, 0,
    "com8", 7, 0
};
int nos2dev = (sizeof(os2devtab) / sizeof(struct keytab));

/*
  Terminal parameters that can be set by SET commands.
  Used by the ck?con.c terminal emulator code.  
  For now, only use for OS/2.  Should add these for Macintosh.
*/
int tt_arrow = 1;			/* Arrow key mode */
int tt_keypad = 0;			/* Keypad mode */
int tt_wrap = 1;			/* Autowrap */
int tt_type = TT_VT102;			/* Terminal type */
int tt_cursor = 0;			/* Cursor type */
#endif /* OS2 */

#ifdef OS2
struct keytab akmtab[] = {		/* Arrow key mode */
    "application", 1, 0,
    "cursor",      0, 0
};
struct keytab kpmtab[] = {		/* Keypad mode */
    "application", 0, 0,
    "numeric",     1, 0
};

struct keytab ttycoltab[] = {		/* Items to be colored */
    "help",        4, 0,		/* Help screen */
    "normal",      0, 0,		/* Normal screen text */
    "reverse",     1, 0,		/* Reverse video */
    "status",      3, 0,		/* Status line */
    "underlined",  2, 0			/* Underlined text */
};
int ncolors = 5;

struct keytab ttyclrtab[] = {		/* Colors */
    "black",       0, 0,
    "blue",        1, 0,
    "brown",       6, 0,
    "cyan",        3, 0,
    "dgray",       8, 0,
    "green",       2, 0,
    "lblue",       9, 0,
    "lcyan",      11, 0,
    "lgray",       7, 0,
    "lgreen",     10, 0,
    "lmagenta",   13, 0,
    "lred",       12, 0,
    "magenta",     5, 0,
    "red",         4, 0,
    "white",      15, 0,
    "yellow",     14, 0
};
int nclrs = 16;

struct keytab ttycurtab[] = {
    "full",        2, 0,
    "half",        1, 0,
    "underline",   0, 0
};
int ncursors = 3;
#endif /* OS2 */

#ifdef OS2
struct keytab ttyptab[] = {
#ifdef COMMENT
/*
  Not supported yet...
  The idea is to let the console driver handle the escape sequences.
*/
    "none",    TT_NONE,  0,
#endif /* COMMENT */
#ifdef OS2PM
    "tek4014", TT_TEK40, 0,
#endif /* OS2PM */
    "vt102",   TT_VT102, 0,
    "vt52",    TT_VT52,  0
};
int nttyp = 2;
#endif /* OS2 */

/* #ifdef VMS */
struct keytab fbtab[] = {		/* Binary record types for VMS */
    "fixed",     XYFT_B, 0,		/* Fixed is normal for binary */
    "undefined", XYFT_U, 0		/* Undefined if they ask for it */
};
int nfbtyp = (sizeof(fbtab) / sizeof(struct keytab));
/* #endif */

#ifdef VMS
struct keytab lbltab[] = {		/* Labeled File info */
    "acl",         LBL_ACL, 0,
    "backup-date", LBL_BCK, 0,
    "name",        LBL_NAM, 0,
    "owner",       LBL_OWN, 0,
    "path",        LBL_PTH, 0
};
int nlblp = (sizeof(lbltab) / sizeof(struct keytab));
#endif /* VMS */

struct keytab fdtab[] = {		/* SET FILE DISPLAY options */
#ifdef MAC				/* Macintosh */
    "fullscreen", XYFD_R, 0,		/* Full-screen but not curses */
    "none",   XYFD_N, 0,
    "off",    XYFD_N, CM_INV,
    "on",     XYFD_R, CM_INV,
    "quiet",  XYFD_N, CM_INV

#else					/* Not Mac */
    "crt", XYFD_S, 0,			/* CRT display */
#ifdef CK_CURSES
#ifdef COMMENT
    "curses",     XYFD_C, CM_INV,	/* Full-screen, curses */
#endif /* COMMENT */
    "fullscreen", XYFD_C, 0,		/* Full-screen, whatever the method */
#endif /* CK_CURSES */
    "none",   XYFD_N, 0,		/* No display */
    "off",    XYFD_N, CM_INV,		/* Ditto */
    "on",     XYFD_R, CM_INV,		/* On = Serial */
    "quiet",  XYFD_N, CM_INV,		/* No display */
    "serial", XYFD_R, 0			/* Serial */
#endif /* MAC */
};
int nfdtab = (sizeof(fdtab) / sizeof(struct keytab));

struct keytab rsrtab[] = {		/* For REMOTE SET RECEIVE */
    "packet-length", XYLEN, 0,
    "timeout", XYTIMO, 0
};
int nrsrtab = (sizeof(rsrtab) / sizeof(struct keytab));

/* Send/Receive Parameters */
 
struct keytab srtab[] = {
    "end-of-packet", XYEOL, 0,
    "packet-length", XYLEN, 0,
    "pad-character", XYPADC, 0,
    "padding", XYNPAD, 0,
    "start-of-packet", XYMARK, 0,
    "timeout", XYTIMO, 0
};
int nsrtab = (sizeof(srtab) / sizeof(struct keytab));

/* REMOTE SET */

struct keytab rmstab[] = {
    "attributes",  XYATTR, 0,
    "block-check", XYCHKT, 0,
    "file",        XYFILE, 0,
    "incomplete",  XYIFD,  0,
    "receive",     XYRECV, 0,
    "retry",       XYRETR, 0,
    "server",      XYSERV, 0,
    "transfer",    XYXFER, 0,
    "window",      XYWIND, 0
};
int nrms = (sizeof(rmstab) / sizeof(struct keytab));

struct keytab attrtab[] = {
    "all",           AT_XALL, 0,
#ifdef COMMENT
    "blocksize",     AT_BLKS, 0,	/* not used */
#endif /* COMMENT */
    "character-set", AT_ENCO, 0,
    "date",          AT_DATE, 0,
    "disposition",   AT_DISP, 0,
    "encoding",      AT_ENCO, CM_INV,
    "length",        AT_LENK, 0,
    "off",           AT_ALLN, 0,
    "on",            AT_ALLY, 0,
#ifdef COMMENT
    "os-specific",   AT_SYSP, 0,	/* not used by UNIX or VMS */
#endif /* COMMENT */
    "system-id",     AT_SYSI, 0,
    "type",          AT_FTYP, 0,
};
int natr = (sizeof(attrtab) / sizeof(struct keytab)); /* how many attributes */

#ifndef NOSPL
extern int indef, intime, incase, inecho, insilence;
struct keytab inptab [] = {		/* SET INPUT parameters */
    "case",            IN_CAS, 0,
    "default-timeout", IN_DEF, CM_INV,
    "echo",            IN_ECH, 0,
    "silence",         IN_SIL, 0,
    "timeout-action",  IN_TIM, 0
};
int ninp = (sizeof(inptab) / sizeof(struct keytab));

struct keytab intimt[] = {		/* SET INPUT TIMEOUT parameters */
    "proceed", 0, 0,			/* 0 = proceed */
    "quit",    1, 0			/* 1 = quit */
};

struct keytab incast[] = {		/* SET INPUT CASE parameters */
    "ignore",  0, 0,			/* 0 = ignore */
    "observe", 1, 0			/* 1 = observe */
};
#endif /* NOSPL */

/* The following routines broken out of doprm() to give compilers a break. */

/*  S E T O N  --  Parse on/off (default on), set parameter to result  */
 
int
seton(prm) int *prm; {
    int x, y;
    if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
    if ((x = cmcfm()) < 0) return(x);
    *prm = y;
    return(1);
}
 
/*  S E T N U M  --  Set parameter to result of cmnum() parse.  */
/*
 Call with pointer to integer variable to be set,
   x = number from cnum parse, y = return code from cmnum,
   max = maximum value to accept, -1 if no maximum.
 Returns -9 on failure, after printing a message, or 1 on success.
*/
int
setnum(prm,x,y,max) int x, y, *prm, max; {
    extern int cmflgs;
    debug(F101,"setnum","",y);
    if (y == -3) {
	printf("\n?Value required\n");
	return(-9);
    }
    if (y == -2) {
	printf("%s?Not a number: %s\n",cmflgs == 1 ? "" : "\n", atxbuf);
	return(-9);
    }
    if (y < 0) return(y);
    if (max > -1 && x > max) {
	printf("?Sorry, %d is the maximum\n",max);
	return(-9);
    }
    if ((y = cmcfm()) < 0) return(y);
    *prm = x;
    return(1);
}
 
/*  S E T C C  --  Set parameter to an ASCII control character value.  */
 
int
setcc(prm,x,y) int x, y, *prm; {
    if (y == -3) {
	printf("\n?Value required\n");
	return(-3);
    }
    if (y < 0) return(y);
    if ((x > 037) && (x != 0177)) {
	printf("\n?Not in ASCII control range - %d\n",x);
	return(-2);
    }
    if ((y = cmcfm()) < 0) return(y);
    *prm = x;
    return(1);
}

#ifndef NODIAL
_PROTOTYP(static int dialstr,(char **, char *));
/*
  Parse a DIAL-related string, stripping enclosing braces, if any.
*/
static int
dialstr(p,msg) char **p; char *msg; {
    int x;
    if ((x = cmtxt(msg, "", &s, xxstring)) < 0)
      return(x);
    if (*s == '{') {			/* Strip enclosing braces, if any */