 @@ -1,1986 +1,1986 @@
-/*	$NetBSD: telnet.c,v 1.36 2012/01/10 13:49:32 christos Exp $	*/
+/*	$NetBSD: telnet.c,v 1.36.20.1 2018/12/18 18:37:26 martin Exp $	*/
 /*
  * 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. 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.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)telnet.c	8.4 (Berkeley) 5/30/95";
 #else
-__RCSID("$NetBSD: telnet.c,v 1.36 2012/01/10 13:49:32 christos Exp $");
+__RCSID("$NetBSD: telnet.c,v 1.36.20.1 2018/12/18 18:37:26 martin Exp $");
 #endif
 #endif /* not lint */
 #include <sys/param.h>
 #include <signal.h>
 #include <term.h>
 #include <unistd.h>
 /* By the way, we need to include curses.h before telnet.h since,
  * among other things, telnet.h #defines 'DO', which is a variable
  * declared in curses.h.
  */
 #include <arpa/telnet.h>
 #include <ctype.h>
 #include "ring.h"
 #include "defines.h"
 #include "externs.h"
 #include "types.h"
 #include "general.h"
 #include <libtelnet/misc.h>
 #ifdef AUTHENTICATION
 #include <libtelnet/auth.h>
 #endif
 #ifdef ENCRYPTION
 #include <libtelnet/encrypt.h>
 #endif
 #define	strip(x) ((my_want_state_is_wont(TELOPT_BINARY)) ? ((x)&0x7f) : (x))
 static unsigned char	subbuffer[SUBBUFSIZE],
 			*subpointer, *subend;	 /* buffer for sub-options */
 #define	SB_CLEAR()	subpointer = subbuffer;
 #define	SB_TERM()	{ subend = subpointer; SB_CLEAR(); }
 #define	SB_ACCUM(c)	if (subpointer < (subbuffer+sizeof subbuffer)) { \
 				*subpointer++ = (c); \
+			}
 #define	SB_GET()	((*subpointer++)&0xff)
 #define	SB_PEEK()	((*subpointer)&0xff)
 #define	SB_EOF()	(subpointer >= subend)
 #define	SB_LEN()	(subend - subpointer)
 char	options[256];		/* The combined options */
 char	do_dont_resp[256];
 char	will_wont_resp[256];
 int
 	eight = 0,
 	autologin = 0,	/* Autologin anyone? */
 	skiprc = 0,
 	connected,
 	showoptions,
 	In3270,		/* Are we in 3270 mode? */
 	ISend,		/* trying to send network data in */
 	telnet_debug = 0,
 	crmod,
 	netdata,	/* Print out network data flow */
 	crlf,		/* Should '\r' be mapped to <CR><LF> (or <CR><NUL>)? */
 #ifdef TN3270
 	noasynchtty = 0,/* User specified "-noasynch" on command line */
 	noasynchnet = 0,/* User specified "-noasynch" on command line */
 	askedSGA = 0,	/* We have talked about suppress go ahead */
 #endif	/* defined(TN3270) */
 	telnetport,
 	SYNCHing,	/* we are in TELNET SYNCH mode */
 	flushout,	/* flush output */
 	autoflush = 0,	/* flush output when interrupting? */
 	autosynch,	/* send interrupt characters with SYNCH? */
 	localflow,	/* we handle flow control locally */
 	restartany,	/* if flow control enabled, restart on any character */
 	localchars,	/* we recognize interrupt/quit */
 	donelclchars,	/* the user has set "localchars" */
 	donebinarytoggle,	/* the user has put us in binary */
 	dontlecho,	/* do we suppress local echoing right now? */
 	globalmode,
 	doaddrlookup = 1, /* do a reverse address lookup? */
 	clienteof = 0;
 char *prompt = 0;
 cc_t escape;
 cc_t rlogin;
 #ifdef	KLUDGELINEMODE
 cc_t echoc;
 #endif
 /*
  * Telnet receiver states for fsm
  */
 #define	TS_DATA		0
 #define	TS_IAC		1
 #define	TS_WILL		2
 #define	TS_WONT		3
 #define	TS_DO		4
 #define	TS_DONT		5
 #define	TS_CR		6
 #define	TS_SB		7		/* sub-option collection */
 #define	TS_SE		8		/* looking for sub-option end */
 static int	telrcv_state;
 #ifdef	OLD_ENVIRON
 unsigned char telopt_environ = TELOPT_NEW_ENVIRON;
 #else
 # define telopt_environ TELOPT_NEW_ENVIRON
 #endif
 jmp_buf	toplevel = { 0 };
 int	flushline;
 int	linemode;
 #ifdef	KLUDGELINEMODE
 int	kludgelinemode = 1;
 #endif
 static void dooption(int);
 static void dontoption(int);
 static void suboption(void);
 static int telsnd(void);
 static void netclear(void);
 static void doflush(void);
 /*
  * The following are some clocks used to decide how to interpret
  * the relationship between various variables.
  */
 Clocks clocks;
 #ifdef	notdef
 Modelist modelist[] = {
 	{ "telnet command mode", COMMAND_LINE },
 	{ "character-at-a-time mode", 0 },
 	{ "character-at-a-time mode (local echo)", LOCAL_ECHO|LOCAL_CHARS },
 	{ "line-by-line mode (remote echo)", LINE | LOCAL_CHARS },
 	{ "line-by-line mode", LINE | LOCAL_ECHO | LOCAL_CHARS },
 	{ "line-by-line mode (local echoing suppressed)", LINE | LOCAL_CHARS },
 	{ "3270 mode", 0 },
 };
 #endif
 /*
  * Initialize telnet environment.
  */
 void
 init_telnet(void)
+{
     env_init();
     SB_CLEAR();
     ClearArray(options);
     connected = In3270 = ISend = localflow = donebinarytoggle = 0;
 #if	defined(AUTHENTICATION) || defined(ENCRYPTION)
     auth_encrypt_connect(connected);
 #endif	/* defined(AUTHENTICATION) || defined(ENCRYPTION) */
     restartany = -1;
     SYNCHing = 0;
     /* Don't change NetTrace */
     escape = CONTROL(']');
     rlogin = _POSIX_VDISABLE;
 #ifdef	KLUDGELINEMODE
     echoc = CONTROL('E');
 #endif
     flushline = 1;
     telrcv_state = TS_DATA;
+}
 #ifdef	notdef
 #include <stdarg.h>
 /*VARARGS*/
 static void
 printring(Ring *ring, char *format, ...)
     va_dcl
+{
     va_list ap;
     char buffer[100];		/* where things go */
     char *ptr;
     char *string;
     int i;
     va_start(ap, format);
     ptr = buffer;
     while ((i = *format++) != 0) {
 	if (i == '%') {
 	    i = *format++;
 	    switch (i) {
 	    case 'c':
 		*ptr++ = va_arg(ap, int);
 		break;
 	    case 's':
 		string = va_arg(ap, char *);
 		ring_supply_data(ring, buffer, ptr-buffer);
 		ring_supply_data(ring, string, strlen(string));
 		ptr = buffer;
 		break;
 	    case 0:
 		ExitString("printring: trailing %%.\n", 1);
 		/*NOTREACHED*/
 	    default:
 		ExitString("printring: unknown format character.\n", 1);
 		/*NOTREACHED*/
+	    }
 	} else {
 	    *ptr++ = i;
+	}
+    }
     va_end(ap);
     ring_supply_data(ring, buffer, ptr-buffer);
+}
 #endif
 /*
  * These routines are in charge of sending option negotiations
  * to the other side.
+ *
  * The basic idea is that we send the negotiation if either side
  * is in disagreement as to what the current state should be.
  */
 void
 send_do(int c, int init)
+{
     if (init) {
 	if (((do_dont_resp[c] == 0) && my_state_is_do(c)) ||
 				my_want_state_is_do(c))
 	    return;
 	set_my_want_state_do(c);
 	do_dont_resp[c]++;
+    }
     NET2ADD(IAC, DO);
     NETADD(c);
     printoption("SENT", DO, c);
+}
 void
 send_dont(int c, int init)
+{
     if (init) {
 	if (((do_dont_resp[c] == 0) && my_state_is_dont(c)) ||
 				my_want_state_is_dont(c))
 	    return;
 	set_my_want_state_dont(c);
 	do_dont_resp[c]++;
+    }
     NET2ADD(IAC, DONT);
     NETADD(c);
     printoption("SENT", DONT, c);
+}
 void
 send_will(int c, int init)
+{
     if (init) {
 	if (((will_wont_resp[c] == 0) && my_state_is_will(c)) ||
 				my_want_state_is_will(c))
 	    return;
 	set_my_want_state_will(c);
 	will_wont_resp[c]++;
+    }
     NET2ADD(IAC, WILL);
     NETADD(c);
     printoption("SENT", WILL, c);
+}
 void
 send_wont(int c, int init)
+{
     if (init) {
 	if (((will_wont_resp[c] == 0) && my_state_is_wont(c)) ||
 				my_want_state_is_wont(c))
 	    return;
 	set_my_want_state_wont(c);
 	will_wont_resp[c]++;
+    }
     NET2ADD(IAC, WONT);
     NETADD(c);
     printoption("SENT", WONT, c);
+}
 void
 willoption(int option)
+{
 	int new_state_ok = 0;
 	if (do_dont_resp[option]) {
 	    --do_dont_resp[option];
 	    if (do_dont_resp[option] && my_state_is_do(option))
 		--do_dont_resp[option];
+	}
 	if ((do_dont_resp[option] == 0) && my_want_state_is_dont(option)) {
 	    switch (option) {
 	    case TELOPT_ECHO:
 #	    if defined(TN3270)
 		/*
 		 * The following is a pain in the rear-end.
 		 * Various IBM servers (some versions of Wiscnet,
 		 * possibly Fibronics/Spartacus, and who knows who
 		 * else) will NOT allow us to send "DO SGA" too early
 		 * in the setup proceedings.  On the other hand,
 		 * 4.2 servers (telnetd) won't set SGA correctly.
 		 * So, we are stuck.  Empirically (but, based on
 		 * a VERY small sample), the IBM servers don't send
 		 * out anything about ECHO, so we postpone our sending
 		 * "DO SGA" until we see "WILL ECHO" (which 4.2 servers
 		 * DO send).
 		  */
+		{
 		    if (askedSGA == 0) {
 			askedSGA = 1;
 			if (my_want_state_is_dont(TELOPT_SGA))
 			    send_do(TELOPT_SGA, 1);
+		    }
+		}
 		    /* Fall through */
 	    case TELOPT_EOR:
 #endif	    /* defined(TN3270) */
 	    case TELOPT_BINARY:
 	    case TELOPT_SGA:
 		settimer(modenegotiated);
 		/* FALL THROUGH */
 	    case TELOPT_STATUS:
 #ifdef AUTHENTICATION
 	    case TELOPT_AUTHENTICATION:
 #ifdef	ENCRYPTION
 	    case TELOPT_ENCRYPT:
 #endif	/* ENCRYPTION */
 #endif
 		new_state_ok = 1;
 		break;
 	    case TELOPT_TM:
 		if (flushout)
 		    flushout = 0;
 		/*
 		 * Special case for TM.  If we get back a WILL,
 		 * pretend we got back a WONT.
 		 */
 		set_my_want_state_dont(option);
 		set_my_state_dont(option);
 		return;			/* Never reply to TM will's/wont's */
 	    case TELOPT_LINEMODE:
 	    default:
 		break;
+	    }
 	    if (new_state_ok) {
 		set_my_want_state_do(option);
 		send_do(option, 0);
 		setconnmode(0);		/* possibly set new tty mode */
 	    } else {
 		do_dont_resp[option]++;
 		send_dont(option, 0);
+	    }
+	}
 	set_my_state_do(option);
 #ifdef	ENCRYPTION
 	if (option == TELOPT_ENCRYPT)
 		encrypt_send_support();
 #endif	/* ENCRYPTION */
+}
 void
 wontoption(int option)
+{
 	if (do_dont_resp[option]) {
 	    --do_dont_resp[option];
 	    if (do_dont_resp[option] && my_state_is_dont(option))
 		--do_dont_resp[option];
+	}
 	if ((do_dont_resp[option] == 0) && my_want_state_is_do(option)) {
 	    switch (option) {
 #ifdef	KLUDGELINEMODE
 	    case TELOPT_SGA:
 		if (!kludgelinemode)
 		    break;
 		/* FALL THROUGH */
 #endif
 	    case TELOPT_ECHO:
 		settimer(modenegotiated);
 		break;
 	    case TELOPT_TM:
 		if (flushout)
 		    flushout = 0;
 		set_my_want_state_dont(option);
 		set_my_state_dont(option);
 		return;		/* Never reply to TM will's/wont's */
 	    default:
 		break;
+	    }
 	    set_my_want_state_dont(option);
 	    if (my_state_is_do(option))
 		send_dont(option, 0);
 	    setconnmode(0);			/* Set new tty mode */
 	} else if (option == TELOPT_TM) {
 	    /*
 	     * Special case for TM.
 	     */
 	    if (flushout)
 		flushout = 0;
 	    set_my_want_state_dont(option);
+	}
 	set_my_state_dont(option);
+}
 static void
 dooption(int option)
+{
 	int new_state_ok = 0;
 	if (will_wont_resp[option]) {
 	    --will_wont_resp[option];
 	    if (will_wont_resp[option] && my_state_is_will(option))
 		--will_wont_resp[option];
+	}
 	if (will_wont_resp[option] == 0) {
 	  if (my_want_state_is_wont(option)) {
 	    switch (option) {
 	    case TELOPT_TM:
 		/*
 		 * Special case for TM.  We send a WILL, but pretend
 		 * we sent WONT.
 		 */
 		send_will(option, 0);
 		set_my_want_state_wont(TELOPT_TM);
 		set_my_state_wont(TELOPT_TM);
 		return;
 #	if defined(TN3270)
 	    case TELOPT_EOR:		/* end of record */
 #	endif	/* defined(TN3270) */
 	    case TELOPT_BINARY:		/* binary mode */
 	    case TELOPT_NAWS:		/* window size */
 	    case TELOPT_TSPEED:		/* terminal speed */
 	    case TELOPT_LFLOW:		/* local flow control */
 	    case TELOPT_TTYPE:		/* terminal type option */
 	    case TELOPT_SGA:		/* no big deal */
 #ifdef	ENCRYPTION
 	    case TELOPT_ENCRYPT:	/* encryption variable option */
 #endif	/* ENCRYPTION */
 		new_state_ok = 1;
 		break;
 	    case TELOPT_NEW_ENVIRON:	/* New environment variable option */
 #ifdef	OLD_ENVIRON
 		if (my_state_is_will(TELOPT_OLD_ENVIRON))
 			send_wont(TELOPT_OLD_ENVIRON, 1); /* turn off the old */
 		goto env_common;
 	    case TELOPT_OLD_ENVIRON:	/* Old environment variable option */
 		if (my_state_is_will(TELOPT_NEW_ENVIRON))
 			break;		/* Don't enable if new one is in use! */
 	    env_common:
 		telopt_environ = option;
 #endif
 		new_state_ok = 1;
 		break;
 #ifdef AUTHENTICATION
 	    case TELOPT_AUTHENTICATION:
 		if (autologin)
 			new_state_ok = 1;
 		break;
 #endif
 	    case TELOPT_XDISPLOC:	/* X Display location */
 		if (env_getvalue((const unsigned char *)"DISPLAY"))
 		    new_state_ok = 1;
 		break;
 	    case TELOPT_LINEMODE:
 #ifdef	KLUDGELINEMODE
 		kludgelinemode = 0;
 		send_do(TELOPT_SGA, 1);
 #endif
 		set_my_want_state_will(TELOPT_LINEMODE);
 		send_will(option, 0);
 		set_my_state_will(TELOPT_LINEMODE);
 		slc_init();
 		return;
 	    case TELOPT_ECHO:		/* We're never going to echo... */
 	    default:
 		break;
+	    }
 	    if (new_state_ok) {
 		set_my_want_state_will(option);
 		send_will(option, 0);
 		setconnmode(0);			/* Set new tty mode */
 	    } else {
 		will_wont_resp[option]++;
 		send_wont(option, 0);
+	    }
 	  } else {
 	    /*
 	     * Handle options that need more things done after the
 	     * other side has acknowledged the option.
 	     */
 	    switch (option) {
 	    case TELOPT_LINEMODE:
 #ifdef	KLUDGELINEMODE
 		kludgelinemode = 0;
 		send_do(TELOPT_SGA, 1);
 #endif
 		set_my_state_will(option);
 		slc_init();
 		send_do(TELOPT_SGA, 0);
 		return;
+	    }
+	  }
+	}
 	set_my_state_will(option);
+}
 static void
 dontoption(int option)
+{
 	if (will_wont_resp[option]) {
 	    --will_wont_resp[option];
 	    if (will_wont_resp[option] && my_state_is_wont(option))
 		--will_wont_resp[option];
+	}
 	if ((will_wont_resp[option] == 0) && my_want_state_is_will(option)) {
 	    switch (option) {
 	    case TELOPT_LINEMODE:
 		linemode = 0;	/* put us back to the default state */
 		break;
 #ifdef	OLD_ENVIRON
 	    case TELOPT_NEW_ENVIRON:
 		/*
 		 * The new environ option wasn't recognized, try
 		 * the old one.
 		 */
 		send_will(TELOPT_OLD_ENVIRON, 1);
 		telopt_environ = TELOPT_OLD_ENVIRON;
 		break;
 #endif
+	    }
 	    /* we always accept a DONT */
 	    set_my_want_state_wont(option);
 	    if (my_state_is_will(option))
 		send_wont(option, 0);
 	    setconnmode(0);			/* Set new tty mode */
+	}
 	set_my_state_wont(option);
+}
 /*
  * Given a buffer returned by tgetent(), this routine will turn
  * the pipe separated list of names in the buffer into an array
  * of pointers to null terminated names.  We toss out any bad,
  * duplicate, or verbose names (names with spaces).
  */
 static char name_unknown[] = "UNKNOWN";
 static char *unknown[] = { 0, 0 };
 char **
 mklist(char *buf, char *name)
+{
 	int n;
 	char c, *cp, **argvp, *cp2, **argv, **avt;
 	if (name) {
 		if ((int)strlen(name) > 40) {
 			name = 0;
 			unknown[0] = name_unknown;
 		} else {
 			unknown[0] = name;
 			upcase(name);
+		}
 	} else
 		unknown[0] = name_unknown;
 	/*
 	 * Count up the number of names.
 	 */
 	for (n = 1, cp = buf; *cp && *cp != ':'; cp++) {
 		if (*cp == '|')
 			n++;
+	}
 	/*
 	 * Allocate an array to put the name pointers into
 	 */
 	argv = (char **)malloc((n+3)*sizeof(char *));
 	if (argv == 0)
 		return(unknown);
 	/*
 	 * Fill up the array of pointers to names.
 	 */
 	*argv = 0;
 	argvp = argv+1;
 	n = 0;
 	for (cp = cp2 = buf; (c = *cp);  cp++) {
 		if (c == '|' || c == ':') {
 			*cp++ = '\0';
 			/*
 			 * Skip entries that have spaces or are over 40
 			 * characters long.  If this is our environment
 			 * name, then put it up front.  Otherwise, as
 			 * long as this is not a duplicate name (case
 			 * insensitive) add it to the list.
 			 */
 			if (n || (cp - cp2 > 41))
+				;
 			else if (name && (strncasecmp(name, cp2, cp-cp2) == 0))
 				*argv = cp2;
 			else if (is_unique(cp2, argv+1, argvp))
 				*argvp++ = cp2;
 			if (c == ':')
 				break;
 			/*
 			 * Skip multiple delimiters. Reset cp2 to
 			 * the beginning of the next name. Reset n,
 			 * the flag for names with spaces.
 			 */
 			while ((c = *cp) == '|')
 				cp++;
 			cp2 = cp;
 			n = 0;
+		}
 		/*
 		 * Skip entries with spaces or non-ascii values.
 		 * Convert lower case letters to upper case.
 		 */
 		if ((c == ' ') || !isascii(c))
 			n = 1;
 		else if (islower((unsigned char)c))
 			*cp = toupper((unsigned char)c);
+	}
 	/*
 	 * Check for an old V6 2 character name.  If the second
 	 * name points to the beginning of the buffer, and is
 	 * only 2 characters long, move it to the end of the array.
 	 */
 	if ((argv[1] == buf) && (strlen(argv[1]) == 2)) {
 		--argvp;
 		for (avt = &argv[1]; avt < argvp; avt++)
 			*avt = *(avt+1);
 		*argvp++ = buf;
+	}
 	/*
 	 * Duplicate last name, for TTYPE option, and null
 	 * terminate the array.  If we didn't find a match on
 	 * our terminal name, put that name at the beginning.
 	 */
 	cp = *(argvp-1);
 	*argvp++ = cp;
 	*argvp = 0;
 	if (*argv == 0) {
 		if (name)
 			*argv = name;
 		else {
 			--argvp;
 			for (avt = argv; avt < argvp; avt++)
 				*avt = *(avt+1);
+		}
+	}
 	if (*argv)
 		return(argv);
 	else
 		return(unknown);
+}
 int
 is_unique(char *name, char **as, char **ae)
+{
 	char **ap;
 	int n;
 	n = strlen(name) + 1;
 	for (ap = as; ap < ae; ap++)
 		if (strncasecmp(*ap, name, n) == 0)
 			return(0);
 	return (1);
+}
 #ifdef	TERMCAP
 char *termbuf;
 /*ARGSUSED*/
 int
 setupterm(char *tname, int fd, int *errp)
+{
 	char zz[1024], *zz_ptr;
 	char *ext_tc, *newptr;
 	size_t len;
 	if ((termbuf = malloc(1024)) == NULL)
 		goto error;
 	if (tgetent(termbuf, tname) == 1) {
 		/* check for ZZ capability, indicating termcap truncated */
 		zz_ptr = zz;
 		if (tgetstr("ZZ", &zz_ptr) != NULL) {
 			/* it was, fish back the full termcap */
 			sscanf(zz, "%p", &ext_tc);
 			len = strlen(ext_tc) + 1;
 			if ((newptr = realloc(termbuf, len)) == NULL)
 				goto error;
 			memcpy(newptr, ext_tc, len);
 			termbuf = newptr;
+		}
 		if (errp)
 			*errp = 1;
 		return(0);
+	}
   error:
 	if (errp)
 		*errp = 0;
 	return(-1);
+}
 #else
 #define	termbuf	ttytype
 extern char ttytype[];
 #endif
 int resettermname = 1;
 char *
 gettermname(void)
+{
 	char *tname;
 	static char **tnamep = 0;
 	static char **next;
 	int err;
 	if (resettermname) {
 		resettermname = 0;
 		if (tnamep && tnamep != unknown)
 			free(tnamep);
 		if ((tname = (char *)env_getvalue((const unsigned char *)"TERM")) &&
 				(setupterm(tname, 1, &err) == 0)) {
 			tnamep = mklist(termbuf, tname);
 		} else {
 			if (tname && ((int)strlen(tname) <= 40)) {
 				unknown[0] = tname;
 				upcase(tname);
 			} else
 				unknown[0] = name_unknown;
 			tnamep = unknown;
+		}
 		next = tnamep;
+	}
 	if (*next == 0)
 		next = tnamep;
 	return(*next++);
+}
 /*
  * suboption()
+ *
  *	Look at the sub-option buffer, and try to be helpful to the other
  * side.
+ *
  *	Currently we recognize:
+ *
  *		Terminal type, send request.
  *		Terminal speed (send request).
  *		Local flow control (is request).
  *		Linemode
  */
 static void
 suboption(void)
+{
     unsigned char subchar;
     printsub('<', subbuffer, SB_LEN()+2);
     switch (subchar = SB_GET()) {
     case TELOPT_TTYPE:
 	if (my_want_state_is_wont(TELOPT_TTYPE))
 	    return;
 	if (SB_EOF() || SB_GET() != TELQUAL_SEND) {
 	    return;
 	} else {
 	    char *name;
 	    unsigned char temp[50];
 	    int len;
 #ifdef TN3270
 	    if (tn3270_ttype()) {
 		return;
+	    }
 #endif	/* defined(TN3270) */
 	    name = gettermname();
 	    len = strlen(name) + 4 + 2;
 	    if (len < NETROOM()) {
-		sprintf((char *)temp, "%c%c%c%c%s%c%c", IAC, SB, TELOPT_TTYPE,
+		snprintf((char *)temp, sizeof(temp), "%c%c%c%c%s%c%c", IAC, SB,
-				TELQUAL_IS, name, IAC, SE);
+				TELOPT_TTYPE, TELQUAL_IS, name, IAC, SE);
 		ring_supply_data(&netoring, temp, len);
 		printsub('>', &temp[2], len-2);
 	    } else {
 		ExitString("No room in buffer for terminal type.\n", 1);
 		/*NOTREACHED*/
+	    }
+	}
 	break;
     case TELOPT_TSPEED:
 	if (my_want_state_is_wont(TELOPT_TSPEED))
 	    return;
 	if (SB_EOF())
 	    return;
 	if (SB_GET() == TELQUAL_SEND) {
 	    long osp, isp;
 	    unsigned char temp[50];
 	    int len;
 	    TerminalSpeeds(&isp, &osp);
-	    sprintf((char *)temp, "%c%c%c%c%ld,%ld%c%c", IAC, SB, TELOPT_TSPEED,
+	    snprintf((char *)temp, sizeof(temp), "%c%c%c%c%ld,%ld%c%c", IAC, SB,
-		    TELQUAL_IS, osp, isp, IAC, SE);
+		    TELOPT_TSPEED, TELQUAL_IS, osp, isp, IAC, SE);
 	    len = strlen((char *)temp+4) + 4;	/* temp[3] is 0 ... */
 	    if (len < NETROOM()) {
 		ring_supply_data(&netoring, temp, len);
 		printsub('>', temp+2, len - 2);
+	    }
 /*@*/	    else printf("lm_will: not enough room in buffer\n");
+	}
 	break;
     case TELOPT_LFLOW:
 	if (my_want_state_is_wont(TELOPT_LFLOW))
 	    return;
 	if (SB_EOF())
 	    return;
 	switch(SB_GET()) {
 	case LFLOW_RESTART_ANY:
 	    restartany = 1;
 	    break;
 	case LFLOW_RESTART_XON:
 	    restartany = 0;
 	    break;
 	case LFLOW_ON:
 	    localflow = 1;
 	    break;
 	case LFLOW_OFF:
 	    localflow = 0;
 	    break;
 	default:
 	    return;
+	}
 	setcommandmode();
 	setconnmode(0);
 	break;
     case TELOPT_LINEMODE:
 	if (my_want_state_is_wont(TELOPT_LINEMODE))
 	    return;
 	if (SB_EOF())
 	    return;
 	switch (SB_GET()) {
 	case WILL:
 	    lm_will(subpointer, SB_LEN());
 	    break;
 	case WONT:
 	    lm_wont(subpointer, SB_LEN());
 	    break;
 	case DO:
 	    lm_do(subpointer, SB_LEN());
 	    break;
 	case DONT:
 	    lm_dont(subpointer, SB_LEN());
 	    break;
 	case LM_SLC:
 	    slc(subpointer, SB_LEN());
 	    break;
 	case LM_MODE:
 	    lm_mode(subpointer, SB_LEN(), 0);
 	    break;
 	default:
 	    break;
+	}
 	break;
 #ifdef	OLD_ENVIRON
     case TELOPT_OLD_ENVIRON:
 #endif
     case TELOPT_NEW_ENVIRON:
 	if (SB_EOF())
 	    return;
 	switch(SB_PEEK()) {
 	case TELQUAL_IS:
 	case TELQUAL_INFO:
 	    if (my_want_state_is_dont(subchar))
 		return;
 	    break;
 	case TELQUAL_SEND:
 	    if (my_want_state_is_wont(subchar)) {
 		return;
+	    }
 	    break;
 	default:
 	    return;
+	}
 	env_opt(subpointer, SB_LEN());
 	break;
     case TELOPT_XDISPLOC:
 	if (my_want_state_is_wont(TELOPT_XDISPLOC))
 	    return;
 	if (SB_EOF())
 	    return;
 	if (SB_GET() == TELQUAL_SEND) {
 	    unsigned char temp[50], *dp;
 	    int len;
 	    if ((dp = env_getvalue((const unsigned char *)"DISPLAY")) == NULL) {
 		/*
 		 * Something happened, we no longer have a DISPLAY
 		 * variable.  So, turn off the option.
 		 */
 		send_wont(TELOPT_XDISPLOC, 1);
 		break;
+	    }
-	    sprintf((char *)temp, "%c%c%c%c%s%c%c", IAC, SB, TELOPT_XDISPLOC,
+	    snprintf((char *)temp, sizeof(temp), "%c%c%c%c%s%c%c", IAC, SB,
-		    TELQUAL_IS, dp, IAC, SE);
+		    TELOPT_XDISPLOC, TELQUAL_IS, dp, IAC, SE);
 	    len = strlen((char *)temp+4) + 4;	/* temp[3] is 0 ... */
 	    if (len < NETROOM()) {
 		ring_supply_data(&netoring, temp, len);
 		printsub('>', temp+2, len - 2);
+	    }
 /*@*/	    else printf("lm_will: not enough room in buffer\n");
+	}
 	break;
 #ifdef AUTHENTICATION
 	case TELOPT_AUTHENTICATION: {
 		if (!autologin)
 			break;
 		if (SB_EOF())
 			return;
 		switch(SB_GET()) {
 		case TELQUAL_IS:
 			if (my_want_state_is_dont(TELOPT_AUTHENTICATION))
 				return;
 			auth_is(subpointer, SB_LEN());
 			break;
 		case TELQUAL_SEND:
 			if (my_want_state_is_wont(TELOPT_AUTHENTICATION))
 				return;
 			auth_send(subpointer, SB_LEN());
 			break;
 		case TELQUAL_REPLY:
 			if (my_want_state_is_wont(TELOPT_AUTHENTICATION))
 				return;
 			auth_reply(subpointer, SB_LEN());
 			break;
 		case TELQUAL_NAME:
 			if (my_want_state_is_dont(TELOPT_AUTHENTICATION))
 				return;
 			auth_name(subpointer, SB_LEN());
 			break;
+		}
+	}
 	break;
 #endif
 #ifdef	ENCRYPTION
     case TELOPT_ENCRYPT:
 	if (SB_EOF())
 		return;
 	switch(SB_GET()) {
 	case ENCRYPT_START:
 		if (my_want_state_is_dont(TELOPT_ENCRYPT))
 			return;
 		encrypt_start(subpointer, SB_LEN());
 		break;
 	case ENCRYPT_END:
 		if (my_want_state_is_dont(TELOPT_ENCRYPT))
 			return;
 		encrypt_end();
 		break;
 	case ENCRYPT_SUPPORT:
 		if (my_want_state_is_wont(TELOPT_ENCRYPT))
 			return;
 		encrypt_support(subpointer, SB_LEN());
 		break;
 	case ENCRYPT_REQSTART:
 		if (my_want_state_is_wont(TELOPT_ENCRYPT))
 			return;
 		encrypt_request_start(subpointer, SB_LEN());
 		break;
 	case ENCRYPT_REQEND:
 		if (my_want_state_is_wont(TELOPT_ENCRYPT))
 			return;
 		/*
 		 * We can always send an REQEND so that we cannot
 		 * get stuck encrypting.  We should only get this
 		 * if we have been able to get in the correct mode
 		 * anyhow.
 		 */
 		encrypt_request_end();
 		break;
 	case ENCRYPT_IS:
 		if (my_want_state_is_dont(TELOPT_ENCRYPT))
 			return;
 		encrypt_is(subpointer, SB_LEN());
 		break;
 	case ENCRYPT_REPLY:
 		if (my_want_state_is_wont(TELOPT_ENCRYPT))
 			return;
 		encrypt_reply(subpointer, SB_LEN());
 		break;
 	case ENCRYPT_ENC_KEYID:
 		if (my_want_state_is_dont(TELOPT_ENCRYPT))
 			return;
 		encrypt_enc_keyid(subpointer, SB_LEN());
 		break;
 	case ENCRYPT_DEC_KEYID:
 		if (my_want_state_is_wont(TELOPT_ENCRYPT))
 			return;
 		encrypt_dec_keyid(subpointer, SB_LEN());
 		break;
 	default:
 		break;
+	}
 	break;
 #endif	/* ENCRYPTION */
     default:
 	break;
+    }
+}
 static unsigned char str_lm[] = { IAC, SB, TELOPT_LINEMODE, 0, 0, IAC, SE };
 void
 lm_will(unsigned char *cmd, int len)
+{
     if (len < 1) {
 /*@*/	printf("lm_will: no command!!!\n");	/* Should not happen... */
 	return;
+    }
     switch(cmd[0]) {
     case LM_FORWARDMASK:	/* We shouldn't ever get this... */
     default:
 	str_lm[3] = DONT;
 	str_lm[4] = cmd[0];
 	if ((size_t)NETROOM() > sizeof(str_lm)) {
 	    ring_supply_data(&netoring, str_lm, sizeof(str_lm));
 	    printsub('>', &str_lm[2], sizeof(str_lm)-2);
+	}
 /*@*/	else printf("lm_will: not enough room in buffer\n");
 	break;
+    }
+}
 void
 lm_wont(unsigned char *cmd, int len)
+{
     if (len < 1) {
 /*@*/	printf("lm_wont: no command!!!\n");	/* Should not happen... */
 	return;
+    }
     switch(cmd[0]) {
     case LM_FORWARDMASK:	/* We shouldn't ever get this... */
     default:
 	/* We are always DONT, so don't respond */
 	return;
+    }
+}
 void
 lm_do(unsigned char *cmd, int len)
+{
     if (len < 1) {
 /*@*/	printf("lm_do: no command!!!\n");	/* Should not happen... */
 	return;
+    }
     switch(cmd[0]) {
     case LM_FORWARDMASK:
     default:
 	str_lm[3] = WONT;
 	str_lm[4] = cmd[0];
 	if ((size_t)NETROOM() > sizeof(str_lm)) {
 	    ring_supply_data(&netoring, str_lm, sizeof(str_lm));
 	    printsub('>', &str_lm[2], sizeof(str_lm)-2);
+	}
 /*@*/	else printf("lm_do: not enough room in buffer\n");
 	break;
+    }
+}
 void
 lm_dont(unsigned char *cmd, int len)
+{
     if (len < 1) {
 /*@*/	printf("lm_dont: no command!!!\n");	/* Should not happen... */
 	return;
+    }
     switch(cmd[0]) {
     case LM_FORWARDMASK:
     default:
 	/* we are always WONT, so don't respond */
 	break;
+    }
+}
 static unsigned char str_lm_mode[] = {
 	IAC, SB, TELOPT_LINEMODE, LM_MODE, 0, IAC, SE
 };
 void
 lm_mode(unsigned char *cmd, int len, int init)
+{
 	if (len != 1)
 		return;
 	if ((linemode&MODE_MASK&~MODE_ACK) == *cmd)
 		return;
 	if (*cmd&MODE_ACK)
 		return;
 	linemode = *cmd&(MODE_MASK&~MODE_ACK);
 	str_lm_mode[4] = linemode;
 	if (!init)
 	    str_lm_mode[4] |= MODE_ACK;
 	if ((size_t)NETROOM() > sizeof(str_lm_mode)) {
 	    ring_supply_data(&netoring, str_lm_mode, sizeof(str_lm_mode));
 	    printsub('>', &str_lm_mode[2], sizeof(str_lm_mode)-2);
+	}
 /*@*/	else printf("lm_mode: not enough room in buffer\n");
 	setconnmode(0);	/* set changed mode */
+}
 /*
  * slc()
  * Handle special character suboption of LINEMODE.
  */
 struct spc {
 	cc_t val;
 	cc_t *valp;
 	char flags;	/* Current flags & level */
 	char mylevel;	/* Maximum level & flags */
 } spc_data[NSLC+1];
 #define SLC_IMPORT	0
 #define	SLC_EXPORT	1
 #define SLC_RVALUE	2
 static int slc_mode = SLC_EXPORT;
 void
 slc_init(void)
+{
 	struct spc *spcp;
 	localchars = 1;
 	for (spcp = spc_data; spcp < &spc_data[NSLC+1]; spcp++) {
 		spcp->val = 0;
 		spcp->valp = 0;
 		spcp->flags = spcp->mylevel = SLC_NOSUPPORT;
+	}
 #define	initfunc(func, flags) { \
 					spcp = &spc_data[func]; \
 					if ((spcp->valp = tcval(func)) != NULL){ \
 					    spcp->val = *spcp->valp; \
 					    spcp->mylevel = SLC_VARIABLE|flags; \
 					} else { \
 					    spcp->val = 0; \
 					    spcp->mylevel = SLC_DEFAULT; \
 					} \
+				    }
 	initfunc(SLC_SYNCH, 0);
 	/* No BRK */
 	initfunc(SLC_AO, 0);
 	initfunc(SLC_AYT, 0);
 	/* No EOR */
 	initfunc(SLC_ABORT, SLC_FLUSHIN|SLC_FLUSHOUT);
 	initfunc(SLC_EOF, 0);
 	initfunc(SLC_SUSP, SLC_FLUSHIN);
 	initfunc(SLC_EC, 0);
 	initfunc(SLC_EL, 0);
 	initfunc(SLC_EW, 0);
 	initfunc(SLC_RP, 0);
 	initfunc(SLC_LNEXT, 0);
 	initfunc(SLC_XON, 0);
 	initfunc(SLC_XOFF, 0);
 	initfunc(SLC_FORW1, 0);
 	initfunc(SLC_FORW2, 0);
 	/* No FORW2 */
 	initfunc(SLC_IP, SLC_FLUSHIN|SLC_FLUSHOUT);
 #undef	initfunc
 	if (slc_mode == SLC_EXPORT)
 		slc_export();
 	else
 		slc_import(1);
+}
 void
 slcstate(void)
+{
     printf("Special characters are %s values\n",
 		slc_mode == SLC_IMPORT ? "remote default" :
 		slc_mode == SLC_EXPORT ? "local" :
 					 "remote");
+}
 void
 slc_mode_export(int n)
+{
     slc_mode = SLC_EXPORT;
     if (my_state_is_will(TELOPT_LINEMODE))
 	slc_export();
+}
 void
 slc_mode_import(int def)
+{
     slc_mode = def ? SLC_IMPORT : SLC_RVALUE;
     if (my_state_is_will(TELOPT_LINEMODE))
 	slc_import(def);
+}
 unsigned char slc_import_val[] = {
 	IAC, SB, TELOPT_LINEMODE, LM_SLC, 0, SLC_VARIABLE, 0, IAC, SE
 };
 unsigned char slc_import_def[] = {
 	IAC, SB, TELOPT_LINEMODE, LM_SLC, 0, SLC_DEFAULT, 0, IAC, SE
 };
 void
 slc_import(int def)
+{
     if ((size_t)NETROOM() > sizeof(slc_import_val)) {
 	if (def) {
 	    ring_supply_data(&netoring, slc_import_def, sizeof(slc_import_def));
 	    printsub('>', &slc_import_def[2], sizeof(slc_import_def)-2);
 	} else {
 	    ring_supply_data(&netoring, slc_import_val, sizeof(slc_import_val));
 	    printsub('>', &slc_import_val[2], sizeof(slc_import_val)-2);
+	}
+    }
 /*@*/ else printf("slc_import: not enough room\n");
+}
 void
 slc_export(void)
+{
     struct spc *spcp;
     TerminalDefaultChars();
     slc_start_reply();
     for (spcp = &spc_data[1]; spcp < &spc_data[NSLC+1]; spcp++) {
 	if (spcp->mylevel != SLC_NOSUPPORT) {
 	    if (spcp->val == (cc_t)(_POSIX_VDISABLE))
 		spcp->flags = SLC_NOSUPPORT;
 	    else
 		spcp->flags = spcp->mylevel;
 	    if (spcp->valp)
 		spcp->val = *spcp->valp;
 	    slc_add_reply(spcp - spc_data, spcp->flags, spcp->val);
+	}
+    }
     slc_end_reply();
     (void)slc_update();
     setconnmode(1);	/* Make sure the character values are set */
+}
 void
 slc(unsigned char *cp, int len)
+{
 	struct spc *spcp;
 	int func,level;
 	slc_start_reply();
 	for (; len >= 3; len -=3, cp +=3) {
 		func = cp[SLC_FUNC];
 		if (func == 0) {
 			/*
 			 * Client side: always ignore 0 function.
 			 */
 			continue;
+		}
 		if (func > NSLC) {
 			if ((cp[SLC_FLAGS] & SLC_LEVELBITS) != SLC_NOSUPPORT)
 				slc_add_reply(func, SLC_NOSUPPORT, 0);
 			continue;
+		}
 		spcp = &spc_data[func];
 		level = cp[SLC_FLAGS]&(SLC_LEVELBITS|SLC_ACK);
 		if ((cp[SLC_VALUE] == (unsigned char)spcp->val) &&
 		    ((level&SLC_LEVELBITS) == (spcp->flags&SLC_LEVELBITS))) {
 			continue;
+		}
 		if (level == (SLC_DEFAULT|SLC_ACK)) {
 			/*
 			 * This is an error condition, the SLC_ACK
 			 * bit should never be set for the SLC_DEFAULT
 			 * level.  Our best guess to recover is to
 			 * ignore the SLC_ACK bit.
 			 */
 			cp[SLC_FLAGS] &= ~SLC_ACK;
+		}
 		if (level == ((spcp->flags&SLC_LEVELBITS)|SLC_ACK)) {
 			spcp->val = (cc_t)cp[SLC_VALUE];
 			spcp->flags = cp[SLC_FLAGS];	/* include SLC_ACK */
 			continue;
+		}
 		level &= ~SLC_ACK;
 		if (level <= (spcp->mylevel&SLC_LEVELBITS)) {
 			spcp->flags = cp[SLC_FLAGS]|SLC_ACK;
 			spcp->val = (cc_t)cp[SLC_VALUE];
+		}
 		if (level == SLC_DEFAULT) {
 			if ((spcp->mylevel&SLC_LEVELBITS) != SLC_DEFAULT)
 				spcp->flags = spcp->mylevel;
 			else
 				spcp->flags = SLC_NOSUPPORT;
+		}
 		slc_add_reply(func, spcp->flags, spcp->val);
+	}
 	slc_end_reply();
 	if (slc_update())
 		setconnmode(1);	/* set the  new character values */
+}
 void
 slc_check(void)
+{
     struct spc *spcp;
     slc_start_reply();
     for (spcp = &spc_data[1]; spcp < &spc_data[NSLC+1]; spcp++) {
 	if (spcp->valp && spcp->val != *spcp->valp) {
 	    spcp->val = *spcp->valp;
 	    if (spcp->val == (cc_t)(_POSIX_VDISABLE))
 		spcp->flags = SLC_NOSUPPORT;
 	    else
 		spcp->flags = spcp->mylevel;
 	    slc_add_reply(spcp - spc_data, spcp->flags, spcp->val);
+	}
+    }
     slc_end_reply();
     setconnmode(1);
+}
 unsigned char slc_reply[128];
 unsigned char *slc_replyp;
 void
 slc_start_reply(void)
+{
 	slc_replyp = slc_reply;
 	*slc_replyp++ = IAC;
 	*slc_replyp++ = SB;
 	*slc_replyp++ = TELOPT_LINEMODE;
 	*slc_replyp++ = LM_SLC;
+}
 void
 slc_add_reply(unsigned int func, unsigned int flags, cc_t value)
+{
 	if ((size_t)(slc_replyp - slc_reply) + 6 > sizeof(slc_reply))
 		return;
 	if ((*slc_replyp++ = func) == IAC)
 		*slc_replyp++ = IAC;
 	if ((*slc_replyp++ = flags) == IAC)
 		*slc_replyp++ = IAC;
 	if ((*slc_replyp++ = (unsigned char)value) == IAC)
 		*slc_replyp++ = IAC;
+}
 void
 slc_end_reply(void)
+{
     int len;
     len = slc_replyp - slc_reply;
     if (len <= 4 || ((size_t)len + 2 > sizeof(slc_reply)))
 	return;
     *slc_replyp++ = IAC;
     *slc_replyp++ = SE;
     len += 2;
     if (NETROOM() > len) {
 	ring_supply_data(&netoring, slc_reply, slc_replyp - slc_reply);
 	printsub('>', &slc_reply[2], slc_replyp - slc_reply - 2);
+    }
 /*@*/else printf("slc_end_reply: not enough room\n");
+}
 int
 slc_update(void)
+{
 	struct spc *spcp;
 	int need_update = 0;
 	for (spcp = &spc_data[1]; spcp < &spc_data[NSLC+1]; spcp++) {
 		if (!(spcp->flags&SLC_ACK))
 			continue;
 		spcp->flags &= ~SLC_ACK;
 		if (spcp->valp && (*spcp->valp != spcp->val)) {
 			*spcp->valp = spcp->val;
 			need_update = 1;
+		}
+	}
 	return(need_update);
+}
 #ifdef	OLD_ENVIRON
 # ifdef	ENV_HACK
 /*
  * Earlier version of telnet/telnetd from the BSD code had
  * the definitions of VALUE and VAR reversed.  To ensure
  * maximum interoperability, we assume that the server is
  * an older BSD server, until proven otherwise.  The newer
  * BSD servers should be able to handle either definition,
  * so it is better to use the wrong values if we don't
  * know what type of server it is.
  */
 int env_auto = 1;
 int old_env_var = OLD_ENV_VAR;
 int old_env_value = OLD_ENV_VALUE;
 # else
 #  define old_env_var OLD_ENV_VAR
 #  define old_env_value OLD_ENV_VALUE
 # endif
 #endif
 void
 env_opt(unsigned char *buf, int len)
+{
 	unsigned char *ep = 0, *epc = 0;
 	int i;
 	switch(buf[0]&0xff) {
 	case TELQUAL_SEND:
 		env_opt_start();
 		if (len == 1) {
 			env_opt_add(NULL);
 		} else for (i = 1; i < len; i++) {
 			switch (buf[i]&0xff) {
 #ifdef	OLD_ENVIRON
 			case OLD_ENV_VAR:
 # ifdef	ENV_HACK
 				if (telopt_environ == TELOPT_OLD_ENVIRON
 				    && env_auto) {
 					/* Server has the same definitions */
 					old_env_var = OLD_ENV_VAR;
 					old_env_value = OLD_ENV_VALUE;
+				}
 				/* FALL THROUGH */
 # endif
 			case OLD_ENV_VALUE:
 				/*
 				 * Although OLD_ENV_VALUE is not legal, we will
 				 * still recognize it, just in case it is an
 				 * old server that has VAR & VALUE mixed up...
 				 */
 				/* FALL THROUGH */
 #else
 			case NEW_ENV_VAR:
 #endif
 			case ENV_USERVAR:
 				if (ep) {
 					*epc = 0;
 					env_opt_add(ep);
+				}
 				ep = epc = &buf[i+1];
 				break;
 			case ENV_ESC:
 				i++;
 				/*FALL THROUGH*/
 			default:
 				if (epc)
 					*epc++ = buf[i];
 				break;
+			}
+		}
 		if (ep) {
 			*epc = 0;
 			env_opt_add(ep);
+		}
 		env_opt_end(1);
 		break;
 	case TELQUAL_IS:
 	case TELQUAL_INFO:
 		/* Ignore for now.  We shouldn't get it anyway. */
 		break;
 	default:
 		break;
+	}
+}
 #define	OPT_REPLY_SIZE	256
 unsigned char *opt_reply;
 unsigned char *opt_replyp;
 unsigned char *opt_replyend;
 void
 env_opt_start(void)
+{
 	unsigned char *p;
 	if (opt_reply) {
 		p = (unsigned char *)realloc(opt_reply, OPT_REPLY_SIZE);
 		if (p == NULL)
 			free(opt_reply);
 	} else
 		p = (unsigned char *)malloc(OPT_REPLY_SIZE);
 	opt_reply = p;
 	if (opt_reply == NULL) {
 /*@*/		printf("env_opt_start: malloc()/realloc() failed!!!\n");
 		opt_reply = opt_replyp = opt_replyend = NULL;
 		return;
+	}
 	opt_replyp = opt_reply;
 	opt_replyend = opt_reply + OPT_REPLY_SIZE;
 	*opt_replyp++ = IAC;
 	*opt_replyp++ = SB;
 	*opt_replyp++ = telopt_environ;
 	*opt_replyp++ = TELQUAL_IS;
+}
 void
 env_opt_start_info(void)
+{
 	env_opt_start();
 	if (opt_replyp)
 	    opt_replyp[-1] = TELQUAL_INFO;
+}
 void
 env_opt_add(unsigned char *ep)
+{
 	unsigned char *vp, c;
 	unsigned int len, olen, elen;
 	if (opt_reply == NULL)		/*XXX*/
 		return;			/*XXX*/
 	if (ep == NULL || *ep == '\0') {
 		/* Send user defined variables first. */
 		env_default(1, 0);
 		while ((ep = env_default(0, 0)) != NULL)
 			env_opt_add(ep);
 		/* Now add the list of well know variables.  */
 		env_default(1, 1);
 		while ((ep = env_default(0, 1)) != NULL)
 			env_opt_add(ep);
 		return;
+	}
 	vp = env_getvalue(ep);
 	elen = 2 * (vp ? strlen((char *)vp) : 0) +
 * strlen((char *)ep) + 6;
 	if ((unsigned int)(opt_replyend - opt_replyp) < elen)
+	{
 		unsigned char *p;
 		len = opt_replyend - opt_reply + elen;
 		olen = opt_replyp - opt_reply;
 		p = (unsigned char *)realloc(opt_reply, len);
 		if (p == NULL)
 			free(opt_reply);
 		opt_reply = p;
 		if (opt_reply == NULL) {
 /*@*/			printf("env_opt_add: realloc() failed!!!\n");
 			opt_reply = opt_replyp = opt_replyend = NULL;
 			return;
+		}
 		opt_replyp = opt_reply + olen;
 		opt_replyend = opt_reply + len;
+	}
 	if (opt_welldefined(ep))
 #ifdef	OLD_ENVIRON
 		if (telopt_environ == TELOPT_OLD_ENVIRON)
 			*opt_replyp++ = old_env_var;
 		else
 #endif
 			*opt_replyp++ = NEW_ENV_VAR;
 	else
 		*opt_replyp++ = ENV_USERVAR;
 	for (;;) {
 		while ((c = *ep++) != '\0') {
 			switch(c&0xff) {
 			case IAC:
 				*opt_replyp++ = IAC;
 				break;
 			case NEW_ENV_VAR:
 			case NEW_ENV_VALUE:
 			case ENV_ESC:
 			case ENV_USERVAR:
 				*opt_replyp++ = ENV_ESC;
 				break;
+			}
 			*opt_replyp++ = c;
+		}
 		if ((ep = vp) != NULL) {
 #ifdef	OLD_ENVIRON
 			if (telopt_environ == TELOPT_OLD_ENVIRON)
 				*opt_replyp++ = old_env_value;
 			else
 #endif
 				*opt_replyp++ = NEW_ENV_VALUE;
 			vp = NULL;
 		} else
 			break;
+	}
+}
 int
 opt_welldefined(const char *ep)
+{
 	if ((strcmp(ep, "USER") == 0) ||
 	    (strcmp(ep, "DISPLAY") == 0) ||
 	    (strcmp(ep, "PRINTER") == 0) ||
 	    (strcmp(ep, "SYSTEMTYPE") == 0) ||
 	    (strcmp(ep, "JOB") == 0) ||
 	    (strcmp(ep, "ACCT") == 0))
 		return(1);
 	return(0);
+}
 void
 env_opt_end(int emptyok)
+{
 	int len;
 	len = opt_replyp - opt_reply + 2;
 	if (emptyok || len > 6) {
 		*opt_replyp++ = IAC;
 		*opt_replyp++ = SE;
 		if (NETROOM() > len) {
 			ring_supply_data(&netoring, opt_reply, len);
 			printsub('>', &opt_reply[2], len - 2);
+		}
 /*@*/		else printf("slc_end_reply: not enough room\n");
+	}
 	if (opt_reply) {
 		free(opt_reply);
 		opt_reply = opt_replyp = opt_replyend = NULL;
+	}
+}
 int
 telrcv(void)
+{
     int c;
     int scc;
     unsigned char *sbp = NULL;
     int count;
     int returnValue = 0;
     scc = 0;
     count = 0;
     while (TTYROOM() > 2) {
 	if (scc == 0) {
 	    if (count) {
 		ring_consumed(&netiring, count);
 		returnValue = 1;
 		count = 0;
+	    }
 	    sbp = netiring.consume;
 	    scc = ring_full_consecutive(&netiring);
 	    if (scc == 0) {
 		/* No more data coming in */
 		break;
+	    }
+	}
 	c = *sbp++ & 0xff, scc--; count++;
 #ifdef	ENCRYPTION
 	if (decrypt_input)
 		c = (*decrypt_input)(c);
 #endif	/* ENCRYPTION */
 	switch (telrcv_state) {
 	case TS_CR:
 	    telrcv_state = TS_DATA;
 	    if (c == '\0') {
 		break;	/* Ignore \0 after CR */
+	    }
 	    else if ((c == '\n') && my_want_state_is_dont(TELOPT_ECHO) && !crmod) {
 		TTYADD(c);
 		break;
+	    }
 	    /* Else, fall through */
 	case TS_DATA:
 	    if (c == IAC) {
 		telrcv_state = TS_IAC;
 		break;
+	    }
 #	    if defined(TN3270)
 	    if (In3270) {
 		*Ifrontp++ = c;
 		while (scc > 0) {
 		    c = *sbp++ & 0377, scc--; count++;
 #ifdef	ENCRYPTION
 		    if (decrypt_input)
 			c = (*decrypt_input)(c);
 #endif	/* ENCRYPTION */
 		    if (c == IAC) {
 			telrcv_state = TS_IAC;
 			break;
+		    }
 		    *Ifrontp++ = c;
+		}
 	    } else
 #	    endif /* defined(TN3270) */
 		    /*
 		     * The 'crmod' hack (see following) is needed
 		     * since we can't * set CRMOD on output only.
 		     * Machines like MULTICS like to send \r without
 		     * \n; since we must turn off CRMOD to get proper
 		     * input, the mapping is done here (sigh).
 		     */
 	    if ((c == '\r') && my_want_state_is_dont(TELOPT_BINARY)) {
 		if (scc > 0) {
 		    c = *sbp&0xff;
 #ifdef	ENCRYPTION
 		    if (decrypt_input)
 			c = (*decrypt_input)(c);
 #endif	/* ENCRYPTION */
 		    if (c == 0) {
 			sbp++, scc--; count++;
 			/* a "true" CR */
 			TTYADD('\r');
 		    } else if (my_want_state_is_dont(TELOPT_ECHO) &&
 					(c == '\n')) {
 			sbp++, scc--; count++;
 			TTYADD('\n');
 		    } else {
 #ifdef	ENCRYPTION
 			if (decrypt_input)
 			    (*decrypt_input)(-1);
 #endif	/* ENCRYPTION */
 			TTYADD('\r');
 			if (crmod) {
 				TTYADD('\n');
+			}
+		    }
 		} else {
 		    telrcv_state = TS_CR;
 		    TTYADD('\r');
 		    if (crmod) {
 			    TTYADD('\n');
+		    }
+		}
 	    } else {
 		TTYADD(c);
+	    }
 	    continue;
 	case TS_IAC:
 process_iac:
 	    switch (c) {
 	    case WILL:
 		telrcv_state = TS_WILL;
 		continue;
 	    case WONT:
 		telrcv_state = TS_WONT;
 		continue;
 	    case DO:
 		telrcv_state = TS_DO;
 		continue;
 	    case DONT:
 		telrcv_state = TS_DONT;
 		continue;
 	    case DM:
 		    /*
 		     * We may have missed an urgent notification,
 		     * so make sure we flush whatever is in the
 		     * buffer currently.
 		     */
 		printoption("RCVD", IAC, DM);
 		SYNCHing = 1;
 		(void) ttyflush(1);
 		SYNCHing = stilloob();
 		settimer(gotDM);
 		break;
 	    case SB:
 		SB_CLEAR();
 		telrcv_state = TS_SB;
 		continue;
 #	    if defined(TN3270)
 	    case EOR:
 		if (In3270) {
 		    if (Ibackp == Ifrontp) {
 			Ibackp = Ifrontp = Ibuf;
 			ISend = 0;	/* should have been! */
 		    } else {
 			Ibackp += DataFromNetwork(Ibackp, Ifrontp-Ibackp, 1);
 			ISend = 1;
+		    }
+		}
 		printoption("RCVD", IAC, EOR);
 		break;
 #	    endif /* defined(TN3270) */
 	    case IAC:
 #	    if !defined(TN3270)
 		TTYADD(IAC);
 #	    else /* !defined(TN3270) */
 		if (In3270) {
 		    *Ifrontp++ = IAC;
 		} else {
 		    TTYADD(IAC);
+		}
 #	    endif /* !defined(TN3270) */
 		break;
 	    case NOP:
 	    case GA:
 	    default:
 		printoption("RCVD", IAC, c);
 		break;
+	    }
 	    telrcv_state = TS_DATA;
 	    continue;
 	case TS_WILL:
 	    printoption("RCVD", WILL, c);
 	    willoption(c);
 	    SetIn3270();
 	    telrcv_state = TS_DATA;
 	    continue;
 	case TS_WONT:
 	    printoption("RCVD", WONT, c);
 	    wontoption(c);
 	    SetIn3270();
 	    telrcv_state = TS_DATA;
 	    continue;
 	case TS_DO:
 	    printoption("RCVD", DO, c);
 	    dooption(c);
 	    SetIn3270();
 	    if (c == TELOPT_NAWS) {
 		sendnaws();
 	    } else if (c == TELOPT_LFLOW) {
 		localflow = 1;
 		setcommandmode();
 		setconnmode(0);
+	    }
 	    telrcv_state = TS_DATA;
 	    continue;
 	case TS_DONT:
 	    printoption("RCVD", DONT, c);
 	    dontoption(c);
 	    flushline = 1;
 	    setconnmode(0);	/* set new tty mode (maybe) */
 	    SetIn3270();
 	    telrcv_state = TS_DATA;
 	    continue;
 	case TS_SB:
 	    if (c == IAC) {
 		telrcv_state = TS_SE;
 	    } else {
 		SB_ACCUM(c);
+	    }
 	    continue;
 	case TS_SE:
 	    if (c != SE) {
 		if (c != IAC) {
 		    /*
 		     * This is an error.  We only expect to get
 		     * "IAC IAC" or "IAC SE".  Several things may
 		     * have happened.  An IAC was not doubled, the
 		     * IAC SE was left off, or another option got
 		     * inserted into the suboption are all possibilities.
 		     * If we assume that the IAC was not doubled,
 		     * and really the IAC SE was left off, we could
 		     * get into an infinite loop here.  So, instead,
 		     * we terminate the suboption, and process the
 		     * partial suboption if we can.
 		     */
 		    SB_ACCUM(IAC);
 		    SB_ACCUM(c);
 		    subpointer -= 2;
 		    SB_TERM();
 		    printoption("In SUBOPTION processing, RCVD", IAC, c);
 		    suboption();	/* handle sub-option */
 		    SetIn3270();
 		    telrcv_state = TS_IAC;
 		    goto process_iac;
+		}
 		SB_ACCUM(c);
 		telrcv_state = TS_SB;
 	    } else {
 		SB_ACCUM(IAC);
 		SB_ACCUM(SE);

 @@ -1,925 +1,925 @@
-/*	$NetBSD: utilities.c,v 1.23 2012/01/09 16:08:55 christos Exp $	*/
+/*	$NetBSD: utilities.c,v 1.23.20.1 2018/12/18 18:37:26 martin Exp $	*/
 /*
  * 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. 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.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)utilities.c	8.3 (Berkeley) 5/30/95";
 #else
-__RCSID("$NetBSD: utilities.c,v 1.23 2012/01/09 16:08:55 christos Exp $");
+__RCSID("$NetBSD: utilities.c,v 1.23.20.1 2018/12/18 18:37:26 martin Exp $");
 #endif
 #endif /* not lint */
 #define	TELOPTS
 #define	TELCMDS
 #define	SLC_NAMES
 #include <arpa/telnet.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <sys/socket.h>
 #include <unistd.h>
 #include <poll.h>
 #include <ctype.h>
 #include "general.h"
 #include "ring.h"
 #include "defines.h"
 #include "externs.h"
 #ifdef TN3270
 #include "../sys_curses/telextrn.h"
 #endif
 #ifdef AUTHENTICATION
 #include <libtelnet/auth.h>
 #endif
 #ifdef ENCRYPTION
 #include <libtelnet/encrypt.h>
 #endif
 FILE	*NetTrace = 0;		/* Not in bss, since needs to stay */
 int	prettydump;
 /*
  * upcase()
+ *
  *	Upcase (in place) the argument.
  */
 void
 upcase(char *argument)
+{
     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(int fd, int level, int option, int yesno)
+{
     return setsockopt(fd, level, option, (char *)&yesno, sizeof yesno);
+}
 /*
  * The following are routines used to print out debugging information.
  */
 char NetTraceFile[256] = "(standard output)";
 void
 SetNetTrace(char *file)
+{
     if (NetTrace && NetTrace != stdout)
 	fclose(NetTrace);
     if (file  && (strcmp(file, "-") != 0)) {
 	NetTrace = fopen(file, "w");
 	if (NetTrace) {
 	    strlcpy(NetTraceFile, file, sizeof(NetTraceFile));
 	    return;
+	}
 	fprintf(stderr, "Cannot open %s.\n", file);
+    }
     NetTrace = stdout;
     strlcpy(NetTraceFile, "(standard output)", sizeof(NetTraceFile));
+}
 void
 Dump(int 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 */
 	fprintf(NetTrace, "%c 0x%x\t", direction, offset);
 	pThis = buffer;
 	if (prettydump) {
 	    buffer = buffer + min(length, BYTES_PER_LINE/2);
 	    while (pThis < buffer) {
 		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) {
 		fprintf(NetTrace, "%.2x", (*pThis)&0xff);
 		pThis++;
+	    }
 	    length -= BYTES_PER_LINE;
 	    offset += BYTES_PER_LINE;
+	}
 	if (NetTrace == stdout) {
 	    fprintf(NetTrace, "\r\n");
 	} else {
 	    fprintf(NetTrace, "\n");
+	}
 	if (length < 0) {
 	    fflush(NetTrace);
 	    return;
+	}
 	/* find next unique line */
+    }
     fflush(NetTrace);
+}
 void
 printoption(const char *direction, int cmd, int option)
+{
 	if (!showoptions)
 		return;
 	if (cmd == IAC) {
 		if (TELCMD_OK(option))
 		    fprintf(NetTrace, "%s IAC %s", direction, TELCMD(option));
 		else
 		    fprintf(NetTrace, "%s IAC %d", direction, option);
 	} else {
 		const char *fmt;
 		fmt = (cmd == WILL) ? "WILL" : (cmd == WONT) ? "WONT" :
 			(cmd == DO) ? "DO" : (cmd == DONT) ? "DONT" : 0;
 		if (fmt) {
 		    fprintf(NetTrace, "%s %s ", direction, fmt);
 		    if (TELOPT_OK(option))
 			fprintf(NetTrace, "%s", TELOPT(option));
 		    else if (option == TELOPT_EXOPL)
 			fprintf(NetTrace, "EXOPL");
 		    else
 			fprintf(NetTrace, "%d", option);
 		} else
 		    fprintf(NetTrace, "%s %d %d", direction, cmd, option);
+	}
 	if (NetTrace == stdout) {
 	    fprintf(NetTrace, "\r\n");
 	    fflush(NetTrace);
 	} else {
 	    fprintf(NetTrace, "\n");
+	}
 	return;
+}
 void
 optionstatus(void)
+{
     int i;
     extern char will_wont_resp[], do_dont_resp[];
     for (i = 0; i < 256; i++) {
 	if (do_dont_resp[i]) {
 	    if (TELOPT_OK(i))
 		printf("resp DO_DONT %s: %d\n", TELOPT(i), do_dont_resp[i]);
 	    else if (TELCMD_OK(i))
 		printf("resp DO_DONT %s: %d\n", TELCMD(i), do_dont_resp[i]);
 	    else
 		printf("resp DO_DONT %d: %d\n", i,
 				do_dont_resp[i]);
 	    if (my_want_state_is_do(i)) {
 		if (TELOPT_OK(i))
 		    printf("want DO   %s\n", TELOPT(i));
 		else if (TELCMD_OK(i))
 		    printf("want DO   %s\n", TELCMD(i));
 		else
 		    printf("want DO   %d\n", i);
 	    } else {
 		if (TELOPT_OK(i))
 		    printf("want DONT %s\n", TELOPT(i));
 		else if (TELCMD_OK(i))
 		    printf("want DONT %s\n", TELCMD(i));
 		else
 		    printf("want DONT %d\n", i);
+	    }
 	} else {
 	    if (my_state_is_do(i)) {
 		if (TELOPT_OK(i))
 		    printf("     DO   %s\n", TELOPT(i));
 		else if (TELCMD_OK(i))
 		    printf("     DO   %s\n", TELCMD(i));
 		else
 		    printf("     DO   %d\n", i);
+	    }
+	}
 	if (will_wont_resp[i]) {
 	    if (TELOPT_OK(i))
 		printf("resp WILL_WONT %s: %d\n", TELOPT(i), will_wont_resp[i]);
 	    else if (TELCMD_OK(i))
 		printf("resp WILL_WONT %s: %d\n", TELCMD(i), will_wont_resp[i]);
 	    else
 		printf("resp WILL_WONT %d: %d\n",
 				i, will_wont_resp[i]);
 	    if (my_want_state_is_will(i)) {
 		if (TELOPT_OK(i))
 		    printf("want WILL %s\n", TELOPT(i));
 		else if (TELCMD_OK(i))
 		    printf("want WILL %s\n", TELCMD(i));
 		else
 		    printf("want WILL %d\n", i);
 	    } else {
 		if (TELOPT_OK(i))
 		    printf("want WONT %s\n", TELOPT(i));
 		else if (TELCMD_OK(i))
 		    printf("want WONT %s\n", TELCMD(i));
 		else
 		    printf("want WONT %d\n", i);
+	    }
 	} else {
 	    if (my_state_is_will(i)) {
 		if (TELOPT_OK(i))
 		    printf("     WILL %s\n", TELOPT(i));
 		else if (TELCMD_OK(i))
 		    printf("     WILL %s\n", TELCMD(i));
 		else
 		    printf("     WILL %d\n", i);
+	    }
+	}
+    }
+}
 void
 printsub(
     int direction,	/* '<' or '>' */
     unsigned char *pointer,	/* where suboption data sits */
     int		  length)	/* length of suboption data */
+{
     int i;
 #ifdef	ENCRYPTION
     char buf[512];
 #endif	/* ENCRYPTION */
     extern int want_status_response;
     if (showoptions || direction == 0 ||
 	(want_status_response && (pointer[0] == TELOPT_STATUS))) {
 	if (direction) {
 	    fprintf(NetTrace, "%s IAC SB ",
 				(direction == '<')? "RCVD":"SENT");
 	    if (length >= 3) {
 		int j;
 		i = pointer[length-2];
 		j = pointer[length-1];
 		if (i != IAC || j != SE) {
 		    fprintf(NetTrace, "(terminated by ");
 		    if (TELOPT_OK(i))
 			fprintf(NetTrace, "%s ", TELOPT(i));
 		    else if (TELCMD_OK(i))
 			fprintf(NetTrace, "%s ", TELCMD(i));
 		    else
 			fprintf(NetTrace, "%d ", i);
 		    if (TELOPT_OK(j))
 			fprintf(NetTrace, "%s", TELOPT(j));
 		    else if (TELCMD_OK(j))
 			fprintf(NetTrace, "%s", TELCMD(j));
 		    else
 			fprintf(NetTrace, "%d", j);
 		    fprintf(NetTrace, ", not IAC SE!) ");
+		}
+	    }
 	    length -= 2;
+	}
 	if (length < 1) {
 	    fprintf(NetTrace, "(Empty suboption??\?)");
 	    if (NetTrace == stdout)
 		fflush(NetTrace);
 	    return;
+	}
 	switch (pointer[0]) {
 	case TELOPT_TTYPE:
 	    fprintf(NetTrace, "TERMINAL-TYPE ");
 	    switch (pointer[1]) {
 	    case TELQUAL_IS:
 		fprintf(NetTrace, "IS \"%.*s\"", length-2, (char *)pointer+2);
 		break;
 	    case TELQUAL_SEND:
 		fprintf(NetTrace, "SEND");
 		break;
 	    default:
 		fprintf(NetTrace,
 				"- unknown qualifier %d (0x%x).",
 				pointer[1], pointer[1]);
+	    }
 	    break;
 	case TELOPT_TSPEED:
 	    fprintf(NetTrace, "TERMINAL-SPEED");
 	    if (length < 2) {
 		fprintf(NetTrace, " (empty suboption??\?)");
 		break;
+	    }
 	    switch (pointer[1]) {
 	    case TELQUAL_IS:
 		fprintf(NetTrace, " IS ");
 		fprintf(NetTrace, "%.*s", length-2, (char *)pointer+2);
 		break;
 	    default:
 		if (pointer[1] == 1)
 		    fprintf(NetTrace, " SEND");
 		else
 		    fprintf(NetTrace, " %d (unknown)", pointer[1]);
 		for (i = 2; i < length; i++)
 		    fprintf(NetTrace, " ?%d?", pointer[i]);
 		break;
+	    }
 	    break;
 	case TELOPT_LFLOW:
 	    fprintf(NetTrace, "TOGGLE-FLOW-CONTROL");
 	    if (length < 2) {
 		fprintf(NetTrace, " (empty suboption??\?)");
 		break;
+	    }
 	    switch (pointer[1]) {
 	    case LFLOW_OFF:
 		fprintf(NetTrace, " OFF"); break;
 	    case LFLOW_ON:
 		fprintf(NetTrace, " ON"); break;
 	    case LFLOW_RESTART_ANY:
 		fprintf(NetTrace, " RESTART-ANY"); break;
 	    case LFLOW_RESTART_XON:
 		fprintf(NetTrace, " RESTART-XON"); break;
 	    default:
 		fprintf(NetTrace, " %d (unknown)", pointer[1]);
+	    }
 	    for (i = 2; i < length; i++)
 		fprintf(NetTrace, " ?%d?", pointer[i]);
 	    break;
 	case TELOPT_NAWS:
 	    fprintf(NetTrace, "NAWS");
 	    if (length < 2) {
 		fprintf(NetTrace, " (empty suboption??\?)");
 		break;
+	    }
 	    if (length == 2) {
 		fprintf(NetTrace, " ?%d?", pointer[1]);
 		break;
+	    }
 	    fprintf(NetTrace, " %d %d (%d)",
 		pointer[1], pointer[2],
 		(int)((((unsigned int)pointer[1])<<8)|((unsigned int)pointer[2])));
 	    if (length == 4) {
 		fprintf(NetTrace, " ?%d?", pointer[3]);
 		break;
+	    }
 	    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++)
 		fprintf(NetTrace, " ?%d?", pointer[i]);
 	    break;
 #ifdef AUTHENTICATION
 	case TELOPT_AUTHENTICATION:
 	    fprintf(NetTrace, "AUTHENTICATION");
 	    if (length < 2) {
 		fprintf(NetTrace, " (empty suboption??\?)");
 		break;
+	    }
 	    switch (pointer[1]) {
 	    case TELQUAL_REPLY:
 	    case TELQUAL_IS:
 		fprintf(NetTrace, " %s ", (pointer[1] == TELQUAL_IS) ?
 							"IS" : "REPLY");
 		if (AUTHTYPE_NAME_OK(pointer[2]))
 		    fprintf(NetTrace, "%s ", AUTHTYPE_NAME(pointer[2]));
 		else
 		    fprintf(NetTrace, "%d ", pointer[2]);
 		if (length < 3) {
 		    fprintf(NetTrace, "(partial suboption??\?)");
 		    break;
+		}
 		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, buf, sizeof(buf));
 		fprintf(NetTrace, "%s", buf);
 		break;
 	    case TELQUAL_SEND:
 		i = 2;
 		fprintf(NetTrace, " SEND ");
 		while (i < length) {
 		    if (AUTHTYPE_NAME_OK(pointer[i]))
 			fprintf(NetTrace, "%s ", AUTHTYPE_NAME(pointer[i]));
 		    else
 			fprintf(NetTrace, "%d ", pointer[i]);
 		    if (++i >= length) {
 			fprintf(NetTrace, "(partial suboption??\?)");
 			break;
+		    }
 		    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;
 		fprintf(NetTrace, " NAME \"");
 		while (i < length)
 		    putc(pointer[i++], NetTrace);
 		putc('"', NetTrace);
 		break;
 	    default:
 		    for (i = 2; i < length; i++)
 			fprintf(NetTrace, " ?%d?", pointer[i]);
 		    break;
+	    }
 	    break;
 #endif
 #ifdef	ENCRYPTION
 	case TELOPT_ENCRYPT:
 		fprintf(NetTrace, "ENCRYPT");
 		if (length < 2) {
 			fprintf(NetTrace, " (empty suboption??\?)");
 			break;
+		}
 		switch (pointer[1]) {
 		case ENCRYPT_START:
 			fprintf(NetTrace, " START");
 			break;
 		case ENCRYPT_END:
 			fprintf(NetTrace, " END");
 			break;
 		case ENCRYPT_REQSTART:
 			fprintf(NetTrace, " REQUEST-START");
 			break;
 		case ENCRYPT_REQEND:
 			fprintf(NetTrace, " REQUEST-END");
 			break;
 		case ENCRYPT_IS:
 		case ENCRYPT_REPLY:
 			fprintf(NetTrace, " %s ", (pointer[1] == ENCRYPT_IS) ?
 			    "IS" : "REPLY");
 			if (length < 3) {
 				fprintf(NetTrace, " (partial suboption??\?)");
 				break;
+			}
 			if (ENCTYPE_NAME_OK(pointer[2]))
 				fprintf(NetTrace, "%s ",
 				    ENCTYPE_NAME(pointer[2]));
 			else
 				fprintf(NetTrace, " %d (unknown)", pointer[2]);
 			encrypt_printsub(&pointer[1], length - 1, buf,
 			    sizeof(buf));
 			fprintf(NetTrace, "%s", buf);
 			break;
 		case ENCRYPT_SUPPORT:
 			i = 2;
 			fprintf(NetTrace, " SUPPORT ");
 			while (i < length) {
 				if (ENCTYPE_NAME_OK(pointer[i]))
 					fprintf(NetTrace, "%s ",
 					    ENCTYPE_NAME(pointer[i]));
 				else
 					fprintf(NetTrace, "%d ", pointer[i]);
 				i++;
+			}
 			break;
 		case ENCRYPT_ENC_KEYID:
 			fprintf(NetTrace, " ENC_KEYID ");
 			goto encommon;
 		case ENCRYPT_DEC_KEYID:
 			fprintf(NetTrace, " DEC_KEYID ");
 			goto encommon;
 		default:
 			fprintf(NetTrace, " %d (unknown)", pointer[1]);
 		encommon:
 			for (i = 2; i < length; i++)
 				fprintf(NetTrace, " %d", pointer[i]);
 			break;
+		}
 		break;
 #endif	/* ENCRYPTION */
 	case TELOPT_LINEMODE:
 	    fprintf(NetTrace, "LINEMODE ");
 	    if (length < 2) {
 		fprintf(NetTrace, " (empty suboption??\?)");
 		break;
+	    }
 	    switch (pointer[1]) {
 	    case WILL:
 		fprintf(NetTrace, "WILL ");
 		goto common;
 	    case WONT:
 		fprintf(NetTrace, "WONT ");
 		goto common;
 	    case DO:
 		fprintf(NetTrace, "DO ");
 		goto common;
 	    case DONT:
 		fprintf(NetTrace, "DONT ");
 	    common:
 		if (length < 3) {
 		    fprintf(NetTrace, "(no option??\?)");
 		    break;
+		}
 		switch (pointer[2]) {
 		case LM_FORWARDMASK:
 		    fprintf(NetTrace, "Forward Mask");
 		    for (i = 3; i < length; i++)
 			fprintf(NetTrace, " %x", pointer[i]);
 		    break;
 		default:
 		    fprintf(NetTrace, "%d (unknown)", pointer[2]);
 		    for (i = 3; i < length; i++)
 			fprintf(NetTrace, " %d", pointer[i]);
 		    break;
+		}
 		break;
 	    case LM_SLC:
 		fprintf(NetTrace, "SLC");
 		for (i = 2; i < length - 2; i += 3) {
 		    if (SLC_NAME_OK(pointer[i+SLC_FUNC]))
 			fprintf(NetTrace, " %s", SLC_NAME(pointer[i+SLC_FUNC]));
 		    else
 			fprintf(NetTrace, " %d", pointer[i+SLC_FUNC]);
 		    switch (pointer[i+SLC_FLAGS]&SLC_LEVELBITS) {
 		    case SLC_NOSUPPORT:
 			fprintf(NetTrace, " NOSUPPORT"); break;
 		    case SLC_CANTCHANGE:
 			fprintf(NetTrace, " CANTCHANGE"); break;
 		    case SLC_VARIABLE:
 			fprintf(NetTrace, " VARIABLE"); break;
 		    case SLC_DEFAULT:
 			fprintf(NetTrace, " DEFAULT"); break;
+		    }
 		    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))
 			fprintf(NetTrace, "(0x%x)", pointer[i+SLC_FLAGS]);
 		    fprintf(NetTrace, " %d;", pointer[i+SLC_VALUE]);
 		    if ((pointer[i+SLC_VALUE] == IAC) &&
 			(pointer[i+SLC_VALUE+1] == IAC))
 				i++;
+		}
 		for (; i < length; i++)
 		    fprintf(NetTrace, " ?%d?", pointer[i]);
 		break;
 	    case LM_MODE:
 		fprintf(NetTrace, "MODE ");
 		if (length < 3) {
 		    fprintf(NetTrace, "(no mode??\?)");
 		    break;
+		}
+		{
 		    char tbuf[64];
-		    sprintf(tbuf, "%s%s%s%s%s",
+		    snprintf(tbuf, sizeof(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" : "");
 		    fprintf(NetTrace, "%s", tbuf[1] ? &tbuf[1] : "0");
+		}
 		if (pointer[2]&~(MODE_MASK))
 		    fprintf(NetTrace, " (0x%x)", pointer[2]);
 		for (i = 3; i < length; i++)
 		    fprintf(NetTrace, " ?0x%x?", pointer[i]);
 		break;
 	    default:
 		fprintf(NetTrace, "%d (unknown)", pointer[1]);
 		for (i = 2; i < length; i++)
 		    fprintf(NetTrace, " %d", pointer[i]);
+	    }
 	    break;
 	case TELOPT_STATUS: {
 	    const char *cp;
 	    int j, k;
 	    fprintf(NetTrace, "STATUS");
 	    switch (pointer[1]) {
 	    default:
 		if (pointer[1] == TELQUAL_SEND)
 		    fprintf(NetTrace, " SEND");
 		else
 		    fprintf(NetTrace, " %d (unknown)", pointer[1]);
 		for (i = 2; i < length; i++)
 		    fprintf(NetTrace, " ?%d?", pointer[i]);
 		break;
 	    case TELQUAL_IS:
 		if (--want_status_response < 0)
 		    want_status_response = 0;
 		if (NetTrace == stdout)
 		    fprintf(NetTrace, " IS\r\n");
 		else
 		    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]))
 			    fprintf(NetTrace, " %s %s", cp, TELOPT(pointer[i]));
 			else
 			    fprintf(NetTrace, " %s %d", cp, pointer[i]);
 			if (NetTrace == stdout)
 			    fprintf(NetTrace, "\r\n");
 			else
 			    fprintf(NetTrace, "\n");
 			break;
 		    case SB:
 			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) {
 			    fprintf(NetTrace, " SE");
 			    i = j;
 			} else
 			    i = j - 1;
 			if (NetTrace == stdout)
 			    fprintf(NetTrace, "\r\n");
 			else
 			    fprintf(NetTrace, "\n");
 			break;
 		    default:
 			fprintf(NetTrace, " %d", pointer[i]);
 			break;
+		    }
+		}
 		break;
+	    }
 	    break;
+	  }
 	case TELOPT_XDISPLOC:
 	    fprintf(NetTrace, "X-DISPLAY-LOCATION ");
 	    switch (pointer[1]) {
 	    case TELQUAL_IS:
 		fprintf(NetTrace, "IS \"%.*s\"", length-2, (char *)pointer+2);
 		break;
 	    case TELQUAL_SEND:
 		fprintf(NetTrace, "SEND");
 		break;
 	    default:
 		fprintf(NetTrace, "- unknown qualifier %d (0x%x).",
 				pointer[1], pointer[1]);
+	    }
 	    break;
 	case TELOPT_NEW_ENVIRON:
 	    fprintf(NetTrace, "NEW-ENVIRON ");
 #ifdef	OLD_ENVIRON
 	    goto env_common1;
 	case TELOPT_OLD_ENVIRON:
 	    fprintf(NetTrace, "OLD-ENVIRON");
 	env_common1:
 #endif
 	    switch (pointer[1]) {
 	    case TELQUAL_IS:
 		fprintf(NetTrace, "IS ");
 		goto env_common;
 	    case TELQUAL_SEND:
 		fprintf(NetTrace, "SEND ");
 		goto env_common;
 	    case TELQUAL_INFO:
 		fprintf(NetTrace, "INFO ");
 	    env_common:
+		{
 		    static const char NQ[] = "\" ";
 		    const char *noquote = NQ;
 #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)
 				    fprintf(NetTrace, "%s(VALUE) ", noquote);
 				else
 # endif
 				    fprintf(NetTrace, "%sVAR ", noquote);
 			    } else
 #endif /* OLD_ENVIRON */
 				fprintf(NetTrace, "%sVALUE ", noquote);
 			    noquote = NQ;
 			    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)
 				    fprintf(NetTrace, "%s(VAR) ", noquote);
 				else
 # endif
 				    fprintf(NetTrace, "%sVALUE ", noquote);
 			    } else
 #endif /* OLD_ENVIRON */
 				fprintf(NetTrace, "%sVAR ", noquote);
 			    noquote = NQ;
 			    break;
 			case ENV_ESC:
 			    fprintf(NetTrace, "%sESC ", noquote);
 			    noquote = NQ;
 			    break;
 			case ENV_USERVAR:
 			    fprintf(NetTrace, "%sUSERVAR ", noquote);
 			    noquote = NQ;
 			    break;
 			default:
 			    if (isprint(pointer[i]) && pointer[i] != '"') {
 				if (*noquote) {
 				    putc('"', NetTrace);
 				    noquote = "";
+				}
 				putc(pointer[i], NetTrace);
 			    } else {
 				fprintf(NetTrace, "%s%03o ", noquote,
 							pointer[i]);
 				noquote = NQ;
+			    }
 			    break;
+			}
+		    }
 		    if (!noquote)
 			putc('"', NetTrace);
 		    break;
+		}
+	    }
 	    break;
 	default:
 	    if (TELOPT_OK(pointer[0]))
 		fprintf(NetTrace, "%s (unknown)", TELOPT(pointer[0]));
 	    else
 		fprintf(NetTrace, "%d (unknown)", pointer[0]);
 	    for (i = 1; i < length; i++)
 		fprintf(NetTrace, " %d", pointer[i]);
 	    break;
+	}
 	if (direction) {
 	    if (NetTrace == stdout)
 		fprintf(NetTrace, "\r\n");
 	    else
 		fprintf(NetTrace, "\n");
+	}
 	if (NetTrace == stdout)
 	    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 poll).
  */
 void
 EmptyTerminal(void)
+{
     struct pollfd set[1];
     set[0].fd = tout;
     set[0].events = POLLOUT;
     if (TTYBYTES() == 0) {
 	(void) poll(set, 1, INFTIM);
     } else {
 	while (TTYBYTES()) {
 	    (void) ttyflush(0);
 	    (void) poll(set, 1, INFTIM);
+	}
+    }
+}
 void
 SetForExit(void)
+{
     setconnmode(0);
 #ifdef TN3270
     if (In3270) {
 	Finish3270();
+    }
 #else	/* defined(TN3270) */
     do {
 	(void)telrcv();			/* Process any incoming data */
 	EmptyTerminal();
     } while (ring_full_count(&netiring));	/* While there is any */
 #endif	/* defined(TN3270) */
     setcommandmode();
     fflush(stdout);
     fflush(stderr);
 #ifdef TN3270
     if (In3270) {
 	StopScreen(1);
+    }
 #endif	/* defined(TN3270) */
     setconnmode(0);
     EmptyTerminal();			/* Flush the path to the tty */
     setcommandmode();
+}
 void
 Exit(int returnCode)
+{
     SetForExit();
     exit(returnCode);
+}
 void
 ExitString(const char *string, int returnCode)
+{
     SetForExit();
     fwrite(string, 1, strlen(string), stderr);
     exit(returnCode);
+}