Use NULL instead of 0 in various places.
[dragonfly.git] / libexec / telnetd / utility.c
CommitLineData
984263bc
MD
1/*
2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
1de703da
MD
32 *
33 * @(#)utility.c 8.4 (Berkeley) 5/30/95
34 * $FreeBSD: src/libexec/telnetd/utility.c,v 1.13.2.4 2002/04/13 11:07:12 markm Exp $
3e182402 35 * $DragonFly: src/libexec/telnetd/utility.c,v 1.3 2004/02/13 03:49:50 dillon Exp $
984263bc
MD
36 */
37
3e182402 38#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
39#include <locale.h>
40#include <sys/utsname.h>
41#endif
42#include <string.h>
43#define PRINTOPTIONS
44#include "telnetd.h"
45
46
47/*
48 * utility functions performing io related tasks
49 */
50
51/*
52 * ttloop
53 *
54 * A small subroutine to flush the network output buffer, get some data
55 * from the network, and pass it through the telnet state machine. We
56 * also flush the pty input buffer (by dropping its data) if it becomes
57 * too full.
58 */
59
60 void
61ttloop()
62{
63
64 DIAG(TD_REPORT, output_data("td: ttloop\r\n"));
65 if (nfrontp - nbackp > 0) {
66 netflush();
67 }
68 ncc = read(net, netibuf, sizeof netibuf);
69 if (ncc < 0) {
70 syslog(LOG_INFO, "ttloop: read: %m");
71 exit(1);
72 } else if (ncc == 0) {
73 syslog(LOG_INFO, "ttloop: peer died: %m");
74 exit(1);
75 }
76 DIAG(TD_REPORT, output_data("td: ttloop read %d chars\r\n", ncc));
77 netip = netibuf;
78 telrcv(); /* state machine */
79 if (ncc > 0) {
80 pfrontp = pbackp = ptyobuf;
81 telrcv();
82 }
83} /* end of ttloop */
84
85/*
86 * Check a descriptor to see if out of band data exists on it.
87 */
88int
89stilloob(int s)
90{
91 static struct timeval timeout = { 0, 0 };
92 fd_set excepts;
93 int value;
94
95 do {
96 FD_ZERO(&excepts);
97 FD_SET(s, &excepts);
98 memset((char *)&timeout, 0, sizeof timeout);
99 value = select(s+1, (fd_set *)0, (fd_set *)0, &excepts, &timeout);
100 } while ((value == -1) && (errno == EINTR));
101
102 if (value < 0) {
103 fatalperror(pty, "select");
104 }
105 if (FD_ISSET(s, &excepts)) {
106 return 1;
107 } else {
108 return 0;
109 }
110}
111
112void
113ptyflush(void)
114{
115 int n;
116
117 if ((n = pfrontp - pbackp) > 0) {
118 DIAG(TD_REPORT | TD_PTYDATA,
119 output_data("td: ptyflush %d chars\r\n", n));
120 DIAG(TD_PTYDATA, printdata("pd", pbackp, n));
121 n = write(pty, pbackp, n);
122 }
123 if (n < 0) {
124 if (errno == EWOULDBLOCK || errno == EINTR)
125 return;
126 cleanup(0);
127 }
128 pbackp += n;
129 if (pbackp == pfrontp)
130 pbackp = pfrontp = ptyobuf;
131}
132
133/*
134 * nextitem()
135 *
136 * Return the address of the next "item" in the TELNET data
137 * stream. This will be the address of the next character if
138 * the current address is a user data character, or it will
139 * be the address of the character following the TELNET command
140 * if the current address is a TELNET IAC ("I Am a Command")
141 * character.
142 */
143static char *
144nextitem(char *current)
145{
146 if ((*current&0xff) != IAC) {
147 return current+1;
148 }
149 switch (*(current+1)&0xff) {
150 case DO:
151 case DONT:
152 case WILL:
153 case WONT:
154 return current+3;
155 case SB: /* loop forever looking for the SE */
156 {
157 char *look = current+2;
158
159 for (;;) {
160 if ((*look++&0xff) == IAC) {
161 if ((*look++&0xff) == SE) {
162 return look;
163 }
164 }
165 }
166 }
167 default:
168 return current+2;
169 }
170} /* end of nextitem */
171
172/*
173 * netclear()
174 *
175 * We are about to do a TELNET SYNCH operation. Clear
176 * the path to the network.
177 *
178 * Things are a bit tricky since we may have sent the first
179 * byte or so of a previous TELNET command into the network.
180 * So, we have to scan the network buffer from the beginning
181 * until we are up to where we want to be.
182 *
183 * A side effect of what we do, just to keep things
184 * simple, is to clear the urgent data pointer. The principal
185 * caller should be setting the urgent data pointer AFTER calling
186 * us in any case.
187 */
188void
189netclear(void)
190{
191 char *thisitem, *next;
192 char *good;
193#define wewant(p) ((nfrontp > p) && ((*p&0xff) == IAC) && \
194 ((*(p+1)&0xff) != EC) && ((*(p+1)&0xff) != EL))
195
196 thisitem = netobuf;
197
198 while ((next = nextitem(thisitem)) <= nbackp) {
199 thisitem = next;
200 }
201
202 /* Now, thisitem is first before/at boundary. */
203
204 good = netobuf; /* where the good bytes go */
205
206 while (nfrontp > thisitem) {
207 if (wewant(thisitem)) {
208 int length;
209
210 next = thisitem;
211 do {
212 next = nextitem(next);
213 } while (wewant(next) && (nfrontp > next));
214 length = next-thisitem;
215 memmove(good, thisitem, length);
216 good += length;
217 thisitem = next;
218 } else {
219 thisitem = nextitem(thisitem);
220 }
221 }
222
223 nbackp = netobuf;
224 nfrontp = good; /* next byte to be sent */
225 neturg = 0;
226} /* end of netclear */
227
228/*
229 * netflush
230 * Send as much data as possible to the network,
231 * handling requests for urgent data.
232 */
233void
234netflush(void)
235{
236 int n;
237 extern int not42;
238
239 while ((n = nfrontp - nbackp) > 0) {
240#if 0
241 /* XXX This causes output_data() to recurse and die */
242 DIAG(TD_REPORT, {
243 n += output_data("td: netflush %d chars\r\n", n);
244 });
245#endif
246 /*
247 * if no urgent data, or if the other side appears to be an
248 * old 4.2 client (and thus unable to survive TCP urgent data),
249 * write the entire buffer in non-OOB mode.
250 */
251 if ((neturg == 0) || (not42 == 0)) {
252 n = write(net, nbackp, n); /* normal write */
253 } else {
254 n = neturg - nbackp;
255 /*
256 * In 4.2 (and 4.3) systems, there is some question about
257 * what byte in a sendOOB operation is the "OOB" data.
258 * To make ourselves compatible, we only send ONE byte
259 * out of band, the one WE THINK should be OOB (though
260 * we really have more the TCP philosophy of urgent data
261 * rather than the Unix philosophy of OOB data).
262 */
263 if (n > 1) {
264 n = send(net, nbackp, n-1, 0); /* send URGENT all by itself */
265 } else {
266 n = send(net, nbackp, n, MSG_OOB); /* URGENT data */
267 }
268 }
269 if (n == -1) {
270 if (errno == EWOULDBLOCK || errno == EINTR)
271 continue;
272 cleanup(0);
273 /* NOTREACHED */
274 }
275 nbackp += n;
276 if (nbackp >= neturg) {
277 neturg = 0;
278 }
279 if (nbackp == nfrontp) {
280 nbackp = nfrontp = netobuf;
281 }
282 }
283 return;
284} /* end of netflush */
285
286
287/*
288 * miscellaneous functions doing a variety of little jobs follow ...
289 */
290
291
292void
293fatal(int f, const char *msg)
294{
295 char buf[BUFSIZ];
296
297 (void) snprintf(buf, sizeof(buf), "telnetd: %s.\r\n", msg);
298 (void) write(f, buf, (int)strlen(buf));
299 sleep(1); /*XXX*/
300 exit(1);
301}
302
303void
304fatalperror(int f, const char *msg)
305{
306 char buf[BUFSIZ];
307
308 (void) snprintf(buf, sizeof(buf), "%s: %s", msg, strerror(errno));
309 fatal(f, buf);
310}
311
312char editedhost[32];
313
314void
315edithost(char *pat, char *host)
316{
317 char *res = editedhost;
318
319 if (!pat)
320 pat = strdup("");
321 while (*pat) {
322 switch (*pat) {
323
324 case '#':
325 if (*host)
326 host++;
327 break;
328
329 case '@':
330 if (*host)
331 *res++ = *host++;
332 break;
333
334 default:
335 *res++ = *pat;
336 break;
337 }
338 if (res == &editedhost[sizeof editedhost - 1]) {
339 *res = '\0';
340 return;
341 }
342 pat++;
343 }
344 if (*host)
345 (void) strncpy(res, host,
346 sizeof editedhost - (res - editedhost) -1);
347 else
348 *res = '\0';
349 editedhost[sizeof editedhost - 1] = '\0';
350}
351
352static char *putlocation;
353
354static void
355putstr(const char *s)
356{
357
358 while (*s)
359 putchr(*s++);
360}
361
362void
363putchr(int cc)
364{
365 *putlocation++ = cc;
366}
367
3e182402 368#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
369static char fmtstr[] = { "%+" };
370#else
371static char fmtstr[] = { "%l:%M%P on %A, %d %B %Y" };
372#endif
373
374void
375putf(char *cp, char *where)
376{
377 char *slash;
378 time_t t;
379 char db[100];
3e182402 380#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
381 static struct utsname kerninfo;
382
383 if (!*kerninfo.sysname)
384 uname(&kerninfo);
385#endif
386
387 putlocation = where;
388
389 while (*cp) {
390 if (*cp =='\n') {
391 putstr("\r\n");
392 cp++;
393 continue;
394 } else if (*cp != '%') {
395 putchr(*cp++);
396 continue;
397 }
398 switch (*++cp) {
399
400 case 't':
401#ifdef STREAMSPTY
402 /* names are like /dev/pts/2 -- we want pts/2 */
403 slash = strchr(line+1, '/');
404#else
405 slash = strrchr(line, '/');
406#endif
407 if (slash == (char *) 0)
408 putstr(line);
409 else
410 putstr(&slash[1]);
411 break;
412
413 case 'h':
414 putstr(editedhost);
415 break;
416
417 case 'd':
3e182402 418#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
419 setlocale(LC_TIME, "");
420#endif
421 (void)time(&t);
422 (void)strftime(db, sizeof(db), fmtstr, localtime(&t));
423 putstr(db);
424 break;
425
3e182402 426#if defined(__DragonFly__) || defined(__FreeBSD__)
984263bc
MD
427 case 's':
428 putstr(kerninfo.sysname);
429 break;
430
431 case 'm':
432 putstr(kerninfo.machine);
433 break;
434
435 case 'r':
436 putstr(kerninfo.release);
437 break;
438
439 case 'v':
440 putstr(kerninfo.version);
441 break;
442#endif
443
444 case '%':
445 putchr('%');
446 break;
447 }
448 cp++;
449 }
450}
451
452#ifdef DIAGNOSTICS
453/*
454 * Print telnet options and commands in plain text, if possible.
455 */
456void
457printoption(const char *fmt, int option)
458{
459 if (TELOPT_OK(option))
460 output_data("%s %s\r\n", fmt, TELOPT(option));
461 else if (TELCMD_OK(option))
462 output_data("%s %s\r\n", fmt, TELCMD(option));
463 else
464 output_data("%s %d\r\n", fmt, option);
465 return;
466}
467
468void
469printsub(char direction, unsigned char *pointer, int length)
470{
471 int i = 0;
472
473 if (!(diagnostic & TD_OPTIONS))
474 return;
475
476 if (direction) {
477 output_data("td: %s suboption ",
478 direction == '<' ? "recv" : "send");
479 if (length >= 3) {
480 int j;
481
482 i = pointer[length-2];
483 j = pointer[length-1];
484
485 if (i != IAC || j != SE) {
486 output_data("(terminated by ");
487 if (TELOPT_OK(i))
488 output_data("%s ", TELOPT(i));
489 else if (TELCMD_OK(i))
490 output_data("%s ", TELCMD(i));
491 else
492 output_data("%d ", i);
493 if (TELOPT_OK(j))
494 output_data("%s", TELOPT(j));
495 else if (TELCMD_OK(j))
496 output_data("%s", TELCMD(j));
497 else
498 output_data("%d", j);
499 output_data(", not IAC SE!) ");
500 }
501 }
502 length -= 2;
503 }
504 if (length < 1) {
505 output_data("(Empty suboption??\?)");
506 return;
507 }
508 switch (pointer[0]) {
509 case TELOPT_TTYPE:
510 output_data("TERMINAL-TYPE ");
511 switch (pointer[1]) {
512 case TELQUAL_IS:
513 output_data("IS \"%.*s\"", length-2, (char *)pointer+2);
514 break;
515 case TELQUAL_SEND:
516 output_data("SEND");
517 break;
518 default:
519 output_data(
520 "- unknown qualifier %d (0x%x).",
521 pointer[1], pointer[1]);
522 }
523 break;
524 case TELOPT_TSPEED:
525 output_data("TERMINAL-SPEED");
526 if (length < 2) {
527 output_data(" (empty suboption??\?)");
528 break;
529 }
530 switch (pointer[1]) {
531 case TELQUAL_IS:
532 output_data(" IS %.*s", length-2, (char *)pointer+2);
533 break;
534 default:
535 if (pointer[1] == 1)
536 output_data(" SEND");
537 else
538 output_data(" %d (unknown)", pointer[1]);
539 for (i = 2; i < length; i++) {
540 output_data(" ?%d?", pointer[i]);
541 }
542 break;
543 }
544 break;
545
546 case TELOPT_LFLOW:
547 output_data("TOGGLE-FLOW-CONTROL");
548 if (length < 2) {
549 output_data(" (empty suboption??\?)");
550 break;
551 }
552 switch (pointer[1]) {
553 case LFLOW_OFF:
554 output_data(" OFF"); break;
555 case LFLOW_ON:
556 output_data(" ON"); break;
557 case LFLOW_RESTART_ANY:
558 output_data(" RESTART-ANY"); break;
559 case LFLOW_RESTART_XON:
560 output_data(" RESTART-XON"); break;
561 default:
562 output_data(" %d (unknown)", pointer[1]);
563 }
564 for (i = 2; i < length; i++) {
565 output_data(" ?%d?", pointer[i]);
566 }
567 break;
568
569 case TELOPT_NAWS:
570 output_data("NAWS");
571 if (length < 2) {
572 output_data(" (empty suboption??\?)");
573 break;
574 }
575 if (length == 2) {
576 output_data(" ?%d?", pointer[1]);
577 break;
578 }
579 output_data(" %d %d (%d)",
580 pointer[1], pointer[2],
581 (int)((((unsigned int)pointer[1])<<8)|((unsigned int)pointer[2])));
582 if (length == 4) {
583 output_data(" ?%d?", pointer[3]);
584 break;
585 }
586 output_data(" %d %d (%d)",
587 pointer[3], pointer[4],
588 (int)((((unsigned int)pointer[3])<<8)|((unsigned int)pointer[4])));
589 for (i = 5; i < length; i++) {
590 output_data(" ?%d?", pointer[i]);
591 }
592 break;
593
594 case TELOPT_LINEMODE:
595 output_data("LINEMODE ");
596 if (length < 2) {
597 output_data(" (empty suboption??\?)");
598 break;
599 }
600 switch (pointer[1]) {
601 case WILL:
602 output_data("WILL ");
603 goto common;
604 case WONT:
605 output_data("WONT ");
606 goto common;
607 case DO:
608 output_data("DO ");
609 goto common;
610 case DONT:
611 output_data("DONT ");
612 common:
613 if (length < 3) {
614 output_data("(no option??\?)");
615 break;
616 }
617 switch (pointer[2]) {
618 case LM_FORWARDMASK:
619 output_data("Forward Mask");
620 for (i = 3; i < length; i++) {
621 output_data(" %x", pointer[i]);
622 }
623 break;
624 default:
625 output_data("%d (unknown)", pointer[2]);
626 for (i = 3; i < length; i++) {
627 output_data(" %d", pointer[i]);
628 }
629 break;
630 }
631 break;
632
633 case LM_SLC:
634 output_data("SLC");
635 for (i = 2; i < length - 2; i += 3) {
636 if (SLC_NAME_OK(pointer[i+SLC_FUNC]))
637 output_data(" %s", SLC_NAME(pointer[i+SLC_FUNC]));
638 else
639 output_data(" %d", pointer[i+SLC_FUNC]);
640 switch (pointer[i+SLC_FLAGS]&SLC_LEVELBITS) {
641 case SLC_NOSUPPORT:
642 output_data(" NOSUPPORT"); break;
643 case SLC_CANTCHANGE:
644 output_data(" CANTCHANGE"); break;
645 case SLC_VARIABLE:
646 output_data(" VARIABLE"); break;
647 case SLC_DEFAULT:
648 output_data(" DEFAULT"); break;
649 }
650 output_data("%s%s%s",
651 pointer[i+SLC_FLAGS]&SLC_ACK ? "|ACK" : "",
652 pointer[i+SLC_FLAGS]&SLC_FLUSHIN ? "|FLUSHIN" : "",
653 pointer[i+SLC_FLAGS]&SLC_FLUSHOUT ? "|FLUSHOUT" : "");
654 if (pointer[i+SLC_FLAGS]& ~(SLC_ACK|SLC_FLUSHIN|
655 SLC_FLUSHOUT| SLC_LEVELBITS)) {
656 output_data("(0x%x)", pointer[i+SLC_FLAGS]);
657 }
658 output_data(" %d;", pointer[i+SLC_VALUE]);
659 if ((pointer[i+SLC_VALUE] == IAC) &&
660 (pointer[i+SLC_VALUE+1] == IAC))
661 i++;
662 }
663 for (; i < length; i++) {
664 output_data(" ?%d?", pointer[i]);
665 }
666 break;
667
668 case LM_MODE:
669 output_data("MODE ");
670 if (length < 3) {
671 output_data("(no mode??\?)");
672 break;
673 }
674 {
675 char tbuf[32];
676 sprintf(tbuf, "%s%s%s%s%s",
677 pointer[2]&MODE_EDIT ? "|EDIT" : "",
678 pointer[2]&MODE_TRAPSIG ? "|TRAPSIG" : "",
679 pointer[2]&MODE_SOFT_TAB ? "|SOFT_TAB" : "",
680 pointer[2]&MODE_LIT_ECHO ? "|LIT_ECHO" : "",
681 pointer[2]&MODE_ACK ? "|ACK" : "");
682 output_data("%s", tbuf[1] ? &tbuf[1] : "0");
683 }
684 if (pointer[2]&~(MODE_EDIT|MODE_TRAPSIG|MODE_ACK)) {
685 output_data(" (0x%x)", pointer[2]);
686 }
687 for (i = 3; i < length; i++) {
688 output_data(" ?0x%x?", pointer[i]);
689 }
690 break;
691 default:
692 output_data("%d (unknown)", pointer[1]);
693 for (i = 2; i < length; i++) {
694 output_data(" %d", pointer[i]);
695 }
696 }
697 break;
698
699 case TELOPT_STATUS: {
700 const char *cp;
701 int j, k;
702
703 output_data("STATUS");
704
705 switch (pointer[1]) {
706 default:
707 if (pointer[1] == TELQUAL_SEND)
708 output_data(" SEND");
709 else
710 output_data(" %d (unknown)", pointer[1]);
711 for (i = 2; i < length; i++) {
712 output_data(" ?%d?", pointer[i]);
713 }
714 break;
715 case TELQUAL_IS:
716 output_data(" IS\r\n");
717
718 for (i = 2; i < length; i++) {
719 switch(pointer[i]) {
720 case DO: cp = "DO"; goto common2;
721 case DONT: cp = "DONT"; goto common2;
722 case WILL: cp = "WILL"; goto common2;
723 case WONT: cp = "WONT"; goto common2;
724 common2:
725 i++;
726 if (TELOPT_OK(pointer[i]))
727 output_data(" %s %s", cp, TELOPT(pointer[i]));
728 else
729 output_data(" %s %d", cp, pointer[i]);
730
731 output_data("\r\n");
732 break;
733
734 case SB:
735 output_data(" SB ");
736 i++;
737 j = k = i;
738 while (j < length) {
739 if (pointer[j] == SE) {
740 if (j+1 == length)
741 break;
742 if (pointer[j+1] == SE)
743 j++;
744 else
745 break;
746 }
747 pointer[k++] = pointer[j++];
748 }
749 printsub(0, &pointer[i], k - i);
750 if (i < length) {
751 output_data(" SE");
752 i = j;
753 } else
754 i = j - 1;
755
756 output_data("\r\n");
757
758 break;
759
760 default:
761 output_data(" %d", pointer[i]);
762 break;
763 }
764 }
765 break;
766 }
767 break;
768 }
769
770 case TELOPT_XDISPLOC:
771 output_data("X-DISPLAY-LOCATION ");
772 switch (pointer[1]) {
773 case TELQUAL_IS:
774 output_data("IS \"%.*s\"", length-2, (char *)pointer+2);
775 break;
776 case TELQUAL_SEND:
777 output_data("SEND");
778 break;
779 default:
780 output_data("- unknown qualifier %d (0x%x).",
781 pointer[1], pointer[1]);
782 }
783 break;
784
785 case TELOPT_NEW_ENVIRON:
786 output_data("NEW-ENVIRON ");
787 goto env_common1;
788 case TELOPT_OLD_ENVIRON:
789 output_data("OLD-ENVIRON");
790 env_common1:
791 switch (pointer[1]) {
792 case TELQUAL_IS:
793 output_data("IS ");
794 goto env_common;
795 case TELQUAL_SEND:
796 output_data("SEND ");
797 goto env_common;
798 case TELQUAL_INFO:
799 output_data("INFO ");
800 env_common:
801 {
802 int noquote = 2;
803 for (i = 2; i < length; i++ ) {
804 switch (pointer[i]) {
805 case NEW_ENV_VAR:
806 output_data("\" VAR " + noquote);
807 noquote = 2;
808 break;
809
810 case NEW_ENV_VALUE:
811 output_data("\" VALUE " + noquote);
812 noquote = 2;
813 break;
814
815 case ENV_ESC:
816 output_data("\" ESC " + noquote);
817 noquote = 2;
818 break;
819
820 case ENV_USERVAR:
821 output_data("\" USERVAR " + noquote);
822 noquote = 2;
823 break;
824
825 default:
826 if (isprint(pointer[i]) && pointer[i] != '"') {
827 if (noquote) {
828 output_data("\"");
829 noquote = 0;
830 }
831 output_data("%c", pointer[i]);
832 } else {
833 output_data("\" %03o " + noquote,
834 pointer[i]);
835 noquote = 2;
836 }
837 break;
838 }
839 }
840 if (!noquote)
841 output_data("\"");
842 break;
843 }
844 }
845 break;
846
847
848
849 default:
850 if (TELOPT_OK(pointer[0]))
851 output_data("%s (unknown)", TELOPT(pointer[0]));
852 else
853 output_data("%d (unknown)", pointer[i]);
854 for (i = 1; i < length; i++) {
855 output_data(" %d", pointer[i]);
856 }
857 break;
858 }
859 output_data("\r\n");
860}
861
862/*
863 * Dump a data buffer in hex and ascii to the output data stream.
864 */
865void
866printdata(const char *tag, char *ptr, int cnt)
867{
868 int i;
869 char xbuf[30];
870
871 while (cnt) {
872 /* flush net output buffer if no room for new data) */
873 if ((&netobuf[BUFSIZ] - nfrontp) < 80) {
874 netflush();
875 }
876
877 /* add a line of output */
878 output_data("%s: ", tag);
879 for (i = 0; i < 20 && cnt; i++) {
880 output_data("%02x", *ptr);
881 if (isprint(*ptr)) {
882 xbuf[i] = *ptr;
883 } else {
884 xbuf[i] = '.';
885 }
886 if (i % 2) {
887 output_data(" ");
888 }
889 cnt--;
890 ptr++;
891 }
892 xbuf[i] = '\0';
893 output_data(" %s\r\n", xbuf );
894 }
895}
896#endif /* DIAGNOSTICS */