xref: /onnv-gate/usr/src/cmd/cmd-inet/usr.bin/telnet/commands.c (revision 473)

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * 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.
 */

#ifndef lint
static char sccsid[] = "@(#)commands.c	8.1 (Berkeley) 6/6/93";
#endif /* not lint */

#include <sys/param.h>
#include <sys/file.h>
#include <sys/socket.h>
#include <sys/sysmacros.h>
#include <netinet/in.h>

#include <signal.h>
#include <netdb.h>
#include <ctype.h>
#include <pwd.h>
#include <errno.h>
#include <strings.h>

#include <arpa/telnet.h>
#include <arpa/inet.h>

#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 <k5-int.h>
#include <profile/prof_int.h>

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 <netinet/ip.h>

/*
 * 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 <value|option>\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 <CR><LF>.\n");
	} else {
		(void) printf(
		    "Will send carriage returns as telnet <CR><NUL>.\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 <CR><LF>",
	    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("<return>\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);
}