/* * Copyright (c) 1988, 1990, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * Copyright 2005 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "general.h" #include "ring.h" #include "externs.h" #include "defines.h" #include "types.h" extern char *telnet_krb5_realm; extern void krb5_profile_get_options(char *, char *, profile_options_boolean*); #include #include profile_options_boolean config_file_options[] = { { "forwardable", &forwardable_flag, 0}, { "forward", &forward_flag, 0}, { "encrypt", &encrypt_flag, 0 }, { "autologin", &autologin, 0 }, { NULL, NULL, 0} }; #include /* * Number of maximum IPv4 gateways user can specify. This number is limited by * the maximum size of the IPv4 options in the IPv4 header. */ #define MAX_GATEWAY 8 /* * Number of maximum IPv6 gateways user can specify. This number is limited by * the maximum header extension length of the IPv6 routing header. */ #define MAX_GATEWAY6 127 #define MAXMAX_GATEWAY MAX(MAX_GATEWAY, MAX_GATEWAY6) /* * Depending on the address resolutions of the target and gateways, * we determine which addresses of the target we'll try connecting to. */ #define ALL_ADDRS 0 /* try all addrs of target */ #define ONLY_V4 1 /* try only IPv4 addrs of target */ #define ONLY_V6 2 /* try only IPv6 addrs of target */ #if defined(USE_TOS) int tos = -1; #endif char *hostname; static char _hostname[MAXHOSTNAMELEN]; static int send_tncmd(void (*func)(), char *, char *); static void call(int n_ptrs, ...); static int cmdrc(char *, char *); typedef struct { char *name; /* command name */ char *help; /* help string (NULL for no help) */ int (*handler)(); /* routine which executes command */ int needconnect; /* Do we need to be connected to execute? */ } Command; /* * storage for IPv6 and/or IPv4 addresses of gateways */ struct gateway { struct in6_addr gw_addr6; struct in_addr gw_addr; }; /* * IPv4 source routing option. * In order to avoid padding for the alignment of IPv4 addresses, ipsr_addrs * is defined as a 2-D array of uint8_t, instead of 1-D array of struct in_addr. * If it were defined as "struct in_addr ipsr_addrs[1]", "ipsr_ptr" would be * followed by one byte of padding to avoid misaligned struct in_addr. */ struct ip_sourceroute { uint8_t ipsr_code; uint8_t ipsr_len; uint8_t ipsr_ptr; /* up to 9 IPv4 addresses */ uint8_t ipsr_addrs[1][sizeof (struct in_addr)]; }; static char *line = NULL; static unsigned linesize = 0; static int margc; static char **margv = NULL; static unsigned margvlen = 0; static int doing_rc = 0; /* .telnetrc file is being read and processed */ static void Close(int *fd) { if (*fd != -1) { (void) close(*fd); *fd = -1; } } static void Free(char **p) { if (*p != NULL) { free(*p); *p = NULL; } } static void FreeHostnameList(char *list[]) { unsigned i; for (i = 0; i <= MAXMAX_GATEWAY && list[i] != NULL; i++) Free(&list[i]); } #define MARGV_CHUNK_SIZE 8 static void set_argv(str) char *str; { if (margc == margvlen) { char **newmargv; margvlen += MARGV_CHUNK_SIZE; if ((newmargv = realloc(margv, margvlen * sizeof (char *))) == NULL) ExitString("telnet: no space for arguments", EXIT_FAILURE); margv = newmargv; } margv[margc] = str; if (str != NULL) margc++; } static void makeargv() { char *cp, *cp2, c; boolean_t shellcmd = B_FALSE; margc = 0; cp = line; if (*cp == '!') { /* Special case shell escape */ set_argv("!"); /* No room in string to get this */ cp++; shellcmd = B_TRUE; } while ((c = *cp) != '\0') { register int inquote = 0; while (isspace(c)) c = *++cp; if (c == '\0') break; set_argv(cp); /* * For the shell escape, put the rest of the line, less * leading space, into a single argument, breaking out from * the loop to prevent the rest of the line being split up * into smaller arguments. */ if (shellcmd) break; for (cp2 = cp; c != '\0'; c = *++cp) { if (inquote) { if (c == inquote) { inquote = 0; continue; } } else { if (c == '\\') { if ((c = *++cp) == '\0') break; } else if (c == '"') { inquote = '"'; continue; } else if (c == '\'') { inquote = '\''; continue; } else if (isspace(c)) break; } *cp2++ = c; } *cp2 = '\0'; if (c == '\0') break; cp++; } set_argv((char *)NULL); } /* * Make a character string into a number. * * Todo: 1. Could take random integers (12, 0x12, 012, 0b1). */ static int special(s) register char *s; { register char c; char b; switch (*s) { case '^': b = *++s; if (b == '?') { c = b | 0x40; /* DEL */ } else { c = b & 0x1f; } break; default: c = *s; break; } return (c); } /* * Construct a control character sequence * for a special character. */ static char * control(c) register cc_t c; { static char buf[5]; /* * The only way I could get the Sun 3.5 compiler * to shut up about * if ((unsigned int)c >= 0x80) * was to assign "c" to an unsigned int variable... * Arggg.... */ register unsigned int uic = (unsigned int)c; if (uic == 0x7f) return ("^?"); if (c == (cc_t)_POSIX_VDISABLE) { return ("off"); } if (uic >= 0x80) { buf[0] = '\\'; buf[1] = ((c>>6)&07) + '0'; buf[2] = ((c>>3)&07) + '0'; buf[3] = (c&07) + '0'; buf[4] = 0; } else if (uic >= 0x20) { buf[0] = c; buf[1] = 0; } else { buf[0] = '^'; buf[1] = '@'+c; buf[2] = 0; } return (buf); } /* * Same as control() except that its only used for escape handling, which uses * _POSIX_VDISABLE differently and is aided by the use of the state variable * escape_valid. */ static char * esc_control(c) register cc_t c; { static char buf[5]; /* * The only way I could get the Sun 3.5 compiler * to shut up about * if ((unsigned int)c >= 0x80) * was to assign "c" to an unsigned int variable... * Arggg.... */ register unsigned int uic = (unsigned int)c; if (escape_valid == B_FALSE) return ("off"); if (uic == 0x7f) return ("^?"); if (uic >= 0x80) { buf[0] = '\\'; buf[1] = ((c>>6)&07) + '0'; buf[2] = ((c>>3)&07) + '0'; buf[3] = (c&07) + '0'; buf[4] = 0; } else if (uic >= 0x20) { buf[0] = c; buf[1] = 0; } else { buf[0] = '^'; buf[1] = '@'+c; buf[2] = 0; } return (buf); } /* * The following are data structures and routines for * the "send" command. * */ struct sendlist { char *name; /* How user refers to it (case independent) */ char *help; /* Help information (0 ==> no help) */ int needconnect; /* Need to be connected */ int narg; /* Number of arguments */ int (*handler)(); /* Routine to perform (for special ops) */ int nbyte; /* Number of bytes to send this command */ int what; /* Character to be sent (<0 ==> special) */ }; static int send_esc(void); static int send_help(void); static int send_docmd(char *); static int send_dontcmd(char *); static int send_willcmd(char *); static int send_wontcmd(char *); static struct sendlist Sendlist[] = { { "ao", "Send Telnet Abort output", 1, 0, 0, 2, AO }, { "ayt", "Send Telnet 'Are You There'", 1, 0, 0, 2, AYT }, { "b", 0, 1, 0, 0, 2, BREAK }, { "br", 0, 1, 0, 0, 2, BREAK }, { "break", 0, 1, 0, 0, 2, BREAK }, { "brk", "Send Telnet Break", 1, 0, 0, 2, BREAK }, { "ec", "Send Telnet Erase Character", 1, 0, 0, 2, EC }, { "el", "Send Telnet Erase Line", 1, 0, 0, 2, EL }, { "escape", "Send current escape character", 1, 0, send_esc, 1, 0 }, { "ga", "Send Telnet 'Go Ahead' sequence", 1, 0, 0, 2, GA }, { "ip", "Send Telnet Interrupt Process", 1, 0, 0, 2, IP }, { "intp", 0, 1, 0, 0, 2, IP }, { "interrupt", 0, 1, 0, 0, 2, IP }, { "intr", 0, 1, 0, 0, 2, IP }, { "nop", "Send Telnet 'No operation'", 1, 0, 0, 2, NOP }, { "eor", "Send Telnet 'End of Record'", 1, 0, 0, 2, EOR }, { "abort", "Send Telnet 'Abort Process'", 1, 0, 0, 2, ABORT }, { "susp", "Send Telnet 'Suspend Process'", 1, 0, 0, 2, SUSP }, { "eof", "Send Telnet End of File Character", 1, 0, 0, 2, xEOF }, { "synch", "Perform Telnet 'Synch operation'", 1, 0, dosynch, 2, 0 }, { "getstatus", "Send request for STATUS", 1, 0, get_status, 6, 0 }, { "?", "Display send options", 0, 0, send_help, 0, 0 }, { "help", 0, 0, 0, send_help, 0, 0 }, { "do", 0, 0, 1, send_docmd, 3, 0 }, { "dont", 0, 0, 1, send_dontcmd, 3, 0 }, { "will", 0, 0, 1, send_willcmd, 3, 0 }, { "wont", 0, 0, 1, send_wontcmd, 3, 0 }, { 0 } }; #define GETSEND(name) ((struct sendlist *)genget(name, (char **)Sendlist, \ sizeof (struct sendlist))) static int sendcmd(argc, argv) int argc; char **argv; { int count; /* how many bytes we are going to need to send */ int i; struct sendlist *s; /* pointer to current command */ int success = 0; int needconnect = 0; if (argc < 2) { (void) printf( "need at least one argument for 'send' command\n"); (void) printf("'send ?' for help\n"); return (0); } /* * First, validate all the send arguments. * In addition, we see how much space we are going to need, and * whether or not we will be doing a "SYNCH" operation (which * flushes the network queue). */ count = 0; for (i = 1; i < argc; i++) { s = GETSEND(argv[i]); if (s == 0) { (void) printf("Unknown send argument '%s'\n'send ?' " "for help.\n", argv[i]); return (0); } else if (Ambiguous(s)) { (void) printf("Ambiguous send argument '%s'\n'send ?' " "for help.\n", argv[i]); return (0); } if (i + s->narg >= argc) { (void) fprintf(stderr, "Need %d argument%s to 'send %s' " "command. 'send %s ?' for help.\n", s->narg, s->narg == 1 ? "" : "s", s->name, s->name); return (0); } count += s->nbyte; if (s->handler == send_help) { (void) send_help(); return (0); } i += s->narg; needconnect += s->needconnect; } if (!connected && needconnect) { (void) printf("?Need to be connected first.\n"); (void) printf("'send ?' for help\n"); return (0); } /* Now, do we have enough room? */ if (NETROOM() < count) { (void) printf("There is not enough room in the buffer " "TO the network\n"); (void) printf( "to process your request. Nothing will be done.\n"); (void) printf("('send synch' will throw away most " "data in the network\n"); (void) printf("buffer, if this might help.)\n"); return (0); } /* OK, they are all OK, now go through again and actually send */ count = 0; for (i = 1; i < argc; i++) { if ((s = GETSEND(argv[i])) == 0) { (void) fprintf(stderr, "Telnet 'send' error - argument disappeared!\n"); (void) quit(); /*NOTREACHED*/ } if (s->handler) { count++; success += (*s->handler)((s->narg > 0) ? argv[i+1] : 0, (s->narg > 1) ? argv[i+2] : 0); i += s->narg; } else { NET2ADD(IAC, s->what); printoption("SENT", IAC, s->what); } } return (count == success); } static int send_esc() { NETADD(escape); return (1); } static int send_docmd(name) char *name; { return (send_tncmd(send_do, "do", name)); } static int send_dontcmd(name) char *name; { return (send_tncmd(send_dont, "dont", name)); } static int send_willcmd(name) char *name; { return (send_tncmd(send_will, "will", name)); } static int send_wontcmd(name) char *name; { return (send_tncmd(send_wont, "wont", name)); } int send_tncmd(func, cmd, name) void (*func)(); char *cmd, *name; { char **cpp; extern char *telopts[]; register int val = 0; if (isprefix(name, "help") || isprefix(name, "?")) { register int col, len; (void) printf("Usage: send %s \n", cmd); (void) printf("\"value\" must be from 0 to 255\n"); (void) printf("Valid options are:\n\t"); col = 8; for (cpp = telopts; *cpp; cpp++) { len = strlen(*cpp) + 3; if (col + len > 65) { (void) printf("\n\t"); col = 8; } (void) printf(" \"%s\"", *cpp); col += len; } (void) printf("\n"); return (0); } cpp = (char **)genget(name, telopts, sizeof (char *)); if (Ambiguous(cpp)) { (void) fprintf(stderr, "'%s': ambiguous argument ('send %s ?' for help).\n", name, cmd); return (0); } if (cpp) { val = cpp - telopts; } else { register char *cp = name; while (*cp >= '0' && *cp <= '9') { val *= 10; val += *cp - '0'; cp++; } if (*cp != 0) { (void) fprintf(stderr, "'%s': unknown argument ('send %s ?' for help).\n", name, cmd); return (0); } else if (val < 0 || val > 255) { (void) fprintf(stderr, "'%s': bad value ('send %s ?' for help).\n", name, cmd); return (0); } } if (!connected) { (void) printf("?Need to be connected first.\n"); return (0); } (*func)(val, 1); return (1); } static int send_help() { struct sendlist *s; /* pointer to current command */ for (s = Sendlist; s->name; s++) { if (s->help) (void) printf("%-15s %s\n", s->name, s->help); } return (0); } /* * The following are the routines and data structures referred * to by the arguments to the "toggle" command. */ static int lclchars() { donelclchars = 1; return (1); } static int togdebug() { if (net > 0 && (SetSockOpt(net, SOL_SOCKET, SO_DEBUG, debug)) < 0) { perror("setsockopt (SO_DEBUG)"); } return (1); } static int togcrlf() { if (crlf) { (void) printf( "Will send carriage returns as telnet .\n"); } else { (void) printf( "Will send carriage returns as telnet .\n"); } return (1); } static int binmode; static int togbinary(val) int val; { donebinarytoggle = 1; if (val >= 0) { binmode = val; } else { if (my_want_state_is_will(TELOPT_BINARY) && my_want_state_is_do(TELOPT_BINARY)) { binmode = 1; } else if (my_want_state_is_wont(TELOPT_BINARY) && my_want_state_is_dont(TELOPT_BINARY)) { binmode = 0; } val = binmode ? 0 : 1; } if (val == 1) { if (my_want_state_is_will(TELOPT_BINARY) && my_want_state_is_do(TELOPT_BINARY)) { (void) printf("Already operating in binary mode " "with remote host.\n"); } else { (void) printf( "Negotiating binary mode with remote host.\n"); tel_enter_binary(3); } } else { if (my_want_state_is_wont(TELOPT_BINARY) && my_want_state_is_dont(TELOPT_BINARY)) { (void) printf("Already in network ascii mode " "with remote host.\n"); } else { (void) printf("Negotiating network ascii mode " "with remote host.\n"); tel_leave_binary(3); } } return (1); } static int togrbinary(val) int val; { donebinarytoggle = 1; if (val == -1) val = my_want_state_is_do(TELOPT_BINARY) ? 0 : 1; if (val == 1) { if (my_want_state_is_do(TELOPT_BINARY)) { (void) printf("Already receiving in binary mode.\n"); } else { (void) printf("Negotiating binary mode on input.\n"); tel_enter_binary(1); } } else { if (my_want_state_is_dont(TELOPT_BINARY)) { (void) printf( "Already receiving in network ascii mode.\n"); } else { (void) printf( "Negotiating network ascii mode on input.\n"); tel_leave_binary(1); } } return (1); } static int togxbinary(val) int val; { donebinarytoggle = 1; if (val == -1) val = my_want_state_is_will(TELOPT_BINARY) ? 0 : 1; if (val == 1) { if (my_want_state_is_will(TELOPT_BINARY)) { (void) printf("Already transmitting in binary mode.\n"); } else { (void) printf("Negotiating binary mode on output.\n"); tel_enter_binary(2); } } else { if (my_want_state_is_wont(TELOPT_BINARY)) { (void) printf( "Already transmitting in network ascii mode.\n"); } else { (void) printf( "Negotiating network ascii mode on output.\n"); tel_leave_binary(2); } } return (1); } static int togglehelp(void); extern int auth_togdebug(int); struct togglelist { char *name; /* name of toggle */ char *help; /* help message */ int (*handler)(); /* routine to do actual setting */ int *variable; char *actionexplanation; }; static struct togglelist Togglelist[] = { { "autoflush", "flushing of output when sending interrupt characters", 0, &autoflush, "flush output when sending interrupt characters" }, { "autosynch", "automatic sending of interrupt characters in urgent mode", 0, &autosynch, "send interrupt characters in urgent mode" }, { "autologin", "automatic sending of login and/or authentication info", 0, &autologin, "send login name and/or authentication information" }, { "authdebug", "authentication debugging", auth_togdebug, 0, "print authentication debugging information" }, { "autoencrypt", "automatic encryption of data stream", EncryptAutoEnc, 0, "automatically encrypt output" }, { "autodecrypt", "automatic decryption of data stream", EncryptAutoDec, 0, "automatically decrypt input" }, { "verbose_encrypt", "verbose encryption output", EncryptVerbose, 0, "print verbose encryption output" }, { "encdebug", "encryption debugging", EncryptDebug, 0, "print encryption debugging information" }, { "skiprc", "don't read ~/.telnetrc file", 0, &skiprc, "skip reading of ~/.telnetrc file" }, { "binary", "sending and receiving of binary data", togbinary, 0, 0 }, { "inbinary", "receiving of binary data", togrbinary, 0, 0 }, { "outbinary", "sending of binary data", togxbinary, 0, 0 }, { "crlf", "sending carriage returns as telnet ", togcrlf, &crlf, 0 }, { "crmod", "mapping of received carriage returns", 0, &crmod, "map carriage return on output" }, { "localchars", "local recognition of certain control characters", lclchars, &localchars, "recognize certain control characters" }, { " ", "", 0 }, /* empty line */ { "debug", "debugging", togdebug, &debug, "turn on socket level debugging" }, { "netdata", "printing of hexadecimal network data (debugging)", 0, &netdata, "print hexadecimal representation of network traffic" }, { "prettydump", "output of \"netdata\" to user readable format (debugging)", 0, &prettydump, "print user readable output for \"netdata\"" }, { "options", "viewing of options processing (debugging)", 0, &showoptions, "show option processing" }, { "termdata", "(debugging) toggle printing of hexadecimal terminal data", 0, &termdata, "print hexadecimal representation of terminal traffic" }, { "?", 0, togglehelp }, { "help", 0, togglehelp }, { 0 } }; static int togglehelp() { struct togglelist *c; for (c = Togglelist; c->name; c++) { if (c->help) { if (*c->help) (void) printf( "%-15s toggle %s\n", c->name, c->help); else (void) printf("\n"); } } (void) printf("\n"); (void) printf("%-15s %s\n", "?", "display help information"); return (0); } static void settogglehelp(set) int set; { struct togglelist *c; for (c = Togglelist; c->name; c++) { if (c->help) { if (*c->help) (void) printf("%-15s %s %s\n", c->name, set ? "enable" : "disable", c->help); else (void) printf("\n"); } } } #define GETTOGGLE(name) (struct togglelist *) \ genget(name, (char **)Togglelist, sizeof (struct togglelist)) static int toggle(argc, argv) int argc; char *argv[]; { int retval = 1; char *name; struct togglelist *c; if (argc < 2) { (void) fprintf(stderr, "Need an argument to 'toggle' command. " "'toggle ?' for help.\n"); return (0); } argc--; argv++; while (argc--) { name = *argv++; c = GETTOGGLE(name); if (Ambiguous(c)) { (void) fprintf(stderr, "'%s': ambiguous argument " "('toggle ?' for help).\n", name); return (0); } else if (c == 0) { (void) fprintf(stderr, "'%s': unknown argument " "('toggle ?' for help).\n", name); return (0); } else { if (c->variable) { *c->variable = !*c->variable; /* invert it */ if (c->actionexplanation) { (void) printf("%s %s.\n", *c->variable ? "Will" : "Won't", c->actionexplanation); } } if (c->handler) { retval &= (*c->handler)(-1); } } } return (retval); } /* * The following perform the "set" command. */ #ifdef USE_TERMIO struct termio new_tc = { 0 }; #endif struct setlist { char *name; /* name */ char *help; /* help information */ void (*handler)(); cc_t *charp; /* where it is located at */ }; static struct setlist Setlist[] = { #ifdef KLUDGELINEMODE { "echo", "character to toggle local echoing on/off", 0, &echoc }, #endif { "escape", "character to escape back to telnet command mode", 0, &escape }, { "rlogin", "rlogin escape character", 0, &rlogin }, { "tracefile", "file to write trace information to", SetNetTrace, (cc_t *)NetTraceFile}, { " ", "" }, { " ", "The following need 'localchars' to be toggled true", 0, 0 }, { "flushoutput", "character to cause an Abort Output", 0, termFlushCharp }, { "interrupt", "character to cause an Interrupt Process", 0, termIntCharp }, { "quit", "character to cause an Abort process", 0, termQuitCharp }, { "eof", "character to cause an EOF ", 0, termEofCharp }, { " ", "" }, { " ", "The following are for local editing in linemode", 0, 0 }, { "erase", "character to use to erase a character", 0, termEraseCharp }, { "kill", "character to use to erase a line", 0, termKillCharp }, { "lnext", "character to use for literal next", 0, termLiteralNextCharp }, { "susp", "character to cause a Suspend Process", 0, termSuspCharp }, { "reprint", "character to use for line reprint", 0, termRprntCharp }, { "worderase", "character to use to erase a word", 0, termWerasCharp }, { "start", "character to use for XON", 0, termStartCharp }, { "stop", "character to use for XOFF", 0, termStopCharp }, { "forw1", "alternate end of line character", 0, termForw1Charp }, { "forw2", "alternate end of line character", 0, termForw2Charp }, { "ayt", "alternate AYT character", 0, termAytCharp }, { 0 } }; static struct setlist * getset(name) char *name; { return ((struct setlist *) genget(name, (char **)Setlist, sizeof (struct setlist))); } void set_escape_char(s) char *s; { if (rlogin != _POSIX_VDISABLE) { rlogin = (s && *s) ? special(s) : _POSIX_VDISABLE; (void) printf("Telnet rlogin escape character is '%s'.\n", control(rlogin)); } else { escape = (s && *s) ? special(s) : _POSIX_VDISABLE; (void) printf("Telnet escape character is '%s'.\n", esc_control(escape)); } } static int setcmd(argc, argv) int argc; char *argv[]; { int value; struct setlist *ct; struct togglelist *c; if (argc < 2 || argc > 3) { (void) printf( "Format is 'set Name Value'\n'set ?' for help.\n"); return (0); } if ((argc == 2) && (isprefix(argv[1], "?") || isprefix(argv[1], "help"))) { for (ct = Setlist; ct->name; ct++) (void) printf("%-15s %s\n", ct->name, ct->help); (void) printf("\n"); settogglehelp(1); (void) printf("%-15s %s\n", "?", "display help information"); return (0); } ct = getset(argv[1]); if (ct == 0) { c = GETTOGGLE(argv[1]); if (c == 0) { (void) fprintf(stderr, "'%s': unknown argument " "('set ?' for help).\n", argv[1]); return (0); } else if (Ambiguous(c)) { (void) fprintf(stderr, "'%s': ambiguous argument " "('set ?' for help).\n", argv[1]); return (0); } if (c->variable) { if ((argc == 2) || (strcmp("on", argv[2]) == 0)) *c->variable = 1; else if (strcmp("off", argv[2]) == 0) *c->variable = 0; else { (void) printf( "Format is 'set togglename [on|off]'\n" "'set ?' for help.\n"); return (0); } if (c->actionexplanation) { (void) printf("%s %s.\n", *c->variable? "Will" : "Won't", c->actionexplanation); } } if (c->handler) (*c->handler)(1); } else if (argc != 3) { (void) printf( "Format is 'set Name Value'\n'set ?' for help.\n"); return (0); } else if (Ambiguous(ct)) { (void) fprintf(stderr, "'%s': ambiguous argument ('set ?' for help).\n", argv[1]); return (0); } else if (ct->handler) { (*ct->handler)(argv[2]); (void) printf( "%s set to \"%s\".\n", ct->name, (char *)ct->charp); } else { if (strcmp("off", argv[2])) { value = special(argv[2]); } else { value = _POSIX_VDISABLE; } *(ct->charp) = (cc_t)value; (void) printf("%s character is '%s'.\n", ct->name, control(*(ct->charp))); } slc_check(); return (1); } static int unsetcmd(argc, argv) int argc; char *argv[]; { struct setlist *ct; struct togglelist *c; register char *name; if (argc < 2) { (void) fprintf(stderr, "Need an argument to 'unset' command. " "'unset ?' for help.\n"); return (0); } if (isprefix(argv[1], "?") || isprefix(argv[1], "help")) { for (ct = Setlist; ct->name; ct++) (void) printf("%-15s %s\n", ct->name, ct->help); (void) printf("\n"); settogglehelp(0); (void) printf("%-15s %s\n", "?", "display help information"); return (0); } argc--; argv++; while (argc--) { name = *argv++; ct = getset(name); if (ct == 0) { c = GETTOGGLE(name); if (c == 0) { (void) fprintf(stderr, "'%s': unknown argument " "('unset ?' for help).\n", name); return (0); } else if (Ambiguous(c)) { (void) fprintf(stderr, "'%s': ambiguous argument " "('unset ?' for help).\n", name); return (0); } if (c->variable) { *c->variable = 0; if (c->actionexplanation) { (void) printf("%s %s.\n", *c->variable? "Will" : "Won't", c->actionexplanation); } } if (c->handler) (*c->handler)(0); } else if (Ambiguous(ct)) { (void) fprintf(stderr, "'%s': ambiguous argument " "('unset ?' for help).\n", name); return (0); } else if (ct->handler) { (*ct->handler)(0); (void) printf("%s reset to \"%s\".\n", ct->name, (char *)ct->charp); } else { *(ct->charp) = _POSIX_VDISABLE; (void) printf("%s character is '%s'.\n", ct->name, control(*(ct->charp))); } } return (1); } /* * The following are the data structures and routines for the * 'mode' command. */ extern int reqd_linemode; #ifdef KLUDGELINEMODE extern int kludgelinemode; static int dokludgemode() { kludgelinemode = 1; send_wont(TELOPT_LINEMODE, 1); send_dont(TELOPT_SGA, 1); send_dont(TELOPT_ECHO, 1); /* * If processing the .telnetrc file, keep track of linemode and/or * kludgelinemode requests which are processed before initial option * negotiations occur. */ if (doing_rc) reqd_linemode = 1; return (1); } #endif static int dolinemode() { #ifdef KLUDGELINEMODE if (kludgelinemode) send_dont(TELOPT_SGA, 1); #endif send_will(TELOPT_LINEMODE, 1); send_dont(TELOPT_ECHO, 1); /* * If processing the .telnetrc file, keep track of linemode and/or * kludgelinemode requests which are processed before initial option * negotiations occur. */ if (doing_rc) reqd_linemode = 1; return (1); } static int docharmode() { #ifdef KLUDGELINEMODE if (kludgelinemode) send_do(TELOPT_SGA, 1); else #endif send_wont(TELOPT_LINEMODE, 1); send_do(TELOPT_ECHO, 1); reqd_linemode = 0; return (1); } static int dolmmode(bit, on) int bit, on; { unsigned char c; extern int linemode; if (my_want_state_is_wont(TELOPT_LINEMODE)) { (void) printf("?Need to have LINEMODE option enabled first.\n"); (void) printf("'mode ?' for help.\n"); return (0); } if (on) c = (linemode | bit); else c = (linemode & ~bit); lm_mode(&c, 1, 1); return (1); } static int setmode(bit) { return (dolmmode(bit, 1)); } static int clearmode(bit) { return (dolmmode(bit, 0)); } struct modelist { char *name; /* command name */ char *help; /* help string */ int (*handler)(); /* routine which executes command */ int needconnect; /* Do we need to be connected to execute? */ int arg1; }; static int modehelp(); static struct modelist ModeList[] = { { "character", "Disable LINEMODE option", docharmode, 1 }, #ifdef KLUDGELINEMODE { "", "(or disable obsolete line-by-line mode)", 0 }, #endif { "line", "Enable LINEMODE option", dolinemode, 1 }, #ifdef KLUDGELINEMODE { "", "(or enable obsolete line-by-line mode)", 0 }, #endif { "", "", 0 }, { "", "These require the LINEMODE option to be enabled", 0 }, { "isig", "Enable signal trapping", setmode, 1, MODE_TRAPSIG }, { "+isig", 0, setmode, 1, MODE_TRAPSIG }, { "-isig", "Disable signal trapping", clearmode, 1, MODE_TRAPSIG }, { "edit", "Enable character editing", setmode, 1, MODE_EDIT }, { "+edit", 0, setmode, 1, MODE_EDIT }, { "-edit", "Disable character editing", clearmode, 1, MODE_EDIT }, { "softtabs", "Enable tab expansion", setmode, 1, MODE_SOFT_TAB }, { "+softtabs", 0, setmode, 1, MODE_SOFT_TAB }, { "-softtabs", "Disable tab expansion", clearmode, 1, MODE_SOFT_TAB }, { "litecho", "Enable literal character echo", setmode, 1, MODE_LIT_ECHO }, { "+litecho", 0, setmode, 1, MODE_LIT_ECHO }, { "-litecho", "Disable literal character echo", clearmode, 1, MODE_LIT_ECHO }, { "help", 0, modehelp, 0 }, #ifdef KLUDGELINEMODE { "kludgeline", 0, dokludgemode, 1 }, #endif { "", "", 0 }, { "?", "Print help information", modehelp, 0 }, { 0 }, }; static int modehelp() { struct modelist *mt; (void) printf("format is: 'mode Mode', where 'Mode' is one of:\n\n"); for (mt = ModeList; mt->name; mt++) { if (mt->help) { if (*mt->help) (void) printf("%-15s %s\n", mt->name, mt->help); else (void) printf("\n"); } } return (0); } #define GETMODECMD(name) (struct modelist *) \ genget(name, (char **)ModeList, sizeof (struct modelist)) static int modecmd(argc, argv) int argc; char *argv[]; { struct modelist *mt; if (argc != 2) { (void) printf("'mode' command requires an argument\n"); (void) printf("'mode ?' for help.\n"); } else if ((mt = GETMODECMD(argv[1])) == 0) { (void) fprintf(stderr, "Unknown mode '%s' ('mode ?' for help).\n", argv[1]); } else if (Ambiguous(mt)) { (void) fprintf(stderr, "Ambiguous mode '%s' ('mode ?' for help).\n", argv[1]); } else if (mt->needconnect && !connected) { (void) printf("?Need to be connected first.\n"); (void) printf("'mode ?' for help.\n"); } else if (mt->handler) { return (*mt->handler)(mt->arg1); } return (0); } /* * The following data structures and routines implement the * "display" command. */ static int display(argc, argv) int argc; char *argv[]; { struct togglelist *tl; struct setlist *sl; #define dotog(tl) if (tl->variable && tl->actionexplanation) { \ if (*tl->variable) { \ (void) printf("will"); \ } else { \ (void) printf("won't"); \ } \ (void) printf(" %s.\n", tl->actionexplanation); \ } #define doset(sl) if (sl->name && *sl->name != ' ') { \ if (sl->handler == 0) \ (void) printf("%-15s [%s]\n", sl->name, \ control(*sl->charp)); \ else \ (void) printf("%-15s \"%s\"\n", sl->name, \ (char *)sl->charp); \ } if (argc == 1) { for (tl = Togglelist; tl->name; tl++) { dotog(tl); } (void) printf("\n"); for (sl = Setlist; sl->name; sl++) { doset(sl); } } else { int i; for (i = 1; i < argc; i++) { sl = getset(argv[i]); tl = GETTOGGLE(argv[i]); if (Ambiguous(sl) || Ambiguous(tl)) { (void) printf( "?Ambiguous argument '%s'.\n", argv[i]); return (0); } else if (!sl && !tl) { (void) printf( "?Unknown argument '%s'.\n", argv[i]); return (0); } else { if (tl) { dotog(tl); } if (sl) { doset(sl); } } } } optionstatus(); (void) EncryptStatus(); return (1); #undef doset #undef dotog } /* * The following are the data structures, and many of the routines, * relating to command processing. */ /* * Set the escape character. */ static int setescape(argc, argv) int argc; char *argv[]; { register char *arg; char *buf = NULL; if (argc > 2) arg = argv[1]; else { (void) printf("new escape character: "); if (GetString(&buf, NULL, stdin) == NULL) { if (!feof(stdin)) { perror("can't set escape character"); goto setescape_exit; } } arg = buf; } /* we place no limitations on what escape can be. */ escape = arg[0]; (void) printf("Escape character is '%s'.\n", esc_control(escape)); (void) fflush(stdout); setescape_exit: Free(&buf); return (1); } /*ARGSUSED*/ static int togcrmod(argc, argv) int argc; char *argv[]; { crmod = !crmod; (void) printf( "%s map carriage return on output.\n", crmod ? "Will" : "Won't"); (void) fflush(stdout); return (1); } /*ARGSUSED*/ static int suspend(argc, argv) int argc; char *argv[]; { setcommandmode(); { unsigned short oldrows, oldcols, newrows, newcols; int err; err = (TerminalWindowSize(&oldrows, &oldcols) == 0) ? 1 : 0; (void) kill(0, SIGTSTP); /* * If we didn't get the window size before the SUSPEND, but we * can get them now (?), then send the NAWS to make sure that * we are set up for the right window size. */ if (TerminalWindowSize(&newrows, &newcols) && connected && (err || ((oldrows != newrows) || (oldcols != newcols)))) { sendnaws(); } } /* reget parameters in case they were changed */ TerminalSaveState(); setconnmode(0); return (1); } /*ARGSUSED*/ static int shell(argc, argv) int argc; char *argv[]; { unsigned short oldrows, oldcols, newrows, newcols; int err; setcommandmode(); err = (TerminalWindowSize(&oldrows, &oldcols) == 0) ? 1 : 0; switch (vfork()) { case -1: perror("Fork failed\n"); break; case 0: { /* * Fire up the shell in the child. */ register char *shellp, *shellname; shellp = getenv("SHELL"); if (shellp == NULL) shellp = "/bin/sh"; if ((shellname = strrchr(shellp, '/')) == 0) shellname = shellp; else shellname++; if (argc > 1) (void) execl(shellp, shellname, "-c", argv[1], 0); else (void) execl(shellp, shellname, 0); perror("Execl"); _exit(EXIT_FAILURE); } default: (void) wait((int *)0); /* Wait for the shell to complete */ if (TerminalWindowSize(&newrows, &newcols) && connected && (err || ((oldrows != newrows) || (oldcols != newcols)))) { sendnaws(); } break; } return (1); } static int bye(argc, argv) int argc; /* Number of arguments */ char *argv[]; /* arguments */ { extern int resettermname; if (connected) { (void) shutdown(net, 2); (void) printf("Connection to %.*s closed.\n", MAXHOSTNAMELEN, hostname); Close(&net); connected = 0; resettermname = 1; /* reset options */ (void) tninit(); } if ((argc != 2) || (strcmp(argv[1], "fromquit") != 0)) { longjmp(toplevel, 1); /* NOTREACHED */ } return (1); /* Keep lint, etc., happy */ } /*VARARGS*/ int quit() { (void) call(3, bye, "bye", "fromquit"); Exit(EXIT_SUCCESS); /*NOTREACHED*/ return (1); } /*ARGSUSED*/ static int logout(argc, argv) int argc; char *argv[]; { send_do(TELOPT_LOGOUT, 1); (void) netflush(); return (1); } /* * The SLC command. */ struct slclist { char *name; char *help; void (*handler)(); int arg; }; static void slc_help(); static struct slclist SlcList[] = { { "export", "Use local special character definitions", slc_mode_export, 0 }, { "import", "Use remote special character definitions", slc_mode_import, 1 }, { "check", "Verify remote special character definitions", slc_mode_import, 0 }, { "help", 0, slc_help, 0 }, { "?", "Print help information", slc_help, 0 }, { 0 }, }; static void slc_help() { struct slclist *c; for (c = SlcList; c->name; c++) { if (c->help) { if (*c->help) (void) printf("%-15s %s\n", c->name, c->help); else (void) printf("\n"); } } } static struct slclist * getslc(name) char *name; { return ((struct slclist *) genget(name, (char **)SlcList, sizeof (struct slclist))); } static int slccmd(argc, argv) int argc; char *argv[]; { struct slclist *c; if (argc != 2) { (void) fprintf(stderr, "Need an argument to 'slc' command. 'slc ?' for help.\n"); return (0); } c = getslc(argv[1]); if (c == 0) { (void) fprintf(stderr, "'%s': unknown argument ('slc ?' for help).\n", argv[1]); return (0); } if (Ambiguous(c)) { (void) fprintf(stderr, "'%s': ambiguous argument ('slc ?' for help).\n", argv[1]); return (0); } (*c->handler)(c->arg); slcstate(); return (1); } /* * The ENVIRON command. */ struct envlist { char *name; char *help; void (*handler)(); int narg; }; static struct env_lst *env_define(unsigned char *, unsigned char *); static void env_undefine(unsigned char *); static void env_export(unsigned char *); static void env_unexport(unsigned char *); static void env_send(unsigned char *); #if defined(OLD_ENVIRON) && defined(ENV_HACK) static void env_varval(unsigned char *); #endif static void env_list(void); static void env_help(void); static struct envlist EnvList[] = { { "define", "Define an environment variable", (void (*)())env_define, 2 }, { "undefine", "Undefine an environment variable", env_undefine, 1 }, { "export", "Mark an environment variable for automatic export", env_export, 1 }, { "unexport", "Don't mark an environment variable for automatic export", env_unexport, 1 }, { "send", "Send an environment variable", env_send, 1 }, { "list", "List the current environment variables", env_list, 0 }, #if defined(OLD_ENVIRON) && defined(ENV_HACK) { "varval", "Reverse VAR and VALUE (auto, right, wrong, status)", env_varval, 1 }, #endif { "help", 0, env_help, 0 }, { "?", "Print help information", env_help, 0 }, { 0 }, }; static void env_help() { struct envlist *c; for (c = EnvList; c->name; c++) { if (c->help) { if (*c->help) (void) printf("%-15s %s\n", c->name, c->help); else (void) printf("\n"); } } } static struct envlist * getenvcmd(name) char *name; { return ((struct envlist *) genget(name, (char **)EnvList, sizeof (struct envlist))); } static int env_cmd(argc, argv) int argc; char *argv[]; { struct envlist *c; if (argc < 2) { (void) fprintf(stderr, "Need an argument to 'environ' command. " "'environ ?' for help.\n"); return (0); } c = getenvcmd(argv[1]); if (c == 0) { (void) fprintf(stderr, "'%s': unknown argument " "('environ ?' for help).\n", argv[1]); return (0); } if (Ambiguous(c)) { (void) fprintf(stderr, "'%s': ambiguous argument " "('environ ?' for help).\n", argv[1]); return (0); } if (c->narg + 2 != argc) { (void) fprintf(stderr, "Need %s%d argument%s to 'environ %s' command. " "'environ ?' for help.\n", c->narg + 2 < argc ? "only " : "", c->narg, c->narg == 1 ? "" : "s", c->name); return (0); } (*c->handler)(argv[2], argv[3]); return (1); } struct env_lst { struct env_lst *next; /* pointer to next structure */ struct env_lst *prev; /* pointer to previous structure */ unsigned char *var; /* pointer to variable name */ unsigned char *value; /* pointer to variable value */ int export; /* 1 -> export with default list of variables */ int welldefined; /* A well defined variable */ }; static struct env_lst envlisthead; static struct env_lst * env_find(var) unsigned char *var; { register struct env_lst *ep; for (ep = envlisthead.next; ep; ep = ep->next) { if (strcmp((char *)ep->var, (char *)var) == 0) return (ep); } return (NULL); } int env_init() { #ifdef lint char **environ = NULL; #else /* lint */ extern char **environ; #endif /* lint */ char **epp, *cp; struct env_lst *ep; for (epp = environ; *epp; epp++) { if (cp = strchr(*epp, '=')) { *cp = '\0'; ep = env_define((unsigned char *)*epp, (unsigned char *)cp+1); if (ep == NULL) return (0); ep->export = 0; *cp = '='; } } /* * Special case for DISPLAY variable. If it is ":0.0" or * "unix:0.0", we have to get rid of "unix" and insert our * hostname. */ if (((ep = env_find((uchar_t *)"DISPLAY")) != NULL) && ((*ep->value == ':') || (strncmp((char *)ep->value, "unix:", 5) == 0))) { char hbuf[MAXHOSTNAMELEN]; char *cp2 = strchr((char *)ep->value, ':'); if (gethostname(hbuf, MAXHOSTNAMELEN) == -1) { perror("telnet: cannot get hostname"); return (0); } hbuf[MAXHOSTNAMELEN-1] = '\0'; cp = malloc(strlen(hbuf) + strlen(cp2) + 1); if (cp == NULL) { perror("telnet: cannot define DISPLAY variable"); return (0); } (void) sprintf((char *)cp, "%s%s", hbuf, cp2); free(ep->value); ep->value = (unsigned char *)cp; } /* * If LOGNAME is defined, but USER is not, then add * USER with the value from LOGNAME. We do this because the "accepted * practice" is to always pass USER on the wire, but SVR4 uses * LOGNAME by default. */ if ((ep = env_find((uchar_t *)"LOGNAME")) != NULL && env_find((uchar_t *)"USER") == NULL) { if (env_define((unsigned char *)"USER", ep->value) != NULL) env_unexport((unsigned char *)"USER"); } env_export((unsigned char *)"DISPLAY"); env_export((unsigned char *)"PRINTER"); return (1); } static struct env_lst * env_define(var, value) unsigned char *var, *value; { unsigned char *tmp_value; unsigned char *tmp_var; struct env_lst *ep; /* * Allocate copies of arguments first, to make cleanup easier * in the case of allocation errors. */ tmp_var = (unsigned char *)strdup((char *)var); if (tmp_var == NULL) { perror("telnet: can't copy environment variable name"); return (NULL); } tmp_value = (unsigned char *)strdup((char *)value); if (tmp_value == NULL) { free(tmp_var); perror("telnet: can't copy environment variable value"); return (NULL); } if (ep = env_find(var)) { if (ep->var) free(ep->var); if (ep->value) free(ep->value); } else { ep = malloc(sizeof (struct env_lst)); if (ep == NULL) { perror("telnet: can't define environment variable"); free(tmp_var); free(tmp_value); return (NULL); } ep->next = envlisthead.next; envlisthead.next = ep; ep->prev = &envlisthead; if (ep->next) ep->next->prev = ep; } ep->welldefined = opt_welldefined((char *)var); ep->export = 1; ep->var = tmp_var; ep->value = tmp_value; return (ep); } static void env_undefine(var) unsigned char *var; { register struct env_lst *ep; if (ep = env_find(var)) { ep->prev->next = ep->next; if (ep->next) ep->next->prev = ep->prev; if (ep->var) free(ep->var); if (ep->value) free(ep->value); free(ep); } } static void env_export(var) unsigned char *var; { register struct env_lst *ep; if (ep = env_find(var)) ep->export = 1; } static void env_unexport(var) unsigned char *var; { register struct env_lst *ep; if (ep = env_find(var)) ep->export = 0; } static void env_send(var) unsigned char *var; { register struct env_lst *ep; if (my_state_is_wont(TELOPT_NEW_ENVIRON) #ifdef OLD_ENVIRON /* old style */ && my_state_is_wont(TELOPT_OLD_ENVIRON) #endif /* no environ */) { (void) fprintf(stderr, "Cannot send '%s': Telnet ENVIRON option not enabled\n", var); return; } ep = env_find(var); if (ep == 0) { (void) fprintf(stderr, "Cannot send '%s': variable not defined\n", var); return; } env_opt_start_info(); env_opt_add(ep->var); env_opt_end(0); } static void env_list() { register struct env_lst *ep; for (ep = envlisthead.next; ep; ep = ep->next) { (void) printf("%c %-20s %s\n", ep->export ? '*' : ' ', ep->var, ep->value); } } unsigned char * env_default(init, welldefined) int init; { static struct env_lst *nep = NULL; if (init) { /* return value is not used */ nep = &envlisthead; return (NULL); } if (nep) { while ((nep = nep->next) != NULL) { if (nep->export && (nep->welldefined == welldefined)) return (nep->var); } } return (NULL); } unsigned char * env_getvalue(var) unsigned char *var; { register struct env_lst *ep; if (ep = env_find(var)) return (ep->value); return (NULL); } #if defined(OLD_ENVIRON) && defined(ENV_HACK) static void env_varval(what) unsigned char *what; { extern int old_env_var, old_env_value, env_auto; int len = strlen((char *)what); if (len == 0) goto unknown; if (strncasecmp((char *)what, "status", len) == 0) { if (env_auto) (void) printf("%s%s", "VAR and VALUE are/will be ", "determined automatically\n"); if (old_env_var == OLD_ENV_VAR) (void) printf( "VAR and VALUE set to correct definitions\n"); else (void) printf( "VAR and VALUE definitions are reversed\n"); } else if (strncasecmp((char *)what, "auto", len) == 0) { env_auto = 1; old_env_var = OLD_ENV_VALUE; old_env_value = OLD_ENV_VAR; } else if (strncasecmp((char *)what, "right", len) == 0) { env_auto = 0; old_env_var = OLD_ENV_VAR; old_env_value = OLD_ENV_VALUE; } else if (strncasecmp((char *)what, "wrong", len) == 0) { env_auto = 0; old_env_var = OLD_ENV_VALUE; old_env_value = OLD_ENV_VAR; } else { unknown: (void) printf( "Unknown \"varval\" command. (\"auto\", \"right\", " "\"wrong\", \"status\")\n"); } } #endif /* OLD_ENVIRON && ENV_HACK */ /* * The AUTHENTICATE command. */ struct authlist { char *name; char *help; int (*handler)(); int narg; }; extern int auth_enable(char *); extern int auth_disable(char *); extern int auth_status(void); static int auth_help(void); static struct authlist AuthList[] = { { "status", "Display current status of authentication information", auth_status, 0 }, { "disable", "Disable an authentication type ('auth disable ?' for more)", auth_disable, 1 }, { "enable", "Enable an authentication type ('auth enable ?' for more)", auth_enable, 1 }, { "help", 0, auth_help, 0 }, { "?", "Print help information", auth_help, 0 }, { 0 }, }; static int auth_help(void) { struct authlist *c; for (c = AuthList; c->name; c++) { if (c->help) { if (*c->help) (void) printf("%-15s %s\n", c->name, c->help); else (void) printf("\n"); } } return (0); } static int auth_cmd(argc, argv) int argc; char *argv[]; { struct authlist *c; if (argc < 2) { (void) fprintf(stderr, "Need an argument to 'auth' " "command. 'auth ?' for help.\n"); return (0); } c = (struct authlist *) genget(argv[1], (char **)AuthList, sizeof (struct authlist)); if (c == 0) { (void) fprintf(stderr, "'%s': unknown argument ('auth ?' for help).\n", argv[1]); return (0); } if (Ambiguous(c)) { (void) fprintf(stderr, "'%s': ambiguous argument ('auth ?' for help).\n", argv[1]); return (0); } if (c->narg + 2 != argc) { (void) fprintf(stderr, "Need %s%d argument%s to 'auth %s' command." " 'auth ?' for help.\n", c->narg + 2 < argc ? "only " : "", c->narg, c->narg == 1 ? "" : "s", c->name); return (0); } return ((*c->handler)(argv[2], argv[3])); } /* * The FORWARD command. */ extern int forward_flags; struct forwlist { char *name; char *help; int (*handler)(); int f_flags; }; static int forw_status(void); static int forw_set(int); static int forw_help(void); static struct forwlist ForwList[] = { {"status", "Display current status of credential forwarding", forw_status, 0}, {"disable", "Disable credential forwarding", forw_set, 0}, {"enable", "Enable credential forwarding", forw_set, OPTS_FORWARD_CREDS}, {"forwardable", "Enable credential forwarding of " "forwardable credentials", forw_set, OPTS_FORWARD_CREDS | OPTS_FORWARDABLE_CREDS}, {"help", 0, forw_help, 0}, {"?", "Print help information", forw_help, 0}, {0}, }; static int forw_status(void) { if (forward_flags & OPTS_FORWARD_CREDS) { if (forward_flags & OPTS_FORWARDABLE_CREDS) (void) printf(gettext( "Credential forwarding of " "forwardable credentials enabled\n")); else (void) printf(gettext( "Credential forwarding enabled\n")); } else (void) printf(gettext("Credential forwarding disabled\n")); return (0); } static int forw_set(int f_flags) { forward_flags = f_flags; return (0); } static int forw_help(void) { struct forwlist *c; for (c = ForwList; c->name; c++) { if (c->help) { if (*c->help) (void) printf("%-15s %s\r\n", c->name, c->help); else (void) printf("\n"); } } return (0); } static int forw_cmd(int argc, char *argv[]) { struct forwlist *c; if (argc < 2) { (void) fprintf(stderr, gettext( "Need an argument to 'forward' " "command. 'forward ?' for help.\n")); return (0); } c = (struct forwlist *)genget(argv[1], (char **)ForwList, sizeof (struct forwlist)); if (c == 0) { (void) fprintf(stderr, gettext( "'%s': unknown argument ('forward ?' for help).\n"), argv[1]); return (0); } if (Ambiguous(c)) { (void) fprintf(stderr, gettext( "'%s': ambiguous argument ('forward ?' for help).\n"), argv[1]); return (0); } if (argc != 2) { (void) fprintf(stderr, gettext( "No arguments needed to 'forward %s' command. " "'forward ?' for help.\n"), c->name); return (0); } return ((*c->handler) (c->f_flags)); } /* * The ENCRYPT command. */ struct encryptlist { char *name; char *help; int (*handler)(); int needconnect; int minarg; int maxarg; }; static int EncryptHelp(void); static struct encryptlist EncryptList[] = { { "enable", "Enable encryption. ('encrypt enable ?' for more)", EncryptEnable, 1, 1, 2 }, { "disable", "Disable encryption. ('encrypt disable ?' for more)", EncryptDisable, 0, 1, 2 }, { "type", "Set encryption type. ('encrypt type ?' for more)", EncryptType, 0, 1, 2 }, { "start", "Start encryption. ('encrypt start ?' for more)", EncryptStart, 1, 0, 1 }, { "stop", "Stop encryption. ('encrypt stop ?' for more)", EncryptStop, 1, 0, 1 }, { "input", "Start encrypting the input stream", EncryptStartInput, 1, 0, 0 }, { "-input", "Stop encrypting the input stream", EncryptStopInput, 1, 0, 0 }, { "output", "Start encrypting the output stream", EncryptStartOutput, 1, 0, 0 }, { "-output", "Stop encrypting the output stream", EncryptStopOutput, 1, 0, 0 }, { "status", "Display current status of encryption information", EncryptStatus, 0, 0, 0 }, { "help", 0, EncryptHelp, 0, 0, 0 }, { "?", "Print help information", EncryptHelp, 0, 0, 0 }, { 0 }, }; static int EncryptHelp(void) { struct encryptlist *c; for (c = EncryptList; c->name; c++) { if (c->help) { if (*c->help) (void) printf("%-15s %s\n", c->name, c->help); else (void) printf("\n"); } } return (0); } static int encrypt_cmd(int argc, char *argv[]) { struct encryptlist *c; if (argc < 2) { (void) fprintf(stderr, gettext( "Need an argument to 'encrypt' command. " "'encrypt ?' for help.\n")); return (0); } c = (struct encryptlist *) genget(argv[1], (char **)EncryptList, sizeof (struct encryptlist)); if (c == 0) { (void) fprintf(stderr, gettext( "'%s': unknown argument ('encrypt ?' for help).\n"), argv[1]); return (0); } if (Ambiguous(c)) { (void) fprintf(stderr, gettext( "'%s': ambiguous argument ('encrypt ?' for help).\n"), argv[1]); return (0); } argc -= 2; if (argc < c->minarg || argc > c->maxarg) { if (c->minarg == c->maxarg) { (void) fprintf(stderr, gettext("Need %s%d %s "), c->minarg < argc ? gettext("only ") : "", c->minarg, c->minarg == 1 ? gettext("argument") : gettext("arguments")); } else { (void) fprintf(stderr, gettext("Need %s%d-%d arguments "), c->maxarg < argc ? gettext("only ") : "", c->minarg, c->maxarg); } (void) fprintf(stderr, gettext( "to 'encrypt %s' command. 'encrypt ?' for help.\n"), c->name); return (0); } if (c->needconnect && !connected) { if (!(argc && (isprefix(argv[2], "help") || isprefix(argv[2], "?")))) { (void) printf( gettext("?Need to be connected first.\n")); return (0); } } return ((*c->handler)(argc > 0 ? argv[2] : 0, argc > 1 ? argv[3] : 0, argc > 2 ? argv[4] : 0)); } /* * Print status about the connection. */ static int status(int argc, char *argv[]) { if (connected) { (void) printf("Connected to %s.\n", hostname); if ((argc < 2) || strcmp(argv[1], "notmuch")) { int mode = getconnmode(); if (my_want_state_is_will(TELOPT_LINEMODE)) { (void) printf( "Operating with LINEMODE option\n"); (void) printf( "%s line editing\n", (mode&MODE_EDIT) ? "Local" : "No"); (void) printf("%s catching of signals\n", (mode&MODE_TRAPSIG) ? "Local" : "No"); slcstate(); #ifdef KLUDGELINEMODE } else if (kludgelinemode && my_want_state_is_dont(TELOPT_SGA)) { (void) printf( "Operating in obsolete linemode\n"); #endif } else { (void) printf( "Operating in single character mode\n"); if (localchars) (void) printf( "Catching signals locally\n"); } (void) printf("%s character echo\n", (mode&MODE_ECHO) ? "Local" : "Remote"); if (my_want_state_is_will(TELOPT_LFLOW)) (void) printf("%s flow control\n", (mode&MODE_FLOW) ? "Local" : "No"); encrypt_display(); } } else { (void) printf("No connection.\n"); } if (rlogin != _POSIX_VDISABLE) (void) printf("Escape character is '%s'.\n", control(rlogin)); else (void) printf( "Escape character is '%s'.\n", esc_control(escape)); (void) fflush(stdout); return (1); } /* * Parse the user input (cmd_line_input) which should: * - start with the target host, or with "@" or "!@" followed by at least one * gateway. * - each host (can be literal address or hostname) can be separated by ",", * "@", or ",@". * Note that the last host is the target, all the others (if any ) are the * gateways. * * Returns: -1 if a library call fails, too many gateways, or parse * error * num_gw otherwise * On successful return, hostname_list points to a list of hosts (last one being * the target, others gateways), src_rtng_type points to the type of source * routing (strict vs. loose) */ static int parse_input(char *cmd_line_input, char **hostname_list, uchar_t *src_rtng_type) { char hname[MAXHOSTNAMELEN + 1]; char *cp; int gw_count; int i; gw_count = 0; cp = cmd_line_input; /* * Defining ICMD generates the Itelnet binary, the special version of * telnet which is used with firewall proxy. * If ICMD is defined, parse_input will treat the whole cmd_line_input * as the target host and set the num_gw to 0. Therefore, none of the * source routing related code paths will be executed. */ #ifndef ICMD if (*cp == '@') { *src_rtng_type = IPOPT_LSRR; cp++; } else if (*cp == '!') { *src_rtng_type = IPOPT_SSRR; /* "!" must be followed by '@' */ if (*(cp + 1) != '@') goto parse_error; cp += 2; } else { #endif /* ICMD */ /* no gateways, just the target */ hostname_list[0] = strdup(cp); if (hostname_list[0] == NULL) { perror("telnet: copying host name"); return (-1); } return (0); #ifndef ICMD } while (*cp != '\0') { /* * Identify each gateway separated by ",", "@" or ",@" and * store in hname[]. */ i = 0; while (*cp != '@' && *cp != ',' && *cp != '\0') { hname[i++] = *cp++; if (i > MAXHOSTNAMELEN) goto parse_error; } hname[i] = '\0'; /* * Two consecutive delimiters which result in a 0 length hname * is a parse error. */ if (i == 0) goto parse_error; hostname_list[gw_count] = strdup(hname); if (hostname_list[gw_count] == NULL) { perror("telnet: copying hostname from list"); return (-1); } if (++gw_count > MAXMAX_GATEWAY) { (void) fprintf(stderr, "telnet: too many gateways\n"); return (-1); } /* Jump over the next delimiter. */ if (*cp != '\0') { /* ...gw1,@gw2... accepted */ if (*cp == ',' && *(cp + 1) == '@') cp += 2; else cp++; } } /* discount the target */ gw_count--; /* Any input starting with '!@' or '@' must have at least one gateway */ if (gw_count <= 0) goto parse_error; return (gw_count); parse_error: (void) printf("Bad source route option: %s\n", cmd_line_input); return (-1); #endif /* ICMD */ } /* * Resolves the target and gateway addresses, determines what type of addresses * (ALL_ADDRS, ONLY_V6, ONLY_V4) telnet will be trying to connect. * * Returns: pointer to resolved target if name resolutions succeed * NULL if name resolutions fail or * a library function call fails * * The last host in the hostname_list is the target. After resolving the target, * determines for what type of addresses it should try to resolve gateways. It * resolves gateway addresses and picks one address for each desired address * type and stores in the array pointed by gw_addrsp. Also, this 'type of * addresses' is pointed by addr_type argument on successful return. */ static struct addrinfo * resolve_hosts(char **hostname_list, int num_gw, struct gateway **gw_addrsp, int *addr_type, const char *portp) { struct gateway *gw_addrs = NULL; struct gateway *gw; /* whether we already picked an IPv4 address for the current gateway */ boolean_t got_v4_addr; boolean_t got_v6_addr; /* whether we need to get an IPv4 address for the current gateway */ boolean_t need_v4_addr = B_FALSE; boolean_t need_v6_addr = B_FALSE; int res_failed_at4; /* save which gateway failed to resolve */ int res_failed_at6; boolean_t is_v4mapped; struct in6_addr *v6addrp; struct in_addr *v4addrp; int error_num; int i; int rc; struct addrinfo *res, *host, *gateway, *addr; struct addrinfo hints; *addr_type = ALL_ADDRS; memset(&hints, 0, sizeof (hints)); hints.ai_flags = AI_CANONNAME; /* used for config files, diags */ hints.ai_socktype = SOCK_STREAM; rc = getaddrinfo(hostname_list[num_gw], (portp != NULL) ? portp : "telnet", &hints, &res); if (rc != 0) { if (hostname_list[num_gw] != NULL && *hostname_list[num_gw] != '\0') (void) fprintf(stderr, "%s: ", hostname_list[num_gw]); (void) fprintf(stderr, "%s\n", gai_strerror(rc)); return (NULL); } /* * Let's see what type of addresses we got for the target. This * determines what type of addresses we'd like to resolve gateways * later. */ for (host = res; host != NULL; host = host->ai_next) { struct sockaddr_in6 *s6; s6 = (struct sockaddr_in6 *)host->ai_addr; if (host->ai_addr->sa_family == AF_INET || IN6_IS_ADDR_V4MAPPED(&s6->sin6_addr)) need_v4_addr = B_TRUE; else need_v6_addr = B_TRUE; /* * Let's stop after seeing we need both IPv6 and IPv4. */ if (need_v4_addr && need_v6_addr) break; } if (num_gw > 0) { /* * In the prepare_optbuf(), we'll store the IPv4 address of the * target in the last slot of gw_addrs array. Therefore we need * space for num_gw+1 hosts. */ gw_addrs = calloc(num_gw + 1, sizeof (struct gateway)); if (gw_addrs == NULL) { perror("telnet: calloc"); freeaddrinfo(res); return (NULL); } } /* * Now we'll go through all the gateways and try to resolve them to * the desired address types. */ gw = gw_addrs; /* -1 means 'no address resolution failure yet' */ res_failed_at4 = -1; res_failed_at6 = -1; for (i = 0; i < num_gw; i++) { rc = getaddrinfo(hostname_list[i], NULL, NULL, &gateway); if (rc != 0) { if (hostname_list[i] != NULL && *hostname_list[i] != '\0') (void) fprintf(stderr, "%s: ", hostname_list[i]); (void) fprintf(stderr, "bad address\n"); return (NULL); } /* * Initially we have no address of any type for this gateway. */ got_v6_addr = B_FALSE; got_v4_addr = B_FALSE; /* * Let's go through all the addresses of this gateway. * Use the first address which matches the needed family. */ for (addr = gateway; addr != NULL; addr = addr->ai_next) { /*LINTED*/ v6addrp = &((struct sockaddr_in6 *)addr->ai_addr)-> sin6_addr; v4addrp = &((struct sockaddr_in *)addr->ai_addr)-> sin_addr; if (addr->ai_family == AF_INET6) is_v4mapped = IN6_IS_ADDR_V4MAPPED(v6addrp); else is_v4mapped = B_FALSE; /* * If we need to determine an IPv4 address and haven't * found one yet and this is a IPv4-mapped IPv6 address, * then bingo! */ if (need_v4_addr && !got_v4_addr) { if (is_v4mapped) { IN6_V4MAPPED_TO_INADDR(v6addrp, &gw->gw_addr); got_v4_addr = B_TRUE; } else if (addr->ai_family = AF_INET) { gw->gw_addr = *v4addrp; got_v4_addr = B_TRUE; } } if (need_v6_addr && !got_v6_addr && addr->ai_family == AF_INET6) { gw->gw_addr6 = *v6addrp; got_v6_addr = B_TRUE; } /* * Let's stop if we got all what we looked for. */ if ((!need_v4_addr || got_v4_addr) && (!need_v6_addr || got_v6_addr)) break; } /* * We needed an IPv4 address for this gateway but couldn't * find one. */ if (need_v4_addr && !got_v4_addr) { res_failed_at4 = i; /* * Since we couldn't resolve a gateway to IPv4 address * we can't use IPv4 at all. Therefore we no longer * need IPv4 addresses for any of the gateways. */ need_v4_addr = B_FALSE; } if (need_v6_addr && !got_v6_addr) { res_failed_at6 = i; need_v6_addr = B_FALSE; } /* * If some gateways don't resolve to any of the desired * address types, we fail. */ if (!need_v4_addr && !need_v6_addr) { if (res_failed_at6 != -1) { (void) fprintf(stderr, "%s: Host doesn't have any IPv6 address\n", hostname_list[res_failed_at6]); } if (res_failed_at4 != -1) { (void) fprintf(stderr, "%s: Host doesn't have any IPv4 address\n", hostname_list[res_failed_at4]); } free(gw_addrs); return (NULL); } gw++; } *gw_addrsp = gw_addrs; /* * When we get here, need_v4_addr and need_v6_addr have their final * values based on the name resolution of the target and gateways. */ if (need_v4_addr && need_v6_addr) *addr_type = ALL_ADDRS; else if (need_v4_addr && !need_v6_addr) *addr_type = ONLY_V4; else if (!need_v4_addr && need_v6_addr) *addr_type = ONLY_V6; return (res); } /* * Initializes the buffer pointed by opt_bufpp for a IPv4 option of type * src_rtng_type using the gateway addresses stored in gw_addrs. If no buffer * is passed, it allocates one. If a buffer is passed, checks if it's big * enough. * On return opt_buf_len points to the buffer length which we need later for the * setsockopt() call, and opt_bufpp points to the newly allocated or already * passed buffer. Returns B_FALSE if a library function call fails or passed * buffer is not big enough, B_TRUE otherwise. */ static boolean_t prepare_optbuf(struct gateway *gw_addrs, int num_gw, char **opt_bufpp, size_t *opt_buf_len, struct in_addr *target, uchar_t src_rtng_type) { struct ip_sourceroute *sr_opt; size_t needed_buflen; int i; /* * We have (num_gw + 1) IP addresses in the buffer because the number * of gateway addresses we put in the option buffer includes the target * address. * At the time of setsockopt() call, passed option length needs to be * multiple of 4 bytes. Therefore we need one IPOPT_NOP before (or * after) IPOPT_LSRR. * 1 = preceding 1 byte of IPOPT_NOP * 3 = 1 (code) + 1 (len) + 1 (ptr) */ needed_buflen = 1 + 3 + (num_gw + 1) * sizeof (struct in_addr); if (*opt_bufpp != NULL) { /* check if the passed buffer is big enough */ if (*opt_buf_len < needed_buflen) { (void) fprintf(stderr, "telnet: buffer too small for IPv4 source routing " "option\n"); return (B_FALSE); } } else { *opt_bufpp = malloc(needed_buflen); if (*opt_bufpp == NULL) { perror("telnet: malloc"); return (B_FALSE); } } *opt_buf_len = needed_buflen; /* final hop is the target */ gw_addrs[num_gw].gw_addr = *target; *opt_bufpp[0] = IPOPT_NOP; /* IPOPT_LSRR starts right after IPOPT_NOP */ sr_opt = (struct ip_sourceroute *)(*opt_bufpp + 1); sr_opt->ipsr_code = src_rtng_type; /* discount the 1 byte of IPOPT_NOP */ sr_opt->ipsr_len = needed_buflen - 1; sr_opt->ipsr_ptr = IPOPT_MINOFF; /* copy the gateways into the optlist */ for (i = 0; i < num_gw + 1; i++) { (void) bcopy(&gw_addrs[i].gw_addr, &sr_opt->ipsr_addrs[i], sizeof (struct in_addr)); } return (B_TRUE); } /* * Initializes the buffer pointed by opt_bufpp for a IPv6 routing header option * using the gateway addresses stored in gw_addrs. If no buffer is passed, it * allocates one. If a buffer is passed, checks if it's big enough. * On return opt_buf_len points to the buffer length which we need later for the * setsockopt() call, and opt_bufpp points to the newly allocated or already * passed buffer. Returns B_FALSE if a library function call fails or passed * buffer is not big enough, B_TRUE otherwise. */ static boolean_t prepare_optbuf6(struct gateway *gw_addrs, int num_gw, char **opt_bufpp, size_t *opt_buf_len) { char *opt_bufp; size_t needed_buflen; int i; needed_buflen = inet6_rth_space(IPV6_RTHDR_TYPE_0, num_gw); if (*opt_bufpp != NULL) { /* check if the passed buffer is big enough */ if (*opt_buf_len < needed_buflen) { (void) fprintf(stderr, "telnet: buffer too small for IPv6 routing " "header option\n"); return (B_FALSE); } } else { *opt_bufpp = malloc(needed_buflen); if (*opt_bufpp == NULL) { perror("telnet: malloc"); return (B_FALSE); } } *opt_buf_len = needed_buflen; opt_bufp = *opt_bufpp; /* * Initialize the buffer to be used for IPv6 routing header type 0. */ if (inet6_rth_init(opt_bufp, needed_buflen, IPV6_RTHDR_TYPE_0, num_gw) == NULL) { perror("telnet: inet6_rth_init"); return (B_FALSE); } /* * Add gateways one by one. */ for (i = 0; i < num_gw; i++) { if (inet6_rth_add(opt_bufp, &gw_addrs[i].gw_addr6) == -1) { perror("telnet: inet6_rth_add"); return (B_FALSE); } } /* successful operation */ return (B_TRUE); } int tn(argc, argv) int argc; char *argv[]; { struct addrinfo *host = NULL; struct addrinfo *h; struct sockaddr_in6 sin6; struct sockaddr_in sin; struct in6_addr addr6; struct in_addr addr; void *addrp; struct gateway *gw_addrs; char *hostname_list[MAXMAX_GATEWAY + 1] = {NULL}; char *opt_buf6 = NULL; /* used for IPv6 routing header */ size_t opt_buf_len6 = 0; uchar_t src_rtng_type; /* type of IPv4 source routing */ struct servent *sp = 0; char *opt_buf = NULL; /* used for IPv4 source routing */ size_t opt_buf_len = 0; char *cmd; char *hostp = NULL; char *portp = NULL; char *user = NULL; #ifdef ICMD char *itelnet_host; char *real_host; unsigned short dest_port; #endif /* ICMD */ /* * The two strings at the end of this function are 24 and 39 * characters long (minus the %.*s in the format strings). Add * one for the null terminator making the longest print string 40. */ char buf[MAXHOSTNAMELEN+40]; /* * In the case of ICMD defined, dest_port will contain the real port * we are trying to telnet to, and target_port will contain * "telnet-passthru" port. */ unsigned short target_port; char abuf[INET6_ADDRSTRLEN]; int num_gw; int ret_val; boolean_t is_v4mapped; /* * Type of addresses we'll try to connect to (ALL_ADDRS, ONLY_V6, * ONLY_V4). */ int addr_type; /* clear the socket address prior to use */ (void) memset(&sin6, '\0', sizeof (sin6)); sin6.sin6_family = AF_INET6; (void) memset(&sin, '\0', sizeof (sin)); sin.sin_family = AF_INET; if (connected) { (void) printf("?Already connected to %s\n", hostname); return (0); } #ifdef ICMD itelnet_host = getenv("INTERNET_HOST"); if (itelnet_host == NULL || itelnet_host[0] == '\0') { (void) printf("INTERNET_HOST environment variable undefined\n"); goto tn_exit; } #endif if (argc < 2) { (void) printf("(to) "); if (GetAndAppendString(&line, &linesize, "open ", stdin) == NULL) { if (!feof(stdin)) { perror("telnet"); goto tn_exit; } } makeargv(); argc = margc; argv = margv; } cmd = *argv; --argc; ++argv; while (argc) { if (isprefix(*argv, "help") == 4 || isprefix(*argv, "?") == 1) goto usage; if (strcmp(*argv, "-l") == 0) { --argc; ++argv; if (argc == 0) goto usage; user = *argv++; --argc; continue; } if (strcmp(*argv, "-a") == 0) { --argc; ++argv; autologin = autologin_set = 1; continue; } if (hostp == 0) { hostp = *argv++; --argc; continue; } if (portp == 0) { portp = *argv++; --argc; /* * Do we treat this like a telnet port or raw? */ if (*portp == '-') { portp++; telnetport = 1; } else telnetport = 0; continue; } usage: (void) printf( "usage: %s [-l user] [-a] host-name [port]\n", cmd); goto tn_exit; } if (hostp == 0) goto usage; #ifdef ICMD /* * For setup phase treat the relay host as the target host. */ real_host = hostp; hostp = itelnet_host; #endif num_gw = parse_input(hostp, hostname_list, &src_rtng_type); if (num_gw < 0) { goto tn_exit; } /* Last host in the hostname_list is the target */ hostp = hostname_list[num_gw]; host = resolve_hosts(hostname_list, num_gw, &gw_addrs, &addr_type, portp); if (host == NULL) { goto tn_exit; } /* * Check if number of gateways is less than max. available */ if ((addr_type == ALL_ADDRS || addr_type == ONLY_V6) && num_gw > MAX_GATEWAY6) { (void) fprintf(stderr, "telnet: too many IPv6 gateways\n"); goto tn_exit; } if ((addr_type == ALL_ADDRS || addr_type == ONLY_V4) && num_gw > MAX_GATEWAY) { (void) fprintf(stderr, "telnet: too many IPv4 gateways\n"); goto tn_exit; } /* * If we pass a literal IPv4 address to getaddrinfo(), in the * returned addrinfo structure, hostname is the IPv4-mapped IPv6 * address string. We prefer to preserve the literal IPv4 address * string as the hostname. Also, if the hostname entered by the * user is IPv4-mapped IPv6 address, we'll downgrade it to IPv4 * address. */ if (inet_addr(hostp) != (in_addr_t)-1) { /* this is a literal IPv4 address */ (void) strlcpy(_hostname, hostp, sizeof (_hostname)); } else if ((inet_pton(AF_INET6, hostp, &addr6) > 0) && IN6_IS_ADDR_V4MAPPED(&addr6)) { /* this is a IPv4-mapped IPv6 address */ IN6_V4MAPPED_TO_INADDR(&addr6, &addr); (void) inet_ntop(AF_INET, &addr, _hostname, sizeof (_hostname)); } else { (void) strlcpy(_hostname, host->ai_canonname, sizeof (_hostname)); } hostname = _hostname; if (portp == NULL) { telnetport = 1; } if (host->ai_family == AF_INET) { target_port = ((struct sockaddr_in *)(host->ai_addr))->sin_port; } else { target_port = ((struct sockaddr_in6 *)(host->ai_addr)) ->sin6_port; } #ifdef ICMD /* * Since we pass the port number as an ascii string to the proxy, * we need it in host format. */ dest_port = ntohs(target_port); sp = getservbyname("telnet-passthru", "tcp"); if (sp == 0) { (void) fprintf(stderr, "telnet: tcp/telnet-passthru: unknown service\n"); goto tn_exit; } target_port = sp->s_port; #endif h = host; /* * For IPv6 source routing, we need to initialize option buffer only * once. */ if (num_gw > 0 && (addr_type == ALL_ADDRS || addr_type == ONLY_V6)) { if (!prepare_optbuf6(gw_addrs, num_gw, &opt_buf6, &opt_buf_len6)) { goto tn_exit; } } /* * We procure the Kerberos config files options only * if the user has choosen Krb5 authentication. */ if (krb5auth_flag > 0) { krb5_profile_get_options(hostname, telnet_krb5_realm, config_file_options); } if (encrypt_flag) { extern boolean_t auth_enable_encrypt; if (krb5_privacy_allowed()) { encrypt_auto(1); decrypt_auto(1); wantencryption = B_TRUE; autologin = 1; auth_enable_encrypt = B_TRUE; } else { (void) fprintf(stderr, gettext( "%s:Encryption not supported.\n"), prompt); exit(1); } } if (forward_flag && forwardable_flag) { (void) fprintf(stderr, gettext( "Error in krb5 configuration file. " "Both forward and forwardable are set.\n")); exit(1); } if (forwardable_flag) { forward_flags |= OPTS_FORWARD_CREDS | OPTS_FORWARDABLE_CREDS; } else if (forward_flag) forward_flags |= OPTS_FORWARD_CREDS; do { /* * Search for an address of desired type in the IP address list * of the target. */ while (h != NULL) { struct sockaddr_in6 *addr; addr = (struct sockaddr_in6 *)h->ai_addr; if (h->ai_family == AF_INET6) is_v4mapped = IN6_IS_ADDR_V4MAPPED(&addr->sin6_addr); else is_v4mapped = B_FALSE; if (addr_type == ALL_ADDRS || (addr_type == ONLY_V6 && h->ai_family == AF_INET6) || (addr_type == ONLY_V4 && (h->ai_family == AF_INET || is_v4mapped))) break; /* skip undesired typed addresses */ h = h->ai_next; } if (h == NULL) { fprintf(stderr, "telnet: Unable to connect to remote host"); goto tn_exit; } /* * We need to open a socket with a family matching the type of * address we are trying to connect to. This is because we * deal with IPv4 options and IPv6 extension headers. */ if (h->ai_family == AF_INET) { addrp = &((struct sockaddr_in *)(h->ai_addr))->sin_addr; ((struct sockaddr_in *)(h->ai_addr))->sin_port = target_port; } else { addrp = &((struct sockaddr_in6 *)(h->ai_addr)) ->sin6_addr; ((struct sockaddr_in6 *)(h->ai_addr))->sin6_port = target_port; } (void) printf("Trying %s...\n", inet_ntop(h->ai_family, addrp, abuf, sizeof (abuf))); net = socket(h->ai_family, SOCK_STREAM, 0); if (net < 0) { perror("telnet: socket"); goto tn_exit; } #ifndef ICMD if (num_gw > 0) { if (h->ai_family == AF_INET || is_v4mapped) { if (!prepare_optbuf(gw_addrs, num_gw, &opt_buf, &opt_buf_len, addrp, src_rtng_type)) { goto tn_exit; } if (setsockopt(net, IPPROTO_IP, IP_OPTIONS, opt_buf, opt_buf_len) < 0) perror("setsockopt (IP_OPTIONS)"); } else { if (setsockopt(net, IPPROTO_IPV6, IPV6_RTHDR, opt_buf6, opt_buf_len6) < 0) perror("setsockopt (IPV6_RTHDR)"); } } #endif #if defined(USE_TOS) if (is_v4mapped) { if (tos < 0) tos = 020; /* Low Delay bit */ if (tos && (setsockopt(net, IPPROTO_IP, IP_TOS, &tos, sizeof (int)) < 0) && (errno != ENOPROTOOPT)) perror("telnet: setsockopt (IP_TOS) (ignored)"); } #endif /* defined(USE_TOS) */ if (debug && SetSockOpt(net, SOL_SOCKET, SO_DEBUG, 1) < 0) { perror("setsockopt (SO_DEBUG)"); } ret_val = connect(net, h->ai_addr, h->ai_addrlen); /* * If failed, try the next address of the target. */ if (ret_val < 0) { Close(&net); if (h->ai_next != NULL) { int oerrno = errno; (void) fprintf(stderr, "telnet: connect to address %s: ", abuf); errno = oerrno; perror((char *)0); h = h->ai_next; continue; } perror("telnet: Unable to connect to remote host"); goto tn_exit; } connected++; } while (connected == 0); freeaddrinfo(host); host = NULL; #ifdef ICMD /* * Do initial protocol to connect to farther end... */ { char buf[1024]; (void) sprintf(buf, "%s %d\n", real_host, (int)dest_port); write(net, buf, strlen(buf)); } #endif if (cmdrc(hostp, hostname) != 0) goto tn_exit; FreeHostnameList(hostname_list); if (autologin && user == NULL) { struct passwd *pw; user = getenv("LOGNAME"); if (user == NULL || ((pw = getpwnam(user)) != NULL) && pw->pw_uid != getuid()) { if (pw = getpwuid(getuid())) user = pw->pw_name; else user = NULL; } } if (user) { if (env_define((unsigned char *)"USER", (unsigned char *)user)) env_export((unsigned char *)"USER"); else { /* Clean up and exit. */ Close(&net); (void) snprintf(buf, sizeof (buf), "Connection to %.*s closed.\n", MAXHOSTNAMELEN, hostname); ExitString(buf, EXIT_FAILURE); /* NOTREACHED */ } } (void) call(3, status, "status", "notmuch"); if (setjmp(peerdied) == 0) telnet(user); Close(&net); (void) snprintf(buf, sizeof (buf), "Connection to %.*s closed by foreign host.\n", MAXHOSTNAMELEN, hostname); ExitString(buf, EXIT_FAILURE); /*NOTREACHED*/ tn_exit: FreeHostnameList(hostname_list); Close(&net); connected = 0; if (host != NULL) freeaddrinfo(host); return (0); } #define HELPINDENT (sizeof ("connect")) static char openhelp[] = "connect to a site"; static char closehelp[] = "close current connection"; static char logouthelp[] = "forcibly logout remote user and close the connection"; static char quithelp[] = "exit telnet"; static char statushelp[] = "print status information"; static char helphelp[] = "print help information"; static char sendhelp[] = "transmit special characters ('send ?' for more)"; static char sethelp[] = "set operating parameters ('set ?' for more)"; static char unsethelp[] = "unset operating parameters ('unset ?' for more)"; static char togglestring[] = "toggle operating parameters ('toggle ?' for more)"; static char slchelp[] = "change state of special charaters ('slc ?' for more)"; static char displayhelp[] = "display operating parameters"; static char authhelp[] = "turn on (off) authentication ('auth ?' for more)"; static char forwardhelp[] = "turn on (off) credential forwarding ('forward ?' for more)"; static char encrypthelp[] = "turn on (off) encryption ('encrypt ?' for more)"; static char zhelp[] = "suspend telnet"; static char shellhelp[] = "invoke a subshell"; static char envhelp[] = "change environment variables ('environ ?' for more)"; static char modestring[] = "try to enter line or character mode ('mode ?' for more)"; static int help(); static Command cmdtab[] = { { "close", closehelp, bye, 1 }, { "logout", logouthelp, logout, 1 }, { "display", displayhelp, display, 0 }, { "mode", modestring, modecmd, 0 }, { "open", openhelp, tn, 0 }, { "quit", quithelp, quit, 0 }, { "send", sendhelp, sendcmd, 0 }, { "set", sethelp, setcmd, 0 }, { "unset", unsethelp, unsetcmd, 0 }, { "status", statushelp, status, 0 }, { "toggle", togglestring, toggle, 0 }, { "slc", slchelp, slccmd, 0 }, { "auth", authhelp, auth_cmd, 0 }, { "encrypt", encrypthelp, encrypt_cmd, 0 }, { "forward", forwardhelp, forw_cmd, 0 }, { "z", zhelp, suspend, 0 }, { "!", shellhelp, shell, 0 }, { "environ", envhelp, env_cmd, 0 }, { "?", helphelp, help, 0 }, 0 }; static Command cmdtab2[] = { { "help", 0, help, 0 }, { "escape", 0, setescape, 0 }, { "crmod", 0, togcrmod, 0 }, 0 }; /* * Call routine with argc, argv set from args. * Uses /usr/include/stdarg.h */ #define MAXVARGS 100 /*VARARGS1*/ static void call(int n_ptrs, ...) { va_list ap; typedef int (*intrtn_t)(); intrtn_t routine; char *args[MAXVARGS+1]; /* leave 1 for trailing NULL */ int argno = 0; if (n_ptrs > MAXVARGS) n_ptrs = MAXVARGS; va_start(ap, n_ptrs); routine = (va_arg(ap, intrtn_t)); /* extract the routine's name */ n_ptrs--; while (argno < n_ptrs) /* extract the routine's args */ args[argno++] = va_arg(ap, char *); args[argno] = NULL; /* NULL terminate for good luck */ va_end(ap); (*routine)(argno, args); } static Command * getcmd(name) char *name; { Command *cm; if (cm = (Command *) genget(name, (char **)cmdtab, sizeof (Command))) return (cm); return (Command *) genget(name, (char **)cmdtab2, sizeof (Command)); } void command(top, tbuf, cnt) int top; char *tbuf; int cnt; { Command *c; setcommandmode(); if (!top) { (void) putchar('\n'); } else { (void) signal(SIGINT, SIG_DFL); (void) signal(SIGQUIT, SIG_DFL); } for (;;) { if (rlogin == _POSIX_VDISABLE) (void) printf("%s> ", prompt); if (tbuf) { char *cp; if (AllocStringBuffer(&line, &linesize, cnt) == NULL) goto command_exit; cp = line; while (cnt > 0 && (*cp++ = *tbuf++) != '\n') cnt--; tbuf = 0; if (cp == line || *--cp != '\n' || cp == line) goto getline; *cp = '\0'; if (rlogin == _POSIX_VDISABLE) (void) printf("%s\n", line); } else { getline: if (rlogin != _POSIX_VDISABLE) (void) printf("%s> ", prompt); if (GetString(&line, &linesize, stdin) == NULL) { if (!feof(stdin)) perror("telnet"); (void) quit(); /*NOTREACHED*/ break; } } if (line[0] == 0) break; makeargv(); if (margv[0] == 0) { break; } c = getcmd(margv[0]); if (Ambiguous(c)) { (void) printf("?Ambiguous command\n"); continue; } if (c == 0) { (void) printf("?Invalid command\n"); continue; } if (c->needconnect && !connected) { (void) printf("?Need to be connected first.\n"); continue; } if ((*c->handler)(margc, margv)) { break; } } command_exit: if (!top) { if (!connected) { longjmp(toplevel, 1); /*NOTREACHED*/ } setconnmode(0); } } /* * Help command. */ static int help(argc, argv) int argc; char *argv[]; { register Command *c; if (argc == 1) { (void) printf( "Commands may be abbreviated. Commands are:\n\n"); for (c = cmdtab; c->name; c++) if (c->help) { (void) printf("%-*s\t%s\n", HELPINDENT, c->name, c->help); } (void) printf("\tleave command mode\n"); return (0); } while (--argc > 0) { register char *arg; arg = *++argv; c = getcmd(arg); if (Ambiguous(c)) (void) printf("?Ambiguous help command %s\n", arg); else if (c == (Command *)0) (void) printf("?Invalid help command %s\n", arg); else if (c->help) { (void) printf("%s\n", c->help); } else { (void) printf("No additional help on %s\n", arg); } } return (0); } static char *rcname = NULL; #define TELNETRC_NAME "telnetrc" #define TELNETRC_COMP "/." TELNETRC_NAME static int cmdrc(char *m1, char *m2) { Command *c; FILE *rcfile = NULL; int gotmachine = 0; int l1 = strlen(m1); int l2 = strlen(m2); char m1save[MAXHOSTNAMELEN]; int ret = 0; char def[] = "DEFAULT"; if (skiprc) goto cmdrc_exit; doing_rc = 1; (void) strlcpy(m1save, m1, sizeof (m1save)); m1 = m1save; if (rcname == NULL) { char *homedir; unsigned rcbuflen; if ((homedir = getenv("HOME")) == NULL) homedir = ""; rcbuflen = strlen(homedir) + strlen(TELNETRC_COMP) + 1; if ((rcname = malloc(rcbuflen)) == NULL) { perror("telnet: can't process " TELNETRC_NAME); ret = 1; goto cmdrc_exit; } (void) strcpy(rcname, homedir); (void) strcat(rcname, TELNETRC_COMP); } if ((rcfile = fopen(rcname, "r")) == NULL) goto cmdrc_exit; for (;;) { if (GetString(&line, &linesize, rcfile) == NULL) { if (!feof(rcfile)) { perror("telnet: error reading " TELNETRC_NAME); ret = 1; goto cmdrc_exit; } break; } if (line[0] == 0) continue; if (line[0] == '#') continue; if (gotmachine) { if (!isspace(line[0])) gotmachine = 0; } if (gotmachine == 0) { if (isspace(line[0])) continue; if (strncasecmp(line, m1, l1) == 0) (void) strcpy(line, &line[l1]); else if (strncasecmp(line, m2, l2) == 0) (void) strcpy(line, &line[l2]); else if (strncasecmp(line, def, sizeof (def) - 1) == 0) (void) strcpy(line, &line[sizeof (def) - 1]); else continue; if (line[0] != ' ' && line[0] != '\t' && line[0] != '\n') continue; gotmachine = 1; } makeargv(); if (margv[0] == 0) continue; c = getcmd(margv[0]); if (Ambiguous(c)) { (void) printf("?Ambiguous command: %s\n", margv[0]); continue; } if (c == 0) { (void) printf("?Invalid command: %s\n", margv[0]); continue; } /* * This should never happen... */ if (c->needconnect && !connected) { (void) printf("?Need to be connected first for %s.\n", margv[0]); continue; } (*c->handler)(margc, margv); } cmdrc_exit: if (rcfile != NULL) (void) fclose(rcfile); doing_rc = 0; return (ret); }