Ansify some function definitions that were previously overlooked.
[dragonfly.git] / libexec / telnetd / utility.c
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.
32  *
33  * @(#)utility.c        8.4 (Berkeley) 5/30/95
34  * $FreeBSD: src/crypto/telnet/telnetd/utility.c,v 1.5.2.4 2002/04/13 10:59:09 markm Exp $
35  */
36
37 #ifdef __FreeBSD__
38 #include <locale.h>
39 #include <sys/utsname.h>
40 #endif
41 #include <string.h>
42 #define PRINTOPTIONS
43 #include "telnetd.h"
44
45 #ifdef  AUTHENTICATION
46 #include <libtelnet/auth.h>
47 #endif
48 #ifdef  ENCRYPTION
49 #include <libtelnet/encrypt.h>
50 #endif
51
52 /*
53  * utility functions performing io related tasks
54  */
55
56 /*
57  * ttloop
58  *
59  *      A small subroutine to flush the network output buffer, get some data
60  * from the network, and pass it through the telnet state machine.  We
61  * also flush the pty input buffer (by dropping its data) if it becomes
62  * too full.
63  */
64
65 void
66 ttloop(void)
67 {
68
69     DIAG(TD_REPORT, output_data("td: ttloop\r\n"));
70     if (nfrontp - nbackp > 0) {
71         netflush();
72     }
73     ncc = read(net, netibuf, sizeof netibuf);
74     if (ncc < 0) {
75         syslog(LOG_INFO, "ttloop:  read: %m");
76         exit(1);
77     } else if (ncc == 0) {
78         syslog(LOG_INFO, "ttloop:  peer died: %m");
79         exit(1);
80     }
81     DIAG(TD_REPORT, output_data("td: ttloop read %d chars\r\n", ncc));
82     netip = netibuf;
83     telrcv();                   /* state machine */
84     if (ncc > 0) {
85         pfrontp = pbackp = ptyobuf;
86         telrcv();
87     }
88 }  /* end of ttloop */
89
90 /*
91  * Check a descriptor to see if out of band data exists on it.
92  */
93 int
94 stilloob(int s)
95 {
96     static struct timeval timeout = { 0, 0 };
97     fd_set      excepts;
98     int value;
99
100     do {
101         FD_ZERO(&excepts);
102         FD_SET(s, &excepts);
103         memset((char *)&timeout, 0, sizeof timeout);
104         value = select(s+1, NULL, NULL, &excepts, &timeout);
105     } while ((value == -1) && (errno == EINTR));
106
107     if (value < 0) {
108         fatalperror(pty, "select");
109     }
110     if (FD_ISSET(s, &excepts)) {
111         return 1;
112     } else {
113         return 0;
114     }
115 }
116
117 void
118 ptyflush(void)
119 {
120         int n;
121
122         if ((n = pfrontp - pbackp) > 0) {
123                 DIAG(TD_REPORT | TD_PTYDATA,
124                     output_data("td: ptyflush %d chars\r\n", n));
125                 DIAG(TD_PTYDATA, printdata("pd", pbackp, n));
126                 n = write(pty, pbackp, n);
127         }
128         if (n < 0) {
129                 if (errno == EWOULDBLOCK || errno == EINTR)
130                         return;
131                 cleanup(0);
132         }
133         pbackp += n;
134         if (pbackp == pfrontp)
135                 pbackp = pfrontp = ptyobuf;
136 }
137
138 /*
139  * nextitem()
140  *
141  *      Return the address of the next "item" in the TELNET data
142  * stream.  This will be the address of the next character if
143  * the current address is a user data character, or it will
144  * be the address of the character following the TELNET command
145  * if the current address is a TELNET IAC ("I Am a Command")
146  * character.
147  */
148 static char *
149 nextitem(char *current)
150 {
151     if ((*current&0xff) != IAC) {
152         return current+1;
153     }
154     switch (*(current+1)&0xff) {
155     case DO:
156     case DONT:
157     case WILL:
158     case WONT:
159         return current+3;
160     case SB:            /* loop forever looking for the SE */
161         {
162             char *look = current+2;
163
164             for (;;) {
165                 if ((*look++&0xff) == IAC) {
166                     if ((*look++&0xff) == SE) {
167                         return look;
168                     }
169                 }
170             }
171         }
172     default:
173         return current+2;
174     }
175 }  /* end of nextitem */
176
177 /*
178  * netclear()
179  *
180  *      We are about to do a TELNET SYNCH operation.  Clear
181  * the path to the network.
182  *
183  *      Things are a bit tricky since we may have sent the first
184  * byte or so of a previous TELNET command into the network.
185  * So, we have to scan the network buffer from the beginning
186  * until we are up to where we want to be.
187  *
188  *      A side effect of what we do, just to keep things
189  * simple, is to clear the urgent data pointer.  The principal
190  * caller should be setting the urgent data pointer AFTER calling
191  * us in any case.
192  */
193 void
194 netclear(void)
195 {
196     char *thisitem, *next;
197     char *good;
198 #define wewant(p)       ((nfrontp > p) && ((*p&0xff) == IAC) && \
199                                 ((*(p+1)&0xff) != EC) && ((*(p+1)&0xff) != EL))
200
201 #ifdef  ENCRYPTION
202     thisitem = nclearto > netobuf ? nclearto : netobuf;
203 #else   /* ENCRYPTION */
204     thisitem = netobuf;
205 #endif  /* ENCRYPTION */
206
207     while ((next = nextitem(thisitem)) <= nbackp) {
208         thisitem = next;
209     }
210
211     /* Now, thisitem is first before/at boundary. */
212
213 #ifdef  ENCRYPTION
214     good = nclearto > netobuf ? nclearto : netobuf;
215 #else   /* ENCRYPTION */
216     good = netobuf;     /* where the good bytes go */
217 #endif  /* ENCRYPTION */
218
219     while (nfrontp > thisitem) {
220         if (wewant(thisitem)) {
221             int length;
222
223             next = thisitem;
224             do {
225                 next = nextitem(next);
226             } while (wewant(next) && (nfrontp > next));
227             length = next-thisitem;
228             memmove(good, thisitem, length);
229             good += length;
230             thisitem = next;
231         } else {
232             thisitem = nextitem(thisitem);
233         }
234     }
235
236     nbackp = netobuf;
237     nfrontp = good;             /* next byte to be sent */
238     neturg = 0;
239 }  /* end of netclear */
240
241 /*
242  *  netflush
243  *              Send as much data as possible to the network,
244  *      handling requests for urgent data.
245  */
246 void
247 netflush(void)
248 {
249     int n;
250     extern int not42;
251
252     while ((n = nfrontp - nbackp) > 0) {
253 #if 0
254         /* XXX This causes output_data() to recurse and die */
255         DIAG(TD_REPORT, {
256             n += output_data("td: netflush %d chars\r\n", n);
257         });
258 #endif
259 #ifdef  ENCRYPTION
260         if (encrypt_output) {
261                 char *s = nclearto ? nclearto : nbackp;
262                 if (nfrontp - s > 0) {
263                         (*encrypt_output)((unsigned char *)s, nfrontp-s);
264                         nclearto = nfrontp;
265                 }
266         }
267 #endif  /* ENCRYPTION */
268         /*
269          * if no urgent data, or if the other side appears to be an
270          * old 4.2 client (and thus unable to survive TCP urgent data),
271          * write the entire buffer in non-OOB mode.
272          */
273         if ((neturg == 0) || (not42 == 0)) {
274             n = write(net, nbackp, n);  /* normal write */
275         } else {
276             n = neturg - nbackp;
277             /*
278              * In 4.2 (and 4.3) systems, there is some question about
279              * what byte in a sendOOB operation is the "OOB" data.
280              * To make ourselves compatible, we only send ONE byte
281              * out of band, the one WE THINK should be OOB (though
282              * we really have more the TCP philosophy of urgent data
283              * rather than the Unix philosophy of OOB data).
284              */
285             if (n > 1) {
286                 n = send(net, nbackp, n-1, 0);  /* send URGENT all by itself */
287             } else {
288                 n = send(net, nbackp, n, MSG_OOB);      /* URGENT data */
289             }
290         }
291         if (n == -1) {
292             if (errno == EWOULDBLOCK || errno == EINTR)
293                 continue;
294             cleanup(0);
295             /* NOTREACHED */
296         }
297         nbackp += n;
298 #ifdef  ENCRYPTION
299         if (nbackp > nclearto)
300             nclearto = 0;
301 #endif  /* ENCRYPTION */
302         if (nbackp >= neturg) {
303             neturg = 0;
304         }
305         if (nbackp == nfrontp) {
306             nbackp = nfrontp = netobuf;
307 #ifdef  ENCRYPTION
308             nclearto = 0;
309 #endif  /* ENCRYPTION */
310         }
311     }
312     return;
313 }  /* end of netflush */
314
315
316 /*
317  * miscellaneous functions doing a variety of little jobs follow ...
318  */
319
320
321 void
322 fatal(int f, const char *msg)
323 {
324         char buf[BUFSIZ];
325
326         (void) snprintf(buf, sizeof(buf), "telnetd: %s.\r\n", msg);
327 #ifdef  ENCRYPTION
328         if (encrypt_output) {
329                 /*
330                  * Better turn off encryption first....
331                  * Hope it flushes...
332                  */
333                 encrypt_send_end();
334                 netflush();
335         }
336 #endif  /* ENCRYPTION */
337         (void) write(f, buf, (int)strlen(buf));
338         sleep(1);       /*XXX*/
339         exit(1);
340 }
341
342 void
343 fatalperror(int f, const char *msg)
344 {
345         char buf[BUFSIZ];
346
347         (void) snprintf(buf, sizeof(buf), "%s: %s", msg, strerror(errno));
348         fatal(f, buf);
349 }
350
351 char editedhost[32];
352
353 void
354 edithost(char *pat, char *host)
355 {
356         char *res = editedhost;
357
358         if (!pat)
359                 pat = strdup("");
360         while (*pat) {
361                 switch (*pat) {
362
363                 case '#':
364                         if (*host)
365                                 host++;
366                         break;
367
368                 case '@':
369                         if (*host)
370                                 *res++ = *host++;
371                         break;
372
373                 default:
374                         *res++ = *pat;
375                         break;
376                 }
377                 if (res == &editedhost[sizeof editedhost - 1]) {
378                         *res = '\0';
379                         return;
380                 }
381                 pat++;
382         }
383         if (*host)
384                 (void) strncpy(res, host,
385                                 sizeof editedhost - (res - editedhost) -1);
386         else
387                 *res = '\0';
388         editedhost[sizeof editedhost - 1] = '\0';
389 }
390
391 static char *putlocation;
392
393 static void
394 putstr(const char *s)
395 {
396
397         while (*s)
398                 putchr(*s++);
399 }
400
401 void
402 putchr(int cc)
403 {
404         *putlocation++ = cc;
405 }
406
407 #ifdef __FreeBSD__
408 static char fmtstr[] = { "%+" };
409 #else
410 static char fmtstr[] = { "%l:%M%P on %A, %d %B %Y" };
411 #endif
412
413 void
414 putf(char *cp, char *where)
415 {
416         char *slash;
417         time_t t;
418         char db[100];
419 #ifdef __FreeBSD__
420         static struct utsname kerninfo;
421
422         if (!*kerninfo.sysname)
423                 uname(&kerninfo);
424 #endif
425
426         putlocation = where;
427
428         while (*cp) {
429                 if (*cp =='\n') {
430                         putstr("\r\n");
431                         cp++;
432                         continue;
433                 } else if (*cp != '%') {
434                         putchr(*cp++);
435                         continue;
436                 }
437                 switch (*++cp) {
438
439                 case 't':
440 #ifdef  STREAMSPTY
441                         /* names are like /dev/pts/2 -- we want pts/2 */
442                         slash = strchr(line+1, '/');
443 #else
444                         slash = strrchr(line, '/');
445 #endif
446                         if (slash == (char *) 0)
447                                 putstr(line);
448                         else
449                                 putstr(&slash[1]);
450                         break;
451
452                 case 'h':
453                         putstr(editedhost);
454                         break;
455
456                 case 'd':
457 #ifdef __FreeBSD__
458                         setlocale(LC_TIME, "");
459 #endif
460                         (void)time(&t);
461                         (void)strftime(db, sizeof(db), fmtstr, localtime(&t));
462                         putstr(db);
463                         break;
464
465 #ifdef __FreeBSD__
466                 case 's':
467                         putstr(kerninfo.sysname);
468                         break;
469
470                 case 'm':
471                         putstr(kerninfo.machine);
472                         break;
473
474                 case 'r':
475                         putstr(kerninfo.release);
476                         break;
477
478                 case 'v':
479                         putstr(kerninfo.version);
480                         break;
481 #endif
482
483                 case '%':
484                         putchr('%');
485                         break;
486                 }
487                 cp++;
488         }
489 }
490
491 #ifdef DIAGNOSTICS
492 /*
493  * Print telnet options and commands in plain text, if possible.
494  */
495 void
496 printoption(const char *fmt, int option)
497 {
498         if (TELOPT_OK(option))
499                 output_data("%s %s\r\n", fmt, TELOPT(option));
500         else if (TELCMD_OK(option))
501                 output_data("%s %s\r\n", fmt, TELCMD(option));
502         else
503                 output_data("%s %d\r\n", fmt, option);
504         return;
505 }
506
507 void
508 printsub(char direction, unsigned char *pointer, int length)
509 {
510     int i = 0;
511
512         if (!(diagnostic & TD_OPTIONS))
513                 return;
514
515         if (direction) {
516             output_data("td: %s suboption ",
517                                         direction == '<' ? "recv" : "send");
518             if (length >= 3) {
519                 int j;
520
521                 i = pointer[length-2];
522                 j = pointer[length-1];
523
524                 if (i != IAC || j != SE) {
525                     output_data("(terminated by ");
526                     if (TELOPT_OK(i))
527                         output_data("%s ", TELOPT(i));
528                     else if (TELCMD_OK(i))
529                         output_data("%s ", TELCMD(i));
530                     else
531                         output_data("%d ", i);
532                     if (TELOPT_OK(j))
533                         output_data("%s", TELOPT(j));
534                     else if (TELCMD_OK(j))
535                         output_data("%s", TELCMD(j));
536                     else
537                         output_data("%d", j);
538                     output_data(", not IAC SE!) ");
539                 }
540             }
541             length -= 2;
542         }
543         if (length < 1) {
544             output_data("(Empty suboption??\?)");
545             return;
546         }
547         switch (pointer[0]) {
548         case TELOPT_TTYPE:
549             output_data("TERMINAL-TYPE ");
550             switch (pointer[1]) {
551             case TELQUAL_IS:
552                 output_data("IS \"%.*s\"", length-2, (char *)pointer+2);
553                 break;
554             case TELQUAL_SEND:
555                 output_data("SEND");
556                 break;
557             default:
558                 output_data(
559                                 "- unknown qualifier %d (0x%x).",
560                                 pointer[1], pointer[1]);
561             }
562             break;
563         case TELOPT_TSPEED:
564             output_data("TERMINAL-SPEED");
565             if (length < 2) {
566                 output_data(" (empty suboption??\?)");
567                 break;
568             }
569             switch (pointer[1]) {
570             case TELQUAL_IS:
571                 output_data(" IS %.*s", length-2, (char *)pointer+2);
572                 break;
573             default:
574                 if (pointer[1] == 1)
575                     output_data(" SEND");
576                 else
577                     output_data(" %d (unknown)", pointer[1]);
578                 for (i = 2; i < length; i++) {
579                     output_data(" ?%d?", pointer[i]);
580                 }
581                 break;
582             }
583             break;
584
585         case TELOPT_LFLOW:
586             output_data("TOGGLE-FLOW-CONTROL");
587             if (length < 2) {
588                 output_data(" (empty suboption??\?)");
589                 break;
590             }
591             switch (pointer[1]) {
592             case LFLOW_OFF:
593                 output_data(" OFF"); break;
594             case LFLOW_ON:
595                 output_data(" ON"); break;
596             case LFLOW_RESTART_ANY:
597                 output_data(" RESTART-ANY"); break;
598             case LFLOW_RESTART_XON:
599                 output_data(" RESTART-XON"); break;
600             default:
601                 output_data(" %d (unknown)", pointer[1]);
602             }
603             for (i = 2; i < length; i++) {
604                 output_data(" ?%d?", pointer[i]);
605             }
606             break;
607
608         case TELOPT_NAWS:
609             output_data("NAWS");
610             if (length < 2) {
611                 output_data(" (empty suboption??\?)");
612                 break;
613             }
614             if (length == 2) {
615                 output_data(" ?%d?", pointer[1]);
616                 break;
617             }
618             output_data(" %d %d (%d)",
619                 pointer[1], pointer[2],
620                 (int)((((unsigned int)pointer[1])<<8)|((unsigned int)pointer[2])));
621             if (length == 4) {
622                 output_data(" ?%d?", pointer[3]);
623                 break;
624             }
625             output_data(" %d %d (%d)",
626                 pointer[3], pointer[4],
627                 (int)((((unsigned int)pointer[3])<<8)|((unsigned int)pointer[4])));
628             for (i = 5; i < length; i++) {
629                 output_data(" ?%d?", pointer[i]);
630             }
631             break;
632
633         case TELOPT_LINEMODE:
634             output_data("LINEMODE ");
635             if (length < 2) {
636                 output_data(" (empty suboption??\?)");
637                 break;
638             }
639             switch (pointer[1]) {
640             case WILL:
641                 output_data("WILL ");
642                 goto common;
643             case WONT:
644                 output_data("WONT ");
645                 goto common;
646             case DO:
647                 output_data("DO ");
648                 goto common;
649             case DONT:
650                 output_data("DONT ");
651             common:
652                 if (length < 3) {
653                     output_data("(no option??\?)");
654                     break;
655                 }
656                 switch (pointer[2]) {
657                 case LM_FORWARDMASK:
658                     output_data("Forward Mask");
659                     for (i = 3; i < length; i++) {
660                         output_data(" %x", pointer[i]);
661                     }
662                     break;
663                 default:
664                     output_data("%d (unknown)", pointer[2]);
665                     for (i = 3; i < length; i++) {
666                         output_data(" %d", pointer[i]);
667                     }
668                     break;
669                 }
670                 break;
671
672             case LM_SLC:
673                 output_data("SLC");
674                 for (i = 2; i < length - 2; i += 3) {
675                     if (SLC_NAME_OK(pointer[i+SLC_FUNC]))
676                         output_data(" %s", SLC_NAME(pointer[i+SLC_FUNC]));
677                     else
678                         output_data(" %d", pointer[i+SLC_FUNC]);
679                     switch (pointer[i+SLC_FLAGS]&SLC_LEVELBITS) {
680                     case SLC_NOSUPPORT:
681                         output_data(" NOSUPPORT"); break;
682                     case SLC_CANTCHANGE:
683                         output_data(" CANTCHANGE"); break;
684                     case SLC_VARIABLE:
685                         output_data(" VARIABLE"); break;
686                     case SLC_DEFAULT:
687                         output_data(" DEFAULT"); break;
688                     }
689                     output_data("%s%s%s",
690                         pointer[i+SLC_FLAGS]&SLC_ACK ? "|ACK" : "",
691                         pointer[i+SLC_FLAGS]&SLC_FLUSHIN ? "|FLUSHIN" : "",
692                         pointer[i+SLC_FLAGS]&SLC_FLUSHOUT ? "|FLUSHOUT" : "");
693                     if (pointer[i+SLC_FLAGS]& ~(SLC_ACK|SLC_FLUSHIN|
694                                                 SLC_FLUSHOUT| SLC_LEVELBITS)) {
695                         output_data("(0x%x)", pointer[i+SLC_FLAGS]);
696                     }
697                     output_data(" %d;", pointer[i+SLC_VALUE]);
698                     if ((pointer[i+SLC_VALUE] == IAC) &&
699                         (pointer[i+SLC_VALUE+1] == IAC))
700                                 i++;
701                 }
702                 for (; i < length; i++) {
703                     output_data(" ?%d?", pointer[i]);
704                 }
705                 break;
706
707             case LM_MODE:
708                 output_data("MODE ");
709                 if (length < 3) {
710                     output_data("(no mode??\?)");
711                     break;
712                 }
713                 {
714                     char tbuf[32];
715                     sprintf(tbuf, "%s%s%s%s%s",
716                         pointer[2]&MODE_EDIT ? "|EDIT" : "",
717                         pointer[2]&MODE_TRAPSIG ? "|TRAPSIG" : "",
718                         pointer[2]&MODE_SOFT_TAB ? "|SOFT_TAB" : "",
719                         pointer[2]&MODE_LIT_ECHO ? "|LIT_ECHO" : "",
720                         pointer[2]&MODE_ACK ? "|ACK" : "");
721                     output_data("%s", tbuf[1] ? &tbuf[1] : "0");
722                 }
723                 if (pointer[2]&~(MODE_EDIT|MODE_TRAPSIG|MODE_ACK)) {
724                     output_data(" (0x%x)", pointer[2]);
725                 }
726                 for (i = 3; i < length; i++) {
727                     output_data(" ?0x%x?", pointer[i]);
728                 }
729                 break;
730             default:
731                 output_data("%d (unknown)", pointer[1]);
732                 for (i = 2; i < length; i++) {
733                     output_data(" %d", pointer[i]);
734                 }
735             }
736             break;
737
738         case TELOPT_STATUS: {
739             const char *cp;
740             int j, k;
741
742             output_data("STATUS");
743
744             switch (pointer[1]) {
745             default:
746                 if (pointer[1] == TELQUAL_SEND)
747                     output_data(" SEND");
748                 else
749                     output_data(" %d (unknown)", pointer[1]);
750                 for (i = 2; i < length; i++) {
751                     output_data(" ?%d?", pointer[i]);
752                 }
753                 break;
754             case TELQUAL_IS:
755                 output_data(" IS\r\n");
756
757                 for (i = 2; i < length; i++) {
758                     switch(pointer[i]) {
759                     case DO:    cp = "DO"; goto common2;
760                     case DONT:  cp = "DONT"; goto common2;
761                     case WILL:  cp = "WILL"; goto common2;
762                     case WONT:  cp = "WONT"; goto common2;
763                     common2:
764                         i++;
765                         if (TELOPT_OK(pointer[i]))
766                             output_data(" %s %s", cp, TELOPT(pointer[i]));
767                         else
768                             output_data(" %s %d", cp, pointer[i]);
769
770                         output_data("\r\n");
771                         break;
772
773                     case SB:
774                         output_data(" SB ");
775                         i++;
776                         j = k = i;
777                         while (j < length) {
778                             if (pointer[j] == SE) {
779                                 if (j+1 == length)
780                                     break;
781                                 if (pointer[j+1] == SE)
782                                     j++;
783                                 else
784                                     break;
785                             }
786                             pointer[k++] = pointer[j++];
787                         }
788                         printsub(0, &pointer[i], k - i);
789                         if (i < length) {
790                             output_data(" SE");
791                             i = j;
792                         } else
793                             i = j - 1;
794
795                         output_data("\r\n");
796
797                         break;
798
799                     default:
800                         output_data(" %d", pointer[i]);
801                         break;
802                     }
803                 }
804                 break;
805             }
806             break;
807           }
808
809         case TELOPT_XDISPLOC:
810             output_data("X-DISPLAY-LOCATION ");
811             switch (pointer[1]) {
812             case TELQUAL_IS:
813                 output_data("IS \"%.*s\"", length-2, (char *)pointer+2);
814                 break;
815             case TELQUAL_SEND:
816                 output_data("SEND");
817                 break;
818             default:
819                 output_data("- unknown qualifier %d (0x%x).",
820                                 pointer[1], pointer[1]);
821             }
822             break;
823
824         case TELOPT_NEW_ENVIRON:
825             output_data("NEW-ENVIRON ");
826             goto env_common1;
827         case TELOPT_OLD_ENVIRON:
828             output_data("OLD-ENVIRON");
829         env_common1:
830             switch (pointer[1]) {
831             case TELQUAL_IS:
832                 output_data("IS ");
833                 goto env_common;
834             case TELQUAL_SEND:
835                 output_data("SEND ");
836                 goto env_common;
837             case TELQUAL_INFO:
838                 output_data("INFO ");
839             env_common:
840                 {
841                     int noquote = 2;
842                     for (i = 2; i < length; i++ ) {
843                         switch (pointer[i]) {
844                         case NEW_ENV_VAR:
845                             output_data("\" VAR " + noquote);
846                             noquote = 2;
847                             break;
848
849                         case NEW_ENV_VALUE:
850                             output_data("\" VALUE " + noquote);
851                             noquote = 2;
852                             break;
853
854                         case ENV_ESC:
855                             output_data("\" ESC " + noquote);
856                             noquote = 2;
857                             break;
858
859                         case ENV_USERVAR:
860                             output_data("\" USERVAR " + noquote);
861                             noquote = 2;
862                             break;
863
864                         default:
865                             if (isprint(pointer[i]) && pointer[i] != '"') {
866                                 if (noquote) {
867                                     output_data("\"");
868                                     noquote = 0;
869                                 }
870                                 output_data("%c", pointer[i]);
871                             } else {
872                                 output_data("\" %03o " + noquote,
873                                                         pointer[i]);
874                                 noquote = 2;
875                             }
876                             break;
877                         }
878                     }
879                     if (!noquote)
880                         output_data("\"");
881                     break;
882                 }
883             }
884             break;
885
886 #ifdef  AUTHENTICATION
887         case TELOPT_AUTHENTICATION:
888             output_data("AUTHENTICATION");
889
890             if (length < 2) {
891                 output_data(" (empty suboption??\?)");
892                 break;
893             }
894             switch (pointer[1]) {
895             case TELQUAL_REPLY:
896             case TELQUAL_IS:
897                 output_data(" %s ", (pointer[1] == TELQUAL_IS) ?
898                                                         "IS" : "REPLY");
899                 if (AUTHTYPE_NAME_OK(pointer[2]))
900                     output_data("%s ", AUTHTYPE_NAME(pointer[2]));
901                 else
902                     output_data("%d ", pointer[2]);
903                 if (length < 3) {
904                     output_data("(partial suboption??\?)");
905                     break;
906                 }
907                 output_data("%s|%s",
908                         ((pointer[3] & AUTH_WHO_MASK) == AUTH_WHO_CLIENT) ?
909                         "CLIENT" : "SERVER",
910                         ((pointer[3] & AUTH_HOW_MASK) == AUTH_HOW_MUTUAL) ?
911                         "MUTUAL" : "ONE-WAY");
912
913                 {
914                     char buf[512];
915                     auth_printsub(&pointer[1], length - 1, buf, sizeof(buf));
916                     output_data("%s", buf);
917                 }
918                 break;
919
920             case TELQUAL_SEND:
921                 i = 2;
922                 output_data(" SEND ");
923                 while (i < length) {
924                     if (AUTHTYPE_NAME_OK(pointer[i]))
925                         output_data("%s ", AUTHTYPE_NAME(pointer[i]));
926                     else
927                         output_data("%d ", pointer[i]);
928                     if (++i >= length) {
929                         output_data("(partial suboption??\?)");
930                         break;
931                     }
932                     output_data("%s|%s ",
933                         ((pointer[i] & AUTH_WHO_MASK) == AUTH_WHO_CLIENT) ?
934                                                         "CLIENT" : "SERVER",
935                         ((pointer[i] & AUTH_HOW_MASK) == AUTH_HOW_MUTUAL) ?
936                                                         "MUTUAL" : "ONE-WAY");
937                     ++i;
938                 }
939                 break;
940
941             case TELQUAL_NAME:
942                 output_data(" NAME \"%.*s\"", length - 2, pointer + 2);
943                 break;
944
945             default:
946                     for (i = 2; i < length; i++) {
947                         output_data(" ?%d?", pointer[i]);
948                     }
949                     break;
950             }
951             break;
952 #endif
953
954 #ifdef  ENCRYPTION
955         case TELOPT_ENCRYPT:
956             output_data("ENCRYPT");
957             if (length < 2) {
958                 output_data(" (empty suboption??\?)");
959                 break;
960             }
961             switch (pointer[1]) {
962             case ENCRYPT_START:
963                 output_data(" START");
964                 break;
965
966             case ENCRYPT_END:
967                 output_data(" END");
968                 break;
969
970             case ENCRYPT_REQSTART:
971                 output_data(" REQUEST-START");
972                 break;
973
974             case ENCRYPT_REQEND:
975                 output_data(" REQUEST-END");
976                 break;
977
978             case ENCRYPT_IS:
979             case ENCRYPT_REPLY:
980                 output_data(" %s ", (pointer[1] == ENCRYPT_IS) ?
981                                                         "IS" : "REPLY");
982                 if (length < 3) {
983                     output_data(" (partial suboption??\?)");
984                     break;
985                 }
986                 if (ENCTYPE_NAME_OK(pointer[2]))
987                     output_data("%s ", ENCTYPE_NAME(pointer[2]));
988                 else
989                     output_data(" %d (unknown)", pointer[2]);
990
991                 {
992                     char buf[512];
993                     encrypt_printsub(&pointer[1], length - 1, buf, sizeof(buf));
994                     output_data("%s", buf);
995                 }
996                 break;
997
998             case ENCRYPT_SUPPORT:
999                 i = 2;
1000                 output_data(" SUPPORT ");
1001                 while (i < length) {
1002                     if (ENCTYPE_NAME_OK(pointer[i]))
1003                         output_data("%s ", ENCTYPE_NAME(pointer[i]));
1004                     else
1005                         output_data("%d ", pointer[i]);
1006                     i++;
1007                 }
1008                 break;
1009
1010             case ENCRYPT_ENC_KEYID:
1011                 output_data(" ENC_KEYID");
1012                 goto encommon;
1013
1014             case ENCRYPT_DEC_KEYID:
1015                 output_data(" DEC_KEYID");
1016                 goto encommon;
1017
1018             default:
1019                 output_data(" %d (unknown)", pointer[1]);
1020             encommon:
1021                 for (i = 2; i < length; i++) {
1022                     output_data(" %d", pointer[i]);
1023                 }
1024                 break;
1025             }
1026             break;
1027 #endif  /* ENCRYPTION */
1028
1029         default:
1030             if (TELOPT_OK(pointer[0]))
1031                 output_data("%s (unknown)", TELOPT(pointer[0]));
1032             else
1033                 output_data("%d (unknown)", pointer[i]);
1034             for (i = 1; i < length; i++) {
1035                 output_data(" %d", pointer[i]);
1036             }
1037             break;
1038         }
1039         output_data("\r\n");
1040 }
1041
1042 /*
1043  * Dump a data buffer in hex and ascii to the output data stream.
1044  */
1045 void
1046 printdata(const char *tag, char *ptr, int cnt)
1047 {
1048         int i;
1049         char xbuf[30];
1050
1051         while (cnt) {
1052                 /* flush net output buffer if no room for new data) */
1053                 if ((&netobuf[BUFSIZ] - nfrontp) < 80) {
1054                         netflush();
1055                 }
1056
1057                 /* add a line of output */
1058                 output_data("%s: ", tag);
1059                 for (i = 0; i < 20 && cnt; i++) {
1060                         output_data("%02x", *ptr);
1061                         if (isprint(*ptr)) {
1062                                 xbuf[i] = *ptr;
1063                         } else {
1064                                 xbuf[i] = '.';
1065                         }
1066                         if (i % 2) {
1067                                 output_data(" ");
1068                         }
1069                         cnt--;
1070                         ptr++;
1071                 }
1072                 xbuf[i] = '\0';
1073                 output_data(" %s\r\n", xbuf );
1074         }
1075 }
1076 #endif /* DIAGNOSTICS */