/*
 * Copyright 1994-2002 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"@(#)utilities.c	1.19	05/06/12 SMI"

/*
 * usr/src/cmd/cmd-inet/usr.bin/telnet/utilities.c
 */

/*
 * Copyright (c) 1988, 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.
 */

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

#define	TELOPTS
#ifdef	lint
static char *telcmds[] = {0};
static char *slc_names[] = {0};
static char *encrypt_names[] = {0};
static char *enctype_names[] = {0};
#else	/* lint */
#define	TELCMDS
#define	SLC_NAMES
#endif	/* lint */
#include <arpa/telnet.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <errno.h>

#include <ctype.h>

#include "general.h"

#include "ring.h"

#include "defines.h"

#include "externs.h"

FILE	*NetTrace = 0;		/* Not in bss, since needs to stay */
int	prettydump;

/*
 * upcase()
 *
 *	Upcase (in place) the argument.
 */

    void
upcase(argument)
	register char *argument;
{
	register int c;

	while ((c = *argument) != 0) {
		if (islower(c)) {
			*argument = toupper(c);
		}
	argument++;
	}
}

/*
 * SetSockOpt()
 *
 * Compensate for differences in 4.2 and 4.3 systems.
 */

    int
SetSockOpt(fd, level, option, yesno)
    int fd, level, option, yesno;
{
	return (setsockopt(fd, level, option, &yesno, sizeof (yesno)));
}

/*
 * The following are routines used to print out debugging information.
 */

unsigned char NetTraceFile[MAXPATHLEN] = "(standard output)";

    void
SetNetTrace(file)
    register char *file;
{
	if (NetTrace && NetTrace != stdout)
		(void) fclose(NetTrace);
	if (file && (strcmp(file, "-") != 0)) {
		NetTrace = fopen(file, "w");
		if (NetTrace) {
			(void) strcpy((char *)NetTraceFile, file);
			return;
		}
		(void) fprintf(stderr, "Cannot open %s.\n", file);
	}
	NetTrace = stdout;
	(void) strcpy((char *)NetTraceFile, "(standard output)");
}

    void
Dump(direction, buffer, length)
    char direction;
    unsigned char *buffer;
    int length;
{
#define	BYTES_PER_LINE	32
#define	min(x, y)	((x < y) ? x:y)
	unsigned char *pThis;
	int offset;

	offset = 0;

	while (length) {
		/* print one line */
		(void) fprintf(NetTrace, "%c 0x%x\t", direction, offset);
		pThis = buffer;
		if (prettydump) {
			buffer = buffer + min(length, BYTES_PER_LINE/2);
			while (pThis < buffer) {
				(void) fprintf(NetTrace, "%c%.2x",
				    (((*pThis)&0xff) == 0xff) ? '*' : ' ',
				    (*pThis)&0xff);
				pThis++;
			}
			length -= BYTES_PER_LINE/2;
			offset += BYTES_PER_LINE/2;
		} else {
			buffer = buffer + min(length, BYTES_PER_LINE);
			while (pThis < buffer) {
				(void) fprintf(NetTrace, "%.2x", (*pThis)&0xff);
				pThis++;
			}
			length -= BYTES_PER_LINE;
			offset += BYTES_PER_LINE;
		}
		if (NetTrace == stdout) {
			(void) fprintf(NetTrace, "\r\n");
		} else {
			(void) fprintf(NetTrace, "\n");
		}
		if (length < 0) {
			(void) fflush(NetTrace);
			return;
		}
		/* find next unique line */
	}
	(void) fflush(NetTrace);
}


	void
printoption(direction, cmd, option)
	char *direction;
	int cmd, option;
{
	if (!showoptions)
		return;
	if (cmd == IAC) {
		if (TELCMD_OK(option))
			(void) fprintf(NetTrace, "%s IAC %s", direction,
			    TELCMD(option));
		else
			(void) fprintf(NetTrace, "%s IAC %d", direction,
				option);
	} else {
		register char *fmt;
		fmt = (cmd == WILL) ? "WILL" : (cmd == WONT) ? "WONT" :
			(cmd == DO) ? "DO" : (cmd == DONT) ? "DONT" : 0;
		if (fmt) {
		    (void) fprintf(NetTrace, "%s %s ", direction, fmt);
		    if (TELOPT_OK(option))
			(void) fprintf(NetTrace, "%s", TELOPT(option));
		    else if (option == TELOPT_EXOPL)
			(void) fprintf(NetTrace, "EXOPL");
		    else
			(void) fprintf(NetTrace, "%d", option);
		} else
			(void) fprintf(NetTrace, "%s %d %d", direction, cmd,
			    option);
	}
	if (NetTrace == stdout) {
	    (void) fprintf(NetTrace, "\r\n");
	    (void) fflush(NetTrace);
	} else {
	    (void) fprintf(NetTrace, "\n");
	}
}

    void
optionstatus()
{
	register int i;
	extern char will_wont_resp[], do_dont_resp[];

	for (i = 0; i < SUBBUFSIZE; i++) {
		if (do_dont_resp[i]) {
			if (TELOPT_OK(i))
				(void) printf("resp DO_DONT %s: %d\n",
				    TELOPT(i), do_dont_resp[i]);
			else if (TELCMD_OK(i))
				(void) printf("resp DO_DONT %s: %d\n",
				    TELCMD(i), do_dont_resp[i]);
			else
				(void) printf("resp DO_DONT %d: %d\n", i,
				    do_dont_resp[i]);
			if (my_want_state_is_do(i)) {
				if (TELOPT_OK(i))
					(void) printf("want DO   %s\n",
					    TELOPT(i));
				else if (TELCMD_OK(i))
					(void) printf("want DO   %s\n",
						TELCMD(i));
				else
					(void) printf("want DO   %d\n", i);
			} else {
				if (TELOPT_OK(i))
					(void) printf("want DONT %s\n",
					    TELOPT(i));
				else if (TELCMD_OK(i))
					(void) printf("want DONT %s\n",
					    TELCMD(i));
				else
					(void) printf("want DONT %d\n", i);
			}
		} else {
			if (my_state_is_do(i)) {
				if (TELOPT_OK(i))
					(void) printf("     DO   %s\n",
					    TELOPT(i));
				else if (TELCMD_OK(i))
					(void) printf("     DO   %s\n",
					    TELCMD(i));
				else
					(void) printf("     DO   %d\n", i);
			}
		}
		if (will_wont_resp[i]) {
			if (TELOPT_OK(i))
				(void) printf("resp WILL_WONT %s: %d\n",
				    TELOPT(i), will_wont_resp[i]);
			else if (TELCMD_OK(i))
				(void) printf("resp WILL_WONT %s: %d\n",
				    TELCMD(i), will_wont_resp[i]);
			else
				(void) printf("resp WILL_WONT %d: %d\n",
				    i, will_wont_resp[i]);
			if (my_want_state_is_will(i)) {
				if (TELOPT_OK(i))
					(void) printf("want WILL %s\n",
					    TELOPT(i));
				else if (TELCMD_OK(i))
					(void) printf("want WILL %s\n",
					    TELCMD(i));
				else
					(void) printf("want WILL %d\n", i);
			} else {
				if (TELOPT_OK(i))
					(void) printf("want WONT %s\n",
					    TELOPT(i));
				else if (TELCMD_OK(i))
					(void) printf("want WONT %s\n",
					    TELCMD(i));
				else
					(void) printf("want WONT %d\n", i);
			}
		} else {
			if (my_state_is_will(i)) {
				if (TELOPT_OK(i))
					(void) printf("     WILL %s\n",
					    TELOPT(i));
				else if (TELCMD_OK(i))
					(void) printf("     WILL %s\n",
					    TELCMD(i));
				else
					(void) printf("     WILL %d\n", i);
			}
		}
	}

}

    void
printsub(direction, pointer, length)
	char direction;	/* '<' or '>' */
	unsigned char *pointer;	/* where suboption data sits */
	int	  length;	/* length of suboption data */
{
	register int i;
	char buf[512];
	extern int want_status_response;

	if (showoptions || direction == 0 ||
	    (want_status_response && (pointer[0] == TELOPT_STATUS))) {
		if (direction) {
			(void) fprintf(NetTrace, "%s IAC SB ",
				(direction == '<')? "RCVD":"SENT");
			if (length >= 3) {
				register int j;

				i = pointer[length-2];
				j = pointer[length-1];

				if (i != IAC || j != SE) {
					(void) fprintf(NetTrace,
					    "(terminated by ");
					if (TELOPT_OK(i))
						(void) fprintf(NetTrace, "%s ",
						    TELOPT(i));
					else if (TELCMD_OK(i))
						(void) fprintf(NetTrace, "%s ",
						    TELCMD(i));
					else
						(void) fprintf(NetTrace, "%d ",
						    i);
					if (TELOPT_OK(j))
						(void) fprintf(NetTrace, "%s",
						    TELOPT(j));
					else if (TELCMD_OK(j))
						(void) fprintf(NetTrace, "%s",
						    TELCMD(j));
					else
						(void) fprintf(NetTrace, "%d",
						    j);
					(void) fprintf(NetTrace,
					    ", not IAC SE!) ");
				}
			}
			length -= 2;
		}
		if (length < 1) {
			(void) fprintf(NetTrace, "(Empty suboption??\?)");
			if (NetTrace == stdout)
				(void) fflush(NetTrace);
			return;
		}
		switch (pointer[0]) {
		case TELOPT_TTYPE:
			(void) fprintf(NetTrace, "TERMINAL-TYPE ");
			switch (pointer[1]) {
			case TELQUAL_IS:
				(void) fprintf(NetTrace, "IS \"%.*s\"",
				    length-2,
				    (char *)pointer+2);
				break;
			case TELQUAL_SEND:
				(void) fprintf(NetTrace, "SEND");
				break;
			default:
				(void) fprintf(NetTrace,
				    "- unknown qualifier %d (0x%x).",
				    pointer[1], pointer[1]);
			}
			break;
		case TELOPT_TSPEED:
			(void) fprintf(NetTrace, "TERMINAL-SPEED");
			if (length < 2) {
				(void) fprintf(NetTrace,
				    " (empty suboption??\?)");
				break;
			}
			switch (pointer[1]) {
			case TELQUAL_IS:
				(void) fprintf(NetTrace, " IS ");
				(void) fprintf(NetTrace, "%.*s", length-2,
				    (char *)pointer+2);
				break;
			default:
				if (pointer[1] == 1)
					(void) fprintf(NetTrace, " SEND");
				else
					(void) fprintf(NetTrace,
					    " %d (unknown)", pointer[1]);
				for (i = 2; i < length; i++)
					(void) fprintf(NetTrace, " ?%d?",
					    pointer[i]);
				break;
			}
			break;

		case TELOPT_LFLOW:
			(void) fprintf(NetTrace, "TOGGLE-FLOW-CONTROL");
			if (length < 2) {
				(void) fprintf(NetTrace,
				    " (empty suboption??\?)");
				break;
			}
			switch (pointer[1]) {
			case LFLOW_OFF:
				(void) fprintf(NetTrace, " OFF");
				break;
			case LFLOW_ON:
				(void) fprintf(NetTrace, " ON");
				break;
			case LFLOW_RESTART_ANY:
				(void) fprintf(NetTrace, " RESTART-ANY");
				break;
			case LFLOW_RESTART_XON:
				(void) fprintf(NetTrace, " RESTART-XON");
				break;
			default:
				(void) fprintf(NetTrace, " %d (unknown)",
				    pointer[1]);
			}
			for (i = 2; i < length; i++)
				(void) fprintf(NetTrace, " ?%d?",
				    pointer[i]);
			break;

		case TELOPT_NAWS:
			(void) fprintf(NetTrace, "NAWS");
			if (length < 2) {
				(void) fprintf(NetTrace,
				    " (empty suboption??\?)");
				break;
			}
			if (length == 2) {
				(void) fprintf(NetTrace, " ?%d?", pointer[1]);
				break;
			}
			(void) fprintf(NetTrace, " %d %d (%d)",
			    pointer[1], pointer[2],
			    (int)((((unsigned int)pointer[1])<<8)|
			    ((unsigned int)pointer[2])));
			if (length == 4) {
				(void) fprintf(NetTrace, " ?%d?", pointer[3]);
				break;
			}
			(void) fprintf(NetTrace, " %d %d (%d)",
			    pointer[3], pointer[4],
			    (int)((((unsigned int)pointer[3])<<8)|
			    ((unsigned int)pointer[4])));
			for (i = 5; i < length; i++)
				(void) fprintf(NetTrace, " ?%d?", pointer[i]);
			break;

		case TELOPT_AUTHENTICATION:
			(void) fprintf(NetTrace, "AUTHENTICATION");
			if (length < 2) {
				(void) fprintf(NetTrace,
					" (empty suboption??\?)");
				break;
			}
			switch (pointer[1]) {
			case TELQUAL_REPLY:
			case TELQUAL_IS:
				(void) fprintf(NetTrace, " %s ",
				    (pointer[1] == TELQUAL_IS) ?
				    "IS" : "REPLY");
				if (AUTHTYPE_NAME_OK(pointer[2]))
					(void) fprintf(NetTrace, "%s ",
					    AUTHTYPE_NAME(pointer[2]));
				else
					(void) fprintf(NetTrace, "%d ",
						pointer[2]);
				if (length < 3) {
					(void) fprintf(NetTrace,
					    "(partial suboption??\?)");
					break;
				}
				(void) fprintf(NetTrace, "%s|%s",
				    ((pointer[3] & AUTH_WHO_MASK) ==
				    AUTH_WHO_CLIENT) ? "CLIENT" : "SERVER",
				    ((pointer[3] & AUTH_HOW_MASK) ==
				    AUTH_HOW_MUTUAL) ? "MUTUAL" : "ONE-WAY");

				auth_printsub(&pointer[1], length - 1,
				    (uchar_t *)buf, sizeof (buf));
				(void) fprintf(NetTrace, "%s", buf);
				break;

			case TELQUAL_SEND:
				i = 2;
				(void) fprintf(NetTrace, " SEND ");
				while (i < length) {
					if (AUTHTYPE_NAME_OK(pointer[i]))
						(void) fprintf(NetTrace, "%s ",
						    AUTHTYPE_NAME(pointer[i]));
					else
						(void) fprintf(NetTrace, "%d ",
						    pointer[i]);
					if (++i >= length) {
						(void) fprintf(NetTrace,
						    "(partial "
						    "suboption??\?)");
						break;
					}
					(void) fprintf(NetTrace, "%s|%s ",
					    ((pointer[i] & AUTH_WHO_MASK) ==
					    AUTH_WHO_CLIENT) ?
					    "CLIENT" : "SERVER",
					    ((pointer[i] & AUTH_HOW_MASK) ==
					    AUTH_HOW_MUTUAL) ?
					    "MUTUAL" : "ONE-WAY");
					++i;
				}
				break;

			case TELQUAL_NAME:
				i = 2;
				(void) fprintf(NetTrace, " NAME \"");
				while (i < length)
					(void) putc(pointer[i++], NetTrace);
				(void) putc('"', NetTrace);
				break;

			default:
				for (i = 2; i < length; i++)
				(void) fprintf(NetTrace, " ?%d?", pointer[i]);
				break;
			}
			break;

		case TELOPT_ENCRYPT:
			(void) fprintf(NetTrace, "ENCRYPT");
			if (length < 2) {
				(void) fprintf(NetTrace,
				    " (empty suboption??\?)");
				break;
			}
			switch (pointer[1]) {
			case ENCRYPT_START:
				(void) fprintf(NetTrace, " START");
				break;

			case ENCRYPT_END:
				(void) fprintf(NetTrace, " END");
				break;

			case ENCRYPT_REQSTART:
				(void) fprintf(NetTrace, " REQUEST-START");
				break;

			case ENCRYPT_REQEND:
				(void) fprintf(NetTrace, " REQUEST-END");
				break;

			case ENCRYPT_IS:
			case ENCRYPT_REPLY:
				(void) fprintf(NetTrace, " %s ",
				    (pointer[1] == ENCRYPT_IS) ?
				    "IS" : "REPLY");
				if (length < 3) {
					(void) fprintf(NetTrace, " (partial "
					    "suboption??\?)");
					break;
				}
				if (ENCTYPE_NAME_OK(pointer[2]))
					(void) fprintf(NetTrace, "%s ",
					    ENCTYPE_NAME(pointer[2]));
				else
					(void) fprintf(NetTrace,
					    " %d (unknown)", pointer[2]);

				encrypt_printsub(&pointer[1], length - 1,
				    (uchar_t *)buf, sizeof (buf));
				(void) fprintf(NetTrace, "%s", buf);
				break;

			case ENCRYPT_SUPPORT:
				i = 2;
				(void) fprintf(NetTrace, " SUPPORT ");
				while (i < length) {
					if (ENCTYPE_NAME_OK(pointer[i]))
						(void) fprintf(NetTrace, "%s ",
						    ENCTYPE_NAME(pointer[i]));
					else
						(void) fprintf(NetTrace, "%d ",
						    pointer[i]);
					i++;
				}
				break;

			case ENCRYPT_ENC_KEYID:
				(void) fprintf(NetTrace, " ENC_KEYID ");
				goto encommon;

			case ENCRYPT_DEC_KEYID:
				(void) fprintf(NetTrace, " DEC_KEYID ");
				goto encommon;

			default:
				(void) fprintf(NetTrace, " %d (unknown)",
				    pointer[1]);
			encommon:
				for (i = 2; i < length; i++)
					(void) fprintf(NetTrace, " %d",
					    pointer[i]);
				break;
			}
			break;

		case TELOPT_LINEMODE:
			(void) fprintf(NetTrace, "LINEMODE ");
			if (length < 2) {
				(void) fprintf(NetTrace,
				    " (empty suboption??\?)");
				break;
			}
			switch (pointer[1]) {
			case WILL:
				(void) fprintf(NetTrace, "WILL ");
				goto common;
			case WONT:
				(void) fprintf(NetTrace, "WONT ");
				goto common;
			case DO:
				(void) fprintf(NetTrace, "DO ");
				goto common;
			case DONT:
				(void) fprintf(NetTrace, "DONT ");
common:
				if (length < 3) {
					(void) fprintf(NetTrace,
						"(no option??\?)");
					break;
				}
				switch (pointer[2]) {
				case LM_FORWARDMASK:
					(void) fprintf(NetTrace,
					    "Forward Mask");
					for (i = 3; i < length; i++)
						(void) fprintf(NetTrace, " %x",
						    pointer[i]);
					break;
				default:
					(void) fprintf(NetTrace, "%d (unknown)",
					    pointer[2]);
					for (i = 3; i < length; i++)
					(void) fprintf(NetTrace,
					    " %d", pointer[i]);
					break;
				}
				break;

			case LM_SLC:
				(void) fprintf(NetTrace, "SLC");
				for (i = 2; i < length - 2; i += 3) {
					if (SLC_NAME_OK(pointer[i+SLC_FUNC]))
						(void) fprintf(NetTrace, " %s",
						    SLC_NAME(pointer[
						    i+SLC_FUNC]));
					else
						(void) fprintf(NetTrace, " %d",
						    pointer[i+SLC_FUNC]);
					switch (pointer[i+SLC_FLAGS] &
					    SLC_LEVELBITS) {
					case SLC_NOSUPPORT:
						(void) fprintf(NetTrace,
						    " NOSUPPORT");
						break;
					case SLC_CANTCHANGE:
						(void) fprintf(NetTrace,
						    " CANTCHANGE");
						break;
					case SLC_VARIABLE:
						(void) fprintf(NetTrace,
						    " VARIABLE");
						break;
					case SLC_DEFAULT:
						(void) fprintf(NetTrace,
						    " DEFAULT");
						break;
					}
					(void) fprintf(NetTrace, "%s%s%s",
					    pointer[i+SLC_FLAGS]&SLC_ACK ?
						"|ACK" : "",
					    pointer[i+SLC_FLAGS]&SLC_FLUSHIN ?
						"|FLUSHIN" : "",
					    pointer[i+SLC_FLAGS]&SLC_FLUSHOUT ?
						"|FLUSHOUT" : "");
					if (pointer[i+SLC_FLAGS] &
					    ~(SLC_ACK|SLC_FLUSHIN|
					    SLC_FLUSHOUT| SLC_LEVELBITS))
					(void) fprintf(NetTrace, "(0x%x)",
					    pointer[i+SLC_FLAGS]);
					(void) fprintf(NetTrace, " %d;",
					    pointer[i+SLC_VALUE]);
					if ((pointer[i+SLC_VALUE] == IAC) &&
					    (pointer[i+SLC_VALUE+1] == IAC))
						i++;
				}
				for (; i < length; i++)
					(void) fprintf(NetTrace, " ?%d?",
					    pointer[i]);
				break;

			case LM_MODE:
				(void) fprintf(NetTrace, "MODE ");
				if (length < 3) {
					(void) fprintf(NetTrace,
					    "(no mode??\?)");
					break;
				}
				{
					char tbuf[64];
					(void) sprintf(tbuf, "%s%s%s%s%s",
					    pointer[2]&MODE_EDIT ? "|EDIT" : "",
					    pointer[2]&MODE_TRAPSIG ?
					    "|TRAPSIG" : "",
					    pointer[2]&MODE_SOFT_TAB ?
					    "|SOFT_TAB" : "",
					    pointer[2]&MODE_LIT_ECHO ?
					    "|LIT_ECHO" : "",
					    pointer[2]&MODE_ACK ? "|ACK" : "");
					(void) fprintf(NetTrace, "%s", tbuf[1] ?
					    &tbuf[1] : "0");
				}
				if (pointer[2]&~(MODE_MASK))
					(void) fprintf(NetTrace, " (0x%x)",
					    pointer[2]);
				for (i = 3; i < length; i++)
					(void) fprintf(NetTrace, " ?0x%x?",
					    pointer[i]);
				break;
			default:
				(void) fprintf(NetTrace, "%d (unknown)",
				    pointer[1]);
				for (i = 2; i < length; i++)
					(void) fprintf(NetTrace, " %d",
					    pointer[i]);
				}
				break;

		case TELOPT_STATUS: {
				register char *cp;
				register int j, k;

				(void) fprintf(NetTrace, "STATUS");

				switch (pointer[1]) {
				default:
					if (pointer[1] == TELQUAL_SEND)
						(void) fprintf(NetTrace,
						    " SEND");
					else
						(void) fprintf(NetTrace,
						    " %d (unknown)",
						    pointer[1]);
					for (i = 2; i < length; i++)
					(void) fprintf(NetTrace, " ?%d?",
					    pointer[i]);
					break;
				case TELQUAL_IS:
					if (--want_status_response < 0)
						want_status_response = 0;
					if (NetTrace == stdout)
						(void) fprintf(NetTrace,
						    " IS\r\n");
					else
						(void) fprintf(NetTrace,
						    " IS\n");

					for (i = 2; i < length; i++) {
						switch (pointer[i]) {
						case DO:
							cp = "DO";
							goto common2;
						case DONT:
							cp = "DONT";
							goto common2;
						case WILL:
							cp = "WILL";
							goto common2;
						case WONT:
							cp = "WONT";
							goto common2;
common2:
							i++;
							if (TELOPT_OK(
							    (int)pointer[i]))
								(void) fprintf(
								    NetTrace,
								    " %s %s",
								    cp,
								    TELOPT(
								    pointer[
								    i]));
							else
								(void) fprintf(
								    NetTrace,
								    " %s %d",
								    cp,
								    pointer[i]);

							if (NetTrace == stdout)
								(void) fprintf(
								    NetTrace,
								    "\r\n");
							else
								(void) fprintf(
								    NetTrace,
								    "\n");
							break;

						case SB:
							(void) fprintf(NetTrace,
							    " SB ");
							i++;
							j = k = i;
							while (j < length) {
			if (pointer[j] == SE) {
				if (j+1 == length)
					break;
				if (pointer[j+1] == SE)
					j++;
				else
					break;
				}
				pointer[k++] = pointer[j++];
							}
							printsub(0,
							    &pointer[i], k - i);
							if (i < length) {
						(void) fprintf(NetTrace, " SE");
				i = j;
			} else
				i = j - 1;

			if (NetTrace == stdout)
				(void) fprintf(NetTrace, "\r\n");
			else
				(void) fprintf(NetTrace, "\n");

							break;

						default:
							(void) fprintf(NetTrace,
							    " %d", pointer[i]);
							break;
						}
					}
					break;
				}
				break;
			}

		case TELOPT_XDISPLOC:
			(void) fprintf(NetTrace, "X-DISPLAY-LOCATION ");
			switch (pointer[1]) {
			case TELQUAL_IS:
				(void) fprintf(NetTrace, "IS \"%.*s\"",
				    length-2, (char *)pointer+2);
				break;
			case TELQUAL_SEND:
				(void) fprintf(NetTrace, "SEND");
				break;
			default:
				(void) fprintf(NetTrace,
				    "- unknown qualifier %d (0x%x).",
				    pointer[1], pointer[1]);
			}
			break;

		case TELOPT_NEW_ENVIRON:
	    (void) fprintf(NetTrace, "NEW-ENVIRON ");
#ifdef	OLD_ENVIRON
	    goto env_common1;
	case TELOPT_OLD_ENVIRON:
	    (void) fprintf(NetTrace, "OLD-ENVIRON ");
	env_common1:
#endif
	    switch (pointer[1]) {
	    case TELQUAL_IS:
		(void) fprintf(NetTrace, "IS ");
		goto env_common;
	    case TELQUAL_SEND:
		(void) fprintf(NetTrace, "SEND ");
		goto env_common;
	    case TELQUAL_INFO:
		(void) fprintf(NetTrace, "INFO ");
	    env_common:
		{
		    register int noquote = 2;
#if defined(ENV_HACK) && defined(OLD_ENVIRON)
		    extern int old_env_var, old_env_value;
#endif
		    for (i = 2; i < length; i++) {
			switch (pointer[i]) {
			case NEW_ENV_VALUE:
#ifdef OLD_ENVIRON
		    /*	case NEW_ENV_OVAR: */
			    if (pointer[0] == TELOPT_OLD_ENVIRON) {
#ifdef	ENV_HACK
				if (old_env_var == OLD_ENV_VALUE)
					(void) fprintf(NetTrace,
					    "\" (VALUE) " + noquote);
				else
#endif
					(void) fprintf(NetTrace,
					    "\" VAR " + noquote);
			    } else
#endif /* OLD_ENVIRON */
				(void) fprintf(NetTrace, "\" VALUE " + noquote);
			    noquote = 2;
			    break;

			case NEW_ENV_VAR:
#ifdef OLD_ENVIRON
		    /* case OLD_ENV_VALUE: */
			    if (pointer[0] == TELOPT_OLD_ENVIRON) {
#ifdef	ENV_HACK
				if (old_env_value == OLD_ENV_VAR)
					(void) fprintf(NetTrace,
					    "\" (VAR) " + noquote);
				else
#endif
					(void) fprintf(NetTrace,
					    "\" VALUE " + noquote);
			    } else
#endif /* OLD_ENVIRON */
				(void) fprintf(NetTrace, "\" VAR " + noquote);
			    noquote = 2;
			    break;

			case ENV_ESC:
			    (void) fprintf(NetTrace, "\" ESC " + noquote);
			    noquote = 2;
			    break;

			case ENV_USERVAR:
			    (void) fprintf(NetTrace, "\" USERVAR " + noquote);
			    noquote = 2;
			    break;

			default:
			def_case:
			    if (isprint(pointer[i]) && pointer[i] != '"') {
				if (noquote) {
				    (void) putc('"', NetTrace);
				    noquote = 0;
				}
				(void) putc(pointer[i], NetTrace);
			    } else {
				(void) fprintf(NetTrace, "\" %03o " + noquote,
							pointer[i]);
				noquote = 2;
			    }
			    break;
			}
		    }
		    if (!noquote)
			(void) putc('"', NetTrace);
		    break;
		}
	    }
	    break;

	default:
	    if (TELOPT_OK(pointer[0]))
		(void) fprintf(NetTrace, "%s (unknown)", TELOPT(pointer[0]));
	    else
		(void) fprintf(NetTrace, "%d (unknown)", pointer[0]);
	    for (i = 1; i < length; i++)
		(void) fprintf(NetTrace, " %d", pointer[i]);
	    break;
	}
	if (direction) {
	    if (NetTrace == stdout)
		(void) fprintf(NetTrace, "\r\n");
	    else
		(void) fprintf(NetTrace, "\n");
	}
	if (NetTrace == stdout)
	    (void) fflush(NetTrace);
	}
}

/*
 * EmptyTerminal - called to make sure that the terminal buffer is empty.
 *			Note that we consider the buffer to run all the
 *			way to the kernel (thus the select).
 */

static void
EmptyTerminal()
{
	fd_set	o;

	FD_ZERO(&o);

	if (TTYBYTES() == 0) {
		FD_SET(tout, &o);
		/* wait for TTLOWAT */
		(void) select(tout+1, NULL, &o, NULL, NULL);
	} else {
		while (TTYBYTES()) {
			if (ttyflush(0) == -2) {
				/* This will not return. */
				fatal_tty_error("write");
			}
			FD_SET(tout, &o);
			/* wait for TTLOWAT */
			(void) select(tout+1, NULL, &o, NULL, NULL);
		}
	}
}

static void
SetForExit()
{
	setconnmode(0);
	do {
		(void) telrcv();		/* Process any incoming data */
		EmptyTerminal();
	} while (ring_full_count(&netiring));	/* While there is any */
	setcommandmode();
	(void) fflush(stdout);
	(void) fflush(stderr);
	setconnmode(0);
	EmptyTerminal();			/* Flush the path to the tty */
	setcommandmode();
}

void
Exit(returnCode)
	int returnCode;
{
	SetForExit();
	exit(returnCode);
}

void
ExitString(string, returnCode)
	char *string;
	int returnCode;
{
	SetForExit();
	(void) fwrite(string, 1, strlen(string), stderr);
	exit(returnCode);
}

#define	BUFFER_CHUNK_SIZE 64

/* Round up to a multiple of BUFFER_CHUNK_SIZE */
#define	ROUND_CHUNK_SIZE(s) ((((s) + BUFFER_CHUNK_SIZE - 1) / \
		BUFFER_CHUNK_SIZE) * BUFFER_CHUNK_SIZE)

/*
 * Optionally allocate a buffer, and optionally read a string from a stream
 * into the buffer, starting at the given offset.  If the buffer isn't
 * large enough for the given offset, or if buffer space is exhausted
 * when reading the string, the size of the buffer is increased.
 *
 * A buffer can be supplied when the function is called, passing the
 * buffer address via the first argument.  The buffer size can be
 * passed as well, in the second argument.  If the second argument is
 * NULL, the function makes no assumptions about the buffer size.
 * The address of the buffer is returned via the first argument, and the
 * buffer size via the second argument if this is not NULL.
 * These returned values may differ from the supplied values if the buffer
 * was reallocated.
 *
 * If no buffer is to be supplied, specify a buffer address of NULL, via
 * the first argument.
 *
 * If the pointer to the buffer address is NULL, the function just returns
 * NULL, and performs no other processing.
 *
 * If a NULL stream is passed, the function will just make sure the
 * supplied buffer is large enough to hold the supplied offset,
 * reallocating it if is too small or too large.
 *
 * The returned buffer will be a multiple of BUFFER_CHUNK_SIZE in size.
 *
 * The function stops reading from the stream when a newline is read,
 * end of file is reached, or an error occurs.  The newline is not
 * returned in the buffer.  The returned string will be NULL terminated.
 *
 * The function returns the address of the buffer if any characters
 * are read and no error occurred, otherwise it returns NULL.
 *
 * If the function returns NULL, a buffer may have been allocated.  The
 * buffer address will be returned via the first argument, together with
 * the buffer size if the second argument is not NULL.
 *
 */
static char *
GetStringAtOffset(bufp, cbufsiz, off, st)
	char **bufp;
	unsigned int *cbufsiz;
	unsigned int off;
	FILE *st;
{
	unsigned int bufsiz;
	char *buf;
	char *nbuf;
	unsigned int idx = off;

	if (bufp == NULL)
		return (NULL);

	buf = *bufp;

	bufsiz = ROUND_CHUNK_SIZE(off + 1);

	if (buf == NULL || cbufsiz == NULL || *cbufsiz != bufsiz) {
		if ((nbuf = realloc(buf, bufsiz)) == NULL)
			return (NULL);

		buf = nbuf;
		*bufp = buf;
		if (cbufsiz != NULL)
			*cbufsiz = bufsiz;
	}


	if (st == NULL)
		return (buf);

	clearerr(st);
	for (;;) {
		int c = getc(st);

		/* Expand the buffer as needed. */
		if (idx == bufsiz) {
			bufsiz += BUFFER_CHUNK_SIZE;
			if ((nbuf = realloc(buf, bufsiz)) == NULL) {
				/* Discard everything we read. */
				buf[off] = 0;
				buf = NULL;
				break;
			}
			buf = nbuf;
			*bufp = buf;
			if (cbufsiz != NULL)
				*cbufsiz = bufsiz;
		}

		if (c == EOF || c == '\n') {
			buf[idx] = 0;
			if (ferror(st) != 0) {
				/* Retry if interrupted by a signal. */
				if (errno == EINTR) {
					clearerr(st);
					continue;
				}
				buf = NULL;
			} else if (feof(st) != 0) {
				/* No characters transferred? */
				if (off == idx)
					buf = NULL;
			}
			break;
		}
		buf[idx++] = c;
	}
	return (buf);
}

/*
 * Read a string from the supplied stream.  Stop reading when a newline
 * is read, end of file reached, or an error occurs.
 *
 * A buffer can be supplied by specifying the buffer address via the
 * first argument. The buffer size can be passed via the second argument.
 * If the second argument is NULL, the function makes no assumptions
 * about the buffer size. The buffer will be reallocated if it is too
 * small or too large for the returned string.
 *
 * If no buffer is to be supplied, specify a buffer address of NULL,
 * via the first argument.
 *
 * If the first argument is NULL, the function just returns NULL, and
 * performs no other processing.
 *
 * The function returns the address of the buffer if any characters are
 * read and no error occurred.
 *
 * If the function returns NULL, a buffer may have been allocated.  The
 * buffer address and buffer size will be returned via the first argument,
 * and the buffer size via the second argument, if this isn't NULL.
 */
char *
GetString(bufp, bufsiz, st)
	char **bufp;
	unsigned int *bufsiz;
	FILE *st;
{
	return (GetStringAtOffset(bufp, bufsiz, 0, st));
}

/*
 * Allocate a buffer to hold a string of given length.
 *
 * An existing buffer can be reallocated by passing its address and via
 * the first argument.  The buffer size can be passed via the second
 * argument.  If the second argument is NULL, the function makes no
 * assumptions about the buffer size.
 *
 * If no existing buffer is to be supplied, pass a NULL buffer address via
 * the first argument.
 *
 * If the first argument is NULL, the function just returns NULL,
 * and performs no other processing.
 */
char *
AllocStringBuffer(bufp, bufsiz, size)
	char **bufp;
	unsigned int *bufsiz;
	unsigned int size;
{
	return (GetStringAtOffset(bufp, bufsiz, size, (FILE *)NULL));
}

/*
 * This function is similar to GetString(), except that the string read
 * from the stream is appended to the supplied string.
 */
char *
GetAndAppendString(bufp, bufsiz, str, st)
	char **bufp;
	unsigned int *bufsiz;
	char *str;
	FILE *st;
{
	unsigned int off = strlen(str);

	if (GetStringAtOffset(bufp, bufsiz, off, st) == NULL)
		return (NULL);

	return (memcpy(*bufp, str, off));
}