![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to commands.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / telnet / Source|
Return to commands.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / telnet / Source |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted ! 6: * provided that this notice is preserved and that due credit is given ! 7: * to the University of California at Berkeley. The name of the University ! 8: * may not be used to endorse or promote products derived from this ! 9: * software without specific prior written permission. This software ! 10: * is provided ``as is'' without express or implied warranty. ! 11: */ ! 12: ! 13: #ifndef lint ! 14: static char sccsid[] = "@(#)commands.c 1.5 (Berkeley) 5/15/88"; ! 15: #endif /* not lint */ ! 16: ! 17: #include <sys/types.h> ! 18: #include <sys/socket.h> ! 19: #include <netinet/in.h> ! 20: ! 21: #include <signal.h> ! 22: #include <netdb.h> ! 23: #include <ctype.h> ! 24: ! 25: #include <arpa/telnet.h> ! 26: ! 27: #include "general.h" ! 28: ! 29: #include "ring.h" ! 30: ! 31: #include "externs.h" ! 32: #include "defines.h" ! 33: #include "types.h" ! 34: ! 35: char *hostname; ! 36: ! 37: #define Ambiguous(s) ((char *)s == ambiguous) ! 38: static char *ambiguous; /* special return value for command routines */ ! 39: ! 40: typedef struct { ! 41: char *name; /* command name */ ! 42: char *help; /* help string */ ! 43: int (*handler)(); /* routine which executes command */ ! 44: int dohelp; /* Should we give general help information? */ ! 45: int needconnect; /* Do we need to be connected to execute? */ ! 46: } Command; ! 47: ! 48: static char line[200]; ! 49: static int margc; ! 50: static char *margv[20]; ! 51: ! 52: /* ! 53: * Various utility routines. ! 54: */ ! 55: ! 56: static void ! 57: makeargv() ! 58: { ! 59: register char *cp; ! 60: register char **argp = margv; ! 61: ! 62: margc = 0; ! 63: cp = line; ! 64: if (*cp == '!') { /* Special case shell escape */ ! 65: *argp++ = "!"; /* No room in string to get this */ ! 66: margc++; ! 67: cp++; ! 68: } ! 69: while (*cp) { ! 70: while (isspace(*cp)) ! 71: cp++; ! 72: if (*cp == '\0') ! 73: break; ! 74: *argp++ = cp; ! 75: margc += 1; ! 76: while (*cp != '\0' && !isspace(*cp)) ! 77: cp++; ! 78: if (*cp == '\0') ! 79: break; ! 80: *cp++ = '\0'; ! 81: } ! 82: *argp++ = 0; ! 83: } ! 84: ! 85: ! 86: static char ** ! 87: genget(name, table, next) ! 88: char *name; /* name to match */ ! 89: char **table; /* name entry in table */ ! 90: char **(*next)(); /* routine to return next entry in table */ ! 91: { ! 92: register char *p, *q; ! 93: register char **c, **found; ! 94: register int nmatches, longest; ! 95: ! 96: if (name == 0) { ! 97: return 0; ! 98: } ! 99: longest = 0; ! 100: nmatches = 0; ! 101: found = 0; ! 102: for (c = table; (p = *c) != 0; c = (*next)(c)) { ! 103: for (q = name; ! 104: (*q == *p) || (isupper(*q) && tolower(*q) == *p); p++, q++) ! 105: if (*q == 0) /* exact match? */ ! 106: return (c); ! 107: if (!*q) { /* the name was a prefix */ ! 108: if (q - name > longest) { ! 109: longest = q - name; ! 110: nmatches = 1; ! 111: found = c; ! 112: } else if (q - name == longest) ! 113: nmatches++; ! 114: } ! 115: } ! 116: if (nmatches > 1) ! 117: return (char **)ambiguous; ! 118: return (found); ! 119: } ! 120: ! 121: /* ! 122: * Make a character string into a number. ! 123: * ! 124: * Todo: 1. Could take random integers (12, 0x12, 012, 0b1). ! 125: */ ! 126: ! 127: static ! 128: special(s) ! 129: register char *s; ! 130: { ! 131: register char c; ! 132: char b; ! 133: ! 134: switch (*s) { ! 135: case '^': ! 136: b = *++s; ! 137: if (b == '?') { ! 138: c = b | 0x40; /* DEL */ ! 139: } else { ! 140: c = b & 0x1f; ! 141: } ! 142: break; ! 143: default: ! 144: c = *s; ! 145: break; ! 146: } ! 147: return c; ! 148: } ! 149: ! 150: /* ! 151: * Construct a control character sequence ! 152: * for a special character. ! 153: */ ! 154: static char * ! 155: control(c) ! 156: register int c; ! 157: { ! 158: static char buf[3]; ! 159: ! 160: if (c == 0x7f) ! 161: return ("^?"); ! 162: if (c == '\377') { ! 163: return "off"; ! 164: } ! 165: if (c >= 0x20) { ! 166: buf[0] = c; ! 167: buf[1] = 0; ! 168: } else { ! 169: buf[0] = '^'; ! 170: buf[1] = '@'+c; ! 171: buf[2] = 0; ! 172: } ! 173: return (buf); ! 174: } ! 175: ! 176: ! 177: ! 178: /* ! 179: * The following are data structures and routines for ! 180: * the "send" command. ! 181: * ! 182: */ ! 183: ! 184: struct sendlist { ! 185: char *name; /* How user refers to it (case independent) */ ! 186: int what; /* Character to be sent (<0 ==> special) */ ! 187: char *help; /* Help information (0 ==> no help) */ ! 188: #if defined(NOT43) ! 189: int (*routine)(); /* Routine to perform (for special ops) */ ! 190: #else /* defined(NOT43) */ ! 191: void (*routine)(); /* Routine to perform (for special ops) */ ! 192: #endif /* defined(NOT43) */ ! 193: }; ! 194: ! 195: #define SENDQUESTION -1 ! 196: #define SENDESCAPE -3 ! 197: ! 198: static struct sendlist Sendlist[] = { ! 199: { "ao", AO, "Send Telnet Abort output" }, ! 200: { "ayt", AYT, "Send Telnet 'Are You There'" }, ! 201: { "brk", BREAK, "Send Telnet Break" }, ! 202: { "ec", EC, "Send Telnet Erase Character" }, ! 203: { "el", EL, "Send Telnet Erase Line" }, ! 204: { "escape", SENDESCAPE, "Send current escape character" }, ! 205: { "ga", GA, "Send Telnet 'Go Ahead' sequence" }, ! 206: { "ip", IP, "Send Telnet Interrupt Process" }, ! 207: { "nop", NOP, "Send Telnet 'No operation'" }, ! 208: { "synch", SYNCH, "Perform Telnet 'Synch operation'", dosynch }, ! 209: { "?", SENDQUESTION, "Display send options" }, ! 210: { 0 } ! 211: }; ! 212: ! 213: static struct sendlist Sendlist2[] = { /* some synonyms */ ! 214: { "break", BREAK, 0 }, ! 215: ! 216: { "intp", IP, 0 }, ! 217: { "interrupt", IP, 0 }, ! 218: { "intr", IP, 0 }, ! 219: ! 220: { "help", SENDQUESTION, 0 }, ! 221: ! 222: { 0 } ! 223: }; ! 224: ! 225: static char ** ! 226: getnextsend(name) ! 227: char *name; ! 228: { ! 229: struct sendlist *c = (struct sendlist *) name; ! 230: ! 231: return (char **) (c+1); ! 232: } ! 233: ! 234: static struct sendlist * ! 235: getsend(name) ! 236: char *name; ! 237: { ! 238: struct sendlist *sl; ! 239: ! 240: if ((sl = (struct sendlist *) ! 241: genget(name, (char **) Sendlist, getnextsend)) != 0) { ! 242: return sl; ! 243: } else { ! 244: return (struct sendlist *) ! 245: genget(name, (char **) Sendlist2, getnextsend); ! 246: } ! 247: } ! 248: ! 249: static ! 250: sendcmd(argc, argv) ! 251: int argc; ! 252: char **argv; ! 253: { ! 254: int what; /* what we are sending this time */ ! 255: int count; /* how many bytes we are going to need to send */ ! 256: int i; ! 257: int question = 0; /* was at least one argument a question */ ! 258: struct sendlist *s; /* pointer to current command */ ! 259: ! 260: if (argc < 2) { ! 261: printf("need at least one argument for 'send' command\n"); ! 262: printf("'send ?' for help\n"); ! 263: return 0; ! 264: } ! 265: /* ! 266: * First, validate all the send arguments. ! 267: * In addition, we see how much space we are going to need, and ! 268: * whether or not we will be doing a "SYNCH" operation (which ! 269: * flushes the network queue). ! 270: */ ! 271: count = 0; ! 272: for (i = 1; i < argc; i++) { ! 273: s = getsend(argv[i]); ! 274: if (s == 0) { ! 275: printf("Unknown send argument '%s'\n'send ?' for help.\n", ! 276: argv[i]); ! 277: return 0; ! 278: } else if (Ambiguous(s)) { ! 279: printf("Ambiguous send argument '%s'\n'send ?' for help.\n", ! 280: argv[i]); ! 281: return 0; ! 282: } ! 283: switch (s->what) { ! 284: case SENDQUESTION: ! 285: break; ! 286: case SENDESCAPE: ! 287: count += 1; ! 288: break; ! 289: case SYNCH: ! 290: count += 2; ! 291: break; ! 292: default: ! 293: count += 2; ! 294: break; ! 295: } ! 296: } ! 297: /* Now, do we have enough room? */ ! 298: if (NETROOM() < count) { ! 299: printf("There is not enough room in the buffer TO the network\n"); ! 300: printf("to process your request. Nothing will be done.\n"); ! 301: printf("('send synch' will throw away most data in the network\n"); ! 302: printf("buffer, if this might help.)\n"); ! 303: return 0; ! 304: } ! 305: /* OK, they are all OK, now go through again and actually send */ ! 306: for (i = 1; i < argc; i++) { ! 307: if ((s = getsend(argv[i])) == 0) { ! 308: fprintf(stderr, "Telnet 'send' error - argument disappeared!\n"); ! 309: quit(); ! 310: /*NOTREACHED*/ ! 311: } ! 312: if (s->routine) { ! 313: (*s->routine)(s); ! 314: } else { ! 315: switch (what = s->what) { ! 316: case SYNCH: ! 317: dosynch(); ! 318: break; ! 319: case SENDQUESTION: ! 320: for (s = Sendlist; s->name; s++) { ! 321: if (s->help) { ! 322: printf(s->name); ! 323: if (s->help) { ! 324: printf("\t%s", s->help); ! 325: } ! 326: printf("\n"); ! 327: } ! 328: } ! 329: question = 1; ! 330: break; ! 331: case SENDESCAPE: ! 332: NETADD(escape); ! 333: break; ! 334: default: ! 335: NET2ADD(IAC, what); ! 336: break; ! 337: } ! 338: } ! 339: } ! 340: return !question; ! 341: } ! 342: ! 343: /* ! 344: * The following are the routines and data structures referred ! 345: * to by the arguments to the "toggle" command. ! 346: */ ! 347: ! 348: static ! 349: lclchars() ! 350: { ! 351: donelclchars = 1; ! 352: return 1; ! 353: } ! 354: ! 355: static ! 356: togdebug() ! 357: { ! 358: #ifndef NOT43 ! 359: if (net > 0 && ! 360: (SetSockOpt(net, SOL_SOCKET, SO_DEBUG, debug)) < 0) { ! 361: perror("setsockopt (SO_DEBUG)"); ! 362: } ! 363: #else /* NOT43 */ ! 364: if (debug) { ! 365: if (net > 0 && SetSockOpt(net, SOL_SOCKET, SO_DEBUG, 0, 0) < 0) ! 366: perror("setsockopt (SO_DEBUG)"); ! 367: } else ! 368: printf("Cannot turn off socket debugging\n"); ! 369: #endif /* NOT43 */ ! 370: return 1; ! 371: } ! 372: ! 373: ! 374: static int ! 375: togcrlf() ! 376: { ! 377: if (crlf) { ! 378: printf("Will send carriage returns as telnet <CR><LF>.\n"); ! 379: } else { ! 380: printf("Will send carriage returns as telnet <CR><NUL>.\n"); ! 381: } ! 382: return 1; ! 383: } ! 384: ! 385: ! 386: static int ! 387: togbinary() ! 388: { ! 389: donebinarytoggle = 1; ! 390: ! 391: if (myopts[TELOPT_BINARY] == 0) { /* Go into binary mode */ ! 392: NET2ADD(IAC, DO); ! 393: NETADD(TELOPT_BINARY); ! 394: printoption("<SENT", doopt, TELOPT_BINARY, 0); ! 395: NET2ADD(IAC, WILL); ! 396: NETADD(TELOPT_BINARY); ! 397: printoption("<SENT", doopt, TELOPT_BINARY, 0); ! 398: hisopts[TELOPT_BINARY] = myopts[TELOPT_BINARY] = 1; ! 399: printf("Negotiating binary mode with remote host.\n"); ! 400: } else { /* Turn off binary mode */ ! 401: NET2ADD(IAC, DONT); ! 402: NETADD(TELOPT_BINARY); ! 403: printoption("<SENT", dont, TELOPT_BINARY, 0); ! 404: NET2ADD(IAC, DONT); ! 405: NETADD(TELOPT_BINARY); ! 406: printoption("<SENT", dont, TELOPT_BINARY, 0); ! 407: hisopts[TELOPT_BINARY] = myopts[TELOPT_BINARY] = 0; ! 408: printf("Negotiating network ascii mode with remote host.\n"); ! 409: } ! 410: return 1; ! 411: } ! 412: ! 413: ! 414: ! 415: extern int togglehelp(); ! 416: ! 417: struct togglelist { ! 418: char *name; /* name of toggle */ ! 419: char *help; /* help message */ ! 420: int (*handler)(); /* routine to do actual setting */ ! 421: int dohelp; /* should we display help information */ ! 422: int *variable; ! 423: char *actionexplanation; ! 424: }; ! 425: ! 426: static struct togglelist Togglelist[] = { ! 427: { "autoflush", ! 428: "toggle flushing of output when sending interrupt characters", ! 429: 0, ! 430: 1, ! 431: &autoflush, ! 432: "flush output when sending interrupt characters" }, ! 433: { "autosynch", ! 434: "toggle automatic sending of interrupt characters in urgent mode", ! 435: 0, ! 436: 1, ! 437: &autosynch, ! 438: "send interrupt characters in urgent mode" }, ! 439: { "binary", ! 440: "toggle sending and receiving of binary data", ! 441: togbinary, ! 442: 1, ! 443: 0, ! 444: 0 }, ! 445: { "crlf", ! 446: "toggle sending carriage returns as telnet <CR><LF>", ! 447: togcrlf, ! 448: 1, ! 449: &crlf, ! 450: 0 }, ! 451: { "crmod", ! 452: "toggle mapping of received carriage returns", ! 453: 0, ! 454: 1, ! 455: &crmod, ! 456: "map carriage return on output" }, ! 457: { "localchars", ! 458: "toggle local recognition of certain control characters", ! 459: lclchars, ! 460: 1, ! 461: &localchars, ! 462: "recognize certain control characters" }, ! 463: { " ", "", 0, 1 }, /* empty line */ ! 464: { "debug", ! 465: "(debugging) toggle debugging", ! 466: togdebug, ! 467: 1, ! 468: &debug, ! 469: "turn on socket level debugging" }, ! 470: { "netdata", ! 471: "(debugging) toggle printing of hexadecimal network data", ! 472: 0, ! 473: 1, ! 474: &netdata, ! 475: "print hexadecimal representation of network traffic" }, ! 476: { "options", ! 477: "(debugging) toggle viewing of options processing", ! 478: 0, ! 479: 1, ! 480: &showoptions, ! 481: "show option processing" }, ! 482: { " ", "", 0, 1 }, /* empty line */ ! 483: { "?", ! 484: "display help information", ! 485: togglehelp, ! 486: 1 }, ! 487: { "help", ! 488: "display help information", ! 489: togglehelp, ! 490: 0 }, ! 491: { 0 } ! 492: }; ! 493: ! 494: static ! 495: togglehelp() ! 496: { ! 497: struct togglelist *c; ! 498: ! 499: for (c = Togglelist; c->name; c++) { ! 500: if (c->dohelp) { ! 501: printf("%s\t%s\n", c->name, c->help); ! 502: } ! 503: } ! 504: return 0; ! 505: } ! 506: ! 507: static char ** ! 508: getnexttoggle(name) ! 509: char *name; ! 510: { ! 511: struct togglelist *c = (struct togglelist *) name; ! 512: ! 513: return (char **) (c+1); ! 514: } ! 515: ! 516: static struct togglelist * ! 517: gettoggle(name) ! 518: char *name; ! 519: { ! 520: return (struct togglelist *) ! 521: genget(name, (char **) Togglelist, getnexttoggle); ! 522: } ! 523: ! 524: static ! 525: toggle(argc, argv) ! 526: int argc; ! 527: char *argv[]; ! 528: { ! 529: int retval = 1; ! 530: char *name; ! 531: struct togglelist *c; ! 532: ! 533: if (argc < 2) { ! 534: fprintf(stderr, ! 535: "Need an argument to 'toggle' command. 'toggle ?' for help.\n"); ! 536: return 0; ! 537: } ! 538: argc--; ! 539: argv++; ! 540: while (argc--) { ! 541: name = *argv++; ! 542: c = gettoggle(name); ! 543: if (Ambiguous(c)) { ! 544: fprintf(stderr, "'%s': ambiguous argument ('toggle ?' for help).\n", ! 545: name); ! 546: return 0; ! 547: } else if (c == 0) { ! 548: fprintf(stderr, "'%s': unknown argument ('toggle ?' for help).\n", ! 549: name); ! 550: return 0; ! 551: } else { ! 552: if (c->variable) { ! 553: *c->variable = !*c->variable; /* invert it */ ! 554: if (c->actionexplanation) { ! 555: printf("%s %s.\n", *c->variable? "Will" : "Won't", ! 556: c->actionexplanation); ! 557: } ! 558: printf("%s %s.\n", *c->variable? "Will" : "Won't", ! 559: c->actionexplanation); ! 560: } ! 561: if (c->handler) { ! 562: retval &= (*c->handler)(c); ! 563: } ! 564: } ! 565: } ! 566: return retval; ! 567: } ! 568: ! 569: /* ! 570: * The following perform the "set" command. ! 571: */ ! 572: ! 573: struct setlist { ! 574: char *name; /* name */ ! 575: char *help; /* help information */ ! 576: char *charp; /* where it is located at */ ! 577: }; ! 578: ! 579: static struct setlist Setlist[] = { ! 580: { "echo", "character to toggle local echoing on/off", &echoc }, ! 581: { "escape", "character to escape back to telnet command mode", &escape }, ! 582: { " ", "" }, ! 583: { " ", "The following need 'localchars' to be toggled true", 0 }, ! 584: { "erase", "character to cause an Erase Character", &termEraseChar }, ! 585: { "flushoutput", "character to cause an Abort Oubput", &termFlushChar }, ! 586: { "interrupt", "character to cause an Interrupt Process", &termIntChar }, ! 587: { "kill", "character to cause an Erase Line", &termKillChar }, ! 588: { "quit", "character to cause a Break", &termQuitChar }, ! 589: { "eof", "character to cause an EOF ", &termEofChar }, ! 590: { 0 } ! 591: }; ! 592: ! 593: static char ** ! 594: getnextset(name) ! 595: char *name; ! 596: { ! 597: struct setlist *c = (struct setlist *)name; ! 598: ! 599: return (char **) (c+1); ! 600: } ! 601: ! 602: static struct setlist * ! 603: getset(name) ! 604: char *name; ! 605: { ! 606: return (struct setlist *) genget(name, (char **) Setlist, getnextset); ! 607: } ! 608: ! 609: static ! 610: setcmd(argc, argv) ! 611: int argc; ! 612: char *argv[]; ! 613: { ! 614: int value; ! 615: struct setlist *ct; ! 616: ! 617: /* XXX back we go... sigh */ ! 618: if (argc != 3) { ! 619: if ((argc == 2) && ! 620: ((!strcmp(argv[1], "?")) || (!strcmp(argv[1], "help")))) { ! 621: for (ct = Setlist; ct->name; ct++) { ! 622: printf("%s\t%s\n", ct->name, ct->help); ! 623: } ! 624: printf("?\tdisplay help information\n"); ! 625: } else { ! 626: printf("Format is 'set Name Value'\n'set ?' for help.\n"); ! 627: } ! 628: return 0; ! 629: } ! 630: ! 631: ct = getset(argv[1]); ! 632: if (ct == 0) { ! 633: fprintf(stderr, "'%s': unknown argument ('set ?' for help).\n", ! 634: argv[1]); ! 635: return 0; ! 636: } else if (Ambiguous(ct)) { ! 637: fprintf(stderr, "'%s': ambiguous argument ('set ?' for help).\n", ! 638: argv[1]); ! 639: return 0; ! 640: } else { ! 641: if (strcmp("off", argv[2])) { ! 642: value = special(argv[2]); ! 643: } else { ! 644: value = -1; ! 645: } ! 646: *(ct->charp) = value; ! 647: printf("%s character is '%s'.\n", ct->name, control(*(ct->charp))); ! 648: } ! 649: return 1; ! 650: } ! 651: ! 652: /* ! 653: * The following are the data structures and routines for the ! 654: * 'mode' command. ! 655: */ ! 656: ! 657: static ! 658: dolinemode() ! 659: { ! 660: if (hisopts[TELOPT_SGA]) { ! 661: wontoption(TELOPT_SGA, 0); ! 662: } ! 663: if (hisopts[TELOPT_ECHO]) { ! 664: wontoption(TELOPT_ECHO, 0); ! 665: } ! 666: return 1; ! 667: } ! 668: ! 669: static ! 670: docharmode() ! 671: { ! 672: if (!hisopts[TELOPT_SGA]) { ! 673: willoption(TELOPT_SGA, 0); ! 674: } ! 675: if (!hisopts[TELOPT_ECHO]) { ! 676: willoption(TELOPT_ECHO, 0); ! 677: } ! 678: return 1; ! 679: } ! 680: ! 681: static Command Mode_commands[] = { ! 682: { "character", "character-at-a-time mode", docharmode, 1, 1 }, ! 683: { "line", "line-by-line mode", dolinemode, 1, 1 }, ! 684: { 0 }, ! 685: }; ! 686: ! 687: static char ** ! 688: getnextmode(name) ! 689: char *name; ! 690: { ! 691: Command *c = (Command *) name; ! 692: ! 693: return (char **) (c+1); ! 694: } ! 695: ! 696: static Command * ! 697: getmodecmd(name) ! 698: char *name; ! 699: { ! 700: return (Command *) genget(name, (char **) Mode_commands, getnextmode); ! 701: } ! 702: ! 703: static ! 704: modecmd(argc, argv) ! 705: int argc; ! 706: char *argv[]; ! 707: { ! 708: Command *mt; ! 709: ! 710: if ((argc != 2) || !strcmp(argv[1], "?") || !strcmp(argv[1], "help")) { ! 711: printf("format is: 'mode Mode', where 'Mode' is one of:\n\n"); ! 712: for (mt = Mode_commands; mt->name; mt++) { ! 713: printf("%s\t%s\n", mt->name, mt->help); ! 714: } ! 715: return 0; ! 716: } ! 717: mt = getmodecmd(argv[1]); ! 718: if (mt == 0) { ! 719: fprintf(stderr, "Unknown mode '%s' ('mode ?' for help).\n", argv[1]); ! 720: return 0; ! 721: } else if (Ambiguous(mt)) { ! 722: fprintf(stderr, "Ambiguous mode '%s' ('mode ?' for help).\n", argv[1]); ! 723: return 0; ! 724: } else { ! 725: (*mt->handler)(); ! 726: } ! 727: return 1; ! 728: } ! 729: ! 730: /* ! 731: * The following data structures and routines implement the ! 732: * "display" command. ! 733: */ ! 734: ! 735: static ! 736: display(argc, argv) ! 737: int argc; ! 738: char *argv[]; ! 739: { ! 740: #define dotog(tl) if (tl->variable && tl->actionexplanation) { \ ! 741: if (*tl->variable) { \ ! 742: printf("will"); \ ! 743: } else { \ ! 744: printf("won't"); \ ! 745: } \ ! 746: printf(" %s.\n", tl->actionexplanation); \ ! 747: } ! 748: ! 749: #define doset(sl) if (sl->name && *sl->name != ' ') { \ ! 750: printf("[%s]\t%s.\n", control(*sl->charp), sl->name); \ ! 751: } ! 752: ! 753: struct togglelist *tl; ! 754: struct setlist *sl; ! 755: ! 756: if (argc == 1) { ! 757: for (tl = Togglelist; tl->name; tl++) { ! 758: dotog(tl); ! 759: } ! 760: printf("\n"); ! 761: for (sl = Setlist; sl->name; sl++) { ! 762: doset(sl); ! 763: } ! 764: } else { ! 765: int i; ! 766: ! 767: for (i = 1; i < argc; i++) { ! 768: sl = getset(argv[i]); ! 769: tl = gettoggle(argv[i]); ! 770: if (Ambiguous(sl) || Ambiguous(tl)) { ! 771: printf("?Ambiguous argument '%s'.\n", argv[i]); ! 772: return 0; ! 773: } else if (!sl && !tl) { ! 774: printf("?Unknown argument '%s'.\n", argv[i]); ! 775: return 0; ! 776: } else { ! 777: if (tl) { ! 778: dotog(tl); ! 779: } ! 780: if (sl) { ! 781: doset(sl); ! 782: } ! 783: } ! 784: } ! 785: } ! 786: return 1; ! 787: #undef doset ! 788: #undef dotog ! 789: } ! 790: ! 791: /* ! 792: * The following are the data structures, and many of the routines, ! 793: * relating to command processing. ! 794: */ ! 795: ! 796: /* ! 797: * Set the escape character. ! 798: */ ! 799: static ! 800: setescape(argc, argv) ! 801: int argc; ! 802: char *argv[]; ! 803: { ! 804: register char *arg; ! 805: char buf[50]; ! 806: ! 807: printf( ! 808: "Deprecated usage - please use 'set escape%s%s' in the future.\n", ! 809: (argc > 2)? " ":"", (argc > 2)? argv[1]: ""); ! 810: if (argc > 2) ! 811: arg = argv[1]; ! 812: else { ! 813: printf("new escape character: "); ! 814: gets(buf); ! 815: arg = buf; ! 816: } ! 817: if (arg[0] != '\0') ! 818: escape = arg[0]; ! 819: if (!In3270) { ! 820: printf("Escape character is '%s'.\n", control(escape)); ! 821: } ! 822: fflush(stdout); ! 823: return 1; ! 824: } ! 825: ! 826: /*VARARGS*/ ! 827: static ! 828: togcrmod() ! 829: { ! 830: crmod = !crmod; ! 831: printf("Deprecated usage - please use 'toggle crmod' in the future.\n"); ! 832: printf("%s map carriage return on output.\n", crmod ? "Will" : "Won't"); ! 833: fflush(stdout); ! 834: return 1; ! 835: } ! 836: ! 837: /*VARARGS*/ ! 838: suspend() ! 839: { ! 840: setcommandmode(); ! 841: #if defined(unix) ! 842: kill(0, SIGTSTP); ! 843: #endif /* defined(unix) */ ! 844: /* reget parameters in case they were changed */ ! 845: TerminalSaveState(); ! 846: setconnmode(); ! 847: return 1; ! 848: } ! 849: ! 850: /*VARARGS*/ ! 851: static ! 852: bye(argc, argv) ! 853: int argc; /* Number of arguments */ ! 854: char *argv[]; /* arguments */ ! 855: { ! 856: if (connected) { ! 857: shutdown(net, 2); ! 858: printf("Connection closed.\n"); ! 859: NetClose(net); ! 860: connected = 0; ! 861: /* reset options */ ! 862: tninit(); ! 863: #if defined(TN3270) ! 864: SetIn3270(); /* Get out of 3270 mode */ ! 865: #endif /* defined(TN3270) */ ! 866: } ! 867: if ((argc != 2) || (strcmp(argv[1], "fromquit") != 0)) { ! 868: longjmp(toplevel, 1); ! 869: /* NOTREACHED */ ! 870: } ! 871: return 1; /* Keep lint, etc., happy */ ! 872: } ! 873: ! 874: /*VARARGS*/ ! 875: quit() ! 876: { ! 877: (void) call(bye, "bye", "fromquit", 0); ! 878: Exit(0); ! 879: /*NOTREACHED*/ ! 880: return 1; /* just to keep lint happy */ ! 881: } ! 882: ! 883: /* ! 884: * Print status about the connection. ! 885: */ ! 886: static ! 887: status(argc, argv) ! 888: int argc; ! 889: char *argv[]; ! 890: { ! 891: if (connected) { ! 892: printf("Connected to %s.\n", hostname); ! 893: if (argc < 2) { ! 894: printf("Operating in %s.\n", ! 895: modelist[getconnmode()].modedescriptions); ! 896: if (localchars) { ! 897: printf("Catching signals locally.\n"); ! 898: } ! 899: } ! 900: } else { ! 901: printf("No connection.\n"); ! 902: } ! 903: # if !defined(TN3270) ! 904: printf("Escape character is '%s'.\n", control(escape)); ! 905: fflush(stdout); ! 906: # else /* !defined(TN3270) */ ! 907: if ((!In3270) && ((argc < 2) || strcmp(argv[1], "notmuch"))) { ! 908: printf("Escape character is '%s'.\n", control(escape)); ! 909: } ! 910: # if defined(unix) ! 911: if (In3270 && transcom) { ! 912: printf("Transparent mode command is '%s'.\n", transcom); ! 913: } ! 914: # endif /* defined(unix) */ ! 915: fflush(stdout); ! 916: if (In3270) { ! 917: return 0; ! 918: } ! 919: # endif /* defined(TN3270) */ ! 920: return 1; ! 921: } ! 922: ! 923: ! 924: ! 925: int ! 926: tn(argc, argv) ! 927: int argc; ! 928: char *argv[]; ! 929: { ! 930: register struct hostent *host = 0; ! 931: struct sockaddr_in sin; ! 932: struct servent *sp = 0; ! 933: static char hnamebuf[32]; ! 934: ! 935: ! 936: #if defined(MSDOS) ! 937: char *cp; ! 938: #endif /* defined(MSDOS) */ ! 939: ! 940: if (connected) { ! 941: printf("?Already connected to %s\n", hostname); ! 942: return 0; ! 943: } ! 944: if (argc < 2) { ! 945: (void) strcpy(line, "Connect "); ! 946: printf("(to) "); ! 947: gets(&line[strlen(line)]); ! 948: makeargv(); ! 949: argc = margc; ! 950: argv = margv; ! 951: } ! 952: if ((argc < 2) || (argc > 3)) { ! 953: printf("usage: %s host-name [port]\n", argv[0]); ! 954: return 0; ! 955: } ! 956: #if defined(MSDOS) ! 957: for (cp = argv[1]; *cp; cp++) { ! 958: if (isupper(*cp)) { ! 959: *cp = tolower(*cp); ! 960: } ! 961: } ! 962: #endif /* defined(MSDOS) */ ! 963: sin.sin_addr.s_addr = inet_addr(argv[1]); ! 964: if (sin.sin_addr.s_addr != -1) { ! 965: sin.sin_family = AF_INET; ! 966: (void) strcpy(hnamebuf, argv[1]); ! 967: hostname = hnamebuf; ! 968: } else { ! 969: host = gethostbyname(argv[1]); ! 970: if (host) { ! 971: sin.sin_family = host->h_addrtype; ! 972: #if defined(h_addr) /* In 4.3, this is a #define */ ! 973: memcpy((caddr_t)&sin.sin_addr, ! 974: host->h_addr_list[0], host->h_length); ! 975: #else /* defined(h_addr) */ ! 976: memcpy((caddr_t)&sin.sin_addr, host->h_addr, host->h_length); ! 977: #endif /* defined(h_addr) */ ! 978: hostname = host->h_name; ! 979: } else { ! 980: printf("%s: unknown host\n", argv[1]); ! 981: return 0; ! 982: } ! 983: } ! 984: if (argc == 3) { ! 985: sin.sin_port = atoi(argv[2]); ! 986: if (sin.sin_port == 0) { ! 987: sp = getservbyname(argv[2], "tcp"); ! 988: if (sp) ! 989: sin.sin_port = sp->s_port; ! 990: else { ! 991: printf("%s: bad port number\n", argv[2]); ! 992: return 0; ! 993: } ! 994: } else { ! 995: sin.sin_port = atoi(argv[2]); ! 996: sin.sin_port = htons(sin.sin_port); ! 997: } ! 998: telnetport = 0; ! 999: } else { ! 1000: if (sp == 0) { ! 1001: sp = getservbyname("telnet", "tcp"); ! 1002: if (sp == 0) { ! 1003: fprintf(stderr, "telnet: tcp/telnet: unknown service\n",1); ! 1004: return 0; ! 1005: } ! 1006: sin.sin_port = sp->s_port; ! 1007: } ! 1008: telnetport = 1; ! 1009: } ! 1010: printf("Trying...\n"); ! 1011: do { ! 1012: net = socket(AF_INET, SOCK_STREAM, 0); ! 1013: if (net < 0) { ! 1014: perror("telnet: socket"); ! 1015: return 0; ! 1016: } ! 1017: if (debug && SetSockOpt(net, SOL_SOCKET, SO_DEBUG, 1) < 0) { ! 1018: perror("setsockopt (SO_DEBUG)"); ! 1019: } ! 1020: ! 1021: if (connect(net, (struct sockaddr *)&sin, sizeof (sin)) < 0) { ! 1022: #if defined(h_addr) /* In 4.3, this is a #define */ ! 1023: if (host && host->h_addr_list[1]) { ! 1024: int oerrno = errno; ! 1025: ! 1026: fprintf(stderr, "telnet: connect to address %s: ", ! 1027: inet_ntoa(sin.sin_addr)); ! 1028: errno = oerrno; ! 1029: perror((char *)0); ! 1030: host->h_addr_list++; ! 1031: memcpy((caddr_t)&sin.sin_addr, ! 1032: host->h_addr_list[0], host->h_length); ! 1033: fprintf(stderr, "Trying %s...\n", ! 1034: inet_ntoa(sin.sin_addr)); ! 1035: (void) NetClose(net); ! 1036: continue; ! 1037: } ! 1038: #endif /* defined(h_addr) */ ! 1039: perror("telnet: Unable to connect to remote host"); ! 1040: return 0; ! 1041: } ! 1042: connected++; ! 1043: } while (connected == 0); ! 1044: call(status, "status", "notmuch", 0); ! 1045: if (setjmp(peerdied) == 0) ! 1046: telnet(); ! 1047: NetClose(net); ! 1048: ExitString("Connection closed by foreign host.\n",1); ! 1049: /*NOTREACHED*/ ! 1050: } ! 1051: ! 1052: ! 1053: #define HELPINDENT (sizeof ("connect")) ! 1054: ! 1055: static char ! 1056: openhelp[] = "connect to a site", ! 1057: closehelp[] = "close current connection", ! 1058: quithelp[] = "exit telnet", ! 1059: statushelp[] = "print status information", ! 1060: helphelp[] = "print help information", ! 1061: sendhelp[] = "transmit special characters ('send ?' for more)", ! 1062: sethelp[] = "set operating parameters ('set ?' for more)", ! 1063: togglestring[] ="toggle operating parameters ('toggle ?' for more)", ! 1064: displayhelp[] = "display operating parameters", ! 1065: #if defined(TN3270) && defined(unix) ! 1066: transcomhelp[] = "specify Unix command for transparent mode pipe", ! 1067: #endif /* defined(TN3270) && defined(unix) */ ! 1068: #if defined(unix) ! 1069: zhelp[] = "suspend telnet", ! 1070: #endif /* defined(unix */ ! 1071: #if defined(TN3270) ! 1072: shellhelp[] = "invoke a subshell", ! 1073: #endif /* defined(TN3270) */ ! 1074: modehelp[] = "try to enter line-by-line or character-at-a-time mode"; ! 1075: ! 1076: extern int help(), shell(); ! 1077: ! 1078: static Command cmdtab[] = { ! 1079: { "close", closehelp, bye, 1, 1 }, ! 1080: { "display", displayhelp, display, 1, 0 }, ! 1081: { "mode", modehelp, modecmd, 1, 1 }, ! 1082: { "open", openhelp, tn, 1, 0 }, ! 1083: { "quit", quithelp, quit, 1, 0 }, ! 1084: { "send", sendhelp, sendcmd, 1, 1 }, ! 1085: { "set", sethelp, setcmd, 1, 0 }, ! 1086: { "status", statushelp, status, 1, 0 }, ! 1087: { "toggle", togglestring, toggle, 1, 0 }, ! 1088: #if defined(TN3270) && defined(unix) ! 1089: { "transcom", transcomhelp, settranscom, 1, 0 }, ! 1090: #endif /* defined(TN3270) && defined(unix) */ ! 1091: #if defined(unix) ! 1092: { "z", zhelp, suspend, 1, 0 }, ! 1093: #endif /* defined(unix) */ ! 1094: #if defined(TN3270) ! 1095: { "!", shellhelp, shell, 1, 1 }, ! 1096: #endif /* defined(TN3270) */ ! 1097: { "?", helphelp, help, 1, 0 }, ! 1098: 0 ! 1099: }; ! 1100: ! 1101: static char crmodhelp[] = "deprecated command -- use 'toggle crmod' instead"; ! 1102: static char escapehelp[] = "deprecated command -- use 'set escape' instead"; ! 1103: ! 1104: static Command cmdtab2[] = { ! 1105: { "help", helphelp, help, 0, 0 }, ! 1106: { "escape", escapehelp, setescape, 1, 0 }, ! 1107: { "crmod", crmodhelp, togcrmod, 1, 0 }, ! 1108: 0 ! 1109: }; ! 1110: ! 1111: /* ! 1112: * Call routine with argc, argv set from args (terminated by 0). ! 1113: * VARARGS2 ! 1114: */ ! 1115: static ! 1116: call(routine, args) ! 1117: int (*routine)(); ! 1118: char *args; ! 1119: { ! 1120: register char **argp; ! 1121: register int argc; ! 1122: ! 1123: for (argc = 0, argp = &args; *argp++ != 0; argc++) ! 1124: ; ! 1125: return (*routine)(argc, &args); ! 1126: } ! 1127: ! 1128: static char ** ! 1129: getnextcmd(name) ! 1130: char *name; ! 1131: { ! 1132: Command *c = (Command *) name; ! 1133: ! 1134: return (char **) (c+1); ! 1135: } ! 1136: ! 1137: static Command * ! 1138: getcmd(name) ! 1139: char *name; ! 1140: { ! 1141: Command *cm; ! 1142: ! 1143: if ((cm = (Command *) genget(name, (char **) cmdtab, getnextcmd)) != 0) { ! 1144: return cm; ! 1145: } else { ! 1146: return (Command *) genget(name, (char **) cmdtab2, getnextcmd); ! 1147: } ! 1148: } ! 1149: ! 1150: void ! 1151: command(top) ! 1152: int top; ! 1153: { ! 1154: register Command *c; ! 1155: ! 1156: setcommandmode(); ! 1157: if (!top) { ! 1158: putchar('\n'); ! 1159: } else { ! 1160: #if defined(unix) ! 1161: signal(SIGINT, SIG_DFL); ! 1162: signal(SIGQUIT, SIG_DFL); ! 1163: #endif /* defined(unix) */ ! 1164: } ! 1165: for (;;) { ! 1166: printf("%s> ", prompt); ! 1167: if (gets(line) == NULL) { ! 1168: if (feof(stdin) || ferror(stdin)) ! 1169: quit(); ! 1170: break; ! 1171: } ! 1172: if (line[0] == 0) ! 1173: break; ! 1174: makeargv(); ! 1175: c = getcmd(margv[0]); ! 1176: if (Ambiguous(c)) { ! 1177: printf("?Ambiguous command\n"); ! 1178: continue; ! 1179: } ! 1180: if (c == 0) { ! 1181: printf("?Invalid command\n"); ! 1182: continue; ! 1183: } ! 1184: if (c->needconnect && !connected) { ! 1185: printf("?Need to be connected first.\n"); ! 1186: continue; ! 1187: } ! 1188: if ((*c->handler)(margc, margv)) { ! 1189: break; ! 1190: } ! 1191: } ! 1192: if (!top) { ! 1193: if (!connected) { ! 1194: longjmp(toplevel, 1); ! 1195: /*NOTREACHED*/ ! 1196: } ! 1197: #if defined(TN3270) ! 1198: if (shell_active == 0) { ! 1199: setconnmode(); ! 1200: } ! 1201: #else /* defined(TN3270) */ ! 1202: setconnmode(); ! 1203: #endif /* defined(TN3270) */ ! 1204: } ! 1205: } ! 1206: ! 1207: /* ! 1208: * Help command. ! 1209: */ ! 1210: static ! 1211: help(argc, argv) ! 1212: int argc; ! 1213: char *argv[]; ! 1214: { ! 1215: register Command *c; ! 1216: ! 1217: if (argc == 1) { ! 1218: printf("Commands may be abbreviated. Commands are:\n\n"); ! 1219: for (c = cmdtab; c->name; c++) ! 1220: if (c->dohelp) { ! 1221: printf("%-*s\t%s\n", HELPINDENT, c->name, ! 1222: c->help); ! 1223: } ! 1224: return 0; ! 1225: } ! 1226: while (--argc > 0) { ! 1227: register char *arg; ! 1228: arg = *++argv; ! 1229: c = getcmd(arg); ! 1230: if (Ambiguous(c)) ! 1231: printf("?Ambiguous help command %s\n", arg); ! 1232: else if (c == (Command *)0) ! 1233: printf("?Invalid help command %s\n", arg); ! 1234: else ! 1235: printf("%s\n", c->help); ! 1236: } ! 1237: return 0; ! 1238: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.