![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tn3270.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / tn3270|
Return to tn3270.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / tn3270 |
1.1 ! root 1: /* ! 2: * Copyright 1984, 1985 by the Regents of the University of ! 3: * California and by Gregory Glenn Minshall. ! 4: * ! 5: * Permission to use, copy, modify, and distribute these ! 6: * programs and their documentation for any purpose and ! 7: * without fee is hereby granted, provided that this ! 8: * copyright and permission appear on all copies and ! 9: * supporting documentation, the name of the Regents of ! 10: * the University of California not be used in advertising ! 11: * or publicity pertaining to distribution of the programs ! 12: * without specific prior permission, and notice be given in ! 13: * supporting documentation that copying and distribution is ! 14: * by permission of the Regents of the University of California ! 15: * and by Gregory Glenn Minshall. Neither the Regents of the ! 16: * University of California nor Gregory Glenn Minshall make ! 17: * representations about the suitability of this software ! 18: * for any purpose. It is provided "as is" without ! 19: * express or implied warranty. ! 20: */ ! 21: ! 22: ! 23: #ifndef lint ! 24: static char sccsid[] = "@(#)tn3270.c 2.7\t5/13/86"; ! 25: #endif ! 26: ! 27: /* ! 28: * User telnet program, specially modified for tn3270. ! 29: */ ! 30: #include <sys/types.h> ! 31: #include <sys/socket.h> ! 32: #include <sys/ioctl.h> ! 33: #include <sys/time.h> ! 34: ! 35: #include <netinet/in.h> ! 36: ! 37: #define TELOPTS ! 38: #include <arpa/telnet.h> ! 39: ! 40: #include <stdio.h> ! 41: #include <ctype.h> ! 42: #include <errno.h> ! 43: #include <signal.h> ! 44: #include <setjmp.h> ! 45: #include <netdb.h> ! 46: ! 47: #define strip(x) ((x)&0177) ! 48: #define min(x,y) ((x<y)? x:y) ! 49: ! 50: static char Ibuf[8*BUFSIZ], *Ifrontp = Ibuf, *Ibackp = Ibuf; ! 51: static char ttyobuf[BUFSIZ], *tfrontp = ttyobuf, *tbackp = ttyobuf; ! 52: static char netobuf[BUFSIZ], *nfrontp = netobuf, *nbackp = netobuf; ! 53: ! 54: static char SbBuffer[100], *pSb = SbBuffer; ! 55: #define Sb_Option SbBuffer[0] ! 56: #define Sb_Command SbBuffer[1] ! 57: ! 58: ! 59: static char hisopts[256]; ! 60: static char myopts[256]; ! 61: ! 62: static char doopt[] = { IAC, DO, '%', 'c', 0 }; ! 63: static char dont[] = { IAC, DONT, '%', 'c', 0 }; ! 64: static char will[] = { IAC, WILL, '%', 'c', 0 }; ! 65: static char wont[] = { IAC, WONT, '%', 'c', 0 }; ! 66: static char sb_terminal[] = { IAC, SB, ! 67: TELOPT_TTYPE, TELQUAL_IS, ! 68: 'I', 'B', 'M', '-', '3', '2', '7', '7', '-', '2', ! 69: IAC, SE }; ! 70: ! 71: /* The following is a real, live, global. */ ! 72: ! 73: /* The point of HaveInput is to give a hint to the terminal output processor ! 74: * that some input from some source (network or terminal) has come in. ! 75: */ ! 76: ! 77: int HaveInput = 1; /* we have received input in the not too distant past */ ! 78: ! 79: ! 80: static int connected; ! 81: static int SentTerminalType = 0; /* returned sb_terminal to other? */ ! 82: static int In3270 = 0; /* we are in 3270 binary mode */ ! 83: static int ISend = 0; /* trying to send network data in */ ! 84: static int ForceMode = -1; /* for debugging */ ! 85: static int net; ! 86: static int showoptions = 0; ! 87: static int debug = 0; ! 88: static int crmod = 0; ! 89: static int printnet = 0; ! 90: static FILE *NetTrace; ! 91: static char *prompt; ! 92: static char escape = CTRL(]); ! 93: ! 94: static char line[200]; ! 95: static int margc; ! 96: static char *margv[20]; ! 97: ! 98: static jmp_buf toplevel; ! 99: static jmp_buf peerdied; ! 100: ! 101: extern int errno; ! 102: ! 103: int quit(), suspend(); ! 104: static int tn(), bye(), help(); ! 105: static int setescape(), status(), toggle(), setoptions(); ! 106: static int setcrmod(), setdebug(), SetPrintNet(); ! 107: ! 108: #define HELPINDENT (sizeof ("connect")) ! 109: ! 110: struct cmd { ! 111: char *name; /* command name */ ! 112: char *help; /* help string */ ! 113: int (*handler)(); /* routine which executes command */ ! 114: int dohelp; /* Should we give general help information? */ ! 115: }; ! 116: ! 117: static char openhelp[] = "connect to a site"; ! 118: static char closehelp[] = "close current connection"; ! 119: static char quithelp[] = "exit telnet"; ! 120: static char zhelp[] = "suspend telnet"; ! 121: static char debughelp[] = "toggle debugging"; ! 122: static char escapehelp[] = "set escape character"; ! 123: static char statushelp[] = "print status information"; ! 124: static char helphelp[] = "print help information"; ! 125: static char optionshelp[] = "toggle viewing of options processing"; ! 126: static char crmodhelp[] = "toggle mapping of received carriage returns"; ! 127: static char printnethelp[] = "print out raw data to/from net"; ! 128: ! 129: static struct cmd cmdtab[] = { ! 130: { "open", openhelp, tn, 1 }, ! 131: { "close", closehelp, bye, 1 }, ! 132: { "quit", quithelp, quit, 1 }, ! 133: { "z", zhelp, suspend, 1 }, ! 134: { "suspend", zhelp, suspend, 0 }, ! 135: { "escape", escapehelp, setescape, 0 }, ! 136: { "status", statushelp, status, 1 }, ! 137: { "options", optionshelp, setoptions, 0 }, ! 138: { "crmod", crmodhelp, setcrmod, 0 }, ! 139: { "debug", debughelp, setdebug, 0 }, ! 140: { "printnet", printnethelp, SetPrintNet, 0 }, ! 141: { "?", helphelp, help, 1 }, ! 142: { "help", helphelp, help, 0 }, ! 143: 0 ! 144: }; ! 145: ! 146: static struct sockaddr_in sin; ! 147: ! 148: static int intr(), deadpeer(), inputAvailable(); ! 149: static char *control(); ! 150: static struct cmd *getcmd(); ! 151: static struct servent *sp; ! 152: ! 153: static struct tchars otc; ! 154: static struct ltchars oltc; ! 155: static struct sgttyb ottyb; ! 156: ! 157: main(argc, argv) ! 158: int argc; ! 159: char *argv[]; ! 160: { ! 161: ioctl(0, TIOCGETP, (char *)&ottyb); ! 162: ioctl(0, TIOCGETC, (char *)&otc); ! 163: ioctl(0, TIOCGLTC, (char *)&oltc); ! 164: sp = getservbyname("telnet", "tcp"); ! 165: if (sp == 0) { ! 166: ExitString(stderr, "telnet: tcp/telnet: unknown service\n", 1); ! 167: } ! 168: NetTrace = stdout; ! 169: prompt = argv[0]; ! 170: if (argc > 1 && !strcmp(argv[1], "-d")) { ! 171: debug = SO_DEBUG, argv++, argc--; ! 172: } ! 173: if (argc > 1 && !strcmp(argv[1], "-n")) { ! 174: argv++; ! 175: argc--; ! 176: if (argc > 1) { /* get file name */ ! 177: NetTrace = fopen(argv[1], "w"); ! 178: argv++; ! 179: argc--; ! 180: if (NetTrace == NULL) { ! 181: NetTrace = stdout; ! 182: } ! 183: } ! 184: } ! 185: if (argc != 1) { ! 186: if (setjmp(toplevel) != 0) ! 187: Exit(0); ! 188: tn(argc, argv); ! 189: } ! 190: setjmp(toplevel); ! 191: for (;;) ! 192: command(1); ! 193: } ! 194: ! 195: static char *hostname; ! 196: static char hnamebuf[32]; ! 197: ! 198: static ! 199: tn(argc, argv) ! 200: int argc; ! 201: char *argv[]; ! 202: { ! 203: register struct hostent *host; ! 204: char *strcpy(); ! 205: ! 206: if (connected) { ! 207: printf("?Already connected to %s\n", hostname); ! 208: return; ! 209: } ! 210: if (argc < 2) { ! 211: (void) strcpy(line, "Connect "); ! 212: printf("(to) "); ! 213: gets(&line[strlen(line)]); ! 214: makeargv(); ! 215: argc = margc; ! 216: argv = margv; ! 217: } ! 218: if (argc > 3) { ! 219: printf("usage: %s host-name [port]\n", argv[0]); ! 220: return; ! 221: } ! 222: host = gethostbyname(argv[1]); ! 223: if (host) { ! 224: sin.sin_family = host->h_addrtype; ! 225: bcopy(host->h_addr, (caddr_t)&sin.sin_addr, host->h_length); ! 226: hostname = host->h_name; ! 227: } else { ! 228: sin.sin_family = AF_INET; ! 229: sin.sin_addr.s_addr = inet_addr(argv[1]); ! 230: if (sin.sin_addr.s_addr == -1) { ! 231: printf("%s: unknown host\n", argv[1]); ! 232: return; ! 233: } ! 234: (void) strcpy(hnamebuf, argv[1]); ! 235: hostname = hnamebuf; ! 236: } ! 237: sin.sin_port = sp->s_port; ! 238: if (argc == 3) { ! 239: sin.sin_port = atoi(argv[2]); ! 240: sin.sin_port = htons(sin.sin_port); ! 241: } ! 242: net = socket(AF_INET, SOCK_STREAM, 0); ! 243: if (net < 0) { ! 244: perror("telnet: socket"); ! 245: return; ! 246: } ! 247: if (debug && setsockopt(net, SOL_SOCKET, SO_DEBUG, 0, 0) < 0) ! 248: perror("setsockopt (SO_DEBUG)"); ! 249: signal(SIGINT, intr); ! 250: signal(SIGPIPE, deadpeer); ! 251: printf("Trying...\n"); ! 252: if (connect(net, (struct sockaddr *)&sin, sizeof (sin)) < 0) { ! 253: perror("telnet: connect"); ! 254: signal(SIGINT, SIG_DFL); ! 255: return; ! 256: } ! 257: connected++; ! 258: call(status, "status", 0); ! 259: if (setjmp(peerdied) == 0) ! 260: telnet(); ! 261: if (In3270) { ! 262: Stop3270(1); ! 263: } ! 264: ExitString(stderr, "Connection closed by foreign host.\n", 1); ! 265: } ! 266: ! 267: /* ! 268: * Print status about the connection. ! 269: */ ! 270: /*VARARGS*/ ! 271: static ! 272: status() ! 273: { ! 274: if (connected) ! 275: printf("Connected to %s.\n", hostname); ! 276: else ! 277: printf("No connection.\n"); ! 278: /*printf("Escape character is '%s'.\n", control(escape));*/ ! 279: fflush(stdout); ! 280: } ! 281: ! 282: static ! 283: makeargv() ! 284: { ! 285: register char *cp; ! 286: register char **argp = margv; ! 287: ! 288: margc = 0; ! 289: for (cp = line; *cp;) { ! 290: while (isspace(*cp)) ! 291: cp++; ! 292: if (*cp == '\0') ! 293: break; ! 294: *argp++ = cp; ! 295: margc += 1; ! 296: while (*cp != '\0' && !isspace(*cp)) ! 297: cp++; ! 298: if (*cp == '\0') ! 299: break; ! 300: *cp++ = '\0'; ! 301: } ! 302: *argp++ = 0; ! 303: } ! 304: ! 305: /*VARARGS*/ ! 306: suspend() ! 307: { ! 308: register int save; ! 309: ! 310: save = mode(0); ! 311: kill(0, SIGTSTP); ! 312: /* reget parameters in case they were changed */ ! 313: ioctl(0, TIOCGETP, (char *)&ottyb); ! 314: ioctl(0, TIOCGETC, (char *)&otc); ! 315: ioctl(0, TIOCGLTC, (char *)&oltc); ! 316: (void) mode(save); ! 317: } ! 318: ! 319: /*VARARGS*/ ! 320: static ! 321: bye() ! 322: { ! 323: register char *op; ! 324: ! 325: (void) mode(0); ! 326: if (connected) { ! 327: shutdown(net, 2); ! 328: printf("Connection closed.\n"); ! 329: close(net); ! 330: connected = 0; ! 331: /* reset his options */ ! 332: for (op = hisopts; op < &hisopts[256]; op++) ! 333: *op = 0; ! 334: } ! 335: } ! 336: ! 337: /*VARARGS*/ ! 338: quit() ! 339: { ! 340: call(bye, "bye", 0); ! 341: Exit(0); ! 342: } ! 343: ! 344: /* ! 345: * Help command. ! 346: */ ! 347: static ! 348: help(argc, argv) ! 349: int argc; ! 350: char *argv[]; ! 351: { ! 352: register struct cmd *c; ! 353: ! 354: if (argc == 1) { ! 355: printf("Commands may be abbreviated. Commands are:\n\n"); ! 356: for (c = cmdtab; c->name; c++) ! 357: if (c->dohelp) { ! 358: printf("%-*s\t%s\n", HELPINDENT, c->name, c->help); ! 359: } ! 360: return; ! 361: } ! 362: while (--argc > 0) { ! 363: register char *arg; ! 364: arg = *++argv; ! 365: c = getcmd(arg); ! 366: if (c == (struct cmd *)-1) ! 367: printf("?Ambiguous help command %s\n", arg); ! 368: else if (c == (struct cmd *)0) ! 369: printf("?Invalid help command %s\n", arg); ! 370: else ! 371: printf("%s\n", c->help); ! 372: } ! 373: } ! 374: ! 375: /* ! 376: * Call routine with argc, argv set from args (terminated by 0). ! 377: * VARARGS2 ! 378: */ ! 379: static ! 380: call(routine, args) ! 381: int (*routine)(); ! 382: int args; ! 383: { ! 384: register int *argp; ! 385: register int argc; ! 386: ! 387: for (argc = 0, argp = &args; *argp++ != 0; argc++) ! 388: ; ! 389: (*routine)(argc, &args); ! 390: } ! 391: ! 392: static struct tchars notc = { -1, -1, -1, -1, -1, -1 }; ! 393: static struct ltchars noltc = { -1, -1, -1, -1, -1, -1 }; ! 394: ! 395: mode(f) ! 396: register int f; ! 397: { ! 398: static int prevmode = 0; ! 399: struct tchars *tc, tc3; ! 400: struct ltchars *ltc; ! 401: struct sgttyb sb; ! 402: int onoff, old; ! 403: ! 404: if (prevmode == f) ! 405: return (f); ! 406: old = prevmode; ! 407: prevmode = f; ! 408: sb = ottyb; ! 409: if (ForceMode != -1) { ! 410: f = ForceMode; ! 411: ForceMode = -1; ! 412: } ! 413: switch (f) { ! 414: ! 415: case 0: ! 416: onoff = 0; ! 417: tc = &otc; ! 418: ltc = &oltc; ! 419: break; ! 420: ! 421: case 1: /* the rawest */ ! 422: case 2: /* allows for local echoing, newline mapping */ ! 423: case 3: /* like 1, but with XON/XOFF */ ! 424: ! 425: sb.sg_flags |= CBREAK; ! 426: if ((f == 1) || (f == 3)) { ! 427: sb.sg_flags &= ~(ECHO|CRMOD); ! 428: } else { ! 429: sb.sg_flags |= ECHO|CRMOD; ! 430: } ! 431: sb.sg_erase = sb.sg_kill = -1; ! 432: if (f == 3) { ! 433: tc = &tc3; ! 434: tc3 = notc; ! 435: /* get XON, XOFF characters */ ! 436: tc3.t_startc = otc.t_startc; ! 437: tc3.t_stopc = otc.t_stopc; ! 438: } else { ! 439: tc = ¬c; ! 440: } ! 441: ltc = &noltc; ! 442: onoff = 1; ! 443: break; ! 444: ! 445: default: ! 446: return(old); ! 447: } ! 448: ioctl(fileno(stdin), TIOCSLTC, (char *)ltc); ! 449: ioctl(fileno(stdin), TIOCSETC, (char *)tc); ! 450: ioctl(fileno(stdin), TIOCSETP, (char *)&sb); ! 451: ioctl(fileno(stdin), FIONBIO, (char *)&onoff); ! 452: ioctl(fileno(stdout), FIONBIO, (char *)&onoff); ! 453: ioctl(fileno(stdin), FIOASYNC, (char *)&onoff); ! 454: return (old); ! 455: } ! 456: ! 457: static char sibuf[BUFSIZ], *sbp; ! 458: static char tibuf[BUFSIZ], *tbp; ! 459: static int scc, tcc; ! 460: static int tin, tout; /* file descriptors */ ! 461: ! 462: /* ! 463: * Select from tty and network... ! 464: */ ! 465: static ! 466: telnet() ! 467: { ! 468: int on = 1; ! 469: int negativePid = -getpid(); ! 470: int schedValue; ! 471: ! 472: (void) mode(2); ! 473: ioctl(net, FIONBIO, (char *)&on); ! 474: ioctl(net, FIOASYNC, (char *)&on); /* hear about input */ ! 475: ioctl(net, SIOCSPGRP, (char *)&negativePid); /* set my pid */ ! 476: tin = fileno(stdin); ! 477: tout = fileno(stdout); ! 478: ! 479: for (;;) { ! 480: while (schedValue = Scheduler(0)) { ! 481: if (schedValue == -1) { ! 482: (void) mode(0); ! 483: return; ! 484: } ! 485: } ! 486: /* If there is data waiting to go out to terminal, don't ! 487: * schedule any more data for the terminal. ! 488: */ ! 489: if (tfrontp-tbackp) { ! 490: schedValue = 1; ! 491: } else { ! 492: schedValue = DoTerminalOutput(); ! 493: } ! 494: if (schedValue) { ! 495: if (Scheduler(1) == -1) { ! 496: (void) mode(0); ! 497: return; ! 498: } ! 499: } ! 500: } ! 501: } ! 502: ! 503: ! 504: /* Loop around once. */ ! 505: ! 506: static ! 507: Scheduler(block) ! 508: int block; /* should we block in the select? */ ! 509: { ! 510: register int c; ! 511: int ibits = 0, obits = 0; ! 512: /* One wants to be a bit careful about setting returnValue ! 513: * to one, since a one implies we did some useful work, ! 514: * and therefore probably won't be called to block next ! 515: * time. ! 516: */ ! 517: int returnValue = 0; ! 518: static struct timeval TimeValue = {0}; ! 519: ! 520: if (!In3270) { ! 521: if (nfrontp - nbackp) ! 522: obits |= (1 << net); ! 523: else if (tcc == 0) { ! 524: ibits |= (1 << tin); ! 525: } ! 526: if (tfrontp - tbackp) ! 527: obits |= (1 << tout); ! 528: else if (!ISend) ! 529: ibits |= (1 << net); ! 530: } else { ! 531: if (nfrontp - nbackp) { /* something for network? */ ! 532: obits |= 1<<net; /* yes - wait for space */ ! 533: } ! 534: if (tcc == 0) { /* any pending tty input? */ ! 535: ibits |= 1<<tin; /* no, look for new input */ ! 536: } ! 537: if (tfrontp-tbackp) { /* any pending tty output? */ ! 538: obits |= 1<<tout; /* yes - wait for space */ ! 539: } ! 540: if (!ISend) { /* any pending net input? */ ! 541: ibits |= 1<<net; /* no, look for new input */ ! 542: } ! 543: } ! 544: if (scc < 0 && tcc < 0) { ! 545: return(-1); ! 546: } ! 547: if (HaveInput) { /* Reprime SIGIO handler if appropriate */ ! 548: HaveInput = 0; ! 549: signal(SIGIO, inputAvailable); ! 550: } ! 551: select(16, &ibits, &obits, (int *) 0, ! 552: (block)? (struct timeval *)0:&TimeValue); ! 553: if (ibits == 0 && obits == 0 && block) { ! 554: /* I don't like this, does it ever happen? */ ! 555: printf("sleep(5) from tn3270, after select\n"); ! 556: sleep(5); ! 557: return(0); ! 558: } ! 559: ! 560: /* ! 561: * Something to read from the network... ! 562: */ ! 563: if (ibits & (1 << net)) { ! 564: scc = read(net, sibuf, sizeof (sibuf)); ! 565: if (scc < 0 && errno == EWOULDBLOCK) ! 566: scc = 0; ! 567: else { ! 568: if (scc <= 0) ! 569: return(-1); ! 570: sbp = sibuf; ! 571: if (printnet) { ! 572: Dump('<', sbp, scc); ! 573: } ! 574: returnValue = 1; /* did something usefull */ ! 575: } ! 576: } ! 577: ! 578: /* ! 579: * Something to read from the tty... ! 580: */ ! 581: if (ibits & (1 << tin)) { ! 582: tcc = read(tin, tibuf, sizeof tibuf); ! 583: if (tcc < 0 && errno == EWOULDBLOCK) ! 584: tcc = 0; ! 585: else { ! 586: if (tcc <= 0) ! 587: return(-1); ! 588: tbp = tibuf; ! 589: returnValue = 1; /* did something usefull */ ! 590: } ! 591: } ! 592: ! 593: if (tcc > 0) { ! 594: if (In3270) { ! 595: c = DataFromTerminal(tbp, tcc); ! 596: if (c) { ! 597: returnValue = 1; /* did something usefull */ ! 598: } ! 599: tcc -= c; ! 600: tbp += c; ! 601: } else { ! 602: returnValue = 1; /* did something usefull */ ! 603: while (tcc > 0) { ! 604: if ((&netobuf[BUFSIZ] - nfrontp) < 2) ! 605: break; ! 606: c = *tbp++ & 0377, tcc--; ! 607: if (strip(c) == escape) { ! 608: command(0); ! 609: tcc = 0; ! 610: break; ! 611: } ! 612: if (c == IAC) ! 613: *nfrontp++ = c; ! 614: *nfrontp++ = c; ! 615: } ! 616: } ! 617: } ! 618: if ((obits & (1 << net)) && (c = (int) (nfrontp - nbackp)) > 0) { ! 619: netflush(); ! 620: if (c != (int) (nfrontp-nbackp)) { ! 621: returnValue = 1; ! 622: } ! 623: } ! 624: if (scc > 0) { ! 625: if (Ifrontp+scc >= Ibuf+sizeof Ibuf) { ! 626: if (Ibackp != Ibuf) { /* do some copying */ ! 627: bcopy(Ibackp, Ibuf, Ifrontp-Ibackp); ! 628: Ifrontp -= (Ibackp-Ibuf); ! 629: Ibackp = Ibuf; ! 630: } ! 631: } ! 632: if (Ifrontp+scc < Ibuf+sizeof Ibuf) { ! 633: returnValue = 1; /* doing something useful */ ! 634: telrcv(); ! 635: } /* Else - we may never recover */ ! 636: } ! 637: if ((obits & (1 << tout)) && (c = (int) (tfrontp - tbackp)) > 0) { ! 638: ttyflush(); ! 639: if (c != (int) (tfrontp-tbackp)) { ! 640: returnValue = 1; ! 641: } ! 642: } ! 643: if (In3270 && (c = (int) (Ifrontp-Ibackp))) { ! 644: Ibackp += DataFromNetwork(Ibackp, Ifrontp-Ibackp, ISend); ! 645: if (c != (int) (Ifrontp-Ibackp)) { ! 646: returnValue = 1; ! 647: } ! 648: if (Ibackp == Ifrontp) { ! 649: Ibackp = Ifrontp = Ibuf; ! 650: ISend = 0; /* take data from network */ ! 651: } ! 652: } ! 653: return(returnValue); /* good return */ ! 654: } ! 655: ! 656: command(top) ! 657: int top; ! 658: { ! 659: register struct cmd *c; ! 660: int oldmode; ! 661: ! 662: oldmode = mode(0); ! 663: if (!top) ! 664: putchar('\n'); ! 665: else ! 666: signal(SIGINT, SIG_DFL); ! 667: for (;;) { ! 668: printf("%s> ", prompt); ! 669: if (gets(line) == 0) { ! 670: if (feof(stdin)) { ! 671: clearerr(stdin); ! 672: putchar('\n'); ! 673: } ! 674: break; ! 675: } ! 676: if (line[0] == 0) ! 677: break; ! 678: makeargv(); ! 679: c = getcmd(margv[0]); ! 680: if (c == (struct cmd *)-1) { ! 681: printf("?Ambiguous command\n"); ! 682: continue; ! 683: } ! 684: if (c == 0) { ! 685: printf("?Invalid command\n"); ! 686: continue; ! 687: } ! 688: (*c->handler)(margc, margv); ! 689: if (c->handler != help) ! 690: break; ! 691: } ! 692: if (!top) { ! 693: if (!connected) ! 694: longjmp(toplevel, 1); ! 695: (void) mode(oldmode); ! 696: } ! 697: } ! 698: ! 699: /* ! 700: * Telnet receiver states for fsm ! 701: */ ! 702: #define TS_DATA 0 ! 703: #define TS_IAC 1 ! 704: #define TS_WILL 2 ! 705: #define TS_WONT 3 ! 706: #define TS_DO 4 ! 707: #define TS_DONT 5 ! 708: #define TS_SB 6 /* in sub-negotiation */ ! 709: #define TS_SE 7 /* coming out of sub-negotiation */ ! 710: ! 711: #define SB_ACCUM(c) {*pSb = c; /* accumulate character */ \ ! 712: if (pSb >= SbBuffer+sizeof (SbBuffer)) { \ ! 713: /* can't accept any more */ \ ! 714: pSb = SbBuffer; \ ! 715: } \ ! 716: pSb++;} ! 717: ! 718: static ! 719: telrcv() ! 720: { ! 721: register int c; ! 722: register char *Sbp; ! 723: register int Scc; ! 724: static int state = TS_DATA; ! 725: ! 726: while (scc > 0) { ! 727: c = *sbp++ & 0377, scc--; ! 728: switch (state) { ! 729: ! 730: case TS_DATA: ! 731: if (c == IAC) { ! 732: state = TS_IAC; ! 733: continue; ! 734: } ! 735: /* We optimize this loop, since it is ! 736: * where we spend 99% of this routine. ! 737: */ ! 738: if (In3270) { ! 739: *Ifrontp++ = c; ! 740: Sbp = sbp; ! 741: Scc = scc; ! 742: while (Scc > 0) { ! 743: c = *Sbp++ & 0377, Scc--; ! 744: if (c == IAC) { ! 745: state = TS_IAC; ! 746: break; ! 747: } ! 748: *Ifrontp++ = c; ! 749: } ! 750: sbp = Sbp; ! 751: scc = Scc; ! 752: } else { ! 753: *tfrontp++ = c; ! 754: /* ! 755: * This hack is needed since we can't set ! 756: * CRMOD on output only. Machines like MULTICS ! 757: * like to send \r without \n; since we must ! 758: * turn off CRMOD to get proper input, the mapping ! 759: * is done here (sigh). ! 760: */ ! 761: if (c == '\r' && crmod && !In3270) ! 762: *tfrontp++ = '\n'; ! 763: } ! 764: continue; ! 765: ! 766: ! 767: case TS_IAC: ! 768: switch (c) { ! 769: ! 770: case WILL: ! 771: state = TS_WILL; ! 772: continue; ! 773: ! 774: case WONT: ! 775: state = TS_WONT; ! 776: continue; ! 777: ! 778: case DO: ! 779: state = TS_DO; ! 780: continue; ! 781: ! 782: case DONT: ! 783: state = TS_DONT; ! 784: continue; ! 785: ! 786: case DM: ! 787: outputPurge(); ! 788: break; ! 789: ! 790: case NOP: ! 791: case GA: ! 792: break; ! 793: ! 794: case SB: ! 795: state = TS_SB; ! 796: pSb = SbBuffer; /* where to collect */ ! 797: continue; ! 798: ! 799: case EOR: ! 800: if (In3270) { ! 801: Ibackp += DataFromNetwork(Ibackp, ! 802: Ifrontp-Ibackp, 1); ! 803: if (Ibackp == Ifrontp) { ! 804: Ibackp = Ifrontp = Ibuf; ! 805: ISend = 0; /* should have been! */ ! 806: } else { ! 807: ISend = 1; ! 808: } ! 809: } ! 810: break; ! 811: ! 812: case IAC: ! 813: if (In3270) { ! 814: *Ifrontp++ = IAC; ! 815: } else { ! 816: *tfrontp++ = IAC; ! 817: } ! 818: break; ! 819: ! 820: default: ! 821: break; ! 822: } ! 823: state = TS_DATA; ! 824: continue; ! 825: ! 826: case TS_WILL: ! 827: printoption("RCVD", will, c, !hisopts[c]); ! 828: if (!hisopts[c]) ! 829: willoption(c); ! 830: state = TS_DATA; ! 831: continue; ! 832: ! 833: case TS_WONT: ! 834: printoption("RCVD", wont, c, hisopts[c]); ! 835: if (hisopts[c]) ! 836: wontoption(c); ! 837: state = TS_DATA; ! 838: continue; ! 839: ! 840: case TS_DO: ! 841: printoption("RCVD", doopt, c, !myopts[c]); ! 842: if (!myopts[c]) ! 843: dooption(c); ! 844: state = TS_DATA; ! 845: continue; ! 846: ! 847: case TS_DONT: ! 848: printoption("RCVD", dont, c, myopts[c]); ! 849: if (myopts[c]) { ! 850: myopts[c] = 0; ! 851: if (c == TELOPT_BINARY) { ! 852: SetIn3270(); ! 853: } ! 854: sprintf(nfrontp, wont, c); ! 855: nfrontp += sizeof (wont) - 2; ! 856: printoption("SENT", wont, c); ! 857: } ! 858: state = TS_DATA; ! 859: continue; ! 860: case TS_SB: ! 861: if (c == IAC) { ! 862: state = TS_SE; ! 863: continue; ! 864: } ! 865: SB_ACCUM(c); ! 866: continue; ! 867: case TS_SE: ! 868: if (c != SE) { ! 869: if (c != IAC) { ! 870: SB_ACCUM(IAC); ! 871: } ! 872: SB_ACCUM(c); ! 873: state = TS_SB; ! 874: } else { ! 875: /* this is the end of the sub negotiation */ ! 876: /* we only allow a termtype, send, sub */ ! 877: if ((Sb_Option != TELOPT_TTYPE) || ! 878: (Sb_Command != TELQUAL_SEND)) { ! 879: /* what to do? XXX */ ! 880: } else { ! 881: /* send our type */ ! 882: SentTerminalType = 1; ! 883: SetIn3270(); ! 884: bcopy(sb_terminal, nfrontp, sizeof sb_terminal); ! 885: nfrontp += sizeof sb_terminal; ! 886: printoption("SENT", sb_terminal, ! 887: TELOPT_TTYPE); ! 888: } ! 889: state = TS_DATA; ! 890: } ! 891: } ! 892: } ! 893: } ! 894: ! 895: static ! 896: willoption(option) ! 897: int option; ! 898: { ! 899: char *fmt; ! 900: ! 901: switch (option) { ! 902: ! 903: case TELOPT_ECHO: ! 904: (void) mode(1); ! 905: ! 906: case TELOPT_BINARY: ! 907: hisopts[option] = 1; ! 908: SetIn3270(); ! 909: fmt = doopt; ! 910: break; ! 911: ! 912: case TELOPT_EOR: ! 913: case TELOPT_SGA: ! 914: hisopts[option] = 1; ! 915: fmt = doopt; ! 916: break; ! 917: ! 918: case TELOPT_TM: ! 919: fmt = dont; ! 920: break; ! 921: ! 922: default: ! 923: fmt = dont; ! 924: break; ! 925: } ! 926: sprintf(nfrontp, fmt, option); ! 927: nfrontp += sizeof (dont) - 2; ! 928: printoption("SENT", fmt, option); ! 929: } ! 930: ! 931: static ! 932: wontoption(option) ! 933: int option; ! 934: { ! 935: char *fmt; ! 936: ! 937: switch (option) { ! 938: ! 939: case TELOPT_BINARY: ! 940: hisopts[option] = 0; ! 941: SetIn3270(); ! 942: fmt = doopt; ! 943: break; ! 944: ! 945: case TELOPT_ECHO: ! 946: (void) mode(2); ! 947: ! 948: case TELOPT_SGA: ! 949: hisopts[option] = 0; ! 950: fmt = dont; ! 951: break; ! 952: ! 953: default: ! 954: fmt = dont; ! 955: } ! 956: sprintf(nfrontp, fmt, option); ! 957: nfrontp += sizeof (doopt) - 2; ! 958: printoption("SENT", fmt, option); ! 959: } ! 960: ! 961: static ! 962: dooption(option) ! 963: int option; ! 964: { ! 965: char *fmt; ! 966: ! 967: switch (option) { ! 968: ! 969: case TELOPT_TTYPE: ! 970: case TELOPT_BINARY: ! 971: myopts[option] = 1; ! 972: SetIn3270(); ! 973: fmt = will; ! 974: break; ! 975: ! 976: case TELOPT_TM: ! 977: fmt = wont; ! 978: break; ! 979: ! 980: case TELOPT_ECHO: ! 981: (void) mode(2); ! 982: fmt = will; ! 983: hisopts[option] = 0; ! 984: break; ! 985: ! 986: case TELOPT_EOR: ! 987: case TELOPT_SGA: ! 988: fmt = will; ! 989: break; ! 990: ! 991: default: ! 992: fmt = wont; ! 993: break; ! 994: } ! 995: sprintf(nfrontp, fmt, option); ! 996: nfrontp += (sizeof dont)-2; ! 997: printoption("SENT", fmt, option); ! 998: } ! 999: ! 1000: static ! 1001: SetIn3270() ! 1002: { ! 1003: if (SentTerminalType && myopts[TELOPT_BINARY] && hisopts[TELOPT_BINARY]) { ! 1004: if (!In3270) { ! 1005: In3270 = 1; ! 1006: OptInit(); /* initialize mappings */ ! 1007: /* initialize terminal key mapping */ ! 1008: (void) DataFromTerminal(ttyobuf, 0); ! 1009: (void) mode(3); ! 1010: } ! 1011: } else { ! 1012: if (In3270) { ! 1013: Stop3270(1); ! 1014: In3270 = 0; ! 1015: (void) mode(2); ! 1016: } ! 1017: } ! 1018: } ! 1019: ! 1020: /* ! 1021: * Set the escape character. ! 1022: */ ! 1023: static ! 1024: setescape(argc, argv) ! 1025: int argc; ! 1026: char *argv[]; ! 1027: { ! 1028: register char *arg; ! 1029: char buf[50]; ! 1030: ! 1031: if (argc > 2) ! 1032: arg = argv[1]; ! 1033: else { ! 1034: printf("new escape character: "); ! 1035: gets(buf); ! 1036: arg = buf; ! 1037: } ! 1038: if (arg[0] != '\0') ! 1039: escape = arg[0]; ! 1040: printf("Escape character is '%s'.\n", control(escape)); ! 1041: fflush(stdout); ! 1042: } ! 1043: ! 1044: /*VARARGS*/ ! 1045: static ! 1046: setoptions() ! 1047: { ! 1048: ! 1049: showoptions = !showoptions; ! 1050: printf("%s show option processing.\n", showoptions ? "Will" : "Wont"); ! 1051: fflush(stdout); ! 1052: } ! 1053: ! 1054: /*VARARGS*/ ! 1055: static ! 1056: setcrmod() ! 1057: { ! 1058: ! 1059: crmod = !crmod; ! 1060: printf("%s map carriage return on output.\n", crmod ? "Will" : "Wont"); ! 1061: fflush(stdout); ! 1062: } ! 1063: ! 1064: /*VARARGS*/ ! 1065: static ! 1066: setdebug() ! 1067: { ! 1068: ! 1069: debug = !debug; ! 1070: printf("%s turn on socket level debugging.\n", ! 1071: debug ? "Will" : "Wont"); ! 1072: fflush(stdout); ! 1073: if (debug && net > 0 && setsockopt(net, SOL_SOCKET, SO_DEBUG, 0, 0) < 0) ! 1074: perror("setsockopt (SO_DEBUG)"); ! 1075: } ! 1076: ! 1077: /*VARARGS*/ ! 1078: static ! 1079: SetPrintNet() ! 1080: { ! 1081: ! 1082: printnet = !printnet; ! 1083: printf("%s turn on printing of raw network traffic.\n", ! 1084: printnet ? "Will" : "Wont"); ! 1085: } ! 1086: ! 1087: /* ! 1088: * Construct a control character sequence ! 1089: * for a special character. ! 1090: */ ! 1091: static char * ! 1092: control(c) ! 1093: register int c; ! 1094: { ! 1095: static char buf[3]; ! 1096: ! 1097: if (c == 0177) ! 1098: return ("^?"); ! 1099: if (c >= 040) { ! 1100: buf[0] = c; ! 1101: buf[1] = 0; ! 1102: } else { ! 1103: buf[0] = '^'; ! 1104: buf[1] = '@'+c; ! 1105: buf[2] = 0; ! 1106: } ! 1107: return (buf); ! 1108: } ! 1109: ! 1110: static struct cmd * ! 1111: getcmd(name) ! 1112: register char *name; ! 1113: { ! 1114: register char *p, *q; ! 1115: register struct cmd *c, *found; ! 1116: register int nmatches, longest; ! 1117: ! 1118: longest = 0; ! 1119: nmatches = 0; ! 1120: found = 0; ! 1121: for (c = cmdtab; p = c->name; c++) { ! 1122: for (q = name; *q == *p++; q++) ! 1123: if (*q == 0) /* exact match? */ ! 1124: return (c); ! 1125: if (!*q) { /* the name was a prefix */ ! 1126: if (q - name > longest) { ! 1127: longest = q - name; ! 1128: nmatches = 1; ! 1129: found = c; ! 1130: } else if (q - name == longest) ! 1131: nmatches++; ! 1132: } ! 1133: } ! 1134: if (nmatches > 1) ! 1135: return ((struct cmd *)-1); ! 1136: return (found); ! 1137: } ! 1138: ! 1139: static ! 1140: deadpeer() ! 1141: { ! 1142: (void) mode(0); ! 1143: longjmp(peerdied, -1); ! 1144: } ! 1145: ! 1146: static ! 1147: intr() ! 1148: { ! 1149: (void) mode(0); ! 1150: longjmp(toplevel, -1); ! 1151: } ! 1152: ! 1153: static ! 1154: inputAvailable() ! 1155: { ! 1156: HaveInput = 1; ! 1157: } ! 1158: ! 1159: /* outputPurge() - get rid of all output destined for terminal. */ ! 1160: outputPurge() ! 1161: { ! 1162: ioctl(fileno(stdout), TIOCFLUSH, (char *)0); ! 1163: tbackp = tfrontp = ttyobuf; ! 1164: } ! 1165: ! 1166: ttyflush() ! 1167: { ! 1168: int n; ! 1169: ! 1170: if ((n = tfrontp - tbackp) > 0) ! 1171: n = write(tout, tbackp, n); ! 1172: if (n < 0) ! 1173: return; ! 1174: tbackp += n; ! 1175: if (tbackp == tfrontp) ! 1176: tbackp = tfrontp = ttyobuf; ! 1177: } ! 1178: ! 1179: /* TtyChars() - returns the number of characters in the TTY buffer */ ! 1180: TtyChars() ! 1181: { ! 1182: return(tfrontp-tbackp); ! 1183: } ! 1184: ! 1185: netflush() ! 1186: { ! 1187: int n; ! 1188: ! 1189: if ((n = nfrontp - nbackp) > 0) ! 1190: n = write(net, nbackp, n); ! 1191: if (n < 0) { ! 1192: if (errno != ENOBUFS && errno != EWOULDBLOCK) { ! 1193: (void) mode(0); ! 1194: perror(hostname); ! 1195: close(net); ! 1196: longjmp(peerdied, -1); ! 1197: /*NOTREACHED*/ ! 1198: } ! 1199: n = 0; ! 1200: } ! 1201: if (printnet) { ! 1202: Dump('>', nbackp, n); ! 1203: } ! 1204: nbackp += n; ! 1205: if (nbackp == nfrontp) ! 1206: nbackp = nfrontp = netobuf; ! 1207: } ! 1208: ! 1209: /* DataToNetwork - queue up some data to go to network. When last byte is ! 1210: queued, we add on an IAC EOR sequence (so, don't call us until you ! 1211: want that done...) ! 1212: */ ! 1213: ! 1214: int ! 1215: DataToNetwork(buffer, count) ! 1216: register char *buffer; /* where the data is */ ! 1217: register int count; /* how much to send */ ! 1218: { ! 1219: register int c; ! 1220: int origCount; ! 1221: ! 1222: origCount = count; ! 1223: ! 1224: while (count) { ! 1225: if ((&netobuf[sizeof netobuf] - nfrontp) < 6) { ! 1226: netflush(); ! 1227: if ((&netobuf[sizeof netobuf] - nfrontp) < 6) { ! 1228: break; ! 1229: } ! 1230: } ! 1231: c = *buffer++; ! 1232: count--; ! 1233: if (c == IAC) { ! 1234: *nfrontp++ = IAC; ! 1235: *nfrontp++ = IAC; ! 1236: } else { ! 1237: *nfrontp++ = c; ! 1238: } ! 1239: } ! 1240: ! 1241: if (!count) { ! 1242: *nfrontp++ = IAC; ! 1243: *nfrontp++ = EOR; ! 1244: netflush(); /* try to move along as quickly as ... */ ! 1245: } ! 1246: return(origCount - count); ! 1247: } ! 1248: ! 1249: /* DataToTerminal - queue up some data to go to terminal. */ ! 1250: ! 1251: int ! 1252: DataToTerminal(buffer, count) ! 1253: register char *buffer; /* where the data is */ ! 1254: register int count; /* how much to send */ ! 1255: { ! 1256: int origCount; ! 1257: int o; ! 1258: ! 1259: origCount = count; ! 1260: ! 1261: while (count) { ! 1262: if (tfrontp >= &ttyobuf[sizeof ttyobuf]) { ! 1263: ttyflush(); ! 1264: while (tfrontp >= &ttyobuf[sizeof ttyobuf]) { ! 1265: o = 1<<tout; ! 1266: (void) select(tout+1, (int *) 0, &o, (int *) 0, ! 1267: (struct timeval *) 0); ! 1268: ttyflush(); ! 1269: } ! 1270: } ! 1271: *tfrontp++ = *buffer++; ! 1272: count--; ! 1273: } ! 1274: return(origCount - count); ! 1275: } ! 1276: ! 1277: /* EmptyTerminal - called to make sure that the terminal buffer is empty. ! 1278: * Note that we consider the buffer to run all the ! 1279: * way to the kernel (thus the select). ! 1280: */ ! 1281: ! 1282: void ! 1283: EmptyTerminal() ! 1284: { ! 1285: int o; ! 1286: ! 1287: o = 1<<tout; ! 1288: ! 1289: if (tfrontp == tbackp) { ! 1290: (void) select(tout+1, (int *) 0, &o, (int *) 0, ! 1291: (struct timeval *) 0); /* wait for TTLOWAT */ ! 1292: } else { ! 1293: while (tfrontp != tbackp) { ! 1294: ttyflush(); ! 1295: (void) select(tout+1, (int *) 0, &o, (int *) 0, ! 1296: (struct timeval *) 0); /* wait for TTLOWAT */ ! 1297: } ! 1298: } ! 1299: } ! 1300: ! 1301: ! 1302: ! 1303: /* StringToTerminal - output a null terminated string to the terminal */ ! 1304: ! 1305: int ! 1306: StringToTerminal(s) ! 1307: char *s; ! 1308: { ! 1309: int count; ! 1310: ! 1311: count = strlen(s); ! 1312: if (count) { ! 1313: (void) DataToTerminal(s, count); /* we know it always goes... */ ! 1314: } ! 1315: } ! 1316: ! 1317: ! 1318: /* _putchar - output a single character to the terminal. This name is so that ! 1319: * curses(3x) can call us to send out data. ! 1320: */ ! 1321: ! 1322: _putchar(c) ! 1323: char c; ! 1324: { ! 1325: if (tfrontp >= &ttyobuf[sizeof ttyobuf]) { ! 1326: (void) DataToTerminal(&c, 1); ! 1327: } else { ! 1328: *tfrontp++ = c; /* optimize if possible. */ ! 1329: } ! 1330: } ! 1331: ! 1332: static ! 1333: SetForExit() ! 1334: { ! 1335: (void) mode(2); /* switch modes to flush output */ ! 1336: (void) mode(0); ! 1337: fflush(stdout); ! 1338: fflush(stderr); ! 1339: if (In3270) { ! 1340: Stop3270(0); ! 1341: } ! 1342: (void) mode(2); /* make sure we go back to mode 0 */ ! 1343: (void) mode(0); ! 1344: } ! 1345: ! 1346: static ! 1347: Exit(returnCode) ! 1348: int returnCode; ! 1349: { ! 1350: SetForExit(); ! 1351: exit(returnCode); ! 1352: } ! 1353: ! 1354: ExitString(file, string, returnCode) ! 1355: FILE *file; ! 1356: char *string; ! 1357: int returnCode; ! 1358: { ! 1359: SetForExit(); ! 1360: fwrite(string, 1, strlen(string), file); ! 1361: exit(returnCode); ! 1362: } ! 1363: ! 1364: ExitPerror(string, returnCode) ! 1365: char *string; ! 1366: int returnCode; ! 1367: { ! 1368: SetForExit(); ! 1369: perror(string); ! 1370: exit(returnCode); ! 1371: } ! 1372: ! 1373: ! 1374: static ! 1375: Dump(direction, buffer, length) ! 1376: char direction; ! 1377: char *buffer; ! 1378: int length; ! 1379: { ! 1380: # define BYTES_PER_LINE 32 ! 1381: char *pThis; ! 1382: int offset; ! 1383: ! 1384: offset = 0; ! 1385: ! 1386: while (length) { ! 1387: /* print one line */ ! 1388: fprintf(NetTrace, "%c 0x%x\t", direction, offset); ! 1389: pThis = buffer; ! 1390: buffer = buffer+min(length, BYTES_PER_LINE); ! 1391: while (pThis < buffer) { ! 1392: fprintf(NetTrace, "%.2x", (*pThis)&0xff); ! 1393: pThis++; ! 1394: } ! 1395: fprintf(NetTrace, "\n"); ! 1396: length -= BYTES_PER_LINE; ! 1397: offset += BYTES_PER_LINE; ! 1398: if (length < 0) { ! 1399: return; ! 1400: } ! 1401: /* find next unique line */ ! 1402: } ! 1403: } ! 1404: ! 1405: ! 1406: ! 1407: /*VARARGS*/ ! 1408: static ! 1409: printoption(direction, fmt, option, what) ! 1410: char *direction, *fmt; ! 1411: int option, what; ! 1412: { ! 1413: if (!showoptions) ! 1414: return; ! 1415: printf("%s ", direction); ! 1416: if (fmt == doopt) ! 1417: fmt = "do"; ! 1418: else if (fmt == dont) ! 1419: fmt = "dont"; ! 1420: else if (fmt == will) ! 1421: fmt = "will"; ! 1422: else if (fmt == wont) ! 1423: fmt = "wont"; ! 1424: else if (fmt == sb_terminal) ! 1425: fmt = "will (terminal)"; ! 1426: else ! 1427: fmt = "???"; ! 1428: if (option < TELOPT_SUPDUP) ! 1429: printf("%s %s", fmt, telopts[option]); ! 1430: else ! 1431: printf("%s %d", fmt, option); ! 1432: if (*direction == '<') { ! 1433: printf("\r\n"); ! 1434: return; ! 1435: } ! 1436: printf(" (%s)\r\n", what ? "reply" : "don't reply"); ! 1437: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.