![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckuus4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / e / bin / ckermit|
Return to ckuus4.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / ckermit |
1.1 ! root 1: #ifndef NOICP ! 2: ! 3: /* C K U U S 4 -- "User Interface" for Unix Kermit, part 4 */ ! 4: ! 5: /* ! 6: Author: Frank da Cruz ([email protected], [email protected]), ! 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: File ckuus4.c -- Functions moved from other ckuus*.c modules to even ! 18: out their sizes. ! 19: */ ! 20: #include "ckcdeb.h" ! 21: #include "ckcasc.h" ! 22: #include "ckcker.h" ! 23: #include "ckuusr.h" ! 24: #include "ckuver.h" ! 25: #include "ckcnet.h" /* Network symbols */ ! 26: ! 27: #ifndef NOCSETS /* Character sets */ ! 28: #include "ckcxla.h" ! 29: #endif /* NOCSETS */ ! 30: ! 31: #ifndef AMIGA ! 32: #ifndef MAC ! 33: #include <signal.h> ! 34: #include <setjmp.h> ! 35: #endif /* MAC */ ! 36: #endif /* AMIGA */ ! 37: ! 38: #ifdef SUNX25 ! 39: extern int revcall, closgr, cudata, npadx3; ! 40: int x25ver; ! 41: extern char udata[MAXCUDATA]; ! 42: extern CHAR padparms[MAXPADPARMS+1]; ! 43: extern struct keytab padx3tab[]; ! 44: #endif /* SUNX25 */ ! 45: ! 46: #ifdef NETCONN ! 47: extern char ipaddr[]; ! 48: #ifdef TNCODE ! 49: extern int tn_duplex, tn_nlm; ! 50: extern char *tn_term; ! 51: #endif /* TNCODE */ ! 52: #endif /* NETCONN */ ! 53: ! 54: #ifndef NOSPL ! 55: /* This needs to be internationalized... */ ! 56: static ! 57: char *months[] = { ! 58: "Jan", "Feb", "Mar", "Apr", "May", "Jun", ! 59: "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ! 60: }; ! 61: ! 62: static ! 63: char *wkdays[] = { ! 64: "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ! 65: }; ! 66: #endif /* NOSPL */ ! 67: ! 68: #ifdef UNIX ! 69: extern int ttyfd; ! 70: #endif /* UNIX */ ! 71: #ifdef OS2 ! 72: extern int ttyfd; ! 73: #endif /* OS2 */ ! 74: ! 75: _PROTOTYP( static VOID shods, (char *) ); ! 76: ! 77: extern struct keytab colxtab[]; ! 78: ! 79: extern CHAR ! 80: eol, mypadc, mystch, padch, seol, stchr; ! 81: ! 82: extern char ! 83: kermrc[], ttname[], ! 84: *ckxsys, *versio, **xargv, *zinptr; ! 85: ! 86: extern int ! 87: atcapr, autopar, bctr, bctu, bgset, bigrbsiz, bigsbsiz, binary, carrier, ! 88: cdtimo, cmask, crunched, delay, duplex, ebq, ebqflg, escape, flow, fmask, ! 89: fncact, fncnv, incase, inecho, keep, local, lscapr, lscapu, ! 90: maxrps, maxsps, maxtry, mdmspd, mdmtyp, mypadn, ncolx, ! 91: nettype, network, nmac, noinit, npad, parity, pktlog, pkttim, rcflag, ! 92: retrans, rpackets, rptflg, rptq, rtimo, seslog, sessft, sosi, spackets, ! 93: spsiz, spsizf, spsizr, srvtim, stayflg, success, timeouts, tralog, ! 94: tsecs, ttnproto, turn, turnch, urpsiz, wmax, wslotn, wslotr, xargc, xargs, ! 95: zincnt, fdispla, tlevel, xitsta, spmax, insilence, cmdmsk, timint, timef; ! 96: ! 97: #ifdef VMS ! 98: extern int frecl; ! 99: #endif /* VMS */ ! 100: ! 101: extern long ! 102: ffc, filcnt, rptn, speed, tfc, tlci, tlco, vernum; ! 103: ! 104: #ifndef NOSPL ! 105: extern char fspec[], myhost[]; ! 106: #endif /* NOSPL */ ! 107: ! 108: extern char *tfnam[]; /* Command file names */ ! 109: ! 110: #ifdef DCMDBUF ! 111: extern struct cmdptr *cmdstk; ! 112: extern char *line; ! 113: #else ! 114: extern struct cmdptr cmdstk[]; ! 115: extern char line[]; ! 116: #endif /* DCMDBUF */ ! 117: ! 118: extern char pktfil[], /* Packet log file name */ ! 119: #ifdef DEBUG ! 120: debfil[], /* Debug log file name */ ! 121: #endif /* DEBUG */ ! 122: #ifdef TLOG ! 123: trafil[], /* Transaction log file name */ ! 124: #endif /* TLOG */ ! 125: sesfil[]; /* Session log file name */ ! 126: ! 127: #ifndef NOXMIT /* TRANSMIT command variables */ ! 128: extern char xmitbuf[]; ! 129: extern int xmitf, xmitl, xmitp, xmitx, xmits, xmitw; ! 130: #endif /* NOXMIT */ ! 131: ! 132: #ifndef NOSPL ! 133: /* Script programming language items */ ! 134: extern char **a_ptr[]; /* Arrays */ ! 135: extern int a_dim[]; ! 136: extern char inpbuf[], inchar[]; /* Buffers for INPUT and REINPUT */ ! 137: extern char *inpbp; /* And pointer to same */ ! 138: static char *inpbps = inpbuf; /* And another */ ! 139: extern int incount; /* INPUT character count */ ! 140: extern int maclvl; /* Macro invocation level */ ! 141: extern struct mtab *mactab; /* Macro table */ ! 142: extern char *mrval[]; ! 143: extern int macargc[], cmdlvl; ! 144: extern char *m_arg[MACLEVEL][10]; /* You have to put in the dimensions */ ! 145: extern char *g_var[GVARS]; /* for external 2-dimensional arrays. */ ! 146: #ifdef DCMDBUF ! 147: extern int *count; ! 148: #else ! 149: extern int count[]; ! 150: #endif /* DCMDBUF */ ! 151: #endif /* NOSPL */ ! 152: ! 153: #ifdef UNIX ! 154: extern int haslock; /* For UUCP locks */ ! 155: extern char flfnam[]; ! 156: extern int maxnam, maxpath; /* Longest name, path length */ ! 157: #endif /* UNIX */ ! 158: ! 159: #ifndef NODIAL ! 160: /* DIAL-related variables */ ! 161: extern int nmdm, dialhng, dialtmo, dialksp, dialdpy, dialmnp, dialmhu; ! 162: extern char *dialnum, *dialdir, *dialnpr; ! 163: extern struct keytab mdmtab[]; ! 164: #endif /* NODIAL */ ! 165: ! 166: #ifndef NOCSETS ! 167: /* Translation stuff */ ! 168: extern int fcharset, tcharset, tslevel, language, nlng, tcsr, tcsl; ! 169: extern struct keytab lngtab[]; ! 170: extern struct csinfo fcsinfo[], tcsinfo[]; ! 171: extern struct langinfo langs[]; ! 172: #ifdef CK_ANSIC ! 173: extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* Character set */ ! 174: extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(CHAR); /* translation functions */ ! 175: #else ! 176: extern CHAR (*xls[MAXTCSETS+1][MAXFCSETS+1])(); /* Character set */ ! 177: extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(); /* translation functions. */ ! 178: #endif /* CK_ANSIC */ ! 179: #endif /* NOCSETS */ ! 180: ! 181: #ifndef NOSPL ! 182: /* Built-in variable names, maximum length VNAML (20 characters) */ ! 183: ! 184: struct keytab vartab[] = { ! 185: "argc", VN_ARGC, 0, ! 186: "args", VN_ARGS, 0, ! 187: "cmdfile", VN_CMDF, 0, ! 188: "cmdlevel", VN_CMDL, 0, ! 189: "cmdsource", VN_CMDS, 0, ! 190: "count", VN_COUN, 0, ! 191: "cpu", VN_CPU, 0, ! 192: "date", VN_DATE, 0, ! 193: "day", VN_DAY, 0, /* Edit 181 */ ! 194: "directory", VN_DIRE, 0, ! 195: "exitstatus",VN_EXIT, 0, ! 196: "filespec", VN_FILE, 0, ! 197: "fsize", VN_FFC, 0, ! 198: "home", VN_HOME, 0, ! 199: "host", VN_HOST, 0, ! 200: "input", VN_IBUF, 0, ! 201: "inchar", VN_ICHR, 0, ! 202: "incount", VN_ICNT, 0, ! 203: "line", VN_LINE, 0, ! 204: "local", VN_LCL, 0, ! 205: "macro", VN_MAC, 0, ! 206: "ndate", VN_NDAT, 0, ! 207: "nday", VN_NDAY, 0, ! 208: "ntime", VN_NTIM, 0, ! 209: "platform", VN_SYSV, 0, ! 210: "program", VN_PROG, 0, ! 211: "return", VN_RET, 0, ! 212: "speed", VN_SPEE, 0, ! 213: "status", VN_SUCC, 0, ! 214: "system", VN_SYST, 0, ! 215: "tfsize", VN_TFC, 0, ! 216: "time", VN_TIME, 0, ! 217: #ifdef UNIX ! 218: "ttyfd", VN_TTYF, 0, ! 219: #endif /* UNIX */ ! 220: #ifdef OS2 ! 221: "ttyfd", VN_TTYF, 0, ! 222: #endif /* OS2 */ ! 223: "version", VN_VERS, 0 ! 224: }; ! 225: int nvars = (sizeof(vartab) / sizeof(struct keytab)); ! 226: #endif /* NOSPL */ ! 227: ! 228: #ifndef NOSPL ! 229: struct keytab fnctab[] = { /* Function names */ ! 230: "character", FN_CHR, 0, /* Character from code */ ! 231: "code", FN_COD, 0, /* Code from character */ ! 232: "contents", FN_CON, 0, /* Definition (contents) of variable */ ! 233: "definition", FN_DEF, 0, /* Return definition of given macro */ ! 234: "evaluate", FN_EVA, 0, /* Evaluate given arith expression */ ! 235: "execute", FN_EXE, 0, /* Execute given macro */ ! 236: "files", FN_FC, 0, /* File count */ ! 237: "index", FN_IND, 0, /* Index (string search) */ ! 238: "length", FN_LEN, 0, /* Return length of argument */ ! 239: "literal", FN_LIT, 0, /* Return argument literally */ ! 240: "lower", FN_LOW, 0, /* Return lowercased argument */ ! 241: "lpad", FN_LPA, 0, /* Return left-padded argument */ ! 242: "maximum", FN_MAX, 0, /* Return maximum of two arguments */ ! 243: "minimim", FN_MIN, 0, /* Return minimum of two arguments */ ! 244: #ifdef COMMENT ! 245: /* not needed because \feval() has it */ ! 246: "modulus", FN_MOD, 0, /* Return modulus of two arguments */ ! 247: #endif /* COMMENT */ ! 248: "nextfile", FN_FIL, 0, /* Next file in list */ ! 249: "repeat", FN_REP, 0, /* Repeat argument given # of times */ ! 250: #ifndef NOFRILLS ! 251: "reverse", FN_REV, 0, /* Reverse the argument string */ ! 252: #endif /* NOFRILLS */ ! 253: "right", FN_RIG, 0, /* Rightmost n characters */ ! 254: "rpad", FN_RPA, 0, /* Right-pad the argument */ ! 255: "substring", FN_SUB, 0, /* Extract substring from argument */ ! 256: "upper", FN_UPP, 0 /* Return uppercased argument */ ! 257: }; ! 258: int nfuncs = (sizeof(fnctab) / sizeof(struct keytab)); ! 259: #endif /* NOSPL */ ! 260: ! 261: #ifndef NOSPL /* Buffer for expansion of */ ! 262: #define VVBUFL 60 /* built-in variables. */ ! 263: char vvbuf[VVBUFL]; ! 264: #endif /* NOSPL */ ! 265: ! 266: struct keytab disptb[] = { /* Log file disposition */ ! 267: "append", 1, 0, ! 268: "new", 0, 0 ! 269: }; ! 270: ! 271: /* P R E S C A N -- Quick look thru command-line args for init file name */ ! 272: /* Also for -d (debug), -z (force foreground), -S (stay) */ ! 273: ! 274: VOID ! 275: prescan() { ! 276: int yargc; char **yargv; ! 277: char x; ! 278: ! 279: yargc = xargc; ! 280: yargv = xargv; ! 281: strcpy(kermrc,KERMRC); /* Default init file name */ ! 282: #ifndef NOCMDL ! 283: while (--yargc > 0) { /* Look for -y on command line */ ! 284: yargv++; ! 285: if (**yargv == '-') { /* Option starting with dash */ ! 286: x = *(*yargv+1); /* Get option letter */ ! 287: if (x == 'Y') { /* Is it Y (= no init file?) */ ! 288: noinit = 1; ! 289: continue; ! 290: } else if (x == 'y') { /* Is it y? */ ! 291: yargv++, yargc--; /* Yes, count and check argument */ ! 292: if (yargc < 1) fatal("missing name in -y"); ! 293: strcpy(kermrc,*yargv); /* Replace init file name */ ! 294: rcflag = 1; /* Flag that this has been done */ ! 295: continue; ! 296: } else if (x == 'd') { /* Do this early as possible! */ ! 297: debopn("debug.log",0); ! 298: continue; ! 299: } else if (x == 'z') { /* = SET BACKGROUND OFF */ ! 300: bgset = 0; ! 301: continue; ! 302: } else if (x == 'S') { ! 303: stayflg = 1; ! 304: continue; ! 305: } ! 306: } ! 307: } ! 308: #endif /* NOCMDL */ ! 309: } ! 310: ! 311: static int tr_int; /* Flag if TRANSMIT interrupted */ ! 312: ! 313: #ifndef MAC ! 314: SIGTYP ! 315: trtrap(foo) int foo; { /* TRANSMIT interrupt trap */ ! 316: #ifdef __EMX__ ! 317: signal(SIGINT, SIG_ACK); ! 318: #endif ! 319: tr_int = 1; /* (Need arg for ANSI C) */ ! 320: SIGRETURN; ! 321: } ! 322: #endif /* MAC */ ! 323: /* G E T T C S -- Get Transfer (Intermediate) Character Set */ ! 324: ! 325: /* ! 326: Given two file character sets, this routine picks out the appropriate ! 327: "transfer" character set to use for translating between them. ! 328: The transfer character set number is returned. ! 329: ! 330: Translation between two file character sets is done, for example, ! 331: by the CONNECT, TRANSMIT, and TRANSLATE commands. ! 332: ! 333: Translation between Kanji character sets is not yet supported. ! 334: */ ! 335: int ! 336: gettcs(cs1,cs2) int cs1, cs2; { ! 337: #ifdef NOCSETS /* No character-set support */ ! 338: return(0); /* so no translation */ ! 339: #else ! 340: int tcs = TC_TRANSP; ! 341: #ifdef KANJI ! 342: /* Kanji not supported yet */ ! 343: if (fcsinfo[cs1].alphabet == AL_JAPAN || ! 344: fcsinfo[cs2].alphabet == AL_JAPAN ) ! 345: tcs = TC_TRANSP; ! 346: else ! 347: #endif /* KANJI */ ! 348: #ifdef CYRILLIC ! 349: /* ! 350: I can't remember why we don't test both sets here, but I think there ! 351: must have been a reason... ! 352: */ ! 353: if (fcsinfo[cs2].alphabet == AL_CYRIL) ! 354: tcs = TC_CYRILL; ! 355: else ! 356: #endif /* CYRILLIC */ ! 357: #ifdef LATIN2 ! 358: if (cs1 == FC_2LATIN || cs1 == FC_2LATIN || ! 359: cs1 == FC_CP852 || cs1 == FC_CP852 ) ! 360: tcs = TC_2LATIN; ! 361: else ! 362: #endif /* LATIN2 */ ! 363: tcs = TC_1LATIN; ! 364: return(tcs); ! 365: #endif /* NOCSETS */ ! 366: } ! 367: ! 368: #ifndef NOXMIT ! 369: /* T R A N S M I T -- Raw upload */ ! 370: ! 371: /* Obey current line, duplex, parity, flow, text/binary settings. */ ! 372: /* Returns 0 upon apparent success, 1 on obvious failure. */ ! 373: ! 374: /*** ! 375: Things to add: ! 376: . Make both text and binary mode obey set file bytesize. ! 377: . Maybe allow user to specify terminators other than CR? ! 378: . Maybe allow user to specify prompts other than single characters? ! 379: ***/ ! 380: ! 381: /* T R A N S M I T -- Raw upload */ ! 382: ! 383: /* s is the filename, t is the turnaround (prompt) character */ ! 384: ! 385: /* ! 386: Maximum number of characters to buffer. ! 387: Must be less than LINBUFSIZ ! 388: */ ! 389: #define XMBUFS 120 ! 390: ! 391: int ! 392: #ifdef CK_ANSIC ! 393: transmit(char * s, char t) ! 394: #else ! 395: transmit(s,t) char *s; char t; ! 396: #endif /* CK_ANSIC */ ! 397: /* transmit */ { ! 398: #ifdef MAC ! 399: extern char sstate; ! 400: int count = 100; ! 401: #else ! 402: SIGTYP (* oldsig)(); /* For saving old interrupt trap. */ ! 403: #endif /* MAC */ ! 404: long zz; ! 405: int z = 1; /* Return code. 0=fail, 1=succeed. */ ! 406: int x, c, i; /* Workers... */ ! 407: int myflow; ! 408: CHAR csave; ! 409: char *p; ! 410: ! 411: #ifndef NOCSETS ! 412: int tcs = TC_TRANSP; /* Intermediate (xfer) char set */ ! 413: int langsv = L_USASCII; /* Save current language */ ! 414: ! 415: _PROTOTYP ( CHAR (*sxo), (CHAR) ) = NULL; /* Translation functions */ ! 416: _PROTOTYP ( CHAR (*rxo), (CHAR) ) = NULL; ! 417: _PROTOTYP ( CHAR (*sxi), (CHAR) ) = NULL; ! 418: _PROTOTYP ( CHAR (*rxi), (CHAR) ) = NULL; ! 419: #endif /* NOCSETS */ ! 420: ! 421: if (zopeni(ZIFILE,s) == 0) { /* Open the file to be transmitted */ ! 422: printf("?Can't open file %s\n",s); ! 423: return(0); ! 424: } ! 425: x = -1; /* Open the communication line */ ! 426: if (ttopen(ttname,&x,mdmtyp,cdtimo) < 0) { /* (no harm if already open) */ ! 427: printf("Can't open device %s\n",ttname); ! 428: return(0); ! 429: } ! 430: zz = x ? speed : -1L; ! 431: if (binary) { /* Binary file transmission */ ! 432: myflow = (flow == FLO_XONX) ? FLO_NONE : flow; ! 433: if (ttvt(zz,myflow) < 0) { /* So no Xon/Xoff! */ ! 434: printf("Can't condition line\n"); ! 435: return(0); ! 436: } ! 437: } else { ! 438: if (ttpkt(zz,flow,parity) < 0) { /* Put the line in "packet mode" */ ! 439: printf("Can't condition line\n"); /* so Xon/Xoff will work, etc. */ ! 440: return(0); ! 441: } ! 442: } ! 443: ! 444: #ifndef NOCSETS ! 445: tcs = gettcs(tcsr,tcsl); /* Get intermediate set. */ ! 446: ! 447: /* Set up character set translations */ ! 448: if (binary == 0) { ! 449: ! 450: if (tcsr == tcsl || binary) { /* Remote and local sets the same? */ ! 451: sxo = rxo = NULL; /* Or file type is not text? */ ! 452: sxi = rxi = NULL; ! 453: } else { /* Otherwise, set up */ ! 454: sxo = xls[tcs][tcsl]; /* translation function */ ! 455: rxo = xlr[tcs][tcsr]; /* pointers for output functions */ ! 456: sxi = xls[tcs][tcsr]; /* and for input functions. */ ! 457: rxi = xlr[tcs][tcsl]; ! 458: } ! 459: /* ! 460: This is to prevent use of zmstuff() and zdstuff() by translation functions. ! 461: They only work with disk i/o, not with communication i/o. Luckily Russian ! 462: translation functions don't do any stuffing... ! 463: */ ! 464: langsv = language; ! 465: language = L_USASCII; ! 466: } ! 467: #endif /* NOCSETS */ ! 468: ! 469: i = 0; /* Beginning of buffer. */ ! 470: #ifndef MAC ! 471: #ifndef AMIGA ! 472: oldsig = signal(SIGINT, trtrap); /* Save current interrupt trap. */ ! 473: #endif /* AMIGA */ ! 474: #endif /* MAC */ ! 475: tr_int = 0; /* Have not been interrupted (yet). */ ! 476: z = 1; /* Return code presumed good. */ ! 477: #ifdef VMS ! 478: conres(); ! 479: #endif /* VMS */ ! 480: ! 481: c = 0; /* Initial condition */ ! 482: while (c > -1) { /* Loop for all characters in file */ ! 483: #ifdef MAC ! 484: /* ! 485: * It is expensive to run the miniparser so don't do it for ! 486: * every character. ! 487: */ ! 488: if (--count < 0) { ! 489: count = 100; ! 490: miniparser(1); ! 491: if (sstate == 'a') { ! 492: sstate = '\0'; ! 493: z = 0; ! 494: break; ! 495: } ! 496: } ! 497: #else /* Not MAC */ ! 498: if (tr_int) { /* Interrupted? */ ! 499: printf("^C...\n"); /* Print message */ ! 500: z = 0; ! 501: break; ! 502: } ! 503: #endif /* MAC */ ! 504: c = zminchar(); /* Get a file character */ ! 505: debug(F101,"transmit char","",c); ! 506: if (c == -1) /* Test for end-of-file */ ! 507: break; ! 508: c &= fmask; /* Apply SET FILE BYTESIZE mask */ ! 509: ! 510: if (binary) { /* If binary file, */ ! 511: if (ttoc(dopar((char) c)) < 0) { /* else just send the char */ ! 512: printf("?Can't transmit character\n"); ! 513: z = 0; ! 514: break; ! 515: } ! 516: if (xmitw) msleep(xmitw); /* Pause if requested */ ! 517: if (xmitx) { /* SET TRANSMIT ECHO ON? */ ! 518: if (duplex) { /* Yes, for half duplex */ ! 519: conoc((char)(c & cmdmsk)); /* echo locally. */ ! 520: } else { /* For full duplex, */ ! 521: int i, n; /* display whatever is there. */ ! 522: n = ttchk(); /* How many chars are waiting? */ ! 523: for (i = 0; i < n; i++) { /* Read and echo that many. */ ! 524: x = ttinc(1); /* Timed read just in case. */ ! 525: if (x > -1) { /* If no timeout */ ! 526: if (parity) x &= 0x7f; ! 527: conoc((char)(x & cmdmsk)); /* display the char, */ ! 528: } else break; /* otherwise stop reading. */ ! 529: } ! 530: } ! 531: } else ttflui(); /* Not echoing, just flush input. */ ! 532: ! 533: } else { /* Text mode, line at a time. */ ! 534: ! 535: if (c == '\n') { /* Got a line */ ! 536: if (i == 0) { /* Blank line? */ ! 537: if (xmitf) /* Yes, insert fill if asked. */ ! 538: line[i++] = dopar((char) xmitf); ! 539: } ! 540: if (i == 0 || line[i-1] != dopar(CR)) ! 541: line[i++] = dopar(CR); /* Terminate it with CR */ ! 542: if ( ! 543: xmitl ! 544: #ifdef TNCODE ! 545: || (network && ttnproto == NP_TELNET && tn_nlm) ! 546: #endif /* TNCODE */ ! 547: ) ! 548: line[i++] = dopar(LF); /* Include LF if asked */ ! 549: ! 550: } else if (c != -1) { /* Not a newline, regular character */ ! 551: csave = c; /* Remember untranslated version */ ! 552: #ifndef NOCSETS ! 553: /* Translate character sets */ ! 554: if (sxo) c = (*sxo)((CHAR)c); /* From local to intermediate */ ! 555: if (rxo) c = (*rxo)((CHAR)c); /* From intermediate to remote */ ! 556: #endif /* NOCSETS */ ! 557: ! 558: if (xmits && parity && (c & 0200)) { /* If shifting */ ! 559: line[i++] = dopar(SO); /* needs to be done, */ ! 560: line[i++] = dopar((char)c); /* do it here, */ ! 561: line[i++] = dopar(SI); /* crudely. */ ! 562: } else { ! 563: line[i++] = dopar((char)c); /* else, just char itself */ ! 564: } ! 565: } ! 566: ! 567: /* Send characters if buffer full, or at end of line, or at end of file */ ! 568: ! 569: if (i >= XMBUFS || c == '\n' || c == -1) { ! 570: p = line; ! 571: line[i] = '\0'; ! 572: debug(F111,"transmit buf",p,i); ! 573: if (ttol((CHAR *)p,i) < 0) { /* try to send it. */ ! 574: printf("Can't send buffer\n"); ! 575: z = 0; ! 576: break; ! 577: } ! 578: i = 0; /* Reset buffer pointer. */ ! 579: ! 580: /* Worry about echoing here. "xmitx" is SET TRANSMIT ECHO flag. */ ! 581: ! 582: if (duplex && xmitx) { /* If local echo, echo it */ ! 583: if (parity || cmdmsk == 0x7f) { /* Strip off high bits */ ! 584: char *s = p; /* if necessary */ ! 585: while (*s) { ! 586: *s &= 0x7f; ! 587: s++; ! 588: } ! 589: conoll(p); ! 590: } ! 591: } ! 592: if (xmitw) /* Give receiver time to digest. */ ! 593: msleep(xmitw); ! 594: if (t != 0 && c == '\n') { /* Want a turnaround character */ ! 595: x = 0; /* Wait for it */ ! 596: while (x != t) { ! 597: if ((x = ttinc(1)) < 0) break; ! 598: if (xmitx && !duplex) { /* Echo any echoes */ ! 599: if (parity) x &= 0x7f; ! 600: #ifndef NOCSETS ! 601: if (sxi) x = (*sxi)((CHAR)x); /* But translate */ ! 602: if (rxi) x = (*rxi)((CHAR)x); /* them first... */ ! 603: #endif /* NOCSETS */ ! 604: conoc((char) x); ! 605: } ! 606: } ! 607: } else if (xmitx && !duplex) { /* Otherwise, */ ! 608: while (ttchk() > 0) { /* echo for as long as */ ! 609: if ((x = ttinc(0)) < 0) break; /* anything is there. */ ! 610: if (parity) x &= 0x7f; ! 611: #ifndef NOCSETS ! 612: if (sxi) x = (*sxi)((CHAR)x); /* Translate first */ ! 613: if (rxi) x = (*rxi)((CHAR)x); ! 614: #endif /* NOCSETS */ ! 615: conoc((char)x); ! 616: } ! 617: } else ttflui(); /* Otherwise just flush input buffer */ ! 618: } /* End of buffer-dumping block */ ! 619: } /* End of text mode */ ! 620: } /* End of character-reading loop */ ! 621: ! 622: if (*xmitbuf) { /* Anything to send at EOF? */ ! 623: p = xmitbuf; /* Yes, point to string. */ ! 624: while (*p) /* Send it. */ ! 625: ttoc(dopar(*p++)); /* Don't worry about echo here. */ ! 626: } ! 627: ! 628: #ifndef AMIGA ! 629: #ifndef MAC ! 630: signal(SIGINT,oldsig); /* Put old signal action back. */ ! 631: #endif /* MAC */ ! 632: #endif /* AMIGA */ ! 633: #ifdef VMS ! 634: concb(escape); /* Put terminal back, */ ! 635: #endif /* VMS */ ! 636: zclose(ZIFILE); /* Close file, */ ! 637: #ifndef NOCSETS ! 638: language = langsv; /* restore language, */ ! 639: #endif /* NOCSETS */ ! 640: return(z); /* and return successfully. */ ! 641: } ! 642: #endif /* NOXMIT */ ! 643: ! 644: #ifdef MAC ! 645: /* ! 646: This code is not used any more, except on the Macintosh. Instead we call ! 647: system to do the typing. Revive this code if your system can't be called ! 648: to do this. ! 649: */ ! 650: ! 651: /* D O T Y P E -- Type a file */ ! 652: ! 653: int ! 654: dotype(s) char *s; { ! 655: ! 656: #ifdef MAC ! 657: extern char sstate; ! 658: int count = 100; ! 659: #else ! 660: SIGTYP (* oldsig)(); /* For saving old interrupt trap. */ ! 661: #endif /* MAC */ ! 662: int z; /* Return code. */ ! 663: int c; /* Worker. */ ! 664: ! 665: if (zopeni(ZIFILE,s) == 0) { /* Open the file to be typed */ ! 666: printf("?Can't open %s\n",s); ! 667: return(0); ! 668: } ! 669: #ifndef AMIGA ! 670: #ifndef MAC ! 671: oldsig = signal(SIGINT, trtrap); /* Save current interrupt trap. */ ! 672: #endif /* MAC */ ! 673: #endif /* AMIGA */ ! 674: ! 675: tr_int = 0; /* Have not been interrupted (yet). */ ! 676: z = 1; /* Return code presumed good. */ ! 677: ! 678: #ifdef VMS ! 679: conoc(CR); /* On VMS, display blank line first */ ! 680: conoc(LF); ! 681: conres(); /* So Ctrl-C/Y will work */ ! 682: #endif /* VMS */ ! 683: while ((c = zminchar()) != -1) { /* Loop for all characters in file */ ! 684: #ifdef MAC ! 685: /* ! 686: * It is expensive to run the miniparser so don't do it for ! 687: * every character. ! 688: */ ! 689: if (--count < 0) { ! 690: count = 100; ! 691: miniparser(1); ! 692: if (sstate == 'a') { ! 693: sstate = '\0'; ! 694: z = 0; ! 695: break; ! 696: } ! 697: } ! 698: putchar(c); ! 699: #else /* Not MAC */ ! 700: if (tr_int) { /* Interrupted? */ ! 701: printf("^C...\n"); /* Print message */ ! 702: z = 0; ! 703: break; ! 704: } ! 705: conoc(c); /* Echo character on screen */ ! 706: #endif /* MAC */ ! 707: } ! 708: #ifndef AMIGA ! 709: #ifndef MAC ! 710: signal(SIGINT,oldsig); /* put old signal action back. */ ! 711: #endif /* MAC */ ! 712: #endif /* AMIGA */ ! 713: ! 714: tr_int = 0; ! 715: #ifdef VMS ! 716: concb(escape); /* Get back in command-parsing mode, */ ! 717: #endif /* VMS */ ! 718: zclose(ZIFILE); /* close file, */ ! 719: return(z); /* and return successfully. */ ! 720: } ! 721: #endif /* MAC */ ! 722: ! 723: #ifndef NOCSETS ! 724: ! 725: _PROTOTYP( CHAR (*sxx), (CHAR) ); /* Local translation function */ ! 726: _PROTOTYP( CHAR (*rxx), (CHAR) ); /* Local translation function */ ! 727: _PROTOTYP( CHAR zl1as, (CHAR) ); /* Latin-1 to ascii */ ! 728: _PROTOTYP( CHAR xl1as, (CHAR) ); /* ditto */ ! 729: ! 730: /* X L A T E -- Translate a local file from one character set to another */ ! 731: ! 732: /* ! 733: Translates input file (fin) from character set csin to character set csout ! 734: and puts the result in the output file (fout). The two character sets are ! 735: file character sets from fcstab. ! 736: */ ! 737: ! 738: int ! 739: xlate(fin, fout, csin, csout) char *fin, *fout; int csin, csout; { ! 740: ! 741: #ifndef MAC ! 742: SIGTYP (* oldsig)(); /* For saving old interrupt trap. */ ! 743: #endif /* MAC */ ! 744: int filecode; /* Code for output file */ ! 745: ! 746: int z = 1; /* Return code. */ ! 747: int c, tcs; /* Workers */ ! 748: ! 749: if (zopeni(ZIFILE,fin) == 0) { /* Open the file to be translated */ ! 750: printf("?Can't open input file %s\n",fin); ! 751: return(0); ! 752: } ! 753: #ifdef MAC ! 754: /* ! 755: If user specified no output file, it goes to the screen. For the Mac, ! 756: this must be done a special way (result goes to a new window); the Mac ! 757: doesn't have a "controlling terminal" device name. ! 758: */ ! 759: filecode = !strcmp(fout,CTTNAM) ? ZCTERM : ZOFILE; ! 760: #else ! 761: filecode = ZOFILE; ! 762: #endif /* MAC */ ! 763: ! 764: if (zopeno(filecode,fout,NULL,NULL) == 0) { /* And the output file */ ! 765: printf("?Can't open output file %s\n",fout); ! 766: return(0); ! 767: } ! 768: #ifndef AMIGA ! 769: #ifndef MAC ! 770: oldsig = signal(SIGINT, trtrap); /* Save current interrupt trap. */ ! 771: #endif /* MAC */ ! 772: #endif /* AMIGA */ ! 773: ! 774: tr_int = 0; /* Have not been interrupted (yet). */ ! 775: z = 1; /* Return code presumed good. */ ! 776: ! 777: tcs = gettcs(csin,csout); /* Get intermediate set. */ ! 778: ! 779: printf("%s (%s) => %s (%s)\n", /* Say what we're doing. */ ! 780: fin, fcsinfo[csin].name, ! 781: fout,fcsinfo[csout].name ! 782: ); ! 783: printf("via %s", tcsinfo[tcs].name); ! 784: if (language) ! 785: printf(", language: %s\n",langs[language].description); ! 786: printf("\n\n"); ! 787: ! 788: if (csin == csout) { /* Input and output sets the same? */ ! 789: sxx = rxx = NULL; /* If so, no translation. */ ! 790: } else { /* Otherwise, set up */ ! 791: sxx = xls[tcs][csin]; /* translation function */ ! 792: rxx = xlr[tcs][csout]; /* pointers. */ ! 793: if (rxx == zl1as) rxx = xl1as; ! 794: } ! 795: while ((c = zminchar()) != -1) { /* Loop for all characters in file */ ! 796: if (tr_int) { /* Interrupted? */ ! 797: printf("^C...\n"); /* Print message */ ! 798: z = 0; ! 799: break; ! 800: } ! 801: if (sxx) c = (*sxx)((CHAR)c); /* From fcs1 to tcs */ ! 802: if (rxx) c = (*rxx)((CHAR)c); /* from tcs to fcs2 */ ! 803: ! 804: if (zchout(ZOFILE,(char)c) < 0) { /* Output the translated character */ ! 805: printf("File output error\n"); ! 806: z = 0; ! 807: break; ! 808: } ! 809: } ! 810: #ifndef AMIGA ! 811: #ifndef MAC ! 812: signal(SIGINT,oldsig); /* put old signal action back. */ ! 813: #endif /* MAC */ ! 814: #endif /* AMIGA */ ! 815: ! 816: tr_int = 0; ! 817: zclose(ZIFILE); /* close files, */ ! 818: zclose(ZOFILE); ! 819: return(z); /* and return successfully. */ ! 820: } ! 821: #endif /* NOCSETS */ ! 822: ! 823: /* D O L O G -- Do the log command */ ! 824: ! 825: int ! 826: dolog(x) int x; { ! 827: int y, disp; char *s; ! 828: ! 829: switch (x) { ! 830: ! 831: #ifdef DEBUG ! 832: case LOGD: ! 833: y = cmofi("Name of debugging log file","debug.log",&s,xxstring); ! 834: break; ! 835: #endif /* DEBUG */ ! 836: ! 837: case LOGP: ! 838: y = cmofi("Name of packet log file","packet.log",&s,xxstring); ! 839: break; ! 840: ! 841: case LOGS: ! 842: y = cmofi("Name of session log file","session.log",&s,xxstring); ! 843: break; ! 844: ! 845: #ifdef TLOG ! 846: case LOGT: ! 847: y = cmofi("Name of transaction log file","transact.log",&s, ! 848: xxstring); ! 849: break; ! 850: #endif /* TLOG */ ! 851: ! 852: default: ! 853: printf("\n?Unknown log designator - %d\n",x); ! 854: return(-2); ! 855: } ! 856: if (y < 0) return(y); ! 857: ! 858: strcpy(line,s); ! 859: s = line; ! 860: if ((y = cmkey(disptb,2,"Disposition","new",xxstring)) < 0) ! 861: return(y); ! 862: disp = y; ! 863: if ((y = cmcfm()) < 0) return(y); ! 864: ! 865: switch (x) { ! 866: ! 867: #ifdef DEBUG ! 868: case LOGD: ! 869: return(deblog = debopn(s,disp)); ! 870: #endif /* DEBUG */ ! 871: ! 872: case LOGP: ! 873: return(pktlog = pktopn(s,disp)); ! 874: ! 875: case LOGS: ! 876: return(seslog = sesopn(s,disp)); ! 877: ! 878: #ifdef TLOG ! 879: case LOGT: ! 880: return(tralog = traopn(s,disp)); ! 881: #endif /* TLOG */ ! 882: ! 883: default: ! 884: return(-2); ! 885: } ! 886: } ! 887: ! 888: int ! 889: pktopn(s,disp) char *s; int disp; { ! 890: extern char pktfil[]; ! 891: static struct filinfo xx; ! 892: int y; ! 893: ! 894: zclose(ZPFILE); ! 895: if(s[0] == '\0') return(0); ! 896: if (disp) { ! 897: xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0; ! 898: xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = '\0'; ! 899: xx.lblopts = 0; ! 900: y = zopeno(ZPFILE,s,NULL,&xx); ! 901: } else y = zopeno(ZPFILE,s,NULL,NULL); ! 902: if (y > 0) ! 903: strcpy(pktfil,s); ! 904: else ! 905: *pktfil = '\0'; ! 906: return(y); ! 907: } ! 908: ! 909: int ! 910: traopn(s,disp) char *s; int disp; { ! 911: #ifdef TLOG ! 912: extern char trafil[]; ! 913: static struct filinfo xx; ! 914: int y; ! 915: ! 916: zclose(ZTFILE); ! 917: if(s[0] == '\0') return(0); ! 918: if (disp) { ! 919: xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0; ! 920: xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = '\0'; ! 921: xx.lblopts = 0; ! 922: y = zopeno(ZTFILE,s,NULL,&xx); ! 923: } else y = zopeno(ZTFILE,s,NULL,NULL); ! 924: if (y > 0) { ! 925: strcpy(trafil,s); ! 926: tlog(F110,"Transaction Log:",versio,0L); ! 927: #ifndef MAC ! 928: tlog(F100,ckxsys,"",0L); ! 929: #endif /* MAC */ ! 930: ztime(&s); ! 931: tlog(F100,s,"",0L); ! 932: } else *trafil = '\0'; ! 933: return(y); ! 934: #else ! 935: return(0); ! 936: #endif ! 937: } ! 938: ! 939: int ! 940: sesopn(s,disp) char * s; int disp; { ! 941: extern char sesfil[]; ! 942: static struct filinfo xx; ! 943: int y; ! 944: ! 945: zclose(ZSFILE); ! 946: if(s[0] == '\0') return(0); ! 947: if (disp) { ! 948: xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0; ! 949: xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = '\0'; ! 950: xx.lblopts = 0; ! 951: y = zopeno(ZSFILE,s,NULL,&xx); ! 952: } else y = zopeno(ZSFILE,s,NULL,NULL); ! 953: if (y > 0) ! 954: strcpy(sesfil,s); ! 955: else ! 956: *sesfil = '\0'; ! 957: return(y); ! 958: } ! 959: ! 960: int ! 961: debopn(s,disp) char *s; int disp; { ! 962: #ifdef DEBUG ! 963: char *tp; ! 964: static struct filinfo xx; ! 965: ! 966: zclose(ZDFILE); ! 967: ! 968: if (disp) { ! 969: xx.bs = 0; xx.cs = 0; xx.rl = 0; xx.org = 0; xx.cc = 0; ! 970: xx.typ = 0; xx.dsp = XYFZ_A; xx.os_specific = '\0'; ! 971: xx.lblopts = 0; ! 972: deblog = zopeno(ZDFILE,s,NULL,&xx); ! 973: } else deblog = zopeno(ZDFILE,s,NULL,NULL); ! 974: if (deblog > 0) { ! 975: strcpy(debfil,s); ! 976: debug(F110,"Debug Log ",versio,0); ! 977: #ifndef MAC ! 978: debug(F100,ckxsys,"",0); ! 979: #endif /* MAC */ ! 980: ztime(&tp); ! 981: debug(F100,tp,"",0); ! 982: } else *debfil = '\0'; ! 983: return(deblog); ! 984: #else ! 985: return(0); ! 986: #endif ! 987: } ! 988: ! 989: #ifndef NOSHOW ! 990: ! 991: /* S H O P A R -- Show Parameters */ ! 992: ! 993: #ifdef SUNX25 ! 994: VOID ! 995: shox25() { ! 996: if (nettype == NET_SX25) { ! 997: printf("SunLink X.25 V%d.%d",x25ver / 10,x25ver % 10); ! 998: if (ttnproto == NP_X3) printf(", PAD X.3, X.28, X.29 protocol,"); ! 999: printf("\n Reverse charge call %s", ! 1000: revcall ? "selected" : "not selected"); ! 1001: printf (", Closed user group "); ! 1002: if (closgr > -1) ! 1003: printf ("%d",closgr); ! 1004: else ! 1005: printf ("not selected"); ! 1006: printf (","); ! 1007: printf("\n Call user data %s.\n", cudata ? udata : "not selected"); ! 1008: } ! 1009: } ! 1010: #endif /* SUNX25 */ ! 1011: ! 1012: VOID ! 1013: shoparc() { ! 1014: int i; char *s; ! 1015: long zz; ! 1016: ! 1017: puts("Communications Parameters:"); ! 1018: ! 1019: if (network) { ! 1020: printf(" Host: %s",ttname); ! 1021: } else { ! 1022: printf(" Line: %s, speed: ",ttname); ! 1023: if ((zz = ttgspd()) < 0) { ! 1024: printf("unknown"); ! 1025: } else { ! 1026: if (speed == 8880) printf("75/1200"); else printf("%ld",zz); ! 1027: } ! 1028: } ! 1029: printf(", mode: "); ! 1030: if (local) printf("local"); else printf("remote"); ! 1031: if (network == 0) { ! 1032: #ifndef NODIAL ! 1033: for (i = 0; i < nmdm; i++) { ! 1034: if (mdmtab[i].kwval == mdmtyp) { ! 1035: printf(", modem: %s",mdmtab[i].kwd); ! 1036: break; ! 1037: } ! 1038: } ! 1039: #endif /* NODIAL */ ! 1040: } else { ! 1041: if (nettype == NET_TCPA) printf(", TCP/IP"); ! 1042: if (nettype == NET_TCPB) printf(", TCP/IP"); ! 1043: if (nettype == NET_DEC) { ! 1044: if ( ttnproto == NP_LAT ) printf(", DECnet LAT"); ! 1045: else if ( ttnproto == NP_CTERM ) printf(", DECnet CTERM"); ! 1046: else printf(", DECnet"); ! 1047: } ! 1048: if (nettype == NET_PIPE) printf(", Named Pipe"); ! 1049: #ifdef SUNX25 ! 1050: shox25(); ! 1051: #endif /* SUNX25 */ ! 1052: if (ttnproto == NP_TELNET) printf(", telnet protocol"); ! 1053: } ! 1054: if (local) { ! 1055: i = parity ? 7 : 8; ! 1056: if (i == 8) i = (cmask == 0177) ? 7 : 8; ! 1057: printf("\n Terminal bits: %d, p",i); ! 1058: } else printf("\n P"); ! 1059: printf("arity: %s",parnam((char)parity)); ! 1060: printf(", duplex: "); ! 1061: if (duplex) printf("half, "); else printf("full, "); ! 1062: printf("flow: "); ! 1063: if (flow == FLO_KEEP) printf("keep"); ! 1064: else if (flow == FLO_XONX) printf("xon/xoff"); ! 1065: else if (flow == FLO_NONE) printf("none"); ! 1066: else if (flow == FLO_DTRT) printf("dtr/cts"); ! 1067: else if (flow == FLO_RTSC) printf("rts/cts"); ! 1068: else if (flow == FLO_DTRC) printf("dtr/cd"); ! 1069: else printf("%d",flow); ! 1070: printf(", handshake: "); ! 1071: if (turn) printf("%d\n",turnch); else printf("none\n"); ! 1072: if (local && !network) { /* Lockfile & carrier stuff */ ! 1073: if (carrier == CAR_OFF) s = "off"; ! 1074: else if (carrier == CAR_ON) s = "on"; ! 1075: else if (carrier == CAR_AUT) s = "auto"; ! 1076: else s = "unknown"; ! 1077: printf(" Carrier: %s", s); ! 1078: if (carrier == CAR_ON) { ! 1079: if (cdtimo) printf(", timeout: %d sec", cdtimo); ! 1080: else printf(", timeout: none"); ! 1081: } ! 1082: #ifdef UNIX ! 1083: if (haslock && *flfnam) { /* Lockfiles only apply to UNIX... */ ! 1084: printf(", lockfile: %s",flfnam); ! 1085: } ! 1086: #endif /* UNIX */ ! 1087: printf("\n Escape character: %d (^%c)\n",escape,ctl(escape)); ! 1088: } ! 1089: } ! 1090: ! 1091: #ifdef TNCODE ! 1092: static VOID ! 1093: shotel() { ! 1094: printf("SET TELNET parameters:\n echo: %s\n newline-mode: %s\n", ! 1095: tn_duplex ? "local" : "remote", tn_nlm ? "on" : "off"); ! 1096: printf(" terminal-type: "); ! 1097: if (tn_term) printf("%s\n",tn_term); ! 1098: else { ! 1099: char *p; ! 1100: p = getenv("TERM"); ! 1101: if (p) ! 1102: printf("none (%s will be used)\n",p); ! 1103: else printf("none\n"); ! 1104: } ! 1105: } ! 1106: #endif /* TNCODE */ ! 1107: ! 1108: VOID ! 1109: shonet() { ! 1110: #ifndef NETCONN ! 1111: printf("\nNo networks are supported in this version of C-Kermit\n"); ! 1112: #else ! 1113: printf("\nSupported networks:\n"); ! 1114: ! 1115: #ifdef VMS ! 1116: ! 1117: #ifdef MULTINET ! 1118: printf(" TGV MultiNet TCP/IP"); ! 1119: #else ! 1120: #ifdef WINTCP ! 1121: printf(" WOLLONGONG WIN/TCP"); ! 1122: #else ! 1123: #ifdef DEC_TCPIP ! 1124: printf(" DEC TCP/IP Services for (Open)VMS"); ! 1125: #else ! 1126: printf(" None"); ! 1127: #endif /* DEC_TCPIP */ ! 1128: #endif /* WINTCP */ ! 1129: #endif /* MULTINET */ ! 1130: #ifdef TNCODE ! 1131: printf(", TELNET protocol\n\n"); ! 1132: shotel(); ! 1133: #endif /* TNCODE */ ! 1134: printf("\n"); ! 1135: ! 1136: #else /* Not VMS */ ! 1137: ! 1138: #ifdef SUNX25 ! 1139: printf(" SunLink X.25\n"); ! 1140: #endif /* SUNX25 */ ! 1141: #ifdef DECNET ! 1142: printf(" DECnet\n"); ! 1143: #endif /* DECNET */ ! 1144: #ifdef NPIPE ! 1145: printf(" LAN Manager Named Pipe\n"); ! 1146: #endif /* DECNET */ ! 1147: #ifdef TCPSOCKET ! 1148: printf(" TCP/IP"); ! 1149: #ifdef TNCODE ! 1150: printf(", TELNET protocol\n\n"); ! 1151: shotel(); ! 1152: #endif /* TNCODE */ ! 1153: #endif /* TCPSOCKET */ ! 1154: printf("\n"); ! 1155: ! 1156: #endif /* VMS */ ! 1157: ! 1158: printf("Current network type:\n"); ! 1159: if (nettype == NET_TCPA || nettype == NET_TCPB) ! 1160: printf(" TCP/IP\n"); ! 1161: #ifdef SUNX25 ! 1162: else if (nettype == NET_SX25) printf(" X.25\n"); ! 1163: #endif /* SUNX25 */ ! 1164: #ifdef DECNET ! 1165: else if (nettype == NET_DEC) printf(" DECnet\n"); ! 1166: #endif /* DECNET */ ! 1167: ! 1168: printf("\nActive SET HOST connection:\n"); ! 1169: if (network) { ! 1170: printf(" %s",ttname); ! 1171: if (*ipaddr) printf(" [%s]",ipaddr); ! 1172: printf("\n Via: "); ! 1173: if (nettype == NET_TCPA || nettype == NET_TCPB) printf("TCP/IP\n"); ! 1174: else if (nettype == NET_SX25) printf("SunLink X.25\n"); ! 1175: else if (nettype == NET_DEC) { ! 1176: if ( ttnproto == NP_LAT ) printf("DECnet LAT\n"); ! 1177: else if ( ttnproto == NP_CTERM ) printf("DECnet CTERM\n"); ! 1178: else printf("DECnet\n"); ! 1179: } ! 1180: else if (nettype == NET_PIPE) printf("LAN Manager Named Pipe\n"); ! 1181: #ifdef SUNX25 ! 1182: if (nettype == NET_SX25) shox25(); ! 1183: #endif /* SUNX25 */ ! 1184: #ifdef TNCODE ! 1185: if (ttnproto == NP_TELNET) { ! 1186: printf(" TELNET protocol\n"); ! 1187: printf(" Echoing is currently %s\n",duplex ? "local" : "remote"); ! 1188: } ! 1189: #endif /* TNCODE */ ! 1190: } else printf(" None\n"); ! 1191: printf("\n"); ! 1192: #endif /* NETCONN */ ! 1193: } ! 1194: ! 1195: #ifndef NODIAL ! 1196: ! 1197: VOID ! 1198: shodial() { ! 1199: if (mdmtyp >= 0 || local != 0) doshodial(); ! 1200: } ! 1201: ! 1202: static VOID ! 1203: shods(s) char *s; { /* Show a dial-related string */ ! 1204: char c; ! 1205: if (s == NULL || !(*s)) { /* Empty? */ ! 1206: printf("(none)\n"); ! 1207: } else { /* Not empty. */ ! 1208: while (c = *s++) /* Can contain controls */ ! 1209: if (c > 31 && c < 127) { putchar(c); } /* so display them */ ! 1210: else printf("\\{%d}",c); /* in backslash notation */ ! 1211: printf("\n"); ! 1212: } ! 1213: } ! 1214: ! 1215: int ! 1216: doshodial() { ! 1217: printf(" Dial directory: %s\n",dialdir ? dialdir : "(none)"); ! 1218: printf(" Dial hangup: %s, dial modem-hangup: %s\n", ! 1219: dialhng ? "on" : "off", dialmhu ? "on" : "off") ; ! 1220: printf(" Dial kermit-spoof: %s",dialksp ? "on" : "off"); ! 1221: printf(", dial display: %s\n",dialdpy ? "on" : "off"); ! 1222: printf(" Dial speed-matching: %s",mdmspd ? "on" : "off"); ! 1223: printf(", dial mnp-enable: %s\n",dialmnp ? "on" : "off"); ! 1224: printf(" Dial init-string: "); ! 1225: shods(getdws(mdmtyp)); /* Ask dial module for it */ ! 1226: printf(" Dial dial-command: "); ! 1227: shods(getdcs(mdmtyp)); /* Ask dial module for it */ ! 1228: printf(" Dial prefix: "); ! 1229: shods(dialnpr); ! 1230: printf(" Dial timeout: "); ! 1231: if (dialtmo > 0) ! 1232: printf("%d sec", dialtmo); ! 1233: else ! 1234: printf("0 (auto)"); ! 1235: printf(", Redial number: %s\n",dialnum ? dialnum : "(none)"); ! 1236: return(0); ! 1237: } ! 1238: #endif /* NODIAL */ ! 1239: ! 1240: #ifdef SUNX25 ! 1241: VOID ! 1242: shopad() { ! 1243: int i; ! 1244: printf("\nX.3 PAD Parameters:\n"); ! 1245: for (i = 0; i < npadx3; i++) ! 1246: printf(" [%d] %s %d\n",padx3tab[i].kwval,padx3tab[i].kwd, ! 1247: padparms[padx3tab[i].kwval]); ! 1248: } ! 1249: #endif /* SUNX25 */ ! 1250: ! 1251: /* Show File Parameters */ ! 1252: ! 1253: VOID ! 1254: shoparf() { ! 1255: char *s; int i; ! 1256: printf("\nFile parameters: "); ! 1257: #ifdef COMMENT ! 1258: printf("Blocksize: %5d ",fblksiz); ! 1259: #endif /* COMMENT */ ! 1260: printf(" Attributes: "); ! 1261: if (atcapr) printf("on"); else printf("off"); ! 1262: #ifdef VMS ! 1263: printf(" Record-Length: %5d",frecl); ! 1264: #endif /* VMS */ ! 1265: printf("\n Names: "); ! 1266: printf("%-12s",(fncnv) ? "converted" : "literal"); ! 1267: #ifdef DEBUG ! 1268: #ifndef MAC ! 1269: printf(" Debugging Log: "); ! 1270: if (deblog) printf("%s",debfil); else printf("none"); ! 1271: #endif /* MAC */ ! 1272: #endif /* DEBUG */ ! 1273: ! 1274: printf("\n Type: "); ! 1275: switch (binary) { ! 1276: case XYFT_T: s = "text"; break; ! 1277: #ifdef VMS ! 1278: case XYFT_B: s = "binary fixed"; break; ! 1279: case XYFT_I: s = "image"; break; ! 1280: case XYFT_L: s = "labeled"; break; ! 1281: case XYFT_U: s = "binary undef"; break; ! 1282: #else ! 1283: case XYFT_B: s = "binary"; break; ! 1284: #endif /* VMS */ ! 1285: default: s = "?"; break; ! 1286: } ! 1287: printf("%-12s",s); ! 1288: #ifdef COMMENT ! 1289: printf(" Organization: "); ! 1290: switch (forg) { ! 1291: case XYFO_I: printf("%-10s","indexed"); break; ! 1292: case XYFO_R: printf("%-10s","relative"); break; ! 1293: case XYFO_S: printf("%-10s","sequential"); break; ! 1294: } ! 1295: #endif /* COMMENT */ ! 1296: #ifndef MAC ! 1297: printf(" Packet Log: "); ! 1298: if (pktlog) printf(pktfil); else printf("none"); ! 1299: #endif /* MAC */ ! 1300: #ifdef UNIX ! 1301: printf(" Longest filename: %d",maxnam); ! 1302: #endif /* UNIX */ ! 1303: printf("\n Collide: "); ! 1304: for (i = 0; i < ncolx; i++) ! 1305: if (colxtab[i].kwval == fncact) break; ! 1306: printf("%-12s", (i == ncolx) ? "unknown" : colxtab[i].kwd); ! 1307: ! 1308: #ifdef COMMENT ! 1309: printf(" Format: "); ! 1310: switch (frecfm) { ! 1311: case XYFF_F: printf("%-10s","fixed"); break; ! 1312: case XYFF_VB: printf("%-10s","rcw"); break; ! 1313: case XYFF_S: printf("%-10s","stream"); break; ! 1314: case XYFF_U: printf("%-10s","undefined"); break; ! 1315: case XYFF_V: printf("%-10s","variable"); break; ! 1316: } ! 1317: #endif /* COMMENT */ ! 1318: #ifndef MAC ! 1319: printf(" Session Log: "); ! 1320: if (seslog) printf(sesfil); else printf("none"); ! 1321: #endif /* MAC */ ! 1322: #ifdef UNIX ! 1323: printf(" Longest pathname: %d",maxpath); ! 1324: #endif /* UNIX */ ! 1325: printf("\n Display: "); ! 1326: switch (fdispla) { ! 1327: case XYFD_N: printf("%-12s","none"); break; ! 1328: case XYFD_R: printf("%-12s","serial"); break; ! 1329: case XYFD_C: printf("%-12s","fullscreen"); break; ! 1330: case XYFD_S: printf("%-12s","crt"); break; ! 1331: } ! 1332: #ifdef COMMENT ! 1333: printf("Carriage-Control: "); ! 1334: switch (fcctrl) { ! 1335: case XYFP_F: printf("%-10s","fortran"); break; ! 1336: case XYFP_N: printf("%-10s","newline"); break; ! 1337: case XYFP_P: printf("%-10s","machine"); break; ! 1338: case XYFP_X: printf("%-10s","none"); break; ! 1339: } ! 1340: #endif /* COMMENT */ ! 1341: #ifdef TLOG ! 1342: #ifndef MAC ! 1343: printf(" Transaction Log: "); ! 1344: if (tralog) printf(trafil); else printf("none"); ! 1345: #endif /* MAC */ ! 1346: #endif /* TLOG */ ! 1347: #ifndef NOCSETS ! 1348: if (binary == XYFT_T) { ! 1349: shocharset(); ! 1350: } else ! 1351: #endif /* NOCSETS */ ! 1352: printf("\n"); ! 1353: printf("\nFile Byte Size: %d",(fmask == 0177) ? 7 : 8); ! 1354: printf(", Incomplete Files: "); ! 1355: if (keep) printf("keep"); else printf("discard"); ! 1356: #ifdef KERMRC ! 1357: printf(", Init file: %s",kermrc); ! 1358: #endif /* KERMRC */ ! 1359: printf("\n"); ! 1360: } ! 1361: ! 1362: VOID ! 1363: shoparp() { ! 1364: printf("\nProtocol Parameters: Send Receive"); ! 1365: if (timef) ! 1366: printf("\n Timeout (used=%2d):%7d*%8d ", timint, rtimo, pkttim); ! 1367: else ! 1368: printf("\n Timeout (used=%2d):%7d%9d ", timint, rtimo, pkttim); ! 1369: #ifndef NOSERVER ! 1370: printf(" Server Timeout:%4d\n",srvtim); ! 1371: #endif /* NOSERVER */ ! 1372: printf( " Padding: %11d%9d", npad, mypadn); ! 1373: if (bctr == 4) ! 1374: printf(" Block Check: blank-free-2\n"); ! 1375: else ! 1376: printf(" Block Check: %6d\n",bctr); ! 1377: printf( " Pad Character:%11d%9d", padch, mypadc); ! 1378: printf(" Delay: %6d\n",delay); ! 1379: printf( " Packet Start: %11d%9d", mystch, stchr); ! 1380: printf(" Max Retries: %6d\n",maxtry); ! 1381: printf( " Packet End: %11d%9d", seol, eol); ! 1382: if (ebqflg) ! 1383: printf(" 8th-Bit Prefix: '%c'",ebq); ! 1384: #ifdef COMMENT ! 1385: /* ! 1386: This is confusing. ! 1387: */ ! 1388: printf( "\n Packet Length:%11d", spsizf ? spsizr : spsiz); ! 1389: printf( spsizf ? "*" : " " ); printf("%8d", urpsiz); ! 1390: printf( (urpsiz > 94) ? " (94)" : " "); ! 1391: #else ! 1392: printf( "\n Packet Length:%11d ", spmax); ! 1393: printf("%8d ", urpsiz); ! 1394: #endif /* COMMENT */ ! 1395: if (rptflg) ! 1396: printf(" Repeat Prefix: '%c'",rptq); ! 1397: printf( "\n Maximum Length: %9d%9d", maxsps, maxrps); ! 1398: printf(" Window Size:%7d set, %d used\n",wslotr,wmax); ! 1399: printf( " Buffer Size: %11d%9d", bigsbsiz, bigrbsiz); ! 1400: printf(" Locking-Shift: "); ! 1401: if (lscapu == 2) { ! 1402: printf("forced\n"); ! 1403: } else { ! 1404: printf("%s", (lscapr ? "enabled" : "disabled")); ! 1405: if (lscapr) printf(",%s%s", (lscapu ? " " : " not "), "used"); ! 1406: printf("\n"); ! 1407: } ! 1408: } ! 1409: ! 1410: #ifndef NOCSETS ! 1411: VOID ! 1412: shoparl() { ! 1413: #ifdef COMMENT ! 1414: int i; ! 1415: /* Misleading... */ ! 1416: printf("\nAvailable Languages:\n"); ! 1417: for (i = 0; i < MAXLANG; i++) { ! 1418: printf(" %s\n",langs[i].description); ! 1419: } ! 1420: #else ! 1421: printf("\nLanguage-specific translation rules: %s\n", ! 1422: language == L_USASCII ? "none" : langs[language].description); ! 1423: shocharset(); ! 1424: printf("\n\n"); ! 1425: #endif /* COMMENT */ ! 1426: } ! 1427: ! 1428: VOID ! 1429: shocharset() { ! 1430: int x; ! 1431: printf("\n File Character-Set: %s (",fcsinfo[fcharset].name); ! 1432: if ((x = fcsinfo[fcharset].size) == 128) printf("7-bit)"); ! 1433: else if (x == 256) printf("8-bit)"); ! 1434: else printf("(multibyte)"); ! 1435: printf("\n Transfer Character-Set"); ! 1436: #ifdef COMMENT ! 1437: if (tslevel == TS_L2) ! 1438: printf(": (international)"); ! 1439: else ! 1440: #endif /* COMMENT */ ! 1441: if (tcharset == TC_TRANSP) ! 1442: printf(": Transparent"); ! 1443: else ! 1444: printf(": %s",tcsinfo[tcharset].name); ! 1445: } ! 1446: #endif /* NOCSETS */ ! 1447: ! 1448: VOID ! 1449: shopar() { ! 1450: #ifndef MAC ! 1451: printf("\n%s,%s\n",versio,ckxsys); ! 1452: #endif /* MAC */ ! 1453: shoparc(); ! 1454: shoparp(); ! 1455: shoparf(); ! 1456: } ! 1457: #endif /* NOSHOW */ ! 1458: ! 1459: /* D O S T A T -- Display file transfer statistics. */ ! 1460: ! 1461: int ! 1462: dostat() { ! 1463: printf("\nMost recent transaction --\n"); ! 1464: printf("\n files: %ld\n",filcnt); ! 1465: printf(" characters last file : %ld\n",ffc); ! 1466: printf(" total file characters : %ld\n",tfc); ! 1467: printf(" communication line in : %ld\n",tlci); ! 1468: printf(" communication line out : %ld\n",tlco); ! 1469: printf(" packets sent : %d\n", spackets); ! 1470: printf(" packets received : %d\n", rpackets); ! 1471: printf(" damaged packets rec'd : %d\n", crunched); ! 1472: printf(" timeouts : %d\n", timeouts); ! 1473: printf(" retransmissions : %d\n", retrans); ! 1474: if (filcnt > 0) { ! 1475: printf(" parity : %s",parnam((char)parity)); ! 1476: if (autopar) printf(" (detected automatically)"); ! 1477: printf("\n 8th bit prefixing : "); ! 1478: if (ebqflg) printf("yes [%c]\n",ebq); else printf("no\n"); ! 1479: printf(" locking shifts : %s\n", lscapu ? "yes" : "no"); ! 1480: printf(" window slots used : %d of %d\n", wmax, wslotr); ! 1481: printf(" packet length : %d (send), %d (receive)\n", ! 1482: spmax, urpsiz); ! 1483: printf(" compression : "); ! 1484: if (rptflg) printf("yes [%c] (%d)\n",rptq,rptn); else printf("no\n"); ! 1485: if (bctu == 4) ! 1486: printf(" block check type used : blank-free-2\n"); ! 1487: else ! 1488: printf(" block check type used : %d\n",bctu); ! 1489: printf(" elapsed time : %d sec\n",tsecs); ! 1490: if (speed <= 0L) speed = ttgspd(); ! 1491: if (speed > 0L) { ! 1492: if (speed == 8880) ! 1493: printf(" transmission rate : 75/1200 bps\n"); ! 1494: else ! 1495: printf(" transmission rate : %ld bps\n",speed); ! 1496: } ! 1497: if (tsecs > 0) { ! 1498: long lx; ! 1499: lx = (tfc * 10L) / (long) tsecs; ! 1500: printf(" effective data rate : %ld cps\n",lx/10L); ! 1501: if (speed > 0L && speed != 8880L && network == 0) { ! 1502: lx = (lx * 100L) / speed; ! 1503: printf(" efficiency (percent) : %ld\n",lx); ! 1504: } ! 1505: #ifdef COMMENT ! 1506: lx = (tlci * 10L) / (long) tsecs; ! 1507: printf(" throughput (in) : %ld cps\n",lx/10l); ! 1508: lx = (tlco * 10L) / (long) tsecs; ! 1509: printf(" throughput (out) : %ld cps\n",lx/10l); ! 1510: #endif /* COMMENT */ ! 1511: } ! 1512: } ! 1513: return(1); ! 1514: } ! 1515: ! 1516: /* D O C O N E C T -- Do the connect command */ ! 1517: ! 1518: /* Note, we don't call this directly from dial, because we need to give */ ! 1519: /* the user a chance to change parameters (e.g. parity) after the */ ! 1520: /* connection is made. */ ! 1521: ! 1522: int ! 1523: doconect() { ! 1524: int x; ! 1525: conres(); /* Put console back to normal */ ! 1526: x = conect(); /* Connect */ ! 1527: concb((char)escape); /* Put console into cbreak mode, */ ! 1528: return(x); /* for more command parsing. */ ! 1529: } ! 1530: ! 1531: #ifndef NOSPL ! 1532: /* The INPUT command */ ! 1533: ! 1534: #ifdef NETCONN ! 1535: extern int tn_init; ! 1536: #ifndef IAC ! 1537: #define IAC 255 ! 1538: #endif /* IAC */ ! 1539: #endif /* NETCONN */ ! 1540: ! 1541: int ! 1542: doinput(timo,s) int timo; char *s; { ! 1543: int x, y, i, t, icn, anychar; ! 1544: int lastchar = 0; ! 1545: char *xp, *xq = (char *)0; ! 1546: CHAR c; ! 1547: ! 1548: if (local) { /* Put line in "ttvt" mode */ ! 1549: y = ttvt(speed,flow); /* if not already. */ ! 1550: if (y < 0) { ! 1551: printf("?Can't condition line for INPUT\n"); ! 1552: return(0); /* Watch out for failure. */ ! 1553: } ! 1554: } ! 1555: if (!s) s = ""; ! 1556: y = (int)strlen(s); /* If search string is empty */ ! 1557: anychar = (y < 1); /* any input character will do. */ ! 1558: debug(F111,"doinput",s,y); ! 1559: if (timo <= 0) timo = 1; /* Give at least 1 second timeout */ ! 1560: ! 1561: x = 0; /* Return code, assume failure */ ! 1562: i = 0; /* String pattern match position */ ! 1563: ! 1564: if (!incase) { /* INPUT CASE = IGNORE? */ ! 1565: xp = malloc(y+2); /* Make a separate copy of the */ ! 1566: if (!xp) { /* input string for editing. */ ! 1567: printf("?malloc error 5\n"); ! 1568: return(x); ! 1569: } else xq = xp; /* Save pointer to beginning */ ! 1570: ! 1571: while (*s) { /* Convert to lowercase */ ! 1572: *xp = *s; ! 1573: if (isupper(*xp)) *xp = tolower(*xp); ! 1574: xp++; s++; ! 1575: } ! 1576: *xp = NUL; /* Terminate the search string. */ ! 1577: s = xq; /* Point back to beginning. */ ! 1578: } ! 1579: inpbps = inpbp; /* Save current pointer. */ ! 1580: rtimer(); /* Reset timer. */ ! 1581: t = 0; /* Time is 0. */ ! 1582: incount = 0; /* Character counter */ ! 1583: while (1) { /* Character-getting loop */ ! 1584: if (local) { /* One case for local */ ! 1585: y = ttinc(1); /* Get character from comm line. */ ! 1586: debug(F101,"input ttinc(1) returns","",y); ! 1587: if (icn = conchk()) { /* Interrupted from keyboard? */ ! 1588: debug(F101,"input interrupted from keyboard","",icn); ! 1589: while (icn--) coninc(0); /* Yes, read what was typed. */ ! 1590: break; /* And fail. */ ! 1591: } ! 1592: } else { /* Another for remote */ ! 1593: y = coninc(1); ! 1594: debug(F101,"input coninc(1) returns","",y); ! 1595: } ! 1596: if (y > -1) { /* A character arrived */ ! 1597: #ifdef TNCODE ! 1598: /* Check for telnet protocol negotiation */ ! 1599: if (network && (ttnproto == NP_TELNET) && ((y & 0xff) == IAC)) { ! 1600: switch (tn_doop((CHAR)(y & 0xff),duplex,ttinc)) { ! 1601: case 2: duplex = 0; continue; ! 1602: case 1: duplex = 1; ! 1603: default: continue; ! 1604: } ! 1605: } ! 1606: #endif /* TNCODE */ ! 1607: ! 1608: /* Real input character to be checked */ ! 1609: ! 1610: c = cmask & (CHAR) y; /* Mask off parity */ ! 1611: ! 1612: inchar[0] = c; /* Remember character for \v(inchar) */ ! 1613: lastchar = gtimer(); /* Remember when it came. */ ! 1614: ! 1615: if (c == '\0') { /* NUL, we can't use it */ ! 1616: if (anychar) { /* Any character will do? */ ! 1617: x = 1; /* Yes, done. */ ! 1618: incount = 1; /* This must be the first and only. */ ! 1619: break; ! 1620: } else continue; /* Otherwise continue INPUTting */ ! 1621: } ! 1622: ! 1623: *inpbp++ = c; /* Store char in circular buffer */ ! 1624: incount++; /* Count it for \v(incount) */ ! 1625: ! 1626: if (inpbp >= inpbuf + INPBUFSIZ) { /* Time to wrap around? */ ! 1627: inpbp = inpbuf; /* Yes. */ ! 1628: *(inpbp+INPBUFSIZ) = NUL; /* Make sure it's null-terminated. */ ! 1629: } ! 1630: #ifdef MAC ! 1631: { ! 1632: extern char *ttermw; /* fake pointer cast */ ! 1633: if (inecho) { ! 1634: outchar(ttermw, c); /* echo to terminal window */ ! 1635: /* this might be too much overhead to do here ? */ ! 1636: updatecommand(ttermw); ! 1637: } ! 1638: } ! 1639: #else /* Not MAC */ ! 1640: if (inecho) conoc(c); /* Echo and log the input character */ ! 1641: #endif /* MAC */ ! 1642: if (seslog) { ! 1643: #ifdef UNIX ! 1644: if (sessft != 0 || c != '\r') ! 1645: #endif /* UNIX */ ! 1646: if (zchout(ZSFILE,c) < 0) seslog = 0; ! 1647: } ! 1648: if (anychar) { /* Any character will do? */ ! 1649: x = 1; ! 1650: break; ! 1651: } ! 1652: if (!incase) { /* Ignore alphabetic case? */ ! 1653: if (isupper(c)) c = tolower(c); /* Yes */ ! 1654: } ! 1655: debug(F000,"doinput char","",c); ! 1656: debug(F000,"compare char","",s[i]); ! 1657: if (c == s[i]) { /* Check for match */ ! 1658: i++; /* Got one, go to next character */ ! 1659: } else { /* Don't have a match */ ! 1660: int j, size; ! 1661: for (j = i; i-- > 0; ) { /* [jrs] search backwards */ ! 1662: if (c == s[i]) { ! 1663: size = j - i; ! 1664: if (strncmp(s,&s[j-i],i-size)== 0) ! 1665: break; ! 1666: } ! 1667: } ! 1668: i++; /* [jrs] count last char matched */ ! 1669: } /* [jrs] or return to zero from -1 */ ! 1670: if (s[i] == '\0') { /* Matched all the way to end? */ ! 1671: x = 1; /* Yes, */ ! 1672: break; /* done. */ ! 1673: } ! 1674: } ! 1675: if ((t = gtimer()) > timo) /* Did not match, timer exceeded? */ ! 1676: break; ! 1677: else if (insilence > 0 && (t - lastchar) > insilence) ! 1678: break; ! 1679: } /* Still have time left, continue. */ ! 1680: if (!incase) if (xq) free(xq); /* Done, free dynamic memory. */ ! 1681: return(x); /* Return the return code. */ ! 1682: } ! 1683: #endif /* NOSPL */ ! 1684: ! 1685: #ifndef NOSPL ! 1686: /* REINPUT Command */ ! 1687: ! 1688: /* Note, the timeout parameter is required, but ignored. */ ! 1689: /* Syntax is compatible with MS-DOS Kermit except timeout can't be omitted. */ ! 1690: /* This function only looks at the characters already received */ ! 1691: /* and does not read any new characters from the communication line. */ ! 1692: ! 1693: int ! 1694: doreinp(timo,s) int timo; char *s; { ! 1695: int x, y, i; ! 1696: char *xx, *xp, *xq = (char *)0; ! 1697: CHAR c; ! 1698: ! 1699: y = (int)strlen(s); ! 1700: debug(F111,"doreinput",s,y); ! 1701: ! 1702: x = 0; /* Return code, assume failure */ ! 1703: i = 0; /* String pattern match position */ ! 1704: ! 1705: if (!incase) { /* INPUT CASE = IGNORE? */ ! 1706: xp = malloc(y+2); /* Make a separate copy of the */ ! 1707: if (!xp) { /* search string. */ ! 1708: printf("?malloc error 6\n"); ! 1709: return(x); ! 1710: } else xq = xp; /* Keep pointer to beginning. */ ! 1711: while (*s) { /* Yes, convert to lowercase */ ! 1712: *xp = *s; ! 1713: if (isupper(*xp)) *xp = tolower(*xp); ! 1714: xp++; s++; ! 1715: } ! 1716: *xp = NUL; /* Terminate it! */ ! 1717: s = xq; /* Move search pointer to it. */ ! 1718: } ! 1719: xx = inpbp; /* Current INPUT buffer pointer */ ! 1720: do { ! 1721: c = *xx++; /* Get next character */ ! 1722: if (xx >= inpbuf + INPBUFSIZ) xx = inpbuf; /* Wrap around */ ! 1723: if (!incase) { /* Ignore alphabetic case? */ ! 1724: if (isupper(c)) c = tolower(c); /* Yes */ ! 1725: } ! 1726: debug(F000,"doreinp char","",c); ! 1727: debug(F000,"compare char","",s[i]); ! 1728: if (c == s[i]) { /* Check for match */ ! 1729: i++; /* Got one, go to next character */ ! 1730: } else { /* Don't have a match */ ! 1731: int j, size; ! 1732: for (j = i; i-- > 0; ) { /* [jrs] search backwards for it */ ! 1733: if (c == s[i]) { ! 1734: size = j - i; ! 1735: if (strncmp(s,&s[j-i],i-size)== 0) ! 1736: break; ! 1737: } ! 1738: } ! 1739: i++; /* [jrs] count last char matched */ ! 1740: } /* [jrs] or return to zero from -1 */ ! 1741: if (s[i] == '\0') { /* Matched all the way to end? */ ! 1742: x = 1; /* Yes, */ ! 1743: break; /* done. */ ! 1744: } ! 1745: } while (xx != inpbp); /* Until back where we started. */ ! 1746: ! 1747: if (!incase) if (xq) free(xq); /* Free this if it was malloc'd. */ ! 1748: return(x); /* Return search result. */ ! 1749: } ! 1750: #ifndef NOSPL ! 1751: ! 1752: #endif /* NOSPL */ ! 1753: /* X X S T R I N G -- Interpret strings containing backslash escapes */ ! 1754: ! 1755: /* ! 1756: Copies result to new string. ! 1757: strips enclosing braces or doublequotes. ! 1758: interprets backslash escapes. ! 1759: returns 0 on success, nonzero on failure. ! 1760: tries to be compatible with MS-DOS Kermit. ! 1761: ! 1762: Syntax of input string: ! 1763: string = chars | "chars" | {chars} ! 1764: chars = (c*e*)* ! 1765: where c = any printable character, ascii 32-126 ! 1766: and e = a backslash escape ! 1767: and * means 0 or more repetitions of preceding quantity ! 1768: backslash escape = \operand ! 1769: operand = {number} | number | fname(operand) | v(name) | $(name) | m(name) ! 1770: number = [r]n[n[n]]], i.e. an optional radix code followed by 1-3 digits ! 1771: radix code is oO (octal), hHxX (hex), dD or none (decimal). ! 1772: */ ! 1773: ! 1774: #ifndef NOFRILLS ! 1775: int ! 1776: yystring(s,s2) char *s; char **s2; { /* Reverse a string */ ! 1777: int x; ! 1778: static char *new; ! 1779: new = *s2; ! 1780: if (!s || !new) return(-1); /* Watch out for null pointers. */ ! 1781: if ((x = (int)strlen(s)) == 0) { /* Recursion done. */ ! 1782: *new = '\0'; ! 1783: return(0); ! 1784: } ! 1785: x--; /* Otherwise, call self */ ! 1786: *new++ = s[x]; /* to reverse rest of string. */ ! 1787: s[x] = 0; ! 1788: return(yystring(s,&new)); ! 1789: } ! 1790: #endif /* NOFRILLS */ ! 1791: ! 1792: #define FNVALL 1000 ! 1793: char fnval[FNVALL+2]; /* Return value */ ! 1794: ! 1795: char * /* Evaluate builtin function */ ! 1796: fneval(fn,argp,argn) char *fn, *argp[]; int argn; { ! 1797: int i, j, k, len1, len2, n, x, y; ! 1798: char *bp[FNARGS]; /* Pointers to malloc'd strings */ ! 1799: char *p, *s; ! 1800: ! 1801: if (!fn) fn = ""; /* Paranoia */ ! 1802: debug(F111,"fneval",fn,argn); ! 1803: debug(F110,"fneval",argp[0],0); ! 1804: y = lookup(fnctab,fn,nfuncs,&x); ! 1805: if (y < 0) /* bad function name */ ! 1806: return(""); /* so value is null */ ! 1807: ! 1808: #ifdef DEBUG ! 1809: if (deblog) { ! 1810: int j; ! 1811: for (j = 0; j < argn; j++) ! 1812: debug(F111,"fneval function arg",argp[j],j); ! 1813: } ! 1814: #endif /* DEBUG */ ! 1815: ! 1816: if (y == FN_LIT) /* literal(arg1) */ ! 1817: return(argp[0] ? argp[0] : ""); /* return a pointer to arg itself */ ! 1818: ! 1819: if (y == FN_CON) { /* Contents of variable, unexpanded. */ ! 1820: char c; ! 1821: if (!(p = argp[0]) || !*p) return(""); ! 1822: if (*p == CMDQ) p++; ! 1823: if ((c = *p) == '%') { /* Scalar variable. */ ! 1824: c = *++p; /* Get ID character. */ ! 1825: p = ""; /* Assume definition is empty */ ! 1826: if (!c) return(p); /* Double paranoia */ ! 1827: if (c >= '0' && c <= '9') { /* Digit for macro arg */ ! 1828: c -= '0'; /* convert character to integer */ ! 1829: if (maclvl < 0) /* Digit variables are global */ ! 1830: p = g_var[c]; /* if no macro is active */ ! 1831: else /* otherwise */ ! 1832: p = m_arg[maclvl][c]; /* they're on the stack */ ! 1833: } else { ! 1834: if (isupper(c)) c -= ('a'-'A'); ! 1835: p = g_var[c]; /* Letter for global variable */ ! 1836: } ! 1837: return(p ? p : ""); ! 1838: } ! 1839: if (c == '&') { /* Array reference. */ ! 1840: int vbi, d; ! 1841: if (arraynam(p,&vbi,&d) < 0) /* Get name and subscript */ ! 1842: return(""); ! 1843: if (chkarray(vbi,d) > 0) { /* Array is declared? */ ! 1844: vbi -= 'a'; /* Convert name to index */ ! 1845: if (a_dim[vbi] >= d) { /* If subscript in range */ ! 1846: char **ap; ! 1847: ap = a_ptr[vbi]; /* get data pointer */ ! 1848: if (ap) { /* and if there is one */ ! 1849: return(ap[d]); /* return what it points to */ ! 1850: } ! 1851: } ! 1852: } ! 1853: return(p ? p : ""); /* Otherwise its enexpanded value. */ ! 1854: } ! 1855: } ! 1856: ! 1857: for (i = 0; i < argn; i++) { /* Not literal, expand the args */ ! 1858: n = 1024; /* allow 1K per expanded arg, yow! */ ! 1859: bp[i] = s = malloc(n); /* get the new space */ ! 1860: if (bp[i] == NULL) { /* handle failure to get space */ ! 1861: for (k = 0; k < i; k++) if (bp[k]) free(bp[k]); ! 1862: debug(F101,"fneval malloc failure, arg","",i); ! 1863: return(""); ! 1864: } ! 1865: p = argp[i] ? argp[i] : ""; /* Point to this argument */ ! 1866: ! 1867: /* ! 1868: Trim leading and trailing spaces from the original argument, before ! 1869: evaluation. This code new to edit 184. ! 1870: */ ! 1871: if (y != FN_REP || i != 0) { /* Don't trim 1st REPEAT argument */ ! 1872: int j; /* All others... */ ! 1873: while (*p == SP || *p == HT) /* Point past leading whitespace */ ! 1874: p++; ! 1875: j = (int) strlen(p) - 1; /* Trim trailing whitespace */ ! 1876: while (j > 0 && (*(p + j) == SP || *(p + j) == HT)) ! 1877: *(p + j--) = NUL; ! 1878: } ! 1879: ! 1880: /* Now evaluate the argument */ ! 1881: ! 1882: if (xxstring(p,&s,&n) < 0) { /* Expand arg into new space */ ! 1883: debug(F101,"fneval xxstring fails, arg","",i); ! 1884: for (k = 0; k <= i; k++) /* Free up previous space on error */ ! 1885: if (bp[k]) free(bp[k]); ! 1886: return(""); /* and return null string. */ ! 1887: } ! 1888: debug(F111,"fneval arg",bp[i],i); ! 1889: } ! 1890: ! 1891: #ifdef DEBUG ! 1892: if (deblog) { ! 1893: int j; ! 1894: for (j = 0; j < argn; j++) { ! 1895: debug(F111,"fneval arg post eval",argp[j],j); ! 1896: debug(F111,"fneval evaluated arg",bp[j],j); ! 1897: } ! 1898: } ! 1899: #endif /* DEBUG */ ! 1900: ! 1901: switch (y) { /* Do function on expanded args */ ! 1902: ! 1903: case FN_DEF: ! 1904: k = mlook(mactab,bp[0],nmac); /* def(arg1) - Return a macro def */ ! 1905: p = (k > -1) ? mactab[k].mval : ""; ! 1906: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 1907: return(p ? p : ""); ! 1908: ! 1909: case FN_EVA: /* eval(arg1) */ ! 1910: p = evala(bp[0]); ! 1911: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 1912: return(p ? p : ""); ! 1913: ! 1914: case FN_EXE: /* execute(arg1) */ ! 1915: j = (int)strlen(s = bp[0]); /* Length of macro invocation */ ! 1916: p = ""; /* Initialize return value to null */ ! 1917: if (j) { /* If there is a macro to execute */ ! 1918: while (*s == SP) s++,j--; /* strip leading spaces */ ! 1919: p = s; /* remember beginning of macro name */ ! 1920: for (i = 0; i < j; i++) { /* find end of macro name */ ! 1921: if (*s == SP) break; ! 1922: s++; ! 1923: } ! 1924: if (*s == SP) { /* if there was a space after */ ! 1925: *s++ = NUL; /* terminate the macro name */ ! 1926: while (*s == SP) s++; /* skip past any extra spaces */ ! 1927: } else s = ""; /* maybe there are no arguments */ ! 1928: if (p && *p) ! 1929: k = mlook(mactab,p,nmac); /* Look up the macro name */ ! 1930: else k = -1; ! 1931: ! 1932: p = ""; /* Initialize return value */ ! 1933: if (k >= 0) { /* If macro found in table */ ! 1934: if ((j = dodo(k,s)) > 0) { /* Go set it up (like DO cmd) */ ! 1935: if (cmpush() > -1) { /* Push command parser state */ ! 1936: extern int ifc; ! 1937: int ifcsav = ifc; /* Push IF condition on stack */ ! 1938: k = parser(1); /* Call parser to execute the macro */ ! 1939: cmpop(); /* Pop command parser */ ! 1940: ifc = ifcsav; /* Restore IF condition */ ! 1941: if (k == 0) { /* No errors, ignore action cmds. */ ! 1942: p = mrval[maclvl+1]; /* If OK, set return value. */ ! 1943: if (p == NULL) p = ""; ! 1944: } ! 1945: } else { /* Can't push any more */ ! 1946: debug(F100,"fexec pushed too deep","",0); ! 1947: printf("\n?\\fexec() too deeply nested\n"); ! 1948: while (cmpop() > -1) ; ! 1949: p = ""; ! 1950: } ! 1951: } ! 1952: } ! 1953: } ! 1954: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 1955: return(p ? p : ""); ! 1956: ! 1957: case FN_FC: /* File count. */ ! 1958: p = fnval; ! 1959: *p = NUL; ! 1960: if (argn > 0) { ! 1961: k = zxpand(bp[0]); ! 1962: sprintf(fnval,"%d",k); ! 1963: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 1964: } ! 1965: return(p); ! 1966: ! 1967: case FN_FIL: /* Next file in list. */ ! 1968: p = fnval; /* (no args) */ ! 1969: *p = NUL; ! 1970: znext(p); ! 1971: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 1972: return(p ? p : ""); ! 1973: ! 1974: case FN_IND: /* index(arg1,arg2) */ ! 1975: if (argn > 1) { /* Only works if we have 2 args */ ! 1976: int start; ! 1977: len1 = (int)strlen(bp[0]); /* length of string to look for */ ! 1978: len2 = (int)strlen(s = bp[1]); /* length of string to look in */ ! 1979: if (len1 < 0) return(""); /* paranoia */ ! 1980: if (len2 < 0) return(""); ! 1981: j = len2 - len1; /* length difference */ ! 1982: start = 0; /* starting position */ ! 1983: if (argn > 2) { ! 1984: if (chknum(bp[2])) { ! 1985: start = atoi(bp[2]) - 1; ! 1986: if (start < 0) start = 0; ! 1987: } ! 1988: } ! 1989: if (j < 0 || start > j) { /* search string is longer */ ! 1990: p = "0"; ! 1991: } else { ! 1992: if (!incase) { /* input case ignore? */ ! 1993: lower(bp[0]); ! 1994: lower(bp[1]); ! 1995: } ! 1996: s = bp[1] + start; /* Point to beginning of target */ ! 1997: p = "0"; ! 1998: for (i = 0; i <= (j - start); i++) { /* Now compare */ ! 1999: if (!strncmp(bp[0],s++,len1)) { ! 2000: sprintf(fnval,"%d",i+1+start); ! 2001: p = fnval; ! 2002: break; ! 2003: } ! 2004: } ! 2005: } ! 2006: } else p = "0"; ! 2007: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 2008: return(p); ! 2009: ! 2010: case FN_CHR: /* character(arg1) */ ! 2011: if (chknum(bp[0])) { /* Must be numeric */ ! 2012: i = atoi(bp[0]); ! 2013: if (i >= 0 && i < 256) { /* Must be an 8-bit value */ ! 2014: p = fnval; ! 2015: *p++ = i; ! 2016: *p = NUL; ! 2017: p = fnval; ! 2018: } else p = ""; /* Otherwise return null */ ! 2019: } else p = ""; /* Otherwise return null */ ! 2020: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 2021: return(p); ! 2022: ! 2023: case FN_COD: /* code(char) */ ! 2024: p = ""; ! 2025: if ((int)strlen(bp[0]) > 0) { ! 2026: p = fnval; ! 2027: i = *bp[0]; ! 2028: sprintf(p,"%d",(i & 0xff)); ! 2029: } ! 2030: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 2031: return(p); ! 2032: ! 2033: case FN_LEN: /* length(arg1) */ ! 2034: p = fnval; ! 2035: sprintf(p,"%d",(int)strlen(bp[0])); ! 2036: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 2037: return(p); ! 2038: ! 2039: case FN_LOW: /* lower(arg1) */ ! 2040: s = bp[0]; ! 2041: p = fnval; ! 2042: ! 2043: while (*s) { ! 2044: if (isupper(*s)) ! 2045: *p = tolower(*s); ! 2046: else ! 2047: *p = *s; ! 2048: p++; s++; ! 2049: } ! 2050: *p = NUL; ! 2051: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 2052: p = fnval; ! 2053: return(p); ! 2054: ! 2055: case FN_MAX: /* max(arg1,arg2) */ ! 2056: case FN_MIN: /* min(arg1,arg2) */ ! 2057: case FN_MOD: /* mod(arg1,arg2) */ ! 2058: if (chknum(bp[0]) && chknum(bp[1])) { ! 2059: i = atoi(bp[0]); ! 2060: j = atoi(bp[1]); ! 2061: switch (y) { ! 2062: case FN_MAX: ! 2063: if (j < i) j = i; ! 2064: break; ! 2065: case FN_MIN: ! 2066: if (j > i) j = i; ! 2067: break; ! 2068: case FN_MOD: ! 2069: j = i % j; ! 2070: break; ! 2071: } ! 2072: p = fnval; ! 2073: sprintf(p,"%d",j); ! 2074: } else p = ""; ! 2075: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 2076: return(p); ! 2077: ! 2078: case FN_SUB: /* substr(arg1,arg2,arg3) */ ! 2079: case FN_RIG: /* right(arg1,arg2) */ ! 2080: if (((argn > 1) && (int)strlen(bp[1]) && !rdigits(bp[1])) || ! 2081: ((y == FN_SUB) && ! 2082: ((argn > 2) && (int)strlen(bp[2]) && !rdigits(bp[2])))) { ! 2083: p = ""; /* if either, return null */ ! 2084: } else { ! 2085: int lx; ! 2086: p = fnval; /* pointer to result */ ! 2087: lx = strlen(bp[0]); /* length of arg1 */ ! 2088: if (y == FN_SUB) { /* substring */ ! 2089: k = (argn > 2) ? atoi(bp[2]) : 1023; /* length */ ! 2090: j = (argn > 1) ? atoi(bp[1]) : 1; /* start pos for substr */ ! 2091: } else { /* right */ ! 2092: k = (argn > 1) ? atoi(bp[1]) : lx; /* length */ ! 2093: j = lx - k + 1; /* start pos for right */ ! 2094: if (j < 1) j = 1; ! 2095: } ! 2096: if (k > 0 && j <= lx) { /* if start pos in range */ ! 2097: s = bp[0]+j-1; /* point to source string */ ! 2098: for (i = 0; (i < k) && (*p++ = *s++); i++) ; /* copy */ ! 2099: } ! 2100: *p = NUL; /* terminate the result */ ! 2101: p = fnval; /* and point to it. */ ! 2102: } ! 2103: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); /* Free temp mem */ ! 2104: return(p); ! 2105: ! 2106: case FN_UPP: /* upper(arg1) */ ! 2107: s = bp[0]; ! 2108: p = fnval; ! 2109: while (*s) { ! 2110: if (islower(*s)) ! 2111: *p = toupper(*s); ! 2112: else ! 2113: *p = *s; ! 2114: p++; s++; ! 2115: } ! 2116: *p = NUL; ! 2117: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 2118: p = fnval; ! 2119: return(p); ! 2120: ! 2121: case FN_REP: /* Repeat */ ! 2122: p = ""; /* Return value */ ! 2123: if (chknum(bp[1])) { /* Repeat count */ ! 2124: n = atoi(bp[1]); ! 2125: if (n > 0) { /* Make n copies */ ! 2126: p = fnval; ! 2127: *p = '\0'; ! 2128: k = (int)strlen(bp[0]); /* Make sure string has some length */ ! 2129: if (k > 0) { ! 2130: for (i = 0; i < n; i++) { ! 2131: s = bp[0]; ! 2132: for (j = 0; j < k; j++) { ! 2133: if ((p - fnval) >= FNVALL) { /* Protect against */ ! 2134: p = ""; /* core dumps... */ ! 2135: break; ! 2136: } else *p++ = *s++; ! 2137: } ! 2138: } ! 2139: *p = NUL; ! 2140: } ! 2141: } ! 2142: } ! 2143: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 2144: p = fnval; ! 2145: return(p); ! 2146: ! 2147: #ifndef NOFRILLS ! 2148: case FN_REV: ! 2149: p = fnval; ! 2150: yystring(bp[0],&p); ! 2151: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 2152: return(p); ! 2153: #endif /* NOFRILLS */ ! 2154: ! 2155: case FN_RPA: /* RPAD and LPAD */ ! 2156: case FN_LPA: ! 2157: *fnval = NUL; /* Return value */ ! 2158: if (argn == 1) { /* If a number wasn't given */ ! 2159: p = fnval; /* just return the original string */ ! 2160: strncpy(p,bp[0],FNVALL); ! 2161: } else if (chknum(bp[1])) { /* Repeat count */ ! 2162: char pc; ! 2163: n = atoi(bp[1]); ! 2164: if (n >= 0) { /* Pad it out */ ! 2165: p = fnval; ! 2166: k = (int)strlen(bp[0]); /* Length of string to be padded */ ! 2167: pc = (argn < 3) ? SP : *bp[2]; /* Padding character */ ! 2168: if (n > FNVALL) n = FNVALL-1; /* protect against overruns */ ! 2169: if (k > FNVALL) k = FNVALL-1; /* and silly args. */ ! 2170: if (k > n) k = n; ! 2171: if (y == FN_RPA) { /* RPAD */ ! 2172: strncpy(p,bp[0],k); ! 2173: p += k; ! 2174: for (i = k; i < n; i++) ! 2175: *p++ = pc; ! 2176: } else { /* LPAD */ ! 2177: n -= k; ! 2178: for (i = 0; i < n; i++) ! 2179: *p++ = pc; ! 2180: strncpy(p,bp[0],k); ! 2181: p += k; ! 2182: } ! 2183: *p = NUL; ! 2184: } ! 2185: } ! 2186: for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); ! 2187: p = fnval; ! 2188: return(p); ! 2189: ! 2190: default: ! 2191: return(""); ! 2192: } ! 2193: } ! 2194: #endif /* NOSPL */ ! 2195: ! 2196: #ifndef NOSPL ! 2197: ! 2198: char * /* Evaluate builtin variable */ ! 2199: nvlook(s) char *s; { ! 2200: int x, y; ! 2201: long z; ! 2202: char *p; ! 2203: ! 2204: x = 30; ! 2205: p = vvbuf; ! 2206: if (xxstring(s,&p,&x) < 0) { ! 2207: y = -1; ! 2208: } else { ! 2209: s = vvbuf; ! 2210: if ((y = lookup(vartab,s,nvars,&x)) < 0) return(NULL); ! 2211: } ! 2212: switch (y) { ! 2213: case VN_ARGC: /* ARGC */ ! 2214: sprintf(vvbuf,"%d",macargc[maclvl]); ! 2215: return(vvbuf); ! 2216: ! 2217: case VN_ARGS: /* ARGS */ ! 2218: sprintf(vvbuf,"%d",xargs); ! 2219: return(vvbuf); ! 2220: ! 2221: case VN_COUN: /* COUNT */ ! 2222: sprintf(vvbuf,"%d",count[cmdlvl]); ! 2223: return(vvbuf); ! 2224: ! 2225: case VN_DATE: /* DATE */ ! 2226: ztime(&p); /* Get "asctime" string */ ! 2227: if (p == NULL || *p == NUL) return(NULL); ! 2228: vvbuf[0] = p[8]; /* dd */ ! 2229: vvbuf[1] = p[9]; ! 2230: vvbuf[2] = SP; ! 2231: vvbuf[3] = p[4]; /* mmm */ ! 2232: vvbuf[4] = p[5]; ! 2233: vvbuf[5] = p[6]; ! 2234: vvbuf[6] = SP; ! 2235: for (x = 20; x < 24; x++) /* yyyy */ ! 2236: vvbuf[x - 13] = p[x]; ! 2237: vvbuf[11] = NUL; ! 2238: return(vvbuf); ! 2239: ! 2240: case VN_NDAT: /* Numeric date */ ! 2241: ztime(&p); /* Get "asctime" string */ ! 2242: if (p == NULL || *p == NUL) return(NULL); ! 2243: for (x = 20; x < 24; x++) /* yyyy */ ! 2244: vvbuf[x - 20] = p[x]; ! 2245: vvbuf[6] = (p[8] == ' ') ? '0' : p[8]; vvbuf[7] = p[9]; /* dd */ ! 2246: for (x = 0; x < 12; x++) /* mm */ ! 2247: if (!strncmp(p+4,months[x],3)) break; ! 2248: if (x == 12) { ! 2249: vvbuf[4] = vvbuf[5] = '?'; ! 2250: } else { ! 2251: x++; ! 2252: vvbuf[4] = (x < 10) ? '0' : '1'; ! 2253: vvbuf[5] = (x % 10) + 48; ! 2254: } ! 2255: vvbuf[8] = NUL; ! 2256: return(vvbuf); ! 2257: ! 2258: case VN_DIRE: /* DIRECTORY */ ! 2259: return(zgtdir()); ! 2260: ! 2261: case VN_FILE: /* filespec */ ! 2262: return(fspec); ! 2263: ! 2264: case VN_HOST: /* host name */ ! 2265: if (*myhost) { /* If known */ ! 2266: return(myhost); /* return it. */ ! 2267: } else { /* Otherwise */ ! 2268: strcpy(vvbuf,"unknown"); /* just say "unknown" */ ! 2269: return(vvbuf); ! 2270: } ! 2271: ! 2272: case VN_SYST: /* System type */ ! 2273: #ifdef UNIX ! 2274: strcpy(vvbuf,"UNIX"); ! 2275: #else ! 2276: #ifdef VMS ! 2277: strcpy(vvbuf,"VMS"); ! 2278: #else ! 2279: #ifdef OSK ! 2280: strcpy(vvbuf,"OS9/68K"); ! 2281: #else ! 2282: #ifdef AMIGA ! 2283: strcpy(vvbuf,"Amiga"); ! 2284: #else ! 2285: #ifdef MAC ! 2286: strcpy(vvbuf,"Macintosh"); ! 2287: #else ! 2288: #ifdef OS2 ! 2289: strcpy(vvbuf,"OS/2"); ! 2290: #else ! 2291: #ifdef datageneral ! 2292: strcpy(vvbuf,"AOS/VS"); ! 2293: #else ! 2294: #ifdef GEMDOS ! 2295: strcpy(vvbuf,"Atari_ST"); ! 2296: #else ! 2297: strcpy(vvbuf,"unknown"); ! 2298: #endif /* GEMDOS */ ! 2299: #endif /* datageneral */ ! 2300: #endif /* OS2 */ ! 2301: #endif /* MAC */ ! 2302: #endif /* AMIGA */ ! 2303: #endif /* OSK */ ! 2304: #endif /* VMS */ ! 2305: #endif /* UNIX */ ! 2306: return(vvbuf); ! 2307: ! 2308: case VN_SYSV: /* System herald */ ! 2309: for (x = y = 0; x < VVBUFL; x++) { ! 2310: if (ckxsys[x] == SP && y == 0) continue; ! 2311: vvbuf[y++] = (ckxsys[x] == SP) ? '_' : ckxsys[x]; ! 2312: } ! 2313: vvbuf[y] = NUL; ! 2314: return(vvbuf); ! 2315: ! 2316: case VN_TIME: /* TIME. Assumes that ztime returns */ ! 2317: ztime(&p); /* "Thu Feb 8 12:00:00 1990" */ ! 2318: if (p == NULL || *p == NUL) /* like asctime()! */ ! 2319: return(NULL); ! 2320: for (x = 11; x < 19; x++) /* copy hh:mm:ss */ ! 2321: vvbuf[x - 11] = p[x]; /* to vvbuf */ ! 2322: vvbuf[8] = NUL; /* terminate */ ! 2323: return(vvbuf); /* and return it */ ! 2324: ! 2325: case VN_NTIM: /* Numeric time */ ! 2326: ztime(&p); /* "Thu Feb 8 12:00:00 1990" */ ! 2327: if (p == NULL || *p == NUL) /* like asctime()! */ ! 2328: return(NULL); ! 2329: z = atol(p+11) * 3600L + atol(p+14) * 60L + atol(p+17); ! 2330: sprintf(vvbuf,"%ld",z); ! 2331: return(vvbuf); ! 2332: ! 2333: #ifdef UNIX ! 2334: case VN_TTYF: /* TTY file descriptor */ ! 2335: sprintf(vvbuf,"%d",ttyfd); ! 2336: return(vvbuf); ! 2337: #else ! 2338: #ifdef OS2 ! 2339: case VN_TTYF: /* TTY file descriptor */ ! 2340: sprintf(vvbuf,"%d",ttyfd); ! 2341: return(vvbuf); ! 2342: #endif /* OS2 */ ! 2343: #endif /* UNIX */ ! 2344: ! 2345: case VN_VERS: /* Numeric Kermit version number */ ! 2346: sprintf(vvbuf,"%ld",vernum); ! 2347: return(vvbuf); ! 2348: ! 2349: case VN_HOME: /* Home directory */ ! 2350: #ifdef UNIX ! 2351: sprintf(vvbuf,"%s/",zhome()); ! 2352: return(vvbuf); ! 2353: #else ! 2354: return(zhome()); ! 2355: #endif /* UNIX */ ! 2356: ! 2357: case VN_IBUF: /* INPUT buffer */ ! 2358: return(inpbuf); ! 2359: ! 2360: case VN_ICHR: /* INPUT character */ ! 2361: inchar[1] = NUL; ! 2362: return((char *)inchar); ! 2363: ! 2364: case VN_ICNT: /* INPUT character count */ ! 2365: sprintf(vvbuf,"%d",incount); ! 2366: return(vvbuf); ! 2367: ! 2368: case VN_SPEE: { /* Transmission SPEED */ ! 2369: long t; ! 2370: t = ttgspd(); ! 2371: if (t < 0L) ! 2372: sprintf(vvbuf,"unknown"); ! 2373: else ! 2374: sprintf(vvbuf,"%ld",t); ! 2375: return(vvbuf); ! 2376: } ! 2377: case VN_SUCC: /* SUCCESS flag */ ! 2378: sprintf(vvbuf,"%d",(success == 0) ? 1 : 0); ! 2379: return(vvbuf); ! 2380: ! 2381: case VN_LINE: /* LINE */ ! 2382: p = (char *) ttname; ! 2383: return(p); ! 2384: ! 2385: case VN_PROG: /* Program name */ ! 2386: #ifdef MAC ! 2387: return("Mac-Kermit"); ! 2388: #else ! 2389: return("C-Kermit"); ! 2390: #endif /* MAC */ ! 2391: ! 2392: case VN_RET: /* Value of most recent RETURN */ ! 2393: p = mrval[maclvl+1]; ! 2394: if (p == NULL) p = ""; ! 2395: return(p); ! 2396: ! 2397: case VN_FFC: /* Size of most recent file */ ! 2398: sprintf(vvbuf, "%ld", ffc); ! 2399: return(vvbuf); ! 2400: ! 2401: case VN_TFC: /* Size of most recent file group */ ! 2402: sprintf(vvbuf, "%ld", tfc); ! 2403: return(vvbuf); ! 2404: ! 2405: case VN_CPU: /* CPU type */ ! 2406: #ifdef CKCPU ! 2407: return(CKCPU); ! 2408: #else ! 2409: return("unknown"); ! 2410: #endif /* CKCPU */ ! 2411: ! 2412: case VN_CMDL: /* Command level */ ! 2413: sprintf(vvbuf, "%d", cmdlvl); ! 2414: return(vvbuf); ! 2415: ! 2416: case VN_DAY: /* Day of week */ ! 2417: case VN_NDAY: ! 2418: /* ! 2419: Depends on ztime() returning ENGLISH asctime()-format string! ! 2420: asctime() format is: "Thu Feb 8 12:00:00 1990". ! 2421: Needs updating to accommodate non-English asctime() strings. ! 2422: */ ! 2423: ztime(&p); ! 2424: if (p != NULL && *p != NUL) { /* ztime() succeeded. */ ! 2425: if (y == VN_DAY) { /* String day. */ ! 2426: strncpy(vvbuf,p,3); ! 2427: } else { /* Numeric day. */ ! 2428: for (x = 0; x < 7; x++) /* Look up day string in table */ ! 2429: if (!strncmp(p,wkdays[x],3)) ! 2430: break; ! 2431: if (x > 6) x = -1; /* Not found */ ! 2432: sprintf(vvbuf,"%d",x); /* Return the number */ ! 2433: } ! 2434: } else vvbuf[0] = NUL; /* ztime() failed. */ ! 2435: return(vvbuf); /* Return what we got. */ ! 2436: ! 2437: case VN_LCL: /* Local (vs remote) mode */ ! 2438: strcpy(vvbuf, local ? "1" : "0"); ! 2439: return(vvbuf); ! 2440: ! 2441: case VN_CMDS: /* Command source */ ! 2442: if (cmdstk[cmdlvl].src == CMD_KB) ! 2443: strcpy(vvbuf,"prompt"); ! 2444: else if (cmdstk[cmdlvl].src == CMD_MD) ! 2445: strcpy(vvbuf,"macro"); ! 2446: else if (cmdstk[cmdlvl].src == CMD_TF) ! 2447: strcpy(vvbuf,"file"); ! 2448: else strcpy(vvbuf,"unknown"); ! 2449: return(vvbuf); ! 2450: ! 2451: case VN_CMDF: /* Current command file name */ ! 2452: return(tfnam[tlevel] ? tfnam[tlevel] : ""); ! 2453: ! 2454: case VN_MAC: /* Current macro name */ ! 2455: return((maclvl > -1) ? m_arg[maclvl][0] : ""); ! 2456: ! 2457: case VN_EXIT: ! 2458: sprintf(vvbuf,"%d",xitsta); ! 2459: return(vvbuf); ! 2460: ! 2461: default: ! 2462: return(NULL); ! 2463: } ! 2464: } ! 2465: #endif /* NOSPL */ ! 2466: ! 2467: /* ! 2468: X X S T R I N G -- Expand variables and backslash codes. ! 2469: ! 2470: int xxtstring(s,&s2,&n); ! 2471: ! 2472: Expands \ escapes via recursive descent. ! 2473: Argument s is a pointer to string to expand (source). ! 2474: Argument s2 is the address of where to put result (destination). ! 2475: Argument n is the length of the destination string (to prevent overruns). ! 2476: Returns -1 on failure, 0 on success, ! 2477: with destination string null-terminated and s2 pointing to the ! 2478: terminating null, so that subsequent characters can be added. ! 2479: */ ! 2480: ! 2481: #define XXDEPLIM 100 /* Recursion depth limit */ ! 2482: ! 2483: int ! 2484: xxstring(s,s2,n) char *s; char **s2; int *n; { ! 2485: int x, /* Current character */ ! 2486: y, /* Worker */ ! 2487: pp, /* Paren level */ ! 2488: argn, /* Function argument counter */ ! 2489: n2, /* Local copy of n */ ! 2490: d, /* Array dimension */ ! 2491: vbi, /* Variable id (integer form) */ ! 2492: argl; /* String argument length */ ! 2493: ! 2494: char vb, /* Variable id (char form) */ ! 2495: *vp, /* Pointer to variable definition */ ! 2496: *new, /* Local pointer to target string */ ! 2497: *p, /* Worker */ ! 2498: *q; /* Worker */ ! 2499: char *r = (char *)0; /* For holding function args */ ! 2500: char *r2 = (char *)0; ! 2501: ! 2502: #ifndef NOSPL ! 2503: char vnambuf[VNAML]; /* Buffer for variable/function name */ ! 2504: char *argp[FNARGS]; /* Pointers to function args */ ! 2505: #endif /* NOSPL */ ! 2506: ! 2507: static int depth = 0; /* Call depth, avoid overflow */ ! 2508: ! 2509: n2 = *n; /* Make local copies of args */ ! 2510: new = *s2; /* for one less level of indirection */ ! 2511: ! 2512: depth++; /* Sink to a new depth */ ! 2513: if (depth > XXDEPLIM) { /* Too deep? */ ! 2514: printf("?definition is circular or too deep\n"); ! 2515: depth = 0; ! 2516: *new = NUL; ! 2517: return(-1); ! 2518: } ! 2519: if (!s || !new) { /* Watch out for null pointers */ ! 2520: depth = 0; ! 2521: *new = NUL; ! 2522: return(-1); ! 2523: } ! 2524: argl = (int)strlen(s); /* Get length of source string */ ! 2525: debug(F111,"xxstring",s,argl); ! 2526: if (argl < 0) { /* Watch out for garbage */ ! 2527: depth = 0; ! 2528: *new = NUL; ! 2529: return(-1); ! 2530: } ! 2531: while ( x = *s ) { /* Loop for all characters */ ! 2532: if (x != CMDQ) { /* Is it the command-quote char? */ ! 2533: *new++ = *s++; /* No, normal char, just copy */ ! 2534: if (n2-- < 0) { /* and count it, careful of overflow */ ! 2535: return(-1); ! 2536: } ! 2537: continue; ! 2538: } ! 2539: ! 2540: /* We have the command-quote character. */ ! 2541: ! 2542: x = *(s+1); /* Get the following character. */ ! 2543: switch (x) { /* Act according to variable type */ ! 2544: #ifndef NOSPL ! 2545: case '%': /* Variable */ ! 2546: s += 2; /* Get the letter or digit */ ! 2547: vb = *s++; /* and move source pointer past it */ ! 2548: vp = NULL; /* Assume definition is empty */ ! 2549: if (vb >= '0' && vb <= '9') { /* Digit for macro arg */ ! 2550: if (maclvl < 0) /* Digit variables are global */ ! 2551: vp = g_var[vb]; /* if no macro is active */ ! 2552: else /* otherwise */ ! 2553: vp = m_arg[maclvl][vb - '0']; /* they're on the stack */ ! 2554: } else { ! 2555: if (isupper(vb)) vb -= ('a'-'A'); ! 2556: vp = g_var[vb]; /* Letter for global variable */ ! 2557: } ! 2558: if (vp) { /* If definition not empty */ ! 2559: if (xxstring(vp,&new,&n2) < 0) { /* call self to evaluate it */ ! 2560: return(-1); /* Pass along failure */ ! 2561: } ! 2562: } ! 2563: break; ! 2564: case '&': /* An array reference */ ! 2565: if (arraynam(s,&vbi,&d) < 0) { /* Get name and subscript */ ! 2566: return(-1); ! 2567: } ! 2568: pp = 0; /* Bracket counter */ ! 2569: while (*s) { /* Advance source pointer */ ! 2570: if (*s == '[') pp++; ! 2571: if (*s == ']' && --pp == 0) break; ! 2572: s++; ! 2573: } ! 2574: if (*s == ']') s++; /* past the closing bracket. */ ! 2575: if (chkarray(vbi,d) > 0) { /* Array is declared? */ ! 2576: vbi -= 96; /* Convert name to index */ ! 2577: if (a_dim[vbi] >= d) { /* If subscript in range */ ! 2578: char **ap; ! 2579: ap = a_ptr[vbi]; /* get data pointer */ ! 2580: if (ap) { /* and if there is one */ ! 2581: if (ap[d]) { /* If definition not empty */ ! 2582: if (xxstring(ap[d],&new,&n2) < 0) { /* evaluate */ ! 2583: return(-1); /* Pass along failure */ ! 2584: } ! 2585: } ! 2586: } ! 2587: } ! 2588: } ! 2589: break; ! 2590: ! 2591: case 'F': /* A builtin function */ ! 2592: case 'f': ! 2593: q = vnambuf; /* Copy the name */ ! 2594: y = 0; /* into a separate buffer */ ! 2595: s+=2; /* point past 'F' */ ! 2596: while (y++ < VNAML) { ! 2597: if (*s == '(') { s++; break; } /* Look for open paren */ ! 2598: if ((*q = *s) == NUL) break; /* or end of string */ ! 2599: s++; q++; ! 2600: } ! 2601: *q = NUL; /* Terminate function name */ ! 2602: if (y >= VNAML) { /* Handle pathological case */ ! 2603: while (*s && (*s != '(')) /* of very long string entered */ ! 2604: s++; /* as function name. */ ! 2605: if (*s == ')') s++; /* Skip past it. */ ! 2606: } ! 2607: r = r2 = malloc(argl+2); /* And make a place to copy args */ ! 2608: debug(F101,"xxstring r2","",r2); ! 2609: if (!r2) { /* Watch out for malloc failure */ ! 2610: depth = 0; ! 2611: *new = NUL; ! 2612: return(-1); ! 2613: } ! 2614: argn = 0; /* Argument counter */ ! 2615: argp[argn++] = r; /* Point to first argument */ ! 2616: y = 0; /* Completion flag */ ! 2617: pp = 1; /* Paren level (already have one). */ ! 2618: while (*r = *s) { /* Copy each argument, char by char. */ ! 2619: if (*r == '(') pp++; /* Count an opening paren. */ ! 2620: if (*r == ')') { /* Closing paren, count it. */ ! 2621: if (--pp == 0) { /* Final one? */ ! 2622: *r = NUL; /* Make it a terminating null */ ! 2623: s++; ! 2624: y = 1; /* Flag we've got all the args */ ! 2625: break; ! 2626: } ! 2627: } ! 2628: if (*r == ',') { /* Comma */ ! 2629: if (pp == 1) { /* If not within ()'s, */ ! 2630: *r = NUL; /* new arg, skip past it, */ ! 2631: argp[argn++] = r+1; /* point to new arg. */ ! 2632: if (argn == FNARGS) /* Too many args */ ! 2633: break; ! 2634: } /* Otherwise just skip past */ ! 2635: } ! 2636: s++; r++; /* Advance pointers */ ! 2637: } ! 2638: debug(F110,"xxstring function name",vnambuf,0); ! 2639: if (!y) { /* If we didn't find closing paren */ ! 2640: debug(F101,"xxstring r2 before free","",r2); ! 2641: if (r2) free(r2); /* free the temporary storage */ ! 2642: return(-1); /* and return failure. */ ! 2643: } ! 2644: #ifdef DEBUG ! 2645: if (deblog) ! 2646: for (y = 0; y < argn; y++) ! 2647: debug(F111,"xxstring function arg",argp[y],y); ! 2648: #endif /* DEBUG */ ! 2649: vp = fneval(vnambuf,argp,argn); /* Evaluate the function. */ ! 2650: if (vp) { /* If definition not empty */ ! 2651: while (*new++ = *vp++) /* copy it to output string */ ! 2652: if (n2-- < 0) return(-1); /* mindful of overflow */ ! 2653: new--; /* Back up over terminating null */ ! 2654: n2++; /* to allow for further deposits. */ ! 2655: } ! 2656: if (r2) { ! 2657: debug(F101,"xxstring freeing r2","",r2); ! 2658: free(r2); /* Now free the temporary storage */ ! 2659: r2 = NULL; ! 2660: } ! 2661: break; ! 2662: case '$': /* An environment variable */ ! 2663: case 'V': /* Or a named builtin variable. */ ! 2664: case 'v': ! 2665: case 'M': /* Or a macro = long variable */ ! 2666: case 'm': ! 2667: p = s+2; /* $/V/M must be followed by (name) */ ! 2668: if (*p != '(') { /* as in \$(HOME) or \V(count) */ ! 2669: *new++ = *s++; /* If not, just copy it */ ! 2670: if (n2-- < 0) { ! 2671: return(-1); ! 2672: } ! 2673: break; ! 2674: } ! 2675: p++; /* Point to 1st char of name */ ! 2676: q = vnambuf; /* Copy the name */ ! 2677: y = 0; /* into a separate buffer */ ! 2678: while (y++ < VNAML) { /* Watch out for name too long */ ! 2679: if (*p == ')') { /* Name properly terminated with ')' */ ! 2680: p++; /* Move source pointer past ')' */ ! 2681: break; ! 2682: } ! 2683: if ((*q = *p) == NUL) /* String ends before ')' */ ! 2684: break; ! 2685: p++; q++; /* Advance pointers */ ! 2686: } ! 2687: *q = NUL; /* Terminate the variable name */ ! 2688: if (y >= VNAML) { /* Handle pathological case */ ! 2689: while (*p && (*p != ')')) /* of very long string entered */ ! 2690: p++; /* as variable name. */ ! 2691: if (*p == ')') p++; /* Skip ahead to the end of it. */ ! 2692: } ! 2693: s = p; /* Adjust global source pointer */ ! 2694: p = malloc((int)strlen(vnambuf) + 1); /* Make temporary space */ ! 2695: if (p) { /* If we got the space */ ! 2696: vp = vnambuf; /* Point to original */ ! 2697: strcpy(p,vp); /* Make a copy of it */ ! 2698: y = VNAML; /* Length of name buffer */ ! 2699: xxstring(p,&vp,&y); /* Evaluate the copy */ ! 2700: free(p); /* Free the temporary space */ ! 2701: } ! 2702: debug(F110,"xxstring vname",vnambuf,0); ! 2703: if (x == '$') { /* Look up its value */ ! 2704: vp = getenv(vnambuf); /* This way for environment variable */ ! 2705: } else if (x == 'm' || x == 'M') { /* or this way for macro */ ! 2706: y = mlook(mactab,vnambuf,nmac); /* contents (= long variable */ ! 2707: vp = (y > -1) ? mactab[y].mval : ""; /* name)... */ ! 2708: } else { /* or */ ! 2709: vp = nvlook(vnambuf); /* this way for builtin variable */ ! 2710: } ! 2711: if (vp) { /* If definition not empty */ ! 2712: while (*new++ = *vp++) /* copy it to output string. */ ! 2713: if (n2-- < 0) { ! 2714: return(-1); ! 2715: } ! 2716: new--; /* Back up over terminating null */ ! 2717: n2++; /* to allow for further deposits. */ ! 2718: } ! 2719: break; ! 2720: #endif /* NOSPL */ /* Handle \nnn even if NOSPL. */ ! 2721: default: /* Maybe it's a backslash code */ ! 2722: y = xxesc(&s); /* Go interpret it */ ! 2723: if (y < 0) { /* Upon failure */ ! 2724: *new++ = x; /* Just quote the next character */ ! 2725: s += 2; /* Move past the pair */ ! 2726: n2 -= 2; ! 2727: if (n2 < 0) { ! 2728: return(-1); ! 2729: } ! 2730: continue; /* and go back for more */ ! 2731: } else { ! 2732: *new++ = y; /* else deposit interpreted value */ ! 2733: if (n2-- < 0) { ! 2734: return(-1); ! 2735: } ! 2736: } ! 2737: } ! 2738: } ! 2739: *new = NUL; /* Terminate the new string */ ! 2740: depth--; /* Adjust stack depth gauge */ ! 2741: *s2 = new; /* Copy results back into */ ! 2742: *n = n2; /* the argument addresses */ ! 2743: return(0); /* and return. */ ! 2744: } ! 2745: #endif /* NOICP */ ! 2746: ! 2747:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.