开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
commands.c
资源名称：socks5.zip　[点击查看]
上传用户：sddyfurun
上传日期：2007-01-04
资源大小：525k
文件大小：63k
源码类别：

代理服务器

开发平台：

Unix_Linux

commands.c：源码内容
  1. /* Copyright (c) 1988, 1990, 1993                                            */
  2. /* The Regents of the University of California.  All rights reserved.        */
  3. /*                                                                           */
  4. /* Redistribution and use in source and binary forms, with or without        */
  5. /* modification, are permitted provided that the following conditions        */
  6. /* are met:                                                                  */
  7. /* 1. Redistributions of source code must retain the above copyright         */
  8. /* notice, this list of conditions and the following disclaimer.             */
  9. /* 2. Redistributions in binary form must reproduce the above copyright      */
  10. /* notice, this list of conditions and the following disclaimer in the       */
  11. /* documentation and/or other materials provided with the distribution.      */
  12. /* 3. All advertising materials mentioning features or use of this           */
  13. /* software must display the following acknowledgement:                      */
  14. /*   This product includes software developed by the University of           */
  15. /*   California, Berkeley and its contributors.                              */
  16. /* 4. Neither the name of the University nor the names of its contributors   */
  17. /* may be used to endorse or promote products derived from this software     */
  18. /* without specific prior written permission.                                */
  19. /*                                                                           */
  20. /* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND   */
  21. /* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE     */
  22. /* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR        */
  23. /* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE */
  24. /* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR       */
  25. /* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF      */
  26. /* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS  */
  27. /* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN   */
  28. /* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)   */
  29. /* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF    */
  30. /* THE POSSIBILITY OF SUCH DAMAGE.                                           */
  32. #ifdef SHOW_SCCIDS
  33. static char sccsid[] = "@(#)commands.c 8.4 (Berkeley) 5/30/95";
  34. #endif
  36. #include "config.h"
  38. #ifdef HAVE_SYS_PARAM_H
  39. #include <sys/param.h>
  40. #endif
  42. #ifdef HAVE_SYS_TYPES_H
  43. #include <sys/types.h>
  44. #endif
  46. #ifdef HAVE_SYS_FILE_H
  47. #include <sys/file.h>
  48. #endif
  50. #ifdef HAVE_UNISTD_H
  51. #include <unistd.h>
  52. #endif
  54. #include <sys/socket.h>
  55. #include <netinet/in.h>
  57. #ifdef HAVE_SYS_FCNTL_H
  58. #include <sys/fcntl.h>
  59. #endif
  61. #ifdef HAVE_FCNTL_H
  62. #include <fcntl.h>
  63. #endif
  65. #include <stdio.h>
  67. #ifdef HAVE_STRING_H
  68. #include <string.h>
  69. #endif
  71. #ifdef HAVE_STRINGS_H
  72. #include <strings.h>
  73. #endif
  75. #ifdef HAVE_UNISTD_H
  76. #include <unistd.h>
  77. #endif
  79. #ifdef HAVE_STDLIB_H
  80. #include <stdlib.h>
  81. #endif
  83. #include <signal.h>
  84. #include <ctype.h>
  85. #include <pwd.h>
  86. #include <varargs.h>
  87. #include <errno.h>
  89. #include <arpa/telnet.h>
  91. #include "general.h"
  92. #include "ring.h"
  93. #include "externs.h"
  94. #include "defines.h"
  95. #include "types.h"
  97. #ifdef HAVE_MACHINE_ENDIAN_H
  98. #include <machine/endian.h>
  99. #endif
  101. #include <netinet/ip.h>
  103. #define DONT_NEED_SIGBLOCK
  104. #define DONT_NEED_SIGUNBLOCK
  105. #define DONT_NEED_SIGPAUSE
  106. #define DONT_NEED_SIGPENDING
  107. #include "sigfix.h"
  109. #ifndef MAXHOSTNAMELEN
  110. #define MAXHOSTNAMELEN 64
  111. #endif
  113. #if defined(IPPROTO_IP) && defined(IP_TOS)
  114. int tos = -1;
  115. #endif
  117. char *hostname;
  118. static char _hostname[MAXHOSTNAMELEN];
  120. extern int isprefix();
  121. extern char **genget();
  122. extern int Ambiguous();
  123. extern void herror();
  125. static call();
  127. typedef struct {
  128.     char *name; /* command name */
  129.     char *help; /* help string (NULL for no help) */
  130.     int (*handler)(); /* routine which executes command */
  131.     int needconnect; /* Do we need to be connected to execute? */
  132. } Command;
  134. static char line[256];
  135. static char saveline[256];
  136. static int margc;
  137. static char *margv[20];
  139. void cmdrc P((char *, char *));
  141. static void makeargv() {
  142.     register char *cp, *cp2, c;
  143.     register char **argp = margv;
  145.     margc = 0;
  146.     cp = line;
  147.     if (*cp == '!') { /* Special case shell escape */
  148. strcpy(saveline, line); /* save for shell command */
  149. *argp++ = "!"; /* No room in string to get this */
  150. margc++;
  151. cp++;
  152.     }
  153.     while ((c = *cp)) {
  154. register int inquote = 0;
  155. while (isspace(c))
  156.     c = *++cp;
  157. if (c == '')
  158.     break;
  159. *argp++ = cp;
  160. margc += 1;
  161. for (cp2 = cp; c != ''; c = *++cp) {
  162.     if (inquote) {
  163. if (c == inquote) {
  164.     inquote = 0;
  165.     continue;
  166. }
  167.     } else {
  168. if (c == '\') {
  169.     if ((c = *++cp) == '')
  170. break;
  171. } else if (c == '"') {
  172.     inquote = '"';
  173.     continue;
  174. } else if (c == ''') {
  175.     inquote = ''';
  176.     continue;
  177. } else if (isspace(c))
  178.     break;
  179.     }
  180.     *cp2++ = c;
  181. }
  182. *cp2 = '';
  183. if (c == '')
  184.     break;
  185. cp++;
  186.     }
  187.     *argp++ = 0;
  188. }
  190. /* Make a character string into a number.                                    */
  191. /* Todo: 1.  Could take random integers (12, 0x12, 012, 0b1).                */
  192. static char special(register char *s) {
  193.     register char c;
  194.     char b;
  195.     
  196.     switch (*s) {
  197. case '^':
  198.     b = *++s;
  199.     if (b == '?') {
  200. c = b | 0x40; /* DEL */
  201.     } else {
  202. c = b & 0x1f;
  203.     }
  204.     break;
  205. default:
  206.     c = *s;
  207.     break;
  208.     }
  210.     return c;
  211. }
  213. /* Construct a control character sequence for a special character.           */
  214. static char *control(register cc_t c) {
  215.     static char buf[5];
  216.     /* The only way I could get the Sun 3.5 compiler to shut up about "if    */
  217.     /* ((unsigned int)c >= 0x80)" was to assign "c" to an unsigned int       */
  218.     /* variable...  Arggg....                                                */
  219.     register unsigned int uic = (unsigned int)c;
  221.     if (uic == 0x7f) {
  222. return ("^?");
  223.     }
  225.     if (c == (cc_t)_POSIX_VDISABLE) {
  226. return "off";
  227.     }
  229.     if (uic >= 0x80) {
  230. buf[0] = '\';
  231. buf[1] = ((c>>6)&07) + '0';
  232. buf[2] = ((c>>3)&07) + '0';
  233. buf[3] = (c&07) + '0';
  234. buf[4] = 0;
  235.     } else if (uic >= 0x20) {
  236. buf[0] = c;
  237. buf[1] = 0;
  238.     } else {
  239. buf[0] = '^';
  240. buf[1] = '@'+c;
  241. buf[2] = 0;
  242.     }
  244.     return (buf);
  245. }
  247. /* The following are data structures and routines for                        */
  248. /* the "send" command.                                                       */
  249. struct sendlist {
  250.     char *name; /* How user refers to it (case independent) */
  251.     char *help; /* Help information (0 ==> no help) */
  252.     int needconnect; /* Need to be connected */
  253.     int narg; /* Number of arguments */
  254.     int (*handler)(); /* Routine to perform (for special ops) */
  255.     int nbyte; /* Number of bytes to send this command */
  256.     int what; /* Character to be sent (<0 ==> special) */
  257. };
  259. static int
  260. send_esc P((void)),
  261. send_help P((void)),
  262. send_docmd P((char *)),
  263. send_dontcmd P((char *)),
  264. send_willcmd P((char *)),
  265. send_wontcmd P((char *));
  267. static struct sendlist Sendlist[] = {
  268.     { "ao", "Send Telnet Abort output", 1, 0, 0, 2, AO },
  269.     { "ayt", "Send Telnet 'Are You There'", 1, 0, 0, 2, AYT },
  270.     { "brk", "Send Telnet Break", 1, 0, 0, 2, BREAK },
  271.     { "break", 0, 1, 0, 0, 2, BREAK },
  272.     { "ec", "Send Telnet Erase Character", 1, 0, 0, 2, EC },
  273.     { "el", "Send Telnet Erase Line", 1, 0, 0, 2, EL },
  274.     { "escape", "Send current escape character", 1, 0, send_esc, 1, 0 },
  275.     { "ga", "Send Telnet 'Go Ahead' sequence", 1, 0, 0, 2, GA },
  276.     { "ip", "Send Telnet Interrupt Process", 1, 0, 0, 2, IP },
  277.     { "intp", 0, 1, 0, 0, 2, IP },
  278.     { "interrupt", 0, 1, 0, 0, 2, IP },
  279.     { "intr", 0, 1, 0, 0, 2, IP },
  280.     { "nop", "Send Telnet 'No operation'", 1, 0, 0, 2, NOP },
  281.     { "eor", "Send Telnet 'End of Record'", 1, 0, 0, 2, EOR },
  282.     { "abort", "Send Telnet 'Abort Process'", 1, 0, 0, 2, ABORT },
  283.     { "susp", "Send Telnet 'Suspend Process'", 1, 0, 0, 2, SUSP },
  284.     { "eof", "Send Telnet End of File Character", 1, 0, 0, 2, xEOF },
  285.     { "synch", "Perform Telnet 'Synch operation'", 1, 0, dosynch, 2, 0 },
  286.     { "getstatus", "Send request for STATUS", 1, 0, get_status, 6, 0 },
  287.     { "?", "Display send options", 0, 0, send_help, 0, 0 },
  288.     { "help", 0, 0, 0, send_help, 0, 0 },
  289.     { "do", 0, 0, 1, send_docmd, 3, 0 },
  290.     { "dont", 0, 0, 1, send_dontcmd, 3, 0 },
  291.     { "will", 0, 0, 1, send_willcmd, 3, 0 },
  292.     { "wont", 0, 0, 1, send_wontcmd, 3, 0 },
  293.     { 0 }
  294. };
  296. #define GETSEND(name) ((struct sendlist *) genget(name, (char **) Sendlist, 
  297. sizeof(struct sendlist)))
  299. /*VARARGS*/
  300. static int bye(int argc, char *argv[]) {
  301.     extern int resettermname;
  303.     if (connected) {
  304. (void) shutdown(net, 2);
  305. printf("Connection closed.n");
  306. (void) NetClose(net);
  307. connected = 0;
  308. resettermname = 1;
  309. /* reset options */
  310. tninit();
  311. #ifdef TN3270
  312. SetIn3270(); /* Get out of 3270 mode */
  313. #endif /* defined(TN3270) */
  314.     }
  315.     if ((argc != 2) || (strcmp(argv[1], "fromquit") != 0)) {
  316. longjmp(toplevel, 1);
  317. /* NOTREACHED */
  318.     }
  319.     return 1; /* Keep lint, etc., happy */
  320. }
  322. int quit() {
  323.     call(bye, "bye", "fromquit", 0);
  324.     Exit(0);
  326.     /*NOTREACHED*/
  327.     return 0;
  328. }
  330. int logout() {
  331.     send_do(TELOPT_LOGOUT, 1);
  332.     netflush();
  333.     return 1;
  334. }
  336. static int sendcmd(int argc, char **argv) { 
  337.     int count; /* how many bytes we are going to need to send */
  338.     int i;
  339.     struct sendlist *s; /* pointer to current command */
  340.     int success = 0;
  341.     int needconnect = 0;
  343.     if (argc < 2) {
  344. printf("need at least one argument for 'send' commandn");
  345. printf("'send ?' for helpn");
  346. return 0;
  347.     }
  348.     /* First, validate all the send arguments.  In addition, we see how much */
  349.     /* space we are going to need, and whether or not we will be doing a     */
  350.     /* "SYNCH" operation (which flushes the network queue).                  */
  351.     count = 0;
  353.     for (i = 1; i < argc; i++) {
  354. s = GETSEND(argv[i]);
  355. if (s == 0) {
  356.     printf("Unknown send argument '%s'n'send ?' for help.n", argv[i]);
  357.     return 0;
  358. } else if (Ambiguous(s)) {
  359.     printf("Ambiguous send argument '%s'n'send ?' for help.n", argv[i]);
  360.     return 0;
  361. }
  363. if (i + s->narg >= argc) {
  364.     fprintf(stderr, "Need %d argument%s to 'send %s' command.  'send %s ?' for help.n",
  365.     s->narg, s->narg == 1 ? "" : "s", s->name, s->name);
  366.     return 0;
  367. }
  369. count += s->nbyte;
  371. if (s->handler == send_help) {
  372.     send_help();
  373.     return 0;
  374. }
  376. i += s->narg;
  377. needconnect += s->needconnect;
  378.     }
  380.     if (!connected && needconnect) {
  381. printf("?Need to be connected first.n");
  382. printf("'send ?' for helpn");
  383. return 0;
  384.     }
  386.     /* Now, do we have enough room? */
  387.     if (NETROOM() < count) {
  388. printf("There is not enough room in the buffer TO the networkn");
  389. printf("to process your request.  Nothing will be done.n");
  390. printf("('send synch' will throw away most data in the networkn");
  391. printf("buffer, if this might help.)n");
  392. return 0;
  393.     }
  395.     /* OK, they are all OK, now go through again and actually send */
  396.     count = 0;
  398.     for (i = 1; i < argc; i++) {
  399. if ((s = GETSEND(argv[i])) == 0) {
  400.     fprintf(stderr, "Telnet 'send' error - argument disappeared!n");
  401.     (void) quit();
  402.     /*NOTREACHED*/
  403. }
  404. if (s->handler) {
  405.     count++;
  406.     success += (*s->handler)((s->narg > 0) ? argv[i+1] : 0,
  407.   (s->narg > 1) ? argv[i+2] : 0);
  408.     i += s->narg;
  409. } else {
  410.     NET2ADD(IAC, s->what);
  411.     printoption("SENT", IAC, s->what);
  412. }
  413.     }
  415.     return (count == success);
  416. }
  418. static int send_esc() {
  419.     NETADD(escape);
  420.     return 1;
  421. }
  423. static int send_tncmd(void (*func)(), char *cmd, char *name) {
  424.     char **cpp;
  425.     extern char *telopts[];
  426.     register int val = 0;
  428.     if (isprefix(name, "help") || isprefix(name, "?")) {
  429. register int col, len;
  431. printf("Usage: send %s <value|option>n", cmd);
  432. printf(""value" must be from 0 to 255n");
  433. printf("Valid options are:nt");
  435. col = 8;
  437. for (cpp = telopts; *cpp; cpp++) {
  438.     len = strlen(*cpp) + 3;
  440.     if (col + len > 65) {
  441. printf("nt");
  442. col = 8;
  443.     }
  445.     printf(" "%s"", *cpp);
  446.     col += len;
  447. }
  449. printf("n");
  450. return 0;
  451.     }
  453.     cpp = (char **)genget(name, telopts, sizeof(char *));
  455.     if (Ambiguous(cpp)) {
  456. fprintf(stderr,"'%s': ambiguous argument ('send %s ?' for help).n", name, cmd);
  457. return 0;
  458.     }
  460.     if (cpp) {
  461. val = cpp - telopts;
  462.     } else {
  463. register char *cp = name;
  465. while (*cp >= '0' && *cp <= '9') {
  466.     val *= 10;
  467.     val += *cp - '0';
  468.     cp++;
  469. }
  471. if (*cp != 0) {
  472.     fprintf(stderr, "'%s': unknown argument ('send %s ?' for help).n", name, cmd);
  473.     return 0;
  474. } else if (val < 0 || val > 255) {
  475.     fprintf(stderr, "'%s': bad value ('send %s ?' for help).n", name, cmd);
  476.     return 0;
  477. }
  478.     }
  480.     if (!connected) {
  481. printf("?Need to be connected first.n");
  482. return 0;
  483.     }
  485.     (*func)(val, 1);
  486.     return 1;
  487. }
  489. static int send_docmd(char *name) {
  490.     return(send_tncmd(send_do, "do", name));
  491. }
  493. static int send_dontcmd(char *name) {
  494.     return(send_tncmd(send_dont, "dont", name));
  495. }
  497. static int send_willcmd(char *name) {
  498.     return(send_tncmd(send_will, "will", name));
  499. }
  501. static int send_wontcmd(char *name) {
  502.     return(send_tncmd(send_wont, "wont", name));
  503. }
  505. static int send_help() {
  506.     struct sendlist *s; /* pointer to current command */
  508.     for (s = Sendlist; s->name; s++) {
  509. if (s->help) printf("%-15s %sn", s->name, s->help);
  510.     }
  512.     return(0);
  513. }
  515. /* The following are the routines and data structures referred to by the     */
  516. /* arguments to the "toggle" command.                                        */
  517. static int lclchars() {
  518.     donelclchars = 1;
  519.     return 1;
  520. }
  522. static int togdebug() {
  523. #ifdef NOT43
  524.     if (!debug) {
  525. printf("Cannot turn off socket debuggingn");
  526. return 1;
  527.     }
  528. #endif
  530.     if (net > 0 && SetSockOpt(net, SOL_SOCKET, SO_DEBUG, 0) < 0)
  531. perror("setsockopt (SO_DEBUG)");
  533.     return 1;
  534. }
  536. static int togcrlf() {
  537.     if (crlf) {
  538. printf("Will send carriage returns as telnet <CR><LF>.n");
  539.     } else {
  540. printf("Will send carriage returns as telnet <CR><NUL>.n");
  541.     }
  543.     return 1;
  544. }
  546. int binmode;
  548. static int togbinary(int val) {
  549.     donebinarytoggle = 1;
  551.     if (val >= 0) {
  552. binmode = val;
  553.     } else {
  554. if (my_want_state_is_will(TELOPT_BINARY) &&
  555.     my_want_state_is_do(TELOPT_BINARY)) {
  556.     binmode = 1;
  557. } else if (my_want_state_is_wont(TELOPT_BINARY) &&
  558.    my_want_state_is_dont(TELOPT_BINARY)) {
  559.     binmode = 0;
  560. }
  562. val = binmode ? 0 : 1;
  563.     }
  565.     if (val == 1) {
  566. if (my_want_state_is_will(TELOPT_BINARY) &&
  567.     my_want_state_is_do(TELOPT_BINARY)) {
  568.     printf("Already operating in binary mode with remote host.n");
  569. } else {
  570.     printf("Negotiating binary mode with remote host.n");
  571.     tel_enter_binary(3);
  572. }
  573.     } else {
  574. if (my_want_state_is_wont(TELOPT_BINARY) &&
  575.     my_want_state_is_dont(TELOPT_BINARY)) {
  576.     printf("Already in network ascii mode with remote host.n");
  577. } else {
  578.     printf("Negotiating network ascii mode with remote host.n");
  579.     tel_leave_binary(3);
  580. }
  581.     }
  583.     return 1;
  584. }
  586. static int togrbinary(int val) {
  587.     donebinarytoggle = 1;
  588.     
  589.     if (val == -1) {
  590. val = my_want_state_is_do(TELOPT_BINARY) ? 0 : 1;
  591.     }
  593.     if (val == 1) {
  594. if (my_want_state_is_do(TELOPT_BINARY)) {
  595.     printf("Already receiving in binary mode.n");
  596. } else {
  597.     printf("Negotiating binary mode on input.n");
  598.     tel_enter_binary(1);
  599. }
  600.     } else {
  601. if (my_want_state_is_dont(TELOPT_BINARY)) {
  602.     printf("Already receiving in network ascii mode.n");
  603. } else {
  604.     printf("Negotiating network ascii mode on input.n");
  605.     tel_leave_binary(1);
  606. }
  607.     }
  609.     return 1;
  610. }
  612. static int togxbinary(int val) {
  613.     donebinarytoggle = 1;
  615.     if (val == -1) {
  616. val = my_want_state_is_will(TELOPT_BINARY) ? 0 : 1;
  617.     }
  619.     if (val == 1) {
  620. if (my_want_state_is_will(TELOPT_BINARY)) {
  621.     printf("Already transmitting in binary mode.n");
  622. } else {
  623.     printf("Negotiating binary mode on output.n");
  624.     tel_enter_binary(2);
  625. }
  626.     } else {
  627. if (my_want_state_is_wont(TELOPT_BINARY)) {
  628.     printf("Already transmitting in network ascii mode.n");
  629. } else {
  630.     printf("Negotiating network ascii mode on output.n");
  631.     tel_leave_binary(2);
  632. }
  633.     }
  635.     return 1;
  636. }
  639. static int togglehelp P((void));
  642. struct togglelist {
  643.     char *name; /* name of toggle */
  644.     char *help; /* help message */
  645.     int (*handler)(); /* routine to do actual setting */
  646.     int *variable;
  647.     char *actionexplanation;
  648. };
  650. static struct togglelist Togglelist[] = {
  651.     { "autoflush", 
  652.       "flushing of output when sending interrupt characters",
  653.       0,
  654.       &autoflush,
  655.       "flush output when sending interrupt characters" },
  656.     { "autosynch",
  657.       "automatic sending of interrupt characters in urgent mode",
  658.       0,
  659.       &autosynch,
  660.       "send interrupt characters in urgent mode" },
  661.     { "skiprc",
  662.       "don't read ~/.telnetrc file",
  663.       0,
  664.       &skiprc,
  665.       "skip reading of ~/.telnetrc file" },
  666.     { "binary",
  667.       "sending and receiving of binary data",
  668.       togbinary,
  669.       0,
  670.       0 },
  671.     { "inbinary",
  672.       "receiving of binary data",
  673.       togrbinary,
  674.       0,
  675.       0 },
  676.     { "outbinary",
  677.       "sending of binary data",
  678.       togxbinary,
  679.       0,
  680.       0 },
  681.     { "crlf",
  682.       "sending carriage returns as telnet <CR><LF>",
  683.       togcrlf,
  684.       &crlf,
  685.       0 },
  686.     { "crmod",
  687.       "mapping of received carriage returns",
  688.       0,
  689.       &crmod,
  690.       "map carriage return on output" },
  691.     { "localchars",
  692.       "local recognition of certain control characters",
  693.       lclchars,
  694.       &localchars,
  695.       "recognize certain control characters" },
  696.     { " ", "", 0 }, /* empty line */
  697. #ifdef TN3270
  698.     { "apitrace",
  699.       "(debugging) toggle tracing of API transactions",
  700.       0,
  701.       &apitrace,
  702.       "trace API transactions" },
  703.     { "cursesdata",
  704.       "(debugging) toggle printing of hexadecimal curses data",
  705.       0,
  706.       &cursesdata,
  707.       "print hexadecimal representation of curses data" },
  708. #endif
  709.     { "debug",
  710.       "debugging",
  711.       togdebug,
  712.       &debug,
  713.       "turn on socket level debugging" },
  714.     { "netdata",
  715.       "printing of hexadecimal network data (debugging)",
  716.       0,
  717.       &netdata,
  718.       "print hexadecimal representation of network traffic" },
  719.     { "prettydump",
  720.       "output of "netdata" to user readable format (debugging)",
  721.       0,
  722.       &prettydump,
  723.       "print user readable output for "netdata"" },
  724.     { "options",
  725.       "viewing of options processing (debugging)",
  726.       0,
  727.       &showoptions,
  728.       "show option processing" },
  729.     { "termdata",
  730.       "(debugging) toggle printing of hexadecimal terminal data",
  731.       0,
  732.       &termdata,
  733.       "print hexadecimal representation of terminal traffic" },
  734.     { "?",
  735.       0,
  736.       togglehelp },
  737.     { "help",
  738.       0,
  739.       togglehelp },
  740.     { 0 }
  741. };
  743. static int togglehelp() {
  744.     struct togglelist *c;
  746.     for (c = Togglelist; c->name; c++) {
  747. if (c->help) {
  748.     if (*c->help) printf("%-15s toggle %sn", c->name, c->help);
  749.     else printf("n");
  750. }
  751.     }
  753.     printf("n");
  754.     printf("%-15s %sn", "?", "display help information");
  756.     return 0;
  757. }
  759. static void settogglehelp(int set) {
  760.     struct togglelist *c;
  762.     for (c = Togglelist; c->name; c++) {
  763. if (c->help) {
  764.     if (*c->help) printf("%-15s %s %sn", c->name, set ? "enable" : "disable", c->help);
  765.     else printf("n");
  766. }
  767.     }
  768. }
  770. #define GETTOGGLE(name) (struct togglelist *) genget(name, (char **) Togglelist, sizeof(struct togglelist))
  772. static int toggle(int argc, char *argv[]) {
  773.     int retval = 1;
  774.     char *name;
  775.     struct togglelist *c;
  777.     if (argc < 2) {
  778. fprintf(stderr, "Need an argument to 'toggle' command.  'toggle ?' for help.n");
  779. return 0;
  780.     }
  782.     argc--;
  783.     argv++;
  785.     while (argc--) {
  786. name = *argv++;
  787. c = GETTOGGLE(name);
  789. if (Ambiguous(c)) {
  790.     fprintf(stderr, "'%s': ambiguous argument ('toggle ?' for help).n", name);
  791.     return 0;
  792. } else if (c == 0) {
  793.     fprintf(stderr, "'%s': unknown argument ('toggle ?' for help).n", name);
  794.     return 0;
  795. } else {
  796.     if (c->variable) {
  797. *c->variable = !*c->variable; /* invert it */
  798. if (c->actionexplanation) {
  799.     printf("%s %s.n", *c->variable? "Will" : "Won't", c->actionexplanation);
  800. }
  801.     }
  803.     if (c->handler) {
  804. retval &= (*c->handler)(-1);
  805.     }
  806. }
  807.     }
  809.     return retval;
  810. }
  812. /* The following perform the "set" command.                                  */
  813. #ifdef USE_TERMIO
  814. struct termio new_tc = { 0 };
  815. #endif
  817. struct setlist {
  818.     char *name; /* name */
  819.     char *help; /* help information */
  820.     void (*handler)();
  821.     cc_t *charp; /* where it is located at */
  822. };
  824. static struct setlist Setlist[] = {
  825. #ifdef KLUDGELINEMODE
  826.     { "echo",  "character to toggle local echoing on/off", 0, &echoc },
  827. #endif
  828.     { "escape", "character to escape back to telnet command mode", 0, &escape },
  829.     { "rlogin", "rlogin escape character", 0, &rlogin },
  830.     { "tracefile", "file to write trace information to", SetNetTrace, (cc_t *)NetTraceFile},
  831.     { " ", "" },
  832.     { " ", "The following need 'localchars' to be toggled true", 0, 0 },
  833.     { "flushoutput", "character to cause an Abort Output", 0, termFlushCharp },
  834.     { "interrupt", "character to cause an Interrupt Process", 0, termIntCharp },
  835.     { "quit", "character to cause an Abort process", 0, termQuitCharp },
  836.     { "eof", "character to cause an EOF ", 0, termEofCharp },
  837.     { " ", "" },
  838.     { " ", "The following are for local editing in linemode", 0, 0 },
  839.     { "erase", "character to use to erase a character", 0, termEraseCharp },
  840.     { "kill", "character to use to erase a line", 0, termKillCharp },
  841.     { "lnext", "character to use for literal next", 0, termLiteralNextCharp },
  842.     { "susp", "character to cause a Suspend Process", 0, termSuspCharp },
  843.     { "reprint", "character to use for line reprint", 0, termRprntCharp },
  844.     { "worderase", "character to use to erase a word", 0, termWerasCharp },
  845.     { "start", "character to use for XON", 0, termStartCharp },
  846.     { "stop", "character to use for XOFF", 0, termStopCharp },
  847.     { "forw1", "alternate end of line character", 0, termForw1Charp },
  848.     { "forw2", "alternate end of line character", 0, termForw2Charp },
  849.     { "ayt", "alternate AYT character", 0, termAytCharp },
  850.     { 0 }
  851. };
  853. #if defined(CRAY) && !defined(__STDC__)
  854. /* Work around compiler bug in pcc 4.1.5 */
  855. void _setlist_init() {
  856. #ifndef KLUDGELINEMODE
  857. #define N 5
  858. #else
  859. #define N 6
  860. #endif
  861. Setlist[N+0].charp = &termFlushChar;
  862. Setlist[N+1].charp = &termIntChar;
  863. Setlist[N+2].charp = &termQuitChar;
  864. Setlist[N+3].charp = &termEofChar;
  865. Setlist[N+6].charp = &termEraseChar;
  866. Setlist[N+7].charp = &termKillChar;
  867. Setlist[N+8].charp = &termLiteralNextChar;
  868. Setlist[N+9].charp = &termSuspChar;
  869. Setlist[N+10].charp = &termRprntChar;
  870. Setlist[N+11].charp = &termWerasChar;
  871. Setlist[N+12].charp = &termStartChar;
  872. Setlist[N+13].charp = &termStopChar;
  873. Setlist[N+14].charp = &termForw1Char;
  874. Setlist[N+15].charp = &termForw2Char;
  875. Setlist[N+16].charp = &termAytChar;
  876. #undef N
  877. }
  878. #endif /* defined(CRAY) && !defined(__STDC__) */
  880. static struct setlist *getset(char *name) {
  881.     return (struct setlist *)genget(name, (char **) Setlist, sizeof(struct setlist));
  882. }
  884. void set_escape_char(char *s) {
  885.     if (rlogin != _POSIX_VDISABLE) {
  886. rlogin = (s && *s) ? special(s) : _POSIX_VDISABLE;
  887. printf("Telnet rlogin escape character is '%s'.n", control(rlogin));
  888.     } else {
  889. escape = (s && *s) ? special(s) : _POSIX_VDISABLE;
  890. printf("Telnet escape character is '%s'.n", control(escape));
  891.     }
  892. }
  894. static int setcmd(int argc, char *argv[]) {
  895.     int value;
  896.     struct setlist *ct;
  897.     struct togglelist *c;
  899.     if (argc < 2 || argc > 3) {
  900. printf("Format is 'set Name Value'n'set ?' for help.n");
  901. return 0;
  902.     }
  904.     if ((argc == 2) && (isprefix(argv[1], "?") || isprefix(argv[1], "help"))) {
  905. for (ct = Setlist; ct->name; ct++) printf("%-15s %sn", ct->name, ct->help);
  906. printf("n");
  908. settogglehelp(1);
  910. printf("%-15s %sn", "?", "display help information");
  911. return 0;
  912.     }
  914.     ct = getset(argv[1]);
  916.     if (ct == 0) {
  917. c = GETTOGGLE(argv[1]);
  919. if (c == 0) { 
  920.     fprintf(stderr, "'%s': unknown argument ('set ?' for help).n", argv[1]);
  921.     return 0;
  922. } else if (Ambiguous(c)) {
  923.     fprintf(stderr, "'%s': ambiguous argument ('set ?' for help).n", argv[1]);
  924.     return 0;
  925. }
  927. if (c->variable) {
  928.     if ((argc == 2) || (strcmp("on", argv[2]) == 0))
  929. *c->variable = 1;
  930.     else if (strcmp("off", argv[2]) == 0)
  931. *c->variable = 0;
  932.     else {
  933. printf("Format is 'set togglename [on|off]'n'set ?' for help.n");
  934. return 0;
  935.     }
  937.     if (c->actionexplanation) {
  938. printf("%s %s.n", *c->variable? "Will" : "Won't", c->actionexplanation);
  939.     }
  940. }
  942. if (c->handler) (*c->handler)(1);
  943.     } else if (argc != 3) {
  944. printf("Format is 'set Name Value'n'set ?' for help.n");
  945. return 0;
  946.     } else if (Ambiguous(ct)) {
  947. fprintf(stderr, "'%s': ambiguous argument ('set ?' for help).n", argv[1]);
  948. return 0;
  949.     } else if (ct->handler) {
  950. (*ct->handler)(argv[2]);
  951. printf("%s set to "%s".n", ct->name, (char *)ct->charp);
  952.     } else {
  953. if (strcmp("off", argv[2])) {
  954.     value = special(argv[2]);
  955. } else {
  956.     value = _POSIX_VDISABLE;
  957. }
  959. *(ct->charp) = (cc_t)value;
  960. printf("%s character is '%s'.n", ct->name, control(*(ct->charp)));
  961.     }
  963.     slc_check();
  964.     return 1;
  965. }
  967. static int unsetcmd(int argc, char *argv[]) {
  968.     struct setlist *ct;
  969.     struct togglelist *c;
  970.     register char *name;
  972.     if (argc < 2) {
  973. fprintf(stderr, "Need an argument to 'unset' command.  'unset ?' for help.n");
  974. return 0;
  975.     }
  977.     if (isprefix(argv[1], "?") || isprefix(argv[1], "help")) {
  978. for (ct = Setlist; ct->name; ct++) printf("%-15s %sn", ct->name, ct->help);
  979. printf("n");
  981. settogglehelp(0);
  983. printf("%-15s %sn", "?", "display help information");
  984. return 0;
  985.     }
  987.     argc--;
  988.     argv++;
  990.     while (argc--) {
  991. name = *argv++;
  992. ct = getset(name);
  994. if (ct == 0) {
  995.     c = GETTOGGLE(name);
  996.     if (c == 0) {
  997. fprintf(stderr, "'%s': unknown argument ('unset ?' for help).n", name);
  998. return 0;
  999.     } else if (Ambiguous(c)) {
  1000. fprintf(stderr, "'%s': ambiguous argument ('unset ?' for help).n", name);
  1001. return 0;
  1002.     }
  1004.     if (c->variable) {
  1005. *c->variable = 0;
  1006. if (c->actionexplanation) {
  1007.     printf("%s %s.n", *c->variable? "Will" : "Won't", c->actionexplanation);
  1008. }
  1009.     }
  1011.     if (c->handler) (*c->handler)(0);
  1012. } else if (Ambiguous(ct)) {
  1013.     fprintf(stderr, "'%s': ambiguous argument ('unset ?' for help).n", name);
  1014.     return 0;
  1015. } else if (ct->handler) {
  1016.     (*ct->handler)(0);
  1017.     printf("%s reset to "%s".n", ct->name, (char *)ct->charp);
  1018. } else {
  1019.     *(ct->charp) = _POSIX_VDISABLE;
  1020.     printf("%s character is '%s'.n", ct->name, control(*(ct->charp)));
  1021. }
  1022.     }
  1024.     return 1;
  1025. }
  1027. /* The following are the data structures and routines for the 'mode'         */
  1028. /* command.                                                                  */
  1029. #ifdef KLUDGELINEMODE
  1030. extern int kludgelinemode;
  1032. static int dokludgemode() {
  1033.     kludgelinemode = 1;
  1034.     send_wont(TELOPT_LINEMODE, 1);
  1035.     send_dont(TELOPT_SGA, 1);
  1036.     send_dont(TELOPT_ECHO, 1);
  1037.     return 1;
  1038. }
  1039. #endif
  1041. static int dolinemode() {
  1042. #ifdef KLUDGELINEMODE
  1043.     if (kludgelinemode) send_dont(TELOPT_SGA, 1);
  1044. #endif
  1045.     send_will(TELOPT_LINEMODE, 1);
  1046.     send_dont(TELOPT_ECHO, 1);
  1047.     return 1;
  1048. }
  1050. static int docharmode() {
  1051. #ifdef KLUDGELINEMODE
  1052.     if (kludgelinemode) send_do(TELOPT_SGA, 1);
  1053.     else
  1054. #endif
  1055.     send_wont(TELOPT_LINEMODE, 1);
  1056.     send_do(TELOPT_ECHO, 1);
  1057.     return 1;
  1058. }
  1060. static int dolmmode(int bit, int on) {
  1061.     unsigned char c;
  1062.     extern int linemode;
  1064.     if (my_want_state_is_wont(TELOPT_LINEMODE)) {
  1065. printf("?Need to have LINEMODE option enabled first.n");
  1066. printf("'mode ?' for help.n");
  1067. return 0;
  1068.     }
  1070.     if (on) c = (linemode | bit);
  1071.     else    c = (linemode & ~bit);
  1073.     lm_mode(&c, 1, 1);
  1074.     return 1;
  1075. }
  1077. static int tn_setmode(int bit) {
  1078.     return dolmmode(bit, 1);
  1079. }
  1081. static int clearmode(int bit) {
  1082.     return dolmmode(bit, 0);
  1083. }
  1085. struct modelist {
  1086.     char *name; /* command name */
  1087.     char *help; /* help string */
  1088.     int (*handler)(); /* routine which executes command */
  1089.     int needconnect; /* Do we need to be connected to execute? */
  1090.     int arg1;
  1091. };
  1093. extern int modehelp();
  1095. static struct modelist ModeList[] = {
  1096.     { "character", "Disable LINEMODE option",      docharmode, 1 },
  1097. #ifdef KLUDGELINEMODE
  1098.     { "",    "(or disable obsolete line-by-line mode)", 0 },
  1099. #endif
  1100.     { "line",    "Enable LINEMODE option",      dolinemode, 1 },
  1101. #ifdef KLUDGELINEMODE
  1102.     { "", "(or enable obsolete line-by-line mode)", 0 },
  1103. #endif
  1104.     { "", "", 0 },
  1105.     { "",    "These require the LINEMODE option to be enabled", 0 },
  1106.     { "isig",    "Enable signal trapping",      tn_setmode, 1, MODE_TRAPSIG },
  1107.     { "+isig",    NULL,      tn_setmode, 1, MODE_TRAPSIG },
  1108.     { "-isig",    "Disable signal trapping",      clearmode,  1, MODE_TRAPSIG },
  1109.     { "edit",    "Enable character editing",      tn_setmode, 1, MODE_EDIT },
  1110.     { "+edit",    NULL,      tn_setmode, 1, MODE_EDIT },
  1111.     { "-edit",    "Disable character editing",      clearmode,  1, MODE_EDIT },
  1112.     { "softtabs",  "Enable tab expansion",      tn_setmode, 1, MODE_SOFT_TAB },
  1113.     { "+softtabs", NULL,      tn_setmode, 1, MODE_SOFT_TAB },
  1114.     { "-softtabs", "Disable character editing",      clearmode,  1, MODE_SOFT_TAB },
  1115.     { "litecho",   "Enable literal character echo",  tn_setmode, 1, MODE_LIT_ECHO },
  1116.     { "+litecho",  NULL,      tn_setmode, 1, MODE_LIT_ECHO },
  1117.     { "-litecho",  "Disable literal character echo", clearmode,  1, MODE_LIT_ECHO },
  1118.     { "help",    NULL,      modehelp,   0 },
  1119. #ifdef KLUDGELINEMODE
  1120.     { "kludgeline", 0,      dokludgemode, 1 },
  1121. #endif
  1122.     { "", "", 0 },
  1123.     { "?",     "Print help information",      modehelp, 0 },
  1124.     { 0 },
  1125. };
  1128. int modehelp() {
  1129.     struct modelist *mt;
  1131.     printf("format is:  'mode Mode', where 'Mode' is one of:nn");
  1133.     for (mt = ModeList; mt->name; mt++) {
  1134. if (mt->help) {
  1135.     if (*mt->help) printf("%-15s %sn", mt->name, mt->help);
  1136.     else printf("n");
  1137. }
  1138.     }
  1140.     return 0;
  1141. }
  1143. #define GETMODECMD(name) (struct modelist *) genget(name, (char **) ModeList, sizeof(struct modelist))
  1145. static int modecmd(int argc, char *argv[]) {
  1146.     struct modelist *mt;
  1148.     if (argc != 2) {
  1149. printf("'mode' command requires an argumentn");
  1150. printf("'mode ?' for help.n");
  1151.     } else if ((mt = GETMODECMD(argv[1])) == 0) {
  1152. fprintf(stderr, "Unknown mode '%s' ('mode ?' for help).n", argv[1]);
  1153.     } else if (Ambiguous(mt)) {
  1154. fprintf(stderr, "Ambiguous mode '%s' ('mode ?' for help).n", argv[1]);
  1155.     } else if (mt->needconnect && !connected) {
  1156. printf("?Need to be connected first.n");
  1157. printf("'mode ?' for help.n");
  1158.     } else if (mt->handler) {
  1159. return (*mt->handler)(mt->arg1);
  1160.     }
  1161.     return 0;
  1162. }
  1164. /* The following data structures and routines implement the "display"        */
  1165. /* command.                                                                  */
  1166. static int display(int argc, char *argv[]) {
  1167.     struct togglelist *tl;
  1168.     struct setlist *sl;
  1170. #define dotog(tl) if (tl->variable && tl->actionexplanation) { 
  1171.     if (*tl->variable) { 
  1172. printf("will"); 
  1173.     } else { 
  1174. printf("won't"); 
  1175.     } 
  1176.     printf(" %s.n", tl->actionexplanation); 
  1177. }
  1179. #define doset(sl)   if (sl->name && *sl->name != ' ') { 
  1180. if (sl->handler == 0) 
  1181.     printf("%-15s [%s]n", sl->name, control(*sl->charp)); 
  1182. else 
  1183.     printf("%-15s "%s"n", sl->name, (char *)sl->charp); 
  1184.     }
  1186.     if (argc == 1) {
  1187. for (tl = Togglelist; tl->name; tl++) {
  1188.     dotog(tl);
  1189. }
  1191. printf("n");
  1193. for (sl = Setlist; sl->name; sl++) {
  1194.     doset(sl);
  1195. }
  1196.     } else {
  1197. int i;
  1199. for (i = 1; i < argc; i++) {
  1200.     sl = getset(argv[i]);
  1201.     tl = GETTOGGLE(argv[i]);
  1202.     if (Ambiguous(sl) || Ambiguous(tl)) {
  1203. printf("?Ambiguous argument '%s'.n", argv[i]);
  1204. return 0;
  1205.     } else if (!sl && !tl) {
  1206. printf("?Unknown argument '%s'.n", argv[i]);
  1207. return 0;
  1208.     } else {
  1209. if (tl) {
  1210.     dotog(tl);
  1211. }
  1212. if (sl) {
  1213.     doset(sl);
  1214. }
  1215.     }
  1216. }
  1217.     }
  1219.     /*@*/optionstatus();
  1220.     return 1;
  1221. #undef doset
  1222. #undef dotog
  1223. }
  1225. /* The following are the data structures, and many of the routines, relating */
  1226. /* to command processing.                                                    */
  1227. /*                                                                           */
  1229. /* Set the escape character.                                                 */
  1230. static int setescape(int argc, char *argv[]) {
  1231.     register char *arg;
  1232.     char buf[50];
  1233.     
  1234.     printf("Deprecated usage - please use 'set escape%s%s' in the future.n",
  1235.    (argc > 2)? " ":"", (argc > 2)? argv[1]: "");
  1237.     if (argc > 2) arg = argv[1];
  1238.     else {
  1239. printf("new escape character: ");
  1240. fgets(buf, sizeof(buf), stdin);
  1241. arg = buf;
  1242.     }
  1244.     if (arg[0] != '') escape = arg[0];
  1246.     if (!In3270) {
  1247. printf("Escape character is '%s'.n", control(escape));
  1248.     }
  1250.     fflush(stdout);
  1251.     return 1;
  1252. }
  1254. static int togcrmod() {
  1255.     crmod = !crmod;
  1256.     printf("Deprecated usage - please use 'toggle crmod' in the future.n");
  1257.     printf("%s map carriage return on output.n", crmod ? "Will" : "Won't");
  1258.     fflush(stdout);
  1259.     return 1;
  1260. }
  1262. int suspend() {
  1263. #ifdef SIGTSTP
  1264.     long oldrows, oldcols, newrows, newcols, err;
  1266.     setcommandmode();
  1267.     err = (TerminalWindowSize(&oldrows, &oldcols) == 0) ? 1 : 0;
  1268.     kill(0, SIGTSTP);
  1270.     /* If we didn't get the window size before the SUSPEND, but we can get   */
  1271.     /* them now (?), then send the NAWS to make sure that we are set up for  */
  1272.     /* the right window size.                                                                       */
  1273.     if (TerminalWindowSize(&newrows, &newcols) && connected &&
  1274. (err || ((oldrows != newrows) || (oldcols != newcols)))) {
  1275. sendnaws();
  1276.     }
  1278.     /* reget parameters in case they were changed */
  1279.     TerminalSaveState();
  1280.     setconnmode(0);
  1281. #else
  1282.     printf("Suspend is not supported.  Try the '!' command insteadn");
  1283. #endif
  1284.     return 1;
  1285. }
  1287. #ifndef TN3270
  1288. int shell(int argc, char *argv[]) {
  1289.     long oldrows, oldcols, newrows, newcols, err;
  1291.     setcommandmode();
  1293.     err = (TerminalWindowSize(&oldrows, &oldcols) == 0) ? 1 : 0;
  1295.     switch(vfork()) {
  1296.     case -1:
  1297. perror("Fork failedn");
  1298. break;
  1299.     case 0:
  1300. {
  1301.     /* Fire up the shell in the child. */
  1302.     register char *shellp, *shellname;
  1304.     shellp = getenv("SHELL");
  1305.     if (shellp == NULL) shellp = "/bin/sh";
  1307.     if ((shellname = strrchr(shellp, '/')) == 0) shellname = shellp;
  1308.     else shellname++;
  1310.     if (argc > 1) execl(shellp, shellname, "-c", &saveline[1], 0);
  1311.     else execl(shellp, shellname, 0);
  1313.     perror("Execl");
  1314.     _exit(1);
  1315. }
  1316.     default:
  1317. wait(NULL); /* Wait for the shell to complete */
  1319. if (TerminalWindowSize(&newrows, &newcols) && connected &&
  1320.     (err || ((oldrows != newrows) || (oldcols != newcols)))) {
  1321.     sendnaws();
  1322. }
  1324. break;
  1325.     }
  1327.     return 1;
  1328. }
  1329. #else
  1330. extern int shell();
  1331. #endif
  1333. /* The SLC command.                                                          */
  1335. struct slclist {
  1336. char *name;
  1337. char *help;
  1338. void (*handler)();
  1339. int arg;
  1340. };
  1342. static void slc_help();
  1344. struct slclist SlcList[] = {
  1345.     { "export", "Use local special character definitions",     slc_mode_export, 0 },
  1346.     { "import", "Use remote special character definitions",    slc_mode_import, 1 },
  1347.     { "check", "Verify remote special character definitions", slc_mode_import, 0 },
  1348.     { "help", 0,                slc_help, 0 },
  1349.     { "?", "Print help information",                slc_help, 0 },
  1350.     { 0 },
  1351. };
  1353. static void slc_help() {
  1354.     struct slclist *c;
  1356.     for (c = SlcList; c->name; c++) {
  1357. if (c->help) {
  1358.     if (*c->help) printf("%-15s %sn", c->name, c->help);
  1359.     else printf("n");
  1360. }
  1361.     }
  1362. }
  1364. static struct slclist *getslc(char *name) {
  1365.     return (struct slclist *) genget(name, (char **) SlcList, sizeof(struct slclist));
  1366. }
  1368. static int slccmd(int argc, char *argv[]) {
  1369.     struct slclist *c;
  1371.     if (argc != 2) {
  1372. fprintf(stderr, "Need an argument to 'slc' command.  'slc ?' for help.n");
  1373. return 0;
  1374.     }
  1375.     
  1376.     c = getslc(argv[1]);
  1377.     if (c == 0) {
  1378. fprintf(stderr, "'%s': unknown argument ('slc ?' for help).n", argv[1]);
  1379. return 0;
  1380.     }
  1381.     
  1382.     if (Ambiguous(c)) {
  1383. fprintf(stderr, "'%s': ambiguous argument ('slc ?' for help).n", argv[1]);
  1384. return 0;
  1385.     }
  1386.     
  1387.     (*c->handler)(c->arg);
  1388.     slcstate();
  1389.     return 1;
  1390. }
  1392. /* The ENVIRON command. */
  1393. struct envlist {
  1394. char *name;
  1395. char *help;
  1396. void (*handler)();
  1397. int narg;
  1398. };
  1400. extern struct env_lst *
  1401. env_define P((unsigned char *, unsigned char *));
  1402. extern void
  1403. env_undefine P((unsigned char *)),
  1404. env_export P((unsigned char *)),
  1405. env_unexport P((unsigned char *)),
  1406. env_send P((unsigned char *)),
  1407. #if defined(OLD_ENVIRON) && defined(ENV_HACK)
  1408. env_varval P((unsigned char *)),
  1409. #endif
  1410. env_list P((void));
  1411. static void
  1412. env_help P((void));
  1414. struct envlist EnvList[] = {
  1415.     { "define", "Define an environment variable",
  1416. (void (*)())env_define, 2 },
  1417.     { "undefine", "Undefine an environment variable",
  1418. env_undefine, 1 },
  1419.     { "export", "Mark an environment variable for automatic export",
  1420. env_export, 1 },
  1421.     { "unexport", "Don't mark an environment variable for automatic export",
  1422. env_unexport, 1 },
  1423.     { "send", "Send an environment variable", env_send, 1 },
  1424.     { "list", "List the current environment variables",
  1425. env_list, 0 },
  1426. #if defined(OLD_ENVIRON) && defined(ENV_HACK)
  1427.     { "varval", "Reverse VAR and VALUE (auto, right, wrong, status)",
  1428. env_varval,    1 },
  1429. #endif
  1430.     { "help", 0, env_help, 0 },
  1431.     { "?", "Print help information", env_help, 0 },
  1432.     { 0 },
  1433. };
  1435. static void env_help() {
  1436.     struct envlist *c;
  1438.     for (c = EnvList; c->name; c++) {
  1439. if (c->help) {
  1440.     if (*c->help) printf("%-15s %sn", c->name, c->help);
  1441.     else printf("n");
  1442. }
  1443.     }
  1444. }
  1446. static struct envlist *getenvcmd(char *name) {
  1447.     return (struct envlist *)genget(name, (char **) EnvList, sizeof(struct envlist));
  1448. }
  1450. int env_cmd(int argc, char *argv[]) {
  1451.     struct envlist *c;
  1453.     if (argc < 2) {
  1454. fprintf(stderr, "Need an argument to 'environ' command.  'environ ?' for help.n");
  1455. return 0;
  1456.     }
  1458.     c = getenvcmd(argv[1]);
  1459.     if (c == 0) {
  1460. fprintf(stderr, "'%s': unknown argument ('environ ?' for help).n", argv[1]);
  1461. return 0;
  1462.     }
  1464.     if (Ambiguous(c)) {
  1465. fprintf(stderr, "'%s': ambiguous argument ('environ ?' for help).n", argv[1]);
  1466. return 0;
  1467.     }
  1468.     
  1469.     if (c->narg + 2 != argc) {
  1470. fprintf(stderr, "Need %s%d argument%s to 'environ %s' command.  'environ ?' for help.n",
  1471. c->narg < argc + 2 ? "only " : "", c->narg, c->narg == 1 ? "" : "s", c->name);
  1472. return 0;
  1473.     }
  1475.     (*c->handler)(argv[2], argv[3]);
  1476.     return 1;
  1477. }
  1479. struct env_lst {
  1480. struct env_lst *next; /* pointer to next structure */
  1481. struct env_lst *prev; /* pointer to previous structure */
  1482. unsigned char *var; /* pointer to variable name */
  1483. unsigned char *value; /* pointer to variable value */
  1484. int export; /* 1 -> export with default list of variables */
  1485. int welldefined; /* A well defined variable */
  1486. };
  1488. struct env_lst envlisthead;
  1490. struct env_lst *env_find(unsigned char *var) {
  1491.     register struct env_lst *ep;
  1493.     for (ep = envlisthead.next; ep; ep = ep->next) {
  1494. if (strcmp((char *)ep->var, (char *)var) == 0)
  1495.     return(ep);
  1496.     }
  1498.     return(NULL);
  1499. }
  1501. void env_init() {
  1502.     extern char **environ;
  1503.     register char **epp, *cp;
  1504.     register struct env_lst *ep;
  1506.     for (epp = environ; *epp; epp++) {
  1507. if ((cp = strchr(*epp, '='))) {
  1508.     *cp = '';
  1509.     ep = env_define((unsigned char *)*epp, (unsigned char *)cp+1);
  1510.     ep->export = 0;
  1511.     *cp = '=';
  1512. }
  1513.     }
  1515.     /* Special case for DISPLAY variable.  If it is ":0.0" or "unix:0.0", we */
  1516.     /* have to get rid of "unix" and insert our hostname.                    */
  1517.     if ((ep = env_find("DISPLAY")) && ((*ep->value == ':') || (strncmp((char *)ep->value, "unix:", 5) == 0))) {
  1518. char hbuf[256+1];
  1519. char *cp2 = strchr((char *)ep->value, ':');
  1521. gethostname(hbuf, 256);
  1522. hbuf[256] = '';
  1523. cp = (char *)malloc(strlen(hbuf) + strlen(cp2) + 1);
  1524. sprintf((char *)cp, "%s%s", hbuf, cp2);
  1525. free(ep->value);
  1526. ep->value = (unsigned char *)cp;
  1527.     }
  1529.     /* If USER is not defined, but LOGNAME is, then add USER with the value  */
  1530.     /* from LOGNAME.  By default, we don't export the USER variable.         */
  1531.     if ((env_find("USER") == NULL) && (ep = env_find("LOGNAME"))) {
  1532. env_define((unsigned char *)"USER", ep->value);
  1533. env_unexport((unsigned char *)"USER");
  1534.     }
  1536.     env_export((unsigned char *)"DISPLAY");
  1537.     env_export((unsigned char *)"PRINTER");
  1538. }
  1540. struct env_lst *env_define(unsigned char *var, unsigned char *value) {
  1541.     register struct env_lst *ep;
  1543.     if ((ep = env_find(var))) {
  1544. if (ep->var)   free(ep->var);
  1545. if (ep->value) free(ep->value);
  1546.     } else {
  1547. ep = (struct env_lst *)malloc(sizeof(struct env_lst));
  1548. ep->next = envlisthead.next;
  1549. envlisthead.next = ep;
  1550. ep->prev = &envlisthead;
  1551. if (ep->next) ep->next->prev = ep;
  1552.     }
  1554.     ep->welldefined = opt_welldefined((char *)var);
  1555.     ep->export = 1;
  1556.     ep->var = (unsigned char *)strdup((char *)var);
  1557.     ep->value = (unsigned char *)strdup((char *)value);
  1558.     return(ep);
  1559. }
  1561. void env_undefine(unsigned char *var) {
  1562.     register struct env_lst *ep;
  1564.     if ((ep = env_find(var))) {
  1565. ep->prev->next = ep->next;
  1566. if (ep->next)  ep->next->prev = ep->prev;
  1567. if (ep->var)   free(ep->var);
  1568. if (ep->value) free(ep->value);
  1569. free(ep);
  1570.     }
  1571. }
  1573. void env_export(unsigned char *var) {
  1574.     register struct env_lst *ep;
  1575.     
  1576.     if ((ep = env_find(var))) ep->export = 1;
  1577. }
  1579. void env_unexport(unsigned char *var) {
  1580.     register struct env_lst *ep;
  1582.     if ((ep = env_find(var))) ep->export = 0;
  1583. }
  1585. void env_send(unsigned char *var) {
  1586.     register struct env_lst *ep;
  1588.     if (my_state_is_wont(TELOPT_NEW_ENVIRON)
  1589. #ifdef OLD_ENVIRON
  1590. && my_state_is_wont(TELOPT_OLD_ENVIRON)
  1591. #endif
  1592. ) {
  1593. fprintf(stderr, "Cannot send '%s': Telnet ENVIRON option not enabledn", var);
  1594. return;
  1595.     }
  1597.     ep = env_find(var);
  1598.     
  1599.     if (ep == 0) {
  1600. fprintf(stderr, "Cannot send '%s': variable not definedn", var);
  1601. return;
  1602.     }
  1604.     env_opt_start_info();
  1605.     env_opt_add(ep->var);
  1606.     env_opt_end(0);
  1607. }
  1609. void env_list() {
  1610.     register struct env_lst *ep;
  1611.     
  1612.     for (ep = envlisthead.next; ep; ep = ep->next) {
  1613. printf("%c %-20s %sn", ep->export ? '*' : ' ', ep->var, ep->value);
  1614.     }
  1615. }
  1617. unsigned char *
  1618. env_default(init, welldefined)
  1619.     int init, welldefined;
  1620. {
  1621. static struct env_lst *nep = NULL;
  1623. if (init) {
  1624. nep = &envlisthead;
  1625. return NULL;
  1626. }
  1627. if (nep) {
  1628. while ((nep = nep->next)) {
  1629. if (nep->export && (nep->welldefined == welldefined))
  1630. return(nep->var);
  1631. }
  1632. }
  1633. return(NULL);
  1634. }
  1636. unsigned char *
  1637. env_getvalue(var)
  1638. unsigned char *var;
  1639. {
  1640. register struct env_lst *ep;
  1642. if ((ep = env_find(var)))
  1643. return(ep->value);
  1644. return(NULL);
  1645. }
  1647. #if defined(OLD_ENVIRON) && defined(ENV_HACK)
  1648. void
  1649. env_varval(what)
  1650. unsigned char *what;
  1651. {
  1652. extern int old_env_var, old_env_value, env_auto;
  1653. int len = strlen((char *)what);
  1655. if (len == 0)
  1656. goto unknown;
  1658. if (strncasecmp((char *)what, "status", len) == 0) {
  1659. if (env_auto)
  1660. printf("%s%s", "VAR and VALUE are/will be ",
  1661. "determined automaticallyn");
  1662. if (old_env_var == OLD_ENV_VAR)
  1663. printf("VAR and VALUE set to correct definitionsn");
  1664. else
  1665. printf("VAR and VALUE definitions are reversedn");
  1666. } else if (strncasecmp((char *)what, "auto", len) == 0) {
  1667. env_auto = 1;
  1668. old_env_var = OLD_ENV_VALUE;
  1669. old_env_value = OLD_ENV_VAR;
  1670. } else if (strncasecmp((char *)what, "right", len) == 0) {
  1671. env_auto = 0;
  1672. old_env_var = OLD_ENV_VAR;
  1673. old_env_value = OLD_ENV_VALUE;
  1674. } else if (strncasecmp((char *)what, "wrong", len) == 0) {
  1675. env_auto = 0;
  1676. old_env_var = OLD_ENV_VALUE;
  1677. old_env_value = OLD_ENV_VAR;
  1678. } else {
  1679. unknown:
  1680. printf("Unknown "varval" command. ("auto", "right", "wrong", "status")n");
  1681. }
  1682. }
  1683. #endif
  1687. #ifdef TN3270
  1688.     static void
  1689. filestuff(fd)
  1690.     int fd;
  1691. {
  1692.     int res;
  1694. #ifdef F_GETOWN
  1695.     setconnmode(0);
  1696.     res = fcntl(fd, F_GETOWN, 0);
  1697.     setcommandmode();
  1699.     if (res == -1) {
  1700. perror("fcntl");
  1701. return;
  1702.     }
  1703.     printf("tOwner is %d.n", res);
  1704. #endif
  1706.     setconnmode(0);
  1707.     res = fcntl(fd, F_GETFL, 0);
  1708.     setcommandmode();
  1710.     if (res == -1) {
  1711. perror("fcntl");
  1712. return;
  1713.     }
  1714. #ifdef notdef
  1715.     printf("tFlags are 0x%x: %sn", res, decodeflags(res));
  1716. #endif
  1717. }
  1718. #endif
  1720. /*
  1721.  * Print status about the connection.
  1722.  */
  1723.     /*ARGSUSED*/
  1724.     static int 
  1725. status(argc, argv)
  1726.     int  argc;
  1727.     char *argv[];
  1728. {
  1729.     if (connected) {
  1730. printf("Connected to %s.n", hostname);
  1731. if ((argc < 2) || strcmp(argv[1], "notmuch")) {
  1732.     int mode = getconnmode();
  1734.     if (my_want_state_is_will(TELOPT_LINEMODE)) {
  1735. printf("Operating with LINEMODE optionn");
  1736. printf("%s line editingn", (mode&MODE_EDIT) ? "Local" : "No");
  1737. printf("%s catching of signalsn",
  1738. (mode&MODE_TRAPSIG) ? "Local" : "No");
  1739. slcstate();
  1740. #ifdef KLUDGELINEMODE
  1741.     } else if (kludgelinemode && my_want_state_is_dont(TELOPT_SGA)) {
  1742. printf("Operating in obsolete linemoden");
  1743. #endif
  1744.     } else {
  1745. printf("Operating in single character moden");
  1746. if (localchars)
  1747.     printf("Catching signals locallyn");
  1748.     }
  1749.     printf("%s character echon", (mode&MODE_ECHO) ? "Local" : "Remote");
  1750.     if (my_want_state_is_will(TELOPT_LFLOW))
  1751. printf("%s flow controln", (mode&MODE_FLOW) ? "Local" : "No");
  1752. }
  1753.     } else {
  1754. printf("No connection.n");
  1755.     }
  1756. #ifndef TN3270
  1757.     printf("Escape character is '%s'.n", control(escape));
  1758.     (void) fflush(stdout);
  1759. #   else /* !defined(TN3270) */
  1760.     if ((!In3270) && ((argc < 2) || strcmp(argv[1], "notmuch"))) {
  1761. printf("Escape character is '%s'.n", control(escape));
  1762.     }
  1764.     if ((argc >= 2) && !strcmp(argv[1], "everything")) {
  1765. printf("SIGIO received %d time%s.n",
  1766. sigiocount, (sigiocount == 1)? "":"s");
  1767. if (In3270) {
  1768.     printf("Process ID %d, process group %d.n",
  1769.     getpid(), getpgrp(getpid()));
  1770.     printf("Terminal input:n");
  1771.     filestuff(tin);
  1772.     printf("Terminal output:n");
  1773.     filestuff(tout);
  1774.     printf("Network socket:n");
  1775.     filestuff(net);
  1776. }
  1777.     }
  1778.     if (In3270 && transcom) {
  1779.        printf("Transparent mode command is '%s'.n", transcom);
  1780.     }
  1782.     fflush(stdout);
  1783.     if (In3270) return 0;
  1784. #   endif /* defined(TN3270) */
  1785.     return 1;
  1786. }
  1788. #ifdef SIGINFO
  1789. /*
  1790.  * Function that gets called when SIGINFO is received.
  1791.  */
  1792.      void
  1793. ayt_status()
  1794. {
  1795.     (void) call(status, "status", "notmuch", 0);
  1796. }
  1797. #endif
  1799.     int
  1800. tn(argc, argv)
  1801.     int argc;
  1802.     char *argv[];
  1803. {
  1804.     register struct hostent *host = 0;
  1805.     struct sockaddr_in sin;
  1806.     struct servent *sp = 0;
  1807.     unsigned int temp;
  1808. #if defined(IP_OPTIONS) && defined(IPPROTO_IP)
  1809.     char *srp = 0;
  1810.     unsigned int sourceroute(), srlen;
  1811. #endif
  1812.     char *cmd, *hostp = 0, *portp = 0, *user = 0;
  1814.     /* clear the socket address prior to use */
  1815.     memset((char *)&sin, 0, sizeof(sin));
  1817.     if (connected) {
  1818. printf("?Already connected to %sn", hostname);
  1819. setuid(getuid());
  1820. return 0;
  1821.     }
  1822.     if (argc < 2) {
  1823. (void) strcpy(line, "open ");
  1824. printf("(to) ");
  1825. (void) fgets(&line[strlen(line)], sizeof(line) - strlen(line), stdin);
  1826. makeargv();
  1827. argc = margc;
  1828. argv = margv;
  1829.     }
  1830.     cmd = *argv;
  1831.     --argc; ++argv;
  1832.     while (argc) {
  1833. if (isprefix(*argv, "help") || isprefix(*argv, "?"))
  1834.     goto usage;
  1835. if (strcmp(*argv, "-l") == 0) {
  1836.     --argc; ++argv;
  1837.     if (argc == 0)
  1838. goto usage;
  1839.     user = *argv++;
  1840.     --argc;
  1841.     continue;
  1842. }
  1843. if (strcmp(*argv, "-a") == 0) {
  1844.     --argc; ++argv;
  1845.     autologin = 1;
  1846.     continue;
  1847. }
  1848. if (hostp == 0) {
  1849.     hostp = *argv++;
  1850.     --argc;
  1851.     continue;
  1852. }
  1853. if (portp == 0) {
  1854.     portp = *argv++;
  1855.     --argc;
  1856.     continue;
  1857. }
  1858.     usage:
  1859. printf("usage: %s [-l user] [-a] host-name [port]n", cmd);
  1860. setuid(getuid());
  1861. return 0;
  1862.     }
  1863.     if (hostp == 0)
  1864. goto usage;
  1866. #if defined(IP_OPTIONS) && defined(IPPROTO_IP)
  1867.     if (hostp[0] == '@' || hostp[0] == '!') {
  1868. if ((hostname = strrchr(hostp, ':')) == NULL)
  1869.     hostname = strrchr(hostp, '@');
  1870. hostname++;
  1871. srp = 0;
  1872. temp = sourceroute(hostp, &srp, &srlen);
  1873. if (temp == 0) {
  1874.     herror(srp);
  1875.     setuid(getuid());
  1876.     return 0;
  1877. } else if (temp == -1) {
  1878.     printf("Bad source route option: %sn", hostp);
  1879.     setuid(getuid());
  1880.     return 0;
  1881. } else {
  1882.     sin.sin_addr.s_addr = temp;
  1883.     sin.sin_family = AF_INET;
  1884. }
  1885.     } else {
  1886. #endif
  1887. temp = (unsigned int)inet_addr(hostp);
  1888. if (temp != (unsigned int) -1) {
  1889.     sin.sin_addr.s_addr = temp;
  1890.     sin.sin_family = AF_INET;
  1891.     (void) strcpy(_hostname, hostp);
  1892.     hostname = _hostname;
  1893. } else {
  1894.     host = gethostbyname(hostp);
  1895.     if (host) {
  1896. sin.sin_family = host->h_addrtype;
  1897. #ifdef h_addr /* In 4.3, this is a #define */
  1898. memmove((caddr_t)&sin.sin_addr,
  1899. host->h_addr_list[0], host->h_length);
  1900. #else /* defined(h_addr) */
  1901. memmove((caddr_t)&sin.sin_addr, host->h_addr, host->h_length);
  1902. #endif /* defined(h_addr) */
  1903. strncpy(_hostname, host->h_name, sizeof(_hostname));
  1904. _hostname[sizeof(_hostname)-1] = '';
  1905. hostname = _hostname;
  1906.     } else {
  1907. herror(hostp);
  1908. setuid(getuid());
  1909. return 0;
  1910.     }
  1911. }
  1912. #if defined(IP_OPTIONS) && defined(IPPROTO_IP)
  1913.     }
  1914. #endif
  1915.     if (portp) {
  1916. if (*portp == '-') {
  1917.     portp++;
  1918.     telnetport = 1;
  1919. } else
  1920.     telnetport = 0;
  1921. sin.sin_port = atoi(portp);
  1922. if (sin.sin_port == 0) {
  1923.     sp = getservbyname(portp, "tcp");
  1924.     if (sp)
  1925. sin.sin_port = sp->s_port;
  1926.     else {
  1927. printf("%s: bad port numbern", portp);
  1928. setuid(getuid());
  1929. return 0;
  1930.     }
  1931. } else {
  1932.     sin.sin_port = htons(sin.sin_port);
  1933. }
  1934.     } else {
  1935. if (sp == 0) {
  1936.     sp = getservbyname("telnet", "tcp");
  1937.     if (sp == 0) {
  1938. fprintf(stderr, "telnet: tcp/telnet: unknown servicen");
  1939. setuid(getuid());
  1940. return 0;
  1941.     }
  1942.     sin.sin_port = sp->s_port;
  1943. }
  1944. telnetport = 1;
  1945.     }
  1946.     printf("Trying %s...n", inet_ntoa(sin.sin_addr));
  1947.     do {
  1948. net = socket(AF_INET, SOCK_STREAM, 0);
  1949. setuid(getuid());
  1950. if (net < 0) {
  1951.     perror("telnet: socket");
  1952.     return 0;
  1953. }
  1954. #if defined(IP_OPTIONS) && defined(IPPROTO_IP)
  1955. if (srp && setsockopt(net, IPPROTO_IP, IP_OPTIONS, (char *)srp, srlen) < 0)
  1956. perror("setsockopt (IP_OPTIONS)");
  1957. #endif
  1958. #if defined(IPPROTO_IP) && defined(IP_TOS)
  1959. {
  1960. #ifdef HAS_GETTOS
  1961.     struct tosent *tp;
  1962.     if (tos < 0 && (tp = gettosbyname("telnet", "tcp")))
  1963. tos = tp->t_tos;
  1964. # endif
  1965.     if (tos < 0)
  1966. tos = 020; /* Low Delay bit */
  1967.     if (tos
  1968. && (setsockopt(net, IPPROTO_IP, IP_TOS,
  1969.     (char *)&tos, sizeof(int)) < 0)
  1970. && (errno != ENOPROTOOPT))
  1971.     perror("telnet: setsockopt (IP_TOS) (ignored)");
  1972. }
  1973. #endif /* defined(IPPROTO_IP) && defined(IP_TOS) */
  1975. if (debug && SetSockOpt(net, SOL_SOCKET, SO_DEBUG, 1) < 0) {
  1976. perror("setsockopt (SO_DEBUG)");
  1977. }
  1979. if (connect(net, (struct sockaddr *)&sin, sizeof (sin)) < 0) {
  1980. #ifdef h_addr /* In 4.3, this is a #define */
  1981.     if (host && host->h_addr_list[1]) {
  1982. int oerrno = errno;
  1984. fprintf(stderr, "telnet: connect to address %s: ",
  1985. inet_ntoa(sin.sin_addr));
  1986. errno = oerrno;
  1987. perror((char *)0);
  1988. host->h_addr_list++;
  1989. memmove((caddr_t)&sin.sin_addr,
  1990. host->h_addr_list[0], host->h_length);
  1991. NetClose(net);
  1992. continue;
  1993.     }
  1994. #endif /* defined(h_addr) */
  1995.     perror("telnet: Unable to connect to remote host");
  1996.     return 0;
  1997. }
  1998. connected++;
  1999.     } while (connected == 0);
  2000.     cmdrc(hostp, hostname);
  2001.     if (autologin && user == NULL) {
  2002. struct passwd *pw;
  2004. user = getenv("USER");
  2005. if (user == NULL ||
  2006.     (((pw = getpwnam(user))) && pw->pw_uid != getuid())) {
  2007. if ((pw = getpwuid(getuid())))
  2008. user = pw->pw_name;
  2009. else
  2010. user = NULL;
  2011. }
  2012.     }
  2013.     if (user) {
  2014. env_define((unsigned char *)"USER", (unsigned char *)user);
  2015. env_export((unsigned char *)"USER");
  2016.     }
  2017.     (void) call(status, "status", "notmuch", 0);
  2018.     if (setjmp(peerdied) == 0)
  2019. telnet(user);
  2020.     NetClose(net);
  2021.     ExitString("Connection closed by foreign host.n",1);
  2022.     /*NOTREACHED*/
  2023.     return 0;
  2024. }
  2026. #define HELPINDENT (sizeof ("connect"))
  2028. static char
  2029. openhelp[] = "connect to a site",
  2030. closehelp[] = "close current connection",
  2031. logouthelp[] = "forcibly logout remote user and close the connection",
  2032. quithelp[] = "exit telnet",
  2033. statushelp[] = "print status information",
  2034. helphelp[] = "print help information",
  2035. sendhelp[] = "transmit special characters ('send ?' for more)",
  2036. sethelp[] =  "set operating parameters ('set ?' for more)",
  2037. unsethelp[] =  "unset operating parameters ('unset ?' for more)",
  2038. togglestring[] ="toggle operating parameters ('toggle ?' for more)",
  2039. slchelp[] = "change state of special charaters ('slc ?' for more)",
  2040. displayhelp[] = "display operating parameters",
  2041. #ifdef TN3270
  2042. transcomhelp[] = "specify Unix command for transparent mode pipe",
  2043. #endif /* defined(TN3270) */
  2044. zhelp[] = "suspend telnet",
  2045. shellhelp[] = "invoke a subshell",
  2046. envhelp[] = "change environment variables ('environ ?' for more)",
  2047. modestring[] = "try to enter line or character mode ('mode ?' for more)";
  2049. static int help();
  2051. static Command cmdtab[] = {
  2052. { "close", closehelp, bye, 1 },
  2053. { "logout", logouthelp, logout, 1 },
  2054. { "display", displayhelp, display, 0 },
  2055. { "mode", modestring, modecmd, 0 },
  2056. { "open", openhelp, tn, 0 },
  2057. { "quit", quithelp, quit, 0 },
  2058. { "send", sendhelp, sendcmd, 0 },
  2059. { "set", sethelp, setcmd, 0 },
  2060. { "unset", unsethelp, unsetcmd, 0 },
  2061. { "status", statushelp, status, 0 },
  2062. { "toggle", togglestring, toggle, 0 },
  2063. { "slc", slchelp, slccmd, 0 },
  2064. #ifdef TN3270
  2065. { "transcom", transcomhelp, settranscom, 0 },
  2066. #endif /* defined(TN3270) */
  2067. { "z", zhelp, suspend, 0 },
  2068. #ifdef TN3270
  2069. { "!", shellhelp, shell, 1 },
  2070. #else
  2071. { "!", shellhelp, shell, 0 },
  2072. #endif
  2073. { "environ", envhelp, env_cmd, 0 },
  2074. { "?", helphelp, help, 0 },
  2075. { 0 } 
  2076. };
  2078. static char crmodhelp[] = "deprecated command -- use 'toggle crmod' instead";
  2079. static char escapehelp[] = "deprecated command -- use 'set escape' instead";
  2081. static Command cmdtab2[] = {
  2082. { "help", 0, help, 0 },
  2083. { "escape", escapehelp, setescape, 0 },
  2084. { "crmod", crmodhelp, togcrmod, 0 },
  2085. { 0 }
  2086. };
  2089. /*
  2090.  * Call routine with argc, argv set from args (terminated by 0).
  2091.  */
  2093.     /*VARARGS1*/
  2094.     static int
  2095. call(va_alist)
  2096.     va_dcl
  2097. {
  2098.     va_list ap;
  2099.     typedef int (*intrtn_t)();
  2100.     intrtn_t routine;
  2101.     char *args[100];
  2102.     int argno = 0;
  2104.     va_start(ap);
  2105.     routine = (va_arg(ap, intrtn_t));
  2106.     while ((args[argno++] = va_arg(ap, char *)) != 0) {
  2107. ;
  2108.     }
  2109.     va_end(ap);
  2110.     return (*routine)(argno-1, args);
  2111. }
  2114.     static Command *
  2115. getcmd(name)
  2116.     char *name;
  2117. {
  2118.     Command *cm;
  2119.     
  2120.     if ((cm = (Command *) genget(name, (char **) cmdtab, sizeof(Command)))) 
  2121. return cm;
  2122.     return (Command *) genget(name, (char **) cmdtab2, sizeof(Command));
  2123. }
  2125.     void
  2126. command(top, tbuf, cnt)
  2127.     int top;
  2128.     char *tbuf;
  2129.     int cnt;
  2130. {
  2131.     register Command *c;
  2133.     setcommandmode();
  2134.     if (!top) {
  2135. putchar('n');
  2136.     } else {
  2137. Signal(SIGINT, SIG_DFL);
  2138. Signal(SIGQUIT, SIG_DFL);
  2139.     }
  2140.     for (;;) {
  2141. if (rlogin == _POSIX_VDISABLE)
  2142. printf("%s> ", prompt);
  2143. if (tbuf) {
  2144.     register char *cp;
  2145.     cp = line;
  2146.     while (cnt > 0 && (*cp++ = *tbuf++) != 'n')
  2147. cnt--;
  2148.     tbuf = 0;
  2149.     if (cp == line || *--cp != 'n' || cp == line)
  2150. goto getline;
  2151.     *cp = '';
  2152.     if (rlogin == _POSIX_VDISABLE)
  2153. printf("%sn", line);
  2154. } else {
  2155. getline:
  2156.     if (rlogin != _POSIX_VDISABLE)
  2157. printf("%s> ", prompt);
  2158.     if (fgets(line, sizeof(line), stdin) == NULL) {
  2159. if (feof(stdin) || ferror(stdin)) {
  2160.     (void) quit();
  2161.     /*NOTREACHED*/
  2162. }
  2163. break;
  2164.     }
  2165. }
  2166. if (line[0] == 0)
  2167.     break;
  2168. makeargv();
  2169. if (margv[0] == 0) {
  2170.     break;
  2171. }
  2172. c = getcmd(margv[0]);
  2173. if (Ambiguous(c)) {
  2174.     printf("?Ambiguous commandn");
  2175.     continue;
  2176. }
  2177. if (c == 0) {
  2178.     printf("?Invalid commandn");
  2179.     continue;
  2180. }
  2181. if (c->needconnect && !connected) {
  2182.     printf("?Need to be connected first.n");
  2183.     continue;
  2184. }
  2185. if ((*c->handler)(margc, margv)) {
  2186.     break;
  2187. }
  2188.     }
  2189.     if (!top) {
  2190. if (!connected) {
  2191.     longjmp(toplevel, 1);
  2192.     /*NOTREACHED*/
  2193. }
  2194. #ifdef TN3270
  2195. if (shell_active == 0) {
  2196.     setconnmode(0);
  2197. }
  2198. #else /* defined(TN3270) */
  2199. setconnmode(0);
  2200. #endif /* defined(TN3270) */
  2201.     }
  2202. }
  2204. /*
  2205.  * Help command.
  2206.  */
  2207. static int
  2208. help(argc, argv)
  2209. int argc;
  2210. char *argv[];
  2211. {
  2212. register Command *c;
  2214. if (argc == 1) {
  2215. printf("Commands may be abbreviated.  Commands are:nn");
  2216. for (c = cmdtab; c->name; c++)
  2217. if (c->help) {
  2218.     printf("%-*st%sn", (int)HELPINDENT, c->name, c->help);
  2219. }
  2220. return 0;
  2221. }
  2222. while (--argc > 0) {
  2223. register char *arg;
  2224. arg = *++argv;
  2225. c = getcmd(arg);
  2226. if (Ambiguous(c))
  2227. printf("?Ambiguous help command %sn", arg);
  2228. else if (c == (Command *)0)
  2229. printf("?Invalid help command %sn", arg);
  2230. else
  2231. printf("%sn", c->help);
  2232. }
  2233. return 0;
  2234. }
  2236. static char *rcname = 0;
  2237. static char rcbuf[128];
  2239.     void
  2240. cmdrc(m1, m2)
  2241.     char *m1, *m2;
  2242. {
  2243.     register Command *c;
  2244.     FILE *rcfile;
  2245.     int gotmachine = 0;
  2246.     int l1 = strlen(m1);
  2247.     int l2 = strlen(m2);
  2248.     char m1save[64];
  2249.     
  2250.     if (skiprc)
  2251. return;
  2253.     strcpy(m1save, m1);
  2254.     m1 = m1save;
  2256.     if (rcname == 0) {
  2257. rcname = getenv("HOME");
  2258. if (rcname)
  2259.     strcpy(rcbuf, rcname);
  2260. else
  2261.     rcbuf[0] = '';
  2262. strcat(rcbuf, "/.telnetrc");
  2263. rcname = rcbuf;
  2264.     }
  2266.     if ((rcfile = fopen(rcname, "r")) == 0) {
  2267. return;
  2268.     }
  2270.     for (;;) {
  2271. if (fgets(line, sizeof(line), rcfile) == NULL)
  2272.     break;
  2273. if (line[0] == 0)
  2274.     break;
  2275. if (line[0] == '#')
  2276.     continue;
  2277. if (gotmachine) {
  2278.     if (!isspace(line[0]))
  2279. gotmachine = 0;
  2280. }
  2281. if (gotmachine == 0) {
  2282.     if (isspace(line[0]))
  2283. continue;
  2284.     if (strncasecmp(line, m1, l1) == 0)
  2285. strncpy(line, &line[l1], sizeof(line) - l1);
  2286.     else if (strncasecmp(line, m2, l2) == 0)
  2287. strncpy(line, &line[l2], sizeof(line) - l2);
  2288.     else if (strncasecmp(line, "DEFAULT", 7) == 0)
  2289. strncpy(line, &line[7], sizeof(line) - 7);
  2290.     else
  2291. continue;
  2292.     if (line[0] != ' ' && line[0] != 't' && line[0] != 'n')
  2293. continue;
  2294.     gotmachine = 1;
  2295. }
  2296. makeargv();
  2297. if (margv[0] == 0)
  2298.     continue;
  2299. c = getcmd(margv[0]);
  2300. if (Ambiguous(c)) {
  2301.     printf("?Ambiguous command: %sn", margv[0]);
  2302.     continue;
  2303. }
  2304. if (c == 0) {
  2305.     printf("?Invalid command: %sn", margv[0]);
  2306.     continue;
  2307. }
  2308. /*
  2309.  * This should never happen...
  2310.  */
  2311. if (c->needconnect && !connected) {
  2312.     printf("?Need to be connected first for %s.n", margv[0]);
  2313.     continue;
  2314. }
  2315. (*c->handler)(margc, margv);
  2316.     }
  2317.     fclose(rcfile);
  2318. }
  2320. #if defined(IP_OPTIONS) && defined(IPPROTO_IP)
  2322. /*
  2323.  * Source route is handed in as
  2324.  * [!]@hop1@hop2...[@|:]dst
  2325.  * If the leading ! is present, it is a
  2326.  * strict source route, otherwise it is
  2327.  * assmed to be a loose source route.
  2328.  *
  2329.  * We fill in the source route option as
  2330.  * hop1,hop2,hop3...dest
  2331.  * and return a pointer to hop1, which will
  2332.  * be the address to connect() to.
  2333.  *
  2334.  * Arguments:
  2335.  * arg: pointer to route list to decipher
  2336.  *
  2337.  * cpp:  If *cpp is not equal to NULL, this is a
  2338.  * pointer to a pointer to a character array
  2339.  * that should be filled in with the option.
  2340.  *
  2341.  * lenp: pointer to an integer that contains the
  2342.  * length of *cpp if *cpp != NULL.
  2343.  *
  2344.  * Return values:
  2345.  *
  2346.  * Returns the address of the host to connect to.  If the
  2347.  * return value is -1, there was a syntax error in the
  2348.  * option, either unknown characters, or too many hosts.
  2349.  * If the return value is 0, one of the hostnames in the
  2350.  * path is unknown, and *cpp is set to point to the bad
  2351.  * hostname.
  2352.  *
  2353.  * *cpp: If *cpp was equal to NULL, it will be filled
  2354.  * in with a pointer to our static area that has
  2355.  * the option filled in.  This will be 32bit aligned.
  2356.  *
  2357.  * *lenp: This will be filled in with how long the option
  2358.  * pointed to by *cpp is.
  2359.  *
  2360.  */
  2361. unsigned int
  2362. sourceroute(arg, cpp, lenp)
  2363. char *arg;
  2364. char **cpp;
  2365. int *lenp;
  2366. {
  2367. static char lsr[44];
  2368. #ifdef sysV88
  2369. static IOPTN ipopt;
  2370. #endif
  2371. char *cp, *cp2, *lsrp, *lsrep;
  2372. register int tmp;
  2373. struct in_addr sin_addr;
  2374. register struct hostent *host = 0;
  2375. register char c;
  2377. /*
  2378.  * Verify the arguments, and make sure we have
  2379.  * at least 7 bytes for the option.
  2380.  */
  2381. if (cpp == NULL || lenp == NULL)
  2382. return((unsigned int)-1);
  2383. if (*cpp != NULL && *lenp < 7)
  2384. return((unsigned int)-1);
  2385. /*
  2386.  * Decide whether we have a buffer passed to us,
  2387.  * or if we need to use our own static buffer.
  2388.  */
  2389. if (*cpp) {
  2390. lsrp = *cpp;
  2391. lsrep = lsrp + *lenp;
  2392. } else {
  2393. *cpp = lsrp = lsr;
  2394. lsrep = lsrp + 44;
  2395. }
  2397. cp = arg;
  2399. /*
  2400.  * Next, decide whether we have a loose source
  2401.  * route or a strict source route, and fill in
  2402.  * the begining of the option.
  2403.  */
  2404. #ifndef sysV88
  2405. if (*cp == '!') {
  2406. cp++;
  2407. *lsrp++ = IPOPT_SSRR;
  2408. } else
  2409. *lsrp++ = IPOPT_LSRR;
  2410. #else
  2411. if (*cp == '!') {
  2412. cp++;
  2413. ipopt.io_type = IPOPT_SSRR;
  2414. } else
  2415. ipopt.io_type = IPOPT_LSRR;
  2416. #endif
  2418. if (*cp != '@')
  2419. return((unsigned int)-1);
  2421. #ifndef sysV88
  2422. lsrp++; /* skip over length, we'll fill it in later */
  2423. *lsrp++ = 4;
  2424. #endif
  2426. cp++;
  2428. sin_addr.s_addr = 0;
  2430. for (c = 0;;) {
  2431. if (c == ':')
  2432. cp2 = 0;
  2433. else for (cp2 = cp; (c = *cp2); cp2++) {
  2434. if (c == ',') {
  2435. *cp2++ = '';
  2436. if (*cp2 == '@')
  2437. cp2++;
  2438. } else if (c == '@') {
  2439. *cp2++ = '';
  2440. } else if (c == ':') {
  2441. *cp2++ = '';
  2442. } else
  2443. continue;
  2444. break;
  2445. }
  2446. if (!c)
  2447. cp2 = 0;
  2449. if ((tmp = inet_addr(cp)) != -1) {
  2450. sin_addr.s_addr = tmp;
  2451. } else if ((host = gethostbyname(cp))) {
  2452. #ifdef h_addr
  2453. memmove((caddr_t)&sin_addr,
  2454. host->h_addr_list[0], host->h_length);
  2455. #else
  2456. memmove((caddr_t)&sin_addr, host->h_addr, host->h_length);
  2457. #endif
  2458. } else {
  2459. *cpp = cp;
  2460. return(0);
  2461. }
  2462. memmove(lsrp, (char *)&sin_addr, 4);
  2463. lsrp += 4;
  2464. if (cp2)
  2465. cp = cp2;
  2466. else
  2467. break;
  2468. /*
  2469.  * Check to make sure there is space for next address
  2470.  */
  2471. if (lsrp + 4 > lsrep)
  2472. return((unsigned int)-1);
  2473. }
  2474. #ifndef sysV88
  2475. if ((*(*cpp+IPOPT_OLEN) = lsrp - *cpp) <= 7) {
  2476. *cpp = 0;
  2477. *lenp = 0;
  2478. return((unsigned int)-1);
  2479. }
  2480. *lsrp++ = IPOPT_NOP; /* 32 bit word align it */
  2481. *lenp = lsrp - *cpp;
  2482. #else
  2483. ipopt.io_len = lsrp - *cpp;
  2484. if (ipopt.io_len <= 5) { /* Is 3 better ? */
  2485. *cpp = 0;
  2486. *lenp = 0;
  2487. return((unsigned int)-1);
  2488. }
  2489. *lenp = sizeof(ipopt);
  2490. *cpp = (char *) &ipopt;
  2491. #endif
  2492. return(sin_addr.s_addr);
  2493. }
  2494. #endif