1/*
2 * Copyright 1994-2002 Sun Microsystems, Inc.  All rights reserved.
3 * Use is subject to license terms.
4 */
5
6#pragma ident	"%Z%%M%	%I%	%E% SMI"
7
8/*
9 * usr/src/cmd/cmd-inet/usr.bin/telnet/utilities.c
10 */
11
12/*
13 * Copyright (c) 1988, 1993
14 *	The Regents of the University of California.  All rights reserved.
15 *
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
18 * are met:
19 * 1. Redistributions of source code must retain the above copyright
20 *    notice, this list of conditions and the following disclaimer.
21 * 2. Redistributions in binary form must reproduce the above copyright
22 *    notice, this list of conditions and the following disclaimer in the
23 *    documentation and/or other materials provided with the distribution.
24 * 3. All advertising materials mentioning features or use of this software
25 *    must display the following acknowledgement:
26 *	This product includes software developed by the University of
27 *	California, Berkeley and its contributors.
28 * 4. Neither the name of the University nor the names of its contributors
29 *    may be used to endorse or promote products derived from this software
30 *    without specific prior written permission.
31 *
32 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
33 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
34 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
35 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
36 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
40 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
41 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
42 * SUCH DAMAGE.
43 */
44
45#ifndef lint
46static char sccsid[] = "@(#)utilities.c	8.1 (Berkeley) 6/6/93";
47#endif /* not lint */
48
49#define	TELOPTS
50#ifdef	lint
51static char *telcmds[] = {0};
52static char *slc_names[] = {0};
53static char *encrypt_names[] = {0};
54static char *enctype_names[] = {0};
55#else	/* lint */
56#define	TELCMDS
57#define	SLC_NAMES
58#endif	/* lint */
59#include <arpa/telnet.h>
60#include <sys/types.h>
61#include <sys/time.h>
62#include <sys/param.h>
63#include <sys/socket.h>
64#include <errno.h>
65
66#include <ctype.h>
67
68#include "general.h"
69
70#include "ring.h"
71
72#include "defines.h"
73
74#include "externs.h"
75
76FILE	*NetTrace = 0;		/* Not in bss, since needs to stay */
77int	prettydump;
78
79/*
80 * upcase()
81 *
82 *	Upcase (in place) the argument.
83 */
84
85    void
86upcase(argument)
87	register char *argument;
88{
89	register int c;
90
91	while ((c = *argument) != 0) {
92		if (islower(c)) {
93			*argument = toupper(c);
94		}
95	argument++;
96	}
97}
98
99/*
100 * SetSockOpt()
101 *
102 * Compensate for differences in 4.2 and 4.3 systems.
103 */
104
105    int
106SetSockOpt(fd, level, option, yesno)
107    int fd, level, option, yesno;
108{
109	return (setsockopt(fd, level, option, &yesno, sizeof (yesno)));
110}
111
112/*
113 * The following are routines used to print out debugging information.
114 */
115
116unsigned char NetTraceFile[MAXPATHLEN] = "(standard output)";
117
118    void
119SetNetTrace(file)
120    register char *file;
121{
122	if (NetTrace && NetTrace != stdout)
123		(void) fclose(NetTrace);
124	if (file && (strcmp(file, "-") != 0)) {
125		NetTrace = fopen(file, "w");
126		if (NetTrace) {
127			(void) strcpy((char *)NetTraceFile, file);
128			return;
129		}
130		(void) fprintf(stderr, "Cannot open %s.\n", file);
131	}
132	NetTrace = stdout;
133	(void) strcpy((char *)NetTraceFile, "(standard output)");
134}
135
136    void
137Dump(direction, buffer, length)
138    char direction;
139    unsigned char *buffer;
140    int length;
141{
142#define	BYTES_PER_LINE	32
143#define	min(x, y)	((x < y) ? x:y)
144	unsigned char *pThis;
145	int offset;
146
147	offset = 0;
148
149	while (length) {
150		/* print one line */
151		(void) fprintf(NetTrace, "%c 0x%x\t", direction, offset);
152		pThis = buffer;
153		if (prettydump) {
154			buffer = buffer + min(length, BYTES_PER_LINE/2);
155			while (pThis < buffer) {
156				(void) fprintf(NetTrace, "%c%.2x",
157				    (((*pThis)&0xff) == 0xff) ? '*' : ' ',
158				    (*pThis)&0xff);
159				pThis++;
160			}
161			length -= BYTES_PER_LINE/2;
162			offset += BYTES_PER_LINE/2;
163		} else {
164			buffer = buffer + min(length, BYTES_PER_LINE);
165			while (pThis < buffer) {
166				(void) fprintf(NetTrace, "%.2x", (*pThis)&0xff);
167				pThis++;
168			}
169			length -= BYTES_PER_LINE;
170			offset += BYTES_PER_LINE;
171		}
172		if (NetTrace == stdout) {
173			(void) fprintf(NetTrace, "\r\n");
174		} else {
175			(void) fprintf(NetTrace, "\n");
176		}
177		if (length < 0) {
178			(void) fflush(NetTrace);
179			return;
180		}
181		/* find next unique line */
182	}
183	(void) fflush(NetTrace);
184}
185
186
187	void
188printoption(direction, cmd, option)
189	char *direction;
190	int cmd, option;
191{
192	if (!showoptions)
193		return;
194	if (cmd == IAC) {
195		if (TELCMD_OK(option))
196			(void) fprintf(NetTrace, "%s IAC %s", direction,
197			    TELCMD(option));
198		else
199			(void) fprintf(NetTrace, "%s IAC %d", direction,
200				option);
201	} else {
202		register char *fmt;
203		fmt = (cmd == WILL) ? "WILL" : (cmd == WONT) ? "WONT" :
204			(cmd == DO) ? "DO" : (cmd == DONT) ? "DONT" : 0;
205		if (fmt) {
206		    (void) fprintf(NetTrace, "%s %s ", direction, fmt);
207		    if (TELOPT_OK(option))
208			(void) fprintf(NetTrace, "%s", TELOPT(option));
209		    else if (option == TELOPT_EXOPL)
210			(void) fprintf(NetTrace, "EXOPL");
211		    else
212			(void) fprintf(NetTrace, "%d", option);
213		} else
214			(void) fprintf(NetTrace, "%s %d %d", direction, cmd,
215			    option);
216	}
217	if (NetTrace == stdout) {
218	    (void) fprintf(NetTrace, "\r\n");
219	    (void) fflush(NetTrace);
220	} else {
221	    (void) fprintf(NetTrace, "\n");
222	}
223}
224
225    void
226optionstatus()
227{
228	register int i;
229	extern char will_wont_resp[], do_dont_resp[];
230
231	for (i = 0; i < SUBBUFSIZE; i++) {
232		if (do_dont_resp[i]) {
233			if (TELOPT_OK(i))
234				(void) printf("resp DO_DONT %s: %d\n",
235				    TELOPT(i), do_dont_resp[i]);
236			else if (TELCMD_OK(i))
237				(void) printf("resp DO_DONT %s: %d\n",
238				    TELCMD(i), do_dont_resp[i]);
239			else
240				(void) printf("resp DO_DONT %d: %d\n", i,
241				    do_dont_resp[i]);
242			if (my_want_state_is_do(i)) {
243				if (TELOPT_OK(i))
244					(void) printf("want DO   %s\n",
245					    TELOPT(i));
246				else if (TELCMD_OK(i))
247					(void) printf("want DO   %s\n",
248						TELCMD(i));
249				else
250					(void) printf("want DO   %d\n", i);
251			} else {
252				if (TELOPT_OK(i))
253					(void) printf("want DONT %s\n",
254					    TELOPT(i));
255				else if (TELCMD_OK(i))
256					(void) printf("want DONT %s\n",
257					    TELCMD(i));
258				else
259					(void) printf("want DONT %d\n", i);
260			}
261		} else {
262			if (my_state_is_do(i)) {
263				if (TELOPT_OK(i))
264					(void) printf("     DO   %s\n",
265					    TELOPT(i));
266				else if (TELCMD_OK(i))
267					(void) printf("     DO   %s\n",
268					    TELCMD(i));
269				else
270					(void) printf("     DO   %d\n", i);
271			}
272		}
273		if (will_wont_resp[i]) {
274			if (TELOPT_OK(i))
275				(void) printf("resp WILL_WONT %s: %d\n",
276				    TELOPT(i), will_wont_resp[i]);
277			else if (TELCMD_OK(i))
278				(void) printf("resp WILL_WONT %s: %d\n",
279				    TELCMD(i), will_wont_resp[i]);
280			else
281				(void) printf("resp WILL_WONT %d: %d\n",
282				    i, will_wont_resp[i]);
283			if (my_want_state_is_will(i)) {
284				if (TELOPT_OK(i))
285					(void) printf("want WILL %s\n",
286					    TELOPT(i));
287				else if (TELCMD_OK(i))
288					(void) printf("want WILL %s\n",
289					    TELCMD(i));
290				else
291					(void) printf("want WILL %d\n", i);
292			} else {
293				if (TELOPT_OK(i))
294					(void) printf("want WONT %s\n",
295					    TELOPT(i));
296				else if (TELCMD_OK(i))
297					(void) printf("want WONT %s\n",
298					    TELCMD(i));
299				else
300					(void) printf("want WONT %d\n", i);
301			}
302		} else {
303			if (my_state_is_will(i)) {
304				if (TELOPT_OK(i))
305					(void) printf("     WILL %s\n",
306					    TELOPT(i));
307				else if (TELCMD_OK(i))
308					(void) printf("     WILL %s\n",
309					    TELCMD(i));
310				else
311					(void) printf("     WILL %d\n", i);
312			}
313		}
314	}
315
316}
317
318    void
319printsub(direction, pointer, length)
320	char direction;	/* '<' or '>' */
321	unsigned char *pointer;	/* where suboption data sits */
322	int	  length;	/* length of suboption data */
323{
324	register int i;
325	char buf[512];
326	extern int want_status_response;
327
328	if (showoptions || direction == 0 ||
329	    (want_status_response && (pointer[0] == TELOPT_STATUS))) {
330		if (direction) {
331			(void) fprintf(NetTrace, "%s IAC SB ",
332				(direction == '<')? "RCVD":"SENT");
333			if (length >= 3) {
334				register int j;
335
336				i = pointer[length-2];
337				j = pointer[length-1];
338
339				if (i != IAC || j != SE) {
340					(void) fprintf(NetTrace,
341					    "(terminated by ");
342					if (TELOPT_OK(i))
343						(void) fprintf(NetTrace, "%s ",
344						    TELOPT(i));
345					else if (TELCMD_OK(i))
346						(void) fprintf(NetTrace, "%s ",
347						    TELCMD(i));
348					else
349						(void) fprintf(NetTrace, "%d ",
350						    i);
351					if (TELOPT_OK(j))
352						(void) fprintf(NetTrace, "%s",
353						    TELOPT(j));
354					else if (TELCMD_OK(j))
355						(void) fprintf(NetTrace, "%s",
356						    TELCMD(j));
357					else
358						(void) fprintf(NetTrace, "%d",
359						    j);
360					(void) fprintf(NetTrace,
361					    ", not IAC SE!) ");
362				}
363			}
364			length -= 2;
365		}
366		if (length < 1) {
367			(void) fprintf(NetTrace, "(Empty suboption??\?)");
368			if (NetTrace == stdout)
369				(void) fflush(NetTrace);
370			return;
371		}
372		switch (pointer[0]) {
373		case TELOPT_TTYPE:
374			(void) fprintf(NetTrace, "TERMINAL-TYPE ");
375			switch (pointer[1]) {
376			case TELQUAL_IS:
377				(void) fprintf(NetTrace, "IS \"%.*s\"",
378				    length-2,
379				    (char *)pointer+2);
380				break;
381			case TELQUAL_SEND:
382				(void) fprintf(NetTrace, "SEND");
383				break;
384			default:
385				(void) fprintf(NetTrace,
386				    "- unknown qualifier %d (0x%x).",
387				    pointer[1], pointer[1]);
388			}
389			break;
390		case TELOPT_TSPEED:
391			(void) fprintf(NetTrace, "TERMINAL-SPEED");
392			if (length < 2) {
393				(void) fprintf(NetTrace,
394				    " (empty suboption??\?)");
395				break;
396			}
397			switch (pointer[1]) {
398			case TELQUAL_IS:
399				(void) fprintf(NetTrace, " IS ");
400				(void) fprintf(NetTrace, "%.*s", length-2,
401				    (char *)pointer+2);
402				break;
403			default:
404				if (pointer[1] == 1)
405					(void) fprintf(NetTrace, " SEND");
406				else
407					(void) fprintf(NetTrace,
408					    " %d (unknown)", pointer[1]);
409				for (i = 2; i < length; i++)
410					(void) fprintf(NetTrace, " ?%d?",
411					    pointer[i]);
412				break;
413			}
414			break;
415
416		case TELOPT_LFLOW:
417			(void) fprintf(NetTrace, "TOGGLE-FLOW-CONTROL");
418			if (length < 2) {
419				(void) fprintf(NetTrace,
420				    " (empty suboption??\?)");
421				break;
422			}
423			switch (pointer[1]) {
424			case LFLOW_OFF:
425				(void) fprintf(NetTrace, " OFF");
426				break;
427			case LFLOW_ON:
428				(void) fprintf(NetTrace, " ON");
429				break;
430			case LFLOW_RESTART_ANY:
431				(void) fprintf(NetTrace, " RESTART-ANY");
432				break;
433			case LFLOW_RESTART_XON:
434				(void) fprintf(NetTrace, " RESTART-XON");
435				break;
436			default:
437				(void) fprintf(NetTrace, " %d (unknown)",
438				    pointer[1]);
439			}
440			for (i = 2; i < length; i++)
441				(void) fprintf(NetTrace, " ?%d?",
442				    pointer[i]);
443			break;
444
445		case TELOPT_NAWS:
446			(void) fprintf(NetTrace, "NAWS");
447			if (length < 2) {
448				(void) fprintf(NetTrace,
449				    " (empty suboption??\?)");
450				break;
451			}
452			if (length == 2) {
453				(void) fprintf(NetTrace, " ?%d?", pointer[1]);
454				break;
455			}
456			(void) fprintf(NetTrace, " %d %d (%d)",
457			    pointer[1], pointer[2],
458			    (int)((((unsigned int)pointer[1])<<8)|
459			    ((unsigned int)pointer[2])));
460			if (length == 4) {
461				(void) fprintf(NetTrace, " ?%d?", pointer[3]);
462				break;
463			}
464			(void) fprintf(NetTrace, " %d %d (%d)",
465			    pointer[3], pointer[4],
466			    (int)((((unsigned int)pointer[3])<<8)|
467			    ((unsigned int)pointer[4])));
468			for (i = 5; i < length; i++)
469				(void) fprintf(NetTrace, " ?%d?", pointer[i]);
470			break;
471
472		case TELOPT_AUTHENTICATION:
473			(void) fprintf(NetTrace, "AUTHENTICATION");
474			if (length < 2) {
475				(void) fprintf(NetTrace,
476					" (empty suboption??\?)");
477				break;
478			}
479			switch (pointer[1]) {
480			case TELQUAL_REPLY:
481			case TELQUAL_IS:
482				(void) fprintf(NetTrace, " %s ",
483				    (pointer[1] == TELQUAL_IS) ?
484				    "IS" : "REPLY");
485				if (AUTHTYPE_NAME_OK(pointer[2]))
486					(void) fprintf(NetTrace, "%s ",
487					    AUTHTYPE_NAME(pointer[2]));
488				else
489					(void) fprintf(NetTrace, "%d ",
490						pointer[2]);
491				if (length < 3) {
492					(void) fprintf(NetTrace,
493					    "(partial suboption??\?)");
494					break;
495				}
496				(void) fprintf(NetTrace, "%s|%s",
497				    ((pointer[3] & AUTH_WHO_MASK) ==
498				    AUTH_WHO_CLIENT) ? "CLIENT" : "SERVER",
499				    ((pointer[3] & AUTH_HOW_MASK) ==
500				    AUTH_HOW_MUTUAL) ? "MUTUAL" : "ONE-WAY");
501
502				auth_printsub(&pointer[1], length - 1,
503				    (uchar_t *)buf, sizeof (buf));
504				(void) fprintf(NetTrace, "%s", buf);
505				break;
506
507			case TELQUAL_SEND:
508				i = 2;
509				(void) fprintf(NetTrace, " SEND ");
510				while (i < length) {
511					if (AUTHTYPE_NAME_OK(pointer[i]))
512						(void) fprintf(NetTrace, "%s ",
513						    AUTHTYPE_NAME(pointer[i]));
514					else
515						(void) fprintf(NetTrace, "%d ",
516						    pointer[i]);
517					if (++i >= length) {
518						(void) fprintf(NetTrace,
519						    "(partial "
520						    "suboption??\?)");
521						break;
522					}
523					(void) fprintf(NetTrace, "%s|%s ",
524					    ((pointer[i] & AUTH_WHO_MASK) ==
525					    AUTH_WHO_CLIENT) ?
526					    "CLIENT" : "SERVER",
527					    ((pointer[i] & AUTH_HOW_MASK) ==
528					    AUTH_HOW_MUTUAL) ?
529					    "MUTUAL" : "ONE-WAY");
530					++i;
531				}
532				break;
533
534			case TELQUAL_NAME:
535				i = 2;
536				(void) fprintf(NetTrace, " NAME \"");
537				while (i < length)
538					(void) putc(pointer[i++], NetTrace);
539				(void) putc('"', NetTrace);
540				break;
541
542			default:
543				for (i = 2; i < length; i++)
544				(void) fprintf(NetTrace, " ?%d?", pointer[i]);
545				break;
546			}
547			break;
548
549		case TELOPT_ENCRYPT:
550			(void) fprintf(NetTrace, "ENCRYPT");
551			if (length < 2) {
552				(void) fprintf(NetTrace,
553				    " (empty suboption??\?)");
554				break;
555			}
556			switch (pointer[1]) {
557			case ENCRYPT_START:
558				(void) fprintf(NetTrace, " START");
559				break;
560
561			case ENCRYPT_END:
562				(void) fprintf(NetTrace, " END");
563				break;
564
565			case ENCRYPT_REQSTART:
566				(void) fprintf(NetTrace, " REQUEST-START");
567				break;
568
569			case ENCRYPT_REQEND:
570				(void) fprintf(NetTrace, " REQUEST-END");
571				break;
572
573			case ENCRYPT_IS:
574			case ENCRYPT_REPLY:
575				(void) fprintf(NetTrace, " %s ",
576				    (pointer[1] == ENCRYPT_IS) ?
577				    "IS" : "REPLY");
578				if (length < 3) {
579					(void) fprintf(NetTrace, " (partial "
580					    "suboption??\?)");
581					break;
582				}
583				if (ENCTYPE_NAME_OK(pointer[2]))
584					(void) fprintf(NetTrace, "%s ",
585					    ENCTYPE_NAME(pointer[2]));
586				else
587					(void) fprintf(NetTrace,
588					    " %d (unknown)", pointer[2]);
589
590				encrypt_printsub(&pointer[1], length - 1,
591				    (uchar_t *)buf, sizeof (buf));
592				(void) fprintf(NetTrace, "%s", buf);
593				break;
594
595			case ENCRYPT_SUPPORT:
596				i = 2;
597				(void) fprintf(NetTrace, " SUPPORT ");
598				while (i < length) {
599					if (ENCTYPE_NAME_OK(pointer[i]))
600						(void) fprintf(NetTrace, "%s ",
601						    ENCTYPE_NAME(pointer[i]));
602					else
603						(void) fprintf(NetTrace, "%d ",
604						    pointer[i]);
605					i++;
606				}
607				break;
608
609			case ENCRYPT_ENC_KEYID:
610				(void) fprintf(NetTrace, " ENC_KEYID ");
611				goto encommon;
612
613			case ENCRYPT_DEC_KEYID:
614				(void) fprintf(NetTrace, " DEC_KEYID ");
615				goto encommon;
616
617			default:
618				(void) fprintf(NetTrace, " %d (unknown)",
619				    pointer[1]);
620			encommon:
621				for (i = 2; i < length; i++)
622					(void) fprintf(NetTrace, " %d",
623					    pointer[i]);
624				break;
625			}
626			break;
627
628		case TELOPT_LINEMODE:
629			(void) fprintf(NetTrace, "LINEMODE ");
630			if (length < 2) {
631				(void) fprintf(NetTrace,
632				    " (empty suboption??\?)");
633				break;
634			}
635			switch (pointer[1]) {
636			case WILL:
637				(void) fprintf(NetTrace, "WILL ");
638				goto common;
639			case WONT:
640				(void) fprintf(NetTrace, "WONT ");
641				goto common;
642			case DO:
643				(void) fprintf(NetTrace, "DO ");
644				goto common;
645			case DONT:
646				(void) fprintf(NetTrace, "DONT ");
647common:
648				if (length < 3) {
649					(void) fprintf(NetTrace,
650						"(no option??\?)");
651					break;
652				}
653				switch (pointer[2]) {
654				case LM_FORWARDMASK:
655					(void) fprintf(NetTrace,
656					    "Forward Mask");
657					for (i = 3; i < length; i++)
658						(void) fprintf(NetTrace, " %x",
659						    pointer[i]);
660					break;
661				default:
662					(void) fprintf(NetTrace, "%d (unknown)",
663					    pointer[2]);
664					for (i = 3; i < length; i++)
665					(void) fprintf(NetTrace,
666					    " %d", pointer[i]);
667					break;
668				}
669				break;
670
671			case LM_SLC:
672				(void) fprintf(NetTrace, "SLC");
673				for (i = 2; i < length - 2; i += 3) {
674					if (SLC_NAME_OK(pointer[i+SLC_FUNC]))
675						(void) fprintf(NetTrace, " %s",
676						    SLC_NAME(pointer[
677						    i+SLC_FUNC]));
678					else
679						(void) fprintf(NetTrace, " %d",
680						    pointer[i+SLC_FUNC]);
681					switch (pointer[i+SLC_FLAGS] &
682					    SLC_LEVELBITS) {
683					case SLC_NOSUPPORT:
684						(void) fprintf(NetTrace,
685						    " NOSUPPORT");
686						break;
687					case SLC_CANTCHANGE:
688						(void) fprintf(NetTrace,
689						    " CANTCHANGE");
690						break;
691					case SLC_VARIABLE:
692						(void) fprintf(NetTrace,
693						    " VARIABLE");
694						break;
695					case SLC_DEFAULT:
696						(void) fprintf(NetTrace,
697						    " DEFAULT");
698						break;
699					}
700					(void) fprintf(NetTrace, "%s%s%s",
701					    pointer[i+SLC_FLAGS]&SLC_ACK ?
702						"|ACK" : "",
703					    pointer[i+SLC_FLAGS]&SLC_FLUSHIN ?
704						"|FLUSHIN" : "",
705					    pointer[i+SLC_FLAGS]&SLC_FLUSHOUT ?
706						"|FLUSHOUT" : "");
707					if (pointer[i+SLC_FLAGS] &
708					    ~(SLC_ACK|SLC_FLUSHIN|
709					    SLC_FLUSHOUT| SLC_LEVELBITS))
710					(void) fprintf(NetTrace, "(0x%x)",
711					    pointer[i+SLC_FLAGS]);
712					(void) fprintf(NetTrace, " %d;",
713					    pointer[i+SLC_VALUE]);
714					if ((pointer[i+SLC_VALUE] == IAC) &&
715					    (pointer[i+SLC_VALUE+1] == IAC))
716						i++;
717				}
718				for (; i < length; i++)
719					(void) fprintf(NetTrace, " ?%d?",
720					    pointer[i]);
721				break;
722
723			case LM_MODE:
724				(void) fprintf(NetTrace, "MODE ");
725				if (length < 3) {
726					(void) fprintf(NetTrace,
727					    "(no mode??\?)");
728					break;
729				}
730				{
731					char tbuf[64];
732					(void) sprintf(tbuf, "%s%s%s%s%s",
733					    pointer[2]&MODE_EDIT ? "|EDIT" : "",
734					    pointer[2]&MODE_TRAPSIG ?
735					    "|TRAPSIG" : "",
736					    pointer[2]&MODE_SOFT_TAB ?
737					    "|SOFT_TAB" : "",
738					    pointer[2]&MODE_LIT_ECHO ?
739					    "|LIT_ECHO" : "",
740					    pointer[2]&MODE_ACK ? "|ACK" : "");
741					(void) fprintf(NetTrace, "%s", tbuf[1] ?
742					    &tbuf[1] : "0");
743				}
744				if (pointer[2]&~(MODE_MASK))
745					(void) fprintf(NetTrace, " (0x%x)",
746					    pointer[2]);
747				for (i = 3; i < length; i++)
748					(void) fprintf(NetTrace, " ?0x%x?",
749					    pointer[i]);
750				break;
751			default:
752				(void) fprintf(NetTrace, "%d (unknown)",
753				    pointer[1]);
754				for (i = 2; i < length; i++)
755					(void) fprintf(NetTrace, " %d",
756					    pointer[i]);
757				}
758				break;
759
760		case TELOPT_STATUS: {
761				register char *cp;
762				register int j, k;
763
764				(void) fprintf(NetTrace, "STATUS");
765
766				switch (pointer[1]) {
767				default:
768					if (pointer[1] == TELQUAL_SEND)
769						(void) fprintf(NetTrace,
770						    " SEND");
771					else
772						(void) fprintf(NetTrace,
773						    " %d (unknown)",
774						    pointer[1]);
775					for (i = 2; i < length; i++)
776					(void) fprintf(NetTrace, " ?%d?",
777					    pointer[i]);
778					break;
779				case TELQUAL_IS:
780					if (--want_status_response < 0)
781						want_status_response = 0;
782					if (NetTrace == stdout)
783						(void) fprintf(NetTrace,
784						    " IS\r\n");
785					else
786						(void) fprintf(NetTrace,
787						    " IS\n");
788
789					for (i = 2; i < length; i++) {
790						switch (pointer[i]) {
791						case DO:
792							cp = "DO";
793							goto common2;
794						case DONT:
795							cp = "DONT";
796							goto common2;
797						case WILL:
798							cp = "WILL";
799							goto common2;
800						case WONT:
801							cp = "WONT";
802							goto common2;
803common2:
804							i++;
805							if (TELOPT_OK(
806							    (int)pointer[i]))
807								(void) fprintf(
808								    NetTrace,
809								    " %s %s",
810								    cp,
811								    TELOPT(
812								    pointer[
813								    i]));
814							else
815								(void) fprintf(
816								    NetTrace,
817								    " %s %d",
818								    cp,
819								    pointer[i]);
820
821							if (NetTrace == stdout)
822								(void) fprintf(
823								    NetTrace,
824								    "\r\n");
825							else
826								(void) fprintf(
827								    NetTrace,
828								    "\n");
829							break;
830
831						case SB:
832							(void) fprintf(NetTrace,
833							    " SB ");
834							i++;
835							j = k = i;
836							while (j < length) {
837			if (pointer[j] == SE) {
838				if (j+1 == length)
839					break;
840				if (pointer[j+1] == SE)
841					j++;
842				else
843					break;
844				}
845				pointer[k++] = pointer[j++];
846							}
847							printsub(0,
848							    &pointer[i], k - i);
849							if (i < length) {
850						(void) fprintf(NetTrace, " SE");
851				i = j;
852			} else
853				i = j - 1;
854
855			if (NetTrace == stdout)
856				(void) fprintf(NetTrace, "\r\n");
857			else
858				(void) fprintf(NetTrace, "\n");
859
860							break;
861
862						default:
863							(void) fprintf(NetTrace,
864							    " %d", pointer[i]);
865							break;
866						}
867					}
868					break;
869				}
870				break;
871			}
872
873		case TELOPT_XDISPLOC:
874			(void) fprintf(NetTrace, "X-DISPLAY-LOCATION ");
875			switch (pointer[1]) {
876			case TELQUAL_IS:
877				(void) fprintf(NetTrace, "IS \"%.*s\"",
878				    length-2, (char *)pointer+2);
879				break;
880			case TELQUAL_SEND:
881				(void) fprintf(NetTrace, "SEND");
882				break;
883			default:
884				(void) fprintf(NetTrace,
885				    "- unknown qualifier %d (0x%x).",
886				    pointer[1], pointer[1]);
887			}
888			break;
889
890		case TELOPT_NEW_ENVIRON:
891	    (void) fprintf(NetTrace, "NEW-ENVIRON ");
892#ifdef	OLD_ENVIRON
893	    goto env_common1;
894	case TELOPT_OLD_ENVIRON:
895	    (void) fprintf(NetTrace, "OLD-ENVIRON ");
896	env_common1:
897#endif
898	    switch (pointer[1]) {
899	    case TELQUAL_IS:
900		(void) fprintf(NetTrace, "IS ");
901		goto env_common;
902	    case TELQUAL_SEND:
903		(void) fprintf(NetTrace, "SEND ");
904		goto env_common;
905	    case TELQUAL_INFO:
906		(void) fprintf(NetTrace, "INFO ");
907	    env_common:
908		{
909		    register int noquote = 2;
910#if defined(ENV_HACK) && defined(OLD_ENVIRON)
911		    extern int old_env_var, old_env_value;
912#endif
913		    for (i = 2; i < length; i++) {
914			switch (pointer[i]) {
915			case NEW_ENV_VALUE:
916#ifdef OLD_ENVIRON
917		    /*	case NEW_ENV_OVAR: */
918			    if (pointer[0] == TELOPT_OLD_ENVIRON) {
919#ifdef	ENV_HACK
920				if (old_env_var == OLD_ENV_VALUE)
921					(void) fprintf(NetTrace,
922					    "\" (VALUE) " + noquote);
923				else
924#endif
925					(void) fprintf(NetTrace,
926					    "\" VAR " + noquote);
927			    } else
928#endif /* OLD_ENVIRON */
929				(void) fprintf(NetTrace, "\" VALUE " + noquote);
930			    noquote = 2;
931			    break;
932
933			case NEW_ENV_VAR:
934#ifdef OLD_ENVIRON
935		    /* case OLD_ENV_VALUE: */
936			    if (pointer[0] == TELOPT_OLD_ENVIRON) {
937#ifdef	ENV_HACK
938				if (old_env_value == OLD_ENV_VAR)
939					(void) fprintf(NetTrace,
940					    "\" (VAR) " + noquote);
941				else
942#endif
943					(void) fprintf(NetTrace,
944					    "\" VALUE " + noquote);
945			    } else
946#endif /* OLD_ENVIRON */
947				(void) fprintf(NetTrace, "\" VAR " + noquote);
948			    noquote = 2;
949			    break;
950
951			case ENV_ESC:
952			    (void) fprintf(NetTrace, "\" ESC " + noquote);
953			    noquote = 2;
954			    break;
955
956			case ENV_USERVAR:
957			    (void) fprintf(NetTrace, "\" USERVAR " + noquote);
958			    noquote = 2;
959			    break;
960
961			default:
962			def_case:
963			    if (isprint(pointer[i]) && pointer[i] != '"') {
964				if (noquote) {
965				    (void) putc('"', NetTrace);
966				    noquote = 0;
967				}
968				(void) putc(pointer[i], NetTrace);
969			    } else {
970				(void) fprintf(NetTrace, "\" %03o " + noquote,
971							pointer[i]);
972				noquote = 2;
973			    }
974			    break;
975			}
976		    }
977		    if (!noquote)
978			(void) putc('"', NetTrace);
979		    break;
980		}
981	    }
982	    break;
983
984	default:
985	    if (TELOPT_OK(pointer[0]))
986		(void) fprintf(NetTrace, "%s (unknown)", TELOPT(pointer[0]));
987	    else
988		(void) fprintf(NetTrace, "%d (unknown)", pointer[0]);
989	    for (i = 1; i < length; i++)
990		(void) fprintf(NetTrace, " %d", pointer[i]);
991	    break;
992	}
993	if (direction) {
994	    if (NetTrace == stdout)
995		(void) fprintf(NetTrace, "\r\n");
996	    else
997		(void) fprintf(NetTrace, "\n");
998	}
999	if (NetTrace == stdout)
1000	    (void) fflush(NetTrace);
1001	}
1002}
1003
1004/*
1005 * EmptyTerminal - called to make sure that the terminal buffer is empty.
1006 *			Note that we consider the buffer to run all the
1007 *			way to the kernel (thus the select).
1008 */
1009
1010static void
1011EmptyTerminal()
1012{
1013	fd_set	o;
1014
1015	FD_ZERO(&o);
1016
1017	if (TTYBYTES() == 0) {
1018		FD_SET(tout, &o);
1019		/* wait for TTLOWAT */
1020		(void) select(tout+1, NULL, &o, NULL, NULL);
1021	} else {
1022		while (TTYBYTES()) {
1023			if (ttyflush(0) == -2) {
1024				/* This will not return. */
1025				fatal_tty_error("write");
1026			}
1027			FD_SET(tout, &o);
1028			/* wait for TTLOWAT */
1029			(void) select(tout+1, NULL, &o, NULL, NULL);
1030		}
1031	}
1032}
1033
1034static void
1035SetForExit()
1036{
1037	setconnmode(0);
1038	do {
1039		(void) telrcv();		/* Process any incoming data */
1040		EmptyTerminal();
1041	} while (ring_full_count(&netiring));	/* While there is any */
1042	setcommandmode();
1043	(void) fflush(stdout);
1044	(void) fflush(stderr);
1045	setconnmode(0);
1046	EmptyTerminal();			/* Flush the path to the tty */
1047	setcommandmode();
1048}
1049
1050void
1051Exit(returnCode)
1052	int returnCode;
1053{
1054	SetForExit();
1055	exit(returnCode);
1056}
1057
1058void
1059ExitString(string, returnCode)
1060	char *string;
1061	int returnCode;
1062{
1063	SetForExit();
1064	(void) fwrite(string, 1, strlen(string), stderr);
1065	exit(returnCode);
1066}
1067
1068#define	BUFFER_CHUNK_SIZE 64
1069
1070/* Round up to a multiple of BUFFER_CHUNK_SIZE */
1071#define	ROUND_CHUNK_SIZE(s) ((((s) + BUFFER_CHUNK_SIZE - 1) / \
1072		BUFFER_CHUNK_SIZE) * BUFFER_CHUNK_SIZE)
1073
1074/*
1075 * Optionally allocate a buffer, and optionally read a string from a stream
1076 * into the buffer, starting at the given offset.  If the buffer isn't
1077 * large enough for the given offset, or if buffer space is exhausted
1078 * when reading the string, the size of the buffer is increased.
1079 *
1080 * A buffer can be supplied when the function is called, passing the
1081 * buffer address via the first argument.  The buffer size can be
1082 * passed as well, in the second argument.  If the second argument is
1083 * NULL, the function makes no assumptions about the buffer size.
1084 * The address of the buffer is returned via the first argument, and the
1085 * buffer size via the second argument if this is not NULL.
1086 * These returned values may differ from the supplied values if the buffer
1087 * was reallocated.
1088 *
1089 * If no buffer is to be supplied, specify a buffer address of NULL, via
1090 * the first argument.
1091 *
1092 * If the pointer to the buffer address is NULL, the function just returns
1093 * NULL, and performs no other processing.
1094 *
1095 * If a NULL stream is passed, the function will just make sure the
1096 * supplied buffer is large enough to hold the supplied offset,
1097 * reallocating it if is too small or too large.
1098 *
1099 * The returned buffer will be a multiple of BUFFER_CHUNK_SIZE in size.
1100 *
1101 * The function stops reading from the stream when a newline is read,
1102 * end of file is reached, or an error occurs.  The newline is not
1103 * returned in the buffer.  The returned string will be NULL terminated.
1104 *
1105 * The function returns the address of the buffer if any characters
1106 * are read and no error occurred, otherwise it returns NULL.
1107 *
1108 * If the function returns NULL, a buffer may have been allocated.  The
1109 * buffer address will be returned via the first argument, together with
1110 * the buffer size if the second argument is not NULL.
1111 *
1112 */
1113static char *
1114GetStringAtOffset(bufp, cbufsiz, off, st)
1115	char **bufp;
1116	unsigned int *cbufsiz;
1117	unsigned int off;
1118	FILE *st;
1119{
1120	unsigned int bufsiz;
1121	char *buf;
1122	char *nbuf;
1123	unsigned int idx = off;
1124
1125	if (bufp == NULL)
1126		return (NULL);
1127
1128	buf = *bufp;
1129
1130	bufsiz = ROUND_CHUNK_SIZE(off + 1);
1131
1132	if (buf == NULL || cbufsiz == NULL || *cbufsiz != bufsiz) {
1133		if ((nbuf = realloc(buf, bufsiz)) == NULL)
1134			return (NULL);
1135
1136		buf = nbuf;
1137		*bufp = buf;
1138		if (cbufsiz != NULL)
1139			*cbufsiz = bufsiz;
1140	}
1141
1142
1143	if (st == NULL)
1144		return (buf);
1145
1146	clearerr(st);
1147	for (;;) {
1148		int c = getc(st);
1149
1150		/* Expand the buffer as needed. */
1151		if (idx == bufsiz) {
1152			bufsiz += BUFFER_CHUNK_SIZE;
1153			if ((nbuf = realloc(buf, bufsiz)) == NULL) {
1154				/* Discard everything we read. */
1155				buf[off] = 0;
1156				buf = NULL;
1157				break;
1158			}
1159			buf = nbuf;
1160			*bufp = buf;
1161			if (cbufsiz != NULL)
1162				*cbufsiz = bufsiz;
1163		}
1164
1165		if (c == EOF || c == '\n') {
1166			buf[idx] = 0;
1167			if (ferror(st) != 0) {
1168				/* Retry if interrupted by a signal. */
1169				if (errno == EINTR) {
1170					clearerr(st);
1171					continue;
1172				}
1173				buf = NULL;
1174			} else if (feof(st) != 0) {
1175				/* No characters transferred? */
1176				if (off == idx)
1177					buf = NULL;
1178			}
1179			break;
1180		}
1181		buf[idx++] = c;
1182	}
1183	return (buf);
1184}
1185
1186/*
1187 * Read a string from the supplied stream.  Stop reading when a newline
1188 * is read, end of file reached, or an error occurs.
1189 *
1190 * A buffer can be supplied by specifying the buffer address via the
1191 * first argument. The buffer size can be passed via the second argument.
1192 * If the second argument is NULL, the function makes no assumptions
1193 * about the buffer size. The buffer will be reallocated if it is too
1194 * small or too large for the returned string.
1195 *
1196 * If no buffer is to be supplied, specify a buffer address of NULL,
1197 * via the first argument.
1198 *
1199 * If the first argument is NULL, the function just returns NULL, and
1200 * performs no other processing.
1201 *
1202 * The function returns the address of the buffer if any characters are
1203 * read and no error occurred.
1204 *
1205 * If the function returns NULL, a buffer may have been allocated.  The
1206 * buffer address and buffer size will be returned via the first argument,
1207 * and the buffer size via the second argument, if this isn't NULL.
1208 */
1209char *
1210GetString(bufp, bufsiz, st)
1211	char **bufp;
1212	unsigned int *bufsiz;
1213	FILE *st;
1214{
1215	return (GetStringAtOffset(bufp, bufsiz, 0, st));
1216}
1217
1218/*
1219 * Allocate a buffer to hold a string of given length.
1220 *
1221 * An existing buffer can be reallocated by passing its address and via
1222 * the first argument.  The buffer size can be passed via the second
1223 * argument.  If the second argument is NULL, the function makes no
1224 * assumptions about the buffer size.
1225 *
1226 * If no existing buffer is to be supplied, pass a NULL buffer address via
1227 * the first argument.
1228 *
1229 * If the first argument is NULL, the function just returns NULL,
1230 * and performs no other processing.
1231 */
1232char *
1233AllocStringBuffer(bufp, bufsiz, size)
1234	char **bufp;
1235	unsigned int *bufsiz;
1236	unsigned int size;
1237{
1238	return (GetStringAtOffset(bufp, bufsiz, size, (FILE *)NULL));
1239}
1240
1241/*
1242 * This function is similar to GetString(), except that the string read
1243 * from the stream is appended to the supplied string.
1244 */
1245char *
1246GetAndAppendString(bufp, bufsiz, str, st)
1247	char **bufp;
1248	unsigned int *bufsiz;
1249	char *str;
1250	FILE *st;
1251{
1252	unsigned int off = strlen(str);
1253
1254	if (GetStringAtOffset(bufp, bufsiz, off, st) == NULL)
1255		return (NULL);
1256
1257	return (memcpy(*bufp, str, off));
1258}
1259