ckuus5.c

C-Kermit源码。是使用串口/Modem和网络通讯的程序

char *m_cautious = "set win 2, set rec pack 512, set prefixing cautious";
#else
char *m_cautious = "set win 4, set rec pack 1000, set prefixing cautious";
#endif /* pdp11 */
char *m_robust = "set win 1, set rec pack 90, set prefixing all, \
set reliable off, set clearchannel off";
#else
#ifdef BIGBUFOK
#ifdef IRIX65
char *m_fast = "set win 30, set rec pack 4000";
#else
#ifdef IRIX
char *m_fast = "set win 30, set rec pack 4000, set send pack 4000";
#else
char *m_fast = "set win 30, set rec pack 4000";
#endif /* IRIX */
#endif /* IRIX65 */
#else /* Not BIGBUFOK */
char *m_fast = "set win 4, set rec pack 2200";
#endif /* BIGBUFOK */
char *m_cautious = "set win 4, set rec pack 1000";
char *m_robust = "set win 1, set rec pack 90, set reliable off";
#endif /* CK_SPEED */

#ifdef VMS
char *m_purge = "run purge \\%*";
#endif /* VMS */

#ifdef OS2
char *m_manual = "browse \\v(exedir)docs/manual/kermit95.htm";
#endif /* OS2 */

/* Now the multiline macros, defined with addmmac()... */

/* FOR macro */
char *for_def[] = { "_assign _for\\v(cmdlevel) { _getargs,",
"define \\\\\\%1 \\feval(\\%2),:_..top,if \\%5 \\\\\\%1 \\%3 goto _..bot,",
"\\%6,:_..inc,incr \\\\\\%1 \\%4,goto _..top,:_..bot,_putargs},",
"def break goto _..bot, def continue goto _..inc,",
"do _for\\v(cmdlevel) \\%1 \\%2 \\%3 \\%4 { \\%5 },_assign _for\\v(cmdlevel)",
""};

/* WHILE macro */
char *whil_def[] = { "_assign _whi\\v(cmdlevel) {_getargs,",
":_..inc,\\%1,\\%2,goto _..inc,:_..bot,_putargs},",
"_def break goto _..bot, _def continue goto _..inc,",
"do _whi\\v(cmdlevel),_assign _whi\\v(cmdlevel)",
""};

/* SWITCH macro */
char *sw_def[] = { "_assign _sw_\\v(cmdlevel) {_getargs,",
"_forward \\%1,\\%2,:default,:_..bot,_putargs},_def break goto _..bot,",
"do _sw_\\v(cmdlevel),_assign _sw_\\v(cmdlevel)",
""};

/* XIF macro */
char *xif_def[] = {
"_assign _if\\v(cmdlevel) {_getargs,\\%1,_putargs},",
"do _if\\v(cmdlevel),_assign _if\\v(cmdlevel)",
""};

/*
  Variables declared here for use by other ckuus*.c modules.
  Space is allocated here to save room in ckuusr.c.
*/
#ifdef DCMDBUF
struct cmdptr *cmdstk;
int
  *ifcmd  = NULL,
  *count  = NULL,
  *iftest = NULL,
  *intime = NULL,
  *inpcas = NULL,
  *takerr = NULL,
  *merror = NULL;
#else
struct cmdptr cmdstk[CMDSTKL];
int ifcmd[CMDSTKL], count[CMDSTKL], iftest[CMDSTKL], intime[CMDSTKL],
  inpcas[CMDSTKL], takerr[CMDSTKL], merror[CMDSTKL];
#endif /* DCMDBUF */

/* Macro stack */

char *m_line[MACLEVEL] = { NULL, NULL }; /* Stack of macro invocation lines */
char **m_xarg[MACLEVEL];		/* Pointers to arg vector arrays */
int n_xarg[MACLEVEL];			/* Sizes of arg vector arrays */
char *m_arg[MACLEVEL][NARGS];		/* Args of each level */
int macargc[MACLEVEL];			/* Argc of each level */
char *macp[MACLEVEL];			/* Current position in each macro */
char *macx[MACLEVEL];			/* Beginning of each macro def */
char *mrval[MACLEVEL];			/* RETURN value at each level */
int topargc = 0;			/* Argc at top level */
char **topxarg = NULL;			/* Argv at top level */
char *toparg[MAXARGLIST+2];

/* Global Variables */

char *g_var[GVARS];			/* Global \%a..z pointers */
extern char varnam[];			/* \%x variable name buffer */

/* Arrays -- Dimension must be 'z' - ARRAYBASE + 1 */

char **a_ptr[28];			/* Array pointers, for arrays a-z */
int a_dim[28];				/* Dimensions for each array */

char **aa_ptr[CMDSTKL][28];		/* Array stack for automatic arrays */
int aa_dim[CMDSTKL][28];		/* Dimensions for each array */

/* INPUT command buffers and variables */

char * inpbuf = NULL;			/* Buffer for INPUT and REINPUT */
extern char * inpbp;			/* Global/static pointer to it  */
char inchar[2] = { NUL, NUL };		/* Last character that was INPUT */
int  incount = 0;			/* INPUT character count */
extern int instatus;			/* INPUT status */
static char * i_text[] = {		/* INPUT status text */
    "success", "timeout", "interrupted", "internal error", "i/o error"
};

char lblbuf[LBLSIZ];			/* Buffer for labels */

#else  /* NOSPL */

int takerr[MAXTAKE];
#endif /* NOSPL */

static char *prevdir = NULL;

int pacing = 0;				/* OUTPUT pacing */

#ifdef DCMDBUF
char *line;				/* Character buffer for anything */
char *tmpbuf;
#else
char line[LINBUFSIZ+1];
char tmpbuf[TMPBUFSIZ+1];		/* Temporary buffer */
#endif /* DCMDBUF */
char *tp;				/* Temporary buffer pointer */

int timelimit = 0, asktimer = 0;	/* Timers for time-limited commands */

#ifdef CK_APC				/* Application Program Command (APC) */
int apcactive = APC_INACTIVE;
int apcstatus = APC_OFF;		/* OFF by default everywhere */
#ifdef DCMDBUF
char *apcbuf;
#else
char apcbuf[APCBUFLEN];
#endif /* DCMDBUF */
#endif /* CK_APC */

extern char pktfil[],
#ifdef DEBUG
  debfil[],
#endif /* DEBUG */
#ifdef TLOG
  trafil[],
#endif /* TLOG */
  sesfil[];

#ifndef NOFRILLS
extern int rmailf, rprintf;		/* REMOTE MAIL & PRINT items */
extern char optbuf[];
#endif /* NOFRILLS */

char *homdir = "";			/* Pointer to home directory string */

char numbuf[20];			/* Buffer for numeric strings. */
extern int noinit;

#ifndef NOSPL
_PROTOTYP( VOID freelocal, (int) );
_PROTOTYP( static long expon, (long, long) );
_PROTOTYP( static long gcd, (long, long) );
_PROTOTYP( static long fact, (long) );

int			/* Initialize macro data structures. */
macini() {		/* Allocate mactab and preset the first element. */
    int i;
    if (!(mactab = (struct mtab *) malloc(sizeof(struct mtab) * MAC_MAX)))
      return(-1);
    mactab[0].kwd = NULL;
    mactab[0].mval = NULL;
    mactab[0].flgs = 0;
    for (i = 0; i < MACLEVEL; i++)
      localhead[i] = NULL;
    return(0);
}
#endif /* NOSPL */

/*  C M D S R C  --  Returns current command source  */

/*  0 = top level, 1 = file, 2 = macro, -1 = error (shouldn't happen) */

int
cmdsrc() {
#ifndef NOSPL
    if (cmdlvl == 0)
      return(0);
    else if (cmdstk[cmdlvl].src == CMD_MD)
      return(2);
    else if (cmdstk[cmdlvl].src == CMD_TF)
      return(1);
    else
      return(-1);
#else
    if (tlevel < 0)
      return(0);
    else
      return(1);
#endif /* NOSPL */
}

/*  C M D I N I  --  Initialize the interactive command parser  */

static int cmdinited = 0;		/* Command parser initialized */
extern int cmdint;			/* Interrupts are allowed */
#ifdef CK_AUTODL
int cmdadl = 1;				/* Autodownload */
#else
int cmdadl = 0;
#endif /* CK_AUTODL */

char * k_info_dir = NULL;		/* Where to find text files */
#ifdef UNIX
static char * txtdir[] = {
    "/usr/local/doc/",			/* Linux, SunOS, ... */
    "/usr/share/lib/",			/* HP-UX 10.xx... */
    "/usr/share/doc/",			/* Other possibilities... */
    "/usr/local/lib/",			/* NOTE: Each of these is tried */
    "/usr/local/share/",		/* as is, and also with a kermit */
    "/usr/local/share/doc/",		/* subdirectory. */
    "/usr/local/share/lib/",
    "/usr/doc/",
    "/opt/",
    "/doc/",
    ""
};
#endif /* UNIX */

VOID
cmdini() {
    int i = 0, x = 0, y = 0, z = 0, skip = 0;
    char * p;
#ifdef TTSPDLIST
    long * ss = NULL;
    extern int nspd;
    extern struct keytab * spdtab;
#endif /* TTSPDLIST */

#ifndef NOSPL
/*
  On stack to allow recursion!
*/
    char vnambuf[VNAML];		/* Buffer for variable names */
#endif /* NOSPL */

    if (cmdinited)			/* Already initialized */
      return;				/* Don't do it again */

    p = getenv("K_INFO_DIRECTORY");
    if (p && *p && strlen(p) <= CKMAXPATH)
      makestr(&k_info_dir,p);
    if (!k_info_dir) {
        p = getenv("K_INFO_DIR");
        if (p && *p && strlen(p) <= CKMAXPATH)
	  makestr(&k_info_dir,p);
    }
#ifdef UNIX
    if (k_info_dir) {			/* Look for Kermit docs directory */
	if (zchki(k_info_dir) == -2) {
	    char xbuf[CKMAXPATH+32], *s = "";
	    if (ckrchar(k_info_dir) != '/')
	      s = "/";
	    sprintf(xbuf,"%s%sckermit2.txt",k_info_dir,s);
	    if (zchki(xbuf) < 0)
	      makestr(&k_info_dir,NULL);
	}
    }
    if (!k_info_dir) {
	char xbuf[CKMAXPATH+32];
	int i;
	for (i = 0; *(txtdir[i]); i++) {
	    sprintf(xbuf,"%s%s",txtdir[i],"ckermit2.txt");
	    if (zchki(xbuf) > 0) {
		makestr(&k_info_dir,txtdir[i]);
		debug(F110,"k_info_dir 1",k_info_dir,0);
		break;
	    }
	    sprintf(xbuf,"%skermit/%s",txtdir[i],"ckermit2.txt");
	    if (zchki(xbuf) > 0) {
		sprintf(xbuf,"%skermit/",txtdir[i]);
		makestr(&k_info_dir,xbuf);
		debug(F110,"k_info_dir 2",k_info_dir,0);
		break;
	    }
	}
	if (k_info_dir) {		/* Make sure it ends with "/" */
	    if (ckrchar(k_info_dir) != '/') {
		char xbuf[CKMAXPATH+32];
		sprintf(xbuf,"%s/",k_info_dir);
		makestr(&k_info_dir,xbuf);
	    }
	}
    }
#else
#ifdef OS2
    {
	char xdir[CKMAXPATH+8], *s = "";
        extern char startupdir[];
	xdir[0] = NUL;
	if (ckrchar(startupdir) != '/')
	  s = "/";
        if (strlen(s) + strlen(startupdir) + 5 < CKMAXPATH + 8 )
	  sprintf(xdir,"%s%sDOC/",s,startupdir);
        makestr(&k_info_dir,xdir);
    }
#endif /* OS2 */
#endif /* UNIX */

#ifdef TTSPDLIST
    if (!spdtab && (ss = ttspdlist())) { /* Get speed list if necessary */
	int j, k, m = 0, n;		/* Create sorted keyword table */
	char buf[16];
	char * p;
	if ((spdtab =
	     (struct keytab *) malloc(sizeof(struct keytab) * ss[0]))) {
	    for (i = 1; i <= ss[0]; i++) { /* ss[0] = number of elements */
		if (ss[i] < 1L) break;	   /* Shouldn't happen */
		buf[0] = NUL;		   /* Make string */
		sprintf(buf,"%ld",ss[i]);
		if (ss[i] == 8880L)
		  strcpy(buf,"75/1200");
		if (ss[i] == 134L)
		  strcat(buf,".5");
		n = strlen(buf);
		if ((n > 0) && (p = (char *)malloc(n+1))) {
		    if (m > 0) {	/* Have at least one in list */
			for (j = 0;	/* Find slot */
			     j < m && strcmp(buf,spdtab[j].kwd) > 0;
			     j++
			     )
			  ;
			if (j < m) {	/* Must insert */
			    for (k = m-1; k >= j; k--) { /* Move others down */
				spdtab[k+1].kwd = spdtab[k].kwd;
				spdtab[k+1].flgs = spdtab[k].flgs;
				spdtab[k+1].kwval = spdtab[k].kwval;
			    }
			}
		    } else		/* First one */
		      j = 0;
		    strcpy(p,buf);	/* Add new speed */
		    spdtab[j].kwd = p;
		    spdtab[j].flgs = 0;
		    spdtab[j].kwval = (int) ss[i] / 10;
		    m++;		/* Count this one */
		}
	    }
	}
	nspd = m;
    }
#endif /* TTSPDLIST */

#ifndef NOSPL
    /* Allocate INPUT command buffer */
    if (!inpbuf) {
	if (!(inpbuf = (char *) malloc(INPBUFSIZ+1)))
	  fatal("cmdini: no memory for INPUT buffer");
    }
    for (x = 0; x < INPBUFSIZ; x++)	/* Initialize it */
      inpbuf[x] = NUL;
    inpbp = inpbuf;			/* Initialize pointer */
    inbufsize = INPBUFSIZ;		/* and size. */
#endif /* NOSPL */

#ifdef DCMDBUF
    if (cmsetup() < 0) fatal("Can't allocate command buffers!");

#ifndef NOSPL
    /* Allocate command stack allowing command parser to call itself */

    if (!(cmdstk = (struct cmdptr *) malloc(sizeof(struct cmdptr)*CMDSTKL)))
      fatal("cmdini: no memory for cmdstk");
    if (!(ifcmd = (int *) malloc(sizeof(int)*CMDSTKL)))
      fatal("cmdini: no memory for ifcmd");
    if (!(count = (int *) malloc(sizeof(int)*CMDSTKL)))
      fatal("cmdini: no memory for count");
    if (!(iftest = (int *) malloc(sizeof(int)*CMDSTKL)))
      fatal("cmdini: no memory for iftest");
    if (!(intime = (int *) malloc(sizeof(int)*CMDSTKL)))
      fatal("cmdini: no memory for intime");
    if (!(inpcas = (int *) malloc(sizeof(int)*CMDSTKL)))
      fatal("cmdini: no memory for inpcas");
    if (!(takerr = (int *) malloc(sizeof(int)*CMDSTKL)))
      fatal("cmdini: no memory for takerr");
    if (!(merror = (int *) malloc(sizeof(int)*CMDSTKL)))
      fatal("cmdini: no memory for merror");
    if (!(xquiet = (int *) malloc(sizeof(int)*CMDSTKL)))
      fatal("cmdini: no memory for xquiet");
    if (!kermrc)
      if (!(kermrc = (char *) malloc(KERMRCL+1)))
	fatal("cmdini: no memory for kermrc");
#ifdef CK_APC
/* Application Program Command buffer */
    if (!(apcbuf = malloc(APCBUFLEN + 1)))
	fatal("cmdini: no memory for apcbuf");
#endif /* CK_APC */
#endif /* NOSPL */

/* line[] and tmpbuf[] are the two string buffers used by the command parser */

    if (!(line = malloc(LINBUFSIZ + 1)))
	fatal("cmdini: no memory for line");
    if (!(tmpbuf = malloc(LINBUFSIZ + 1)))
	fatal("cmdini: no memory for tmpbuf");
#endif /* DCMDBUF */

#ifndef NOSPL
#ifdef CK_MINPUT
    {					/* Initialize MINPUT pointers */
	int i;
	extern char *ms[];
	for (i = 0; i < MINPMAX; i++)
	  ms[i] = NULL;
    }
#endif /* CK_MINPUT */

    if (macini() < 0)			/* Allocate macro buffers */
      fatal("Can't allocate macro buffers!");

    ifcmd[0] = 0;			/* Command-level related variables. */
    iftest[0] = 0;			/* Initialize variables at top level */
    count[0] = 0;			/* of stack... */
    intime[0] = 0;
    inpcas[0] = 0;
    takerr[0] = 0;
    merror[0] = 0;
    xquiet[0] = quiet;
#endif /* NOSPL */

#ifndef NOSPL
    cmdlvl = 0;				/* Initialize the command stack */
    cmdstk[cmdlvl].src = CMD_KB;	/* Source is console */
    cmdstk[cmdlvl].lvl = 0;		/* Level is 0 */
    cmdstk[cmdlvl].ccflgs = 0;		/* No flags */
#endif /* NOSPL */

    tlevel = -1;			/* Take file level = keyboard */
    for (i = 0; i < MAXTAKE; i++)	/* Initialize command file names */
      tfnam[i] = NULL;

    cmsetp(ckprompt); 			/* Set up C-Kermit's prompt */
                                        /* Can't set IKSD prompt here since */
                                        /* we do not yet know if we are IKSD */
#ifndef NOSPL

    initmac();				/* Initialize macro table */

/* Predefine built-in one-line macros */

    addmac("ibm-linemode",m_ibm);	/* IBM-LINEMODE */
    addmac("fatal",m_fat);		/* FATAL macro */
    y = addmac("fast",m_fast);		/* FAST macro */
    addmac("cautious",m_cautious);	/* CAUTIOUS macro */
    addmac("robust",m_robust);		/* ROBUST macro */
#ifdef OS2
    addmac("manual",m_manual);          /* MANUAL macro */
#endif /* OS2 */
#ifdef VMS
    addmac("purge",m_purge);		/* PURGE macro */
#endif /* VMS */

/*
  Predefine built-in multiline macros; these are top-level commands
  that are implemented internally as macros.  NOTE: When adding a new
  one of these, remember to update the END and RETURN commands to
  account for it, or else END and RETURN from within it won't work right.
*/
    x = addmmac("_forx",for_def);	/* FOR macro */
    if (x > -1) mactab[x].flgs = CM_INV;
    x = addmmac("_xif",xif_def);	/* XIF macro */
    if (x > -1) mactab[x].flgs = CM_INV;
    x = addmmac("_while",whil_def);	/* WHILE macro */