1 /* $NetBSD: telnetd.c,v 1.60 2024/10/29 13:10:10 kre Exp $ */
2
3 /*
4 * Copyright (C) 1997 and 1998 WIDE Project.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the project nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 /*
33 * Copyright (c) 1989, 1993
34 * The Regents of the University of California. All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 3. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 */
60
61 #include <sys/cdefs.h>
62 #ifndef lint
63 __COPYRIGHT("@(#) Copyright (c) 1989, 1993\
64 The Regents of the University of California. All rights reserved.");
65 #if 0
66 static char sccsid[] = "@(#)telnetd.c 8.4 (Berkeley) 5/30/95";
67 #else
68 __RCSID("$NetBSD: telnetd.c,v 1.60 2024/10/29 13:10:10 kre Exp $");
69 #endif
70 #endif /* not lint */
71
72 #include "telnetd.h"
73 #include "pathnames.h"
74
75 #include <arpa/inet.h>
76
77 #include <err.h>
78 #include <termcap.h>
79
80 #include <limits.h>
81
82 #ifdef KRB5
83 #define Authenticator k5_Authenticator
84 #include <krb5.h>
85 #undef Authenticator
86 #include <krb5/com_err.h>
87 #endif
88
89 #if defined(AUTHENTICATION) || defined(ENCRYPTION)
90 #include <libtelnet/misc.h>
91 #endif
92
93 extern int require_hwpreauth;
94 #ifdef KRB5
95 extern krb5_context telnet_context;
96 #endif
97 int registerd_host_only = 0;
98
99
100 /*
101 * I/O data buffers,
102 * pointers, and counters.
103 */
104 char ptyibuf[BUFSIZ], *ptyip = ptyibuf;
105 char ptyibuf2[BUFSIZ];
106
107
108 int hostinfo = 1; /* do we print login banner? */
109
110
111 static int debug = 0;
112 int keepalive = 1;
113 const char *gettyname = "default";
114 char *progname;
115
116 void usage(void) __dead;
117 int getterminaltype(char *, size_t);
118 int getent(char *, const char *);
119 static void doit(struct sockaddr *) __dead;
120 void _gettermname(void);
121 int terminaltypeok(char *);
122 char *getstr(const char *, char **);
123
124 /*
125 * The string to pass to getopt(). We do it this way so
126 * that only the actual options that we support will be
127 * passed off to getopt().
128 */
129 char valid_opts[] = {
130 'd', ':', 'g', ':', 'h', 'k', 'n', 'S', ':', 'u', ':', 'U',
131 '4', '6',
132 #ifdef AUTHENTICATION
133 'a', ':', 'X', ':',
134 #endif
135 #ifdef ENCRYPTION
136 'e', ':',
137 #endif
138 #ifdef DIAGNOSTICS
139 'D', ':',
140 #endif
141 #ifdef LINEMODE
142 'l',
143 #endif
144 #ifdef SECURELOGIN
145 's',
146 #endif
147 #ifdef KRB5
148 'R', ':', 'H',
149 #endif
150 '\0'
151 };
152
153 int family = AF_INET;
154 struct sockaddr_storage from;
155
156 int
main(int argc,char * argv[])157 main(int argc, char *argv[])
158 {
159 static char Xline[] = NULL16STR;
160
161 socklen_t fromlen;
162 int on = 1;
163 int ch;
164 #if defined(IPPROTO_IP) && defined(IP_TOS)
165 int tos = -1;
166 #endif
167
168 line = Xline;
169
170 pfrontp = pbackp = ptyobuf;
171 netip = netibuf;
172 nfrontp = nbackp = netobuf;
173 #ifdef ENCRYPTION
174 nclearto = 0;
175 #endif /* ENCRYPTION */
176
177 progname = *argv;
178
179
180 while ((ch = getopt(argc, argv, valid_opts)) != -1) {
181 switch (ch) {
182
183 #ifdef AUTHENTICATION
184 case 'a':
185 /*
186 * Check for required authentication level
187 */
188 if (strcmp(optarg, "debug") == 0) {
189 auth_debug_mode = 1;
190 } else if (strcasecmp(optarg, "none") == 0) {
191 auth_level = 0;
192 } else if (strcasecmp(optarg, "other") == 0) {
193 auth_level = AUTH_OTHER;
194 } else if (strcasecmp(optarg, "user") == 0) {
195 auth_level = AUTH_USER;
196 } else if (strcasecmp(optarg, "valid") == 0) {
197 auth_level = AUTH_VALID;
198 } else if (strcasecmp(optarg, "off") == 0) {
199 /*
200 * This hack turns off authentication
201 */
202 auth_level = -1;
203 } else {
204 fprintf(stderr,
205 "telnetd: unknown authorization level for -a\n");
206 }
207 break;
208 #endif /* AUTHENTICATION */
209
210
211 case 'd':
212 if (strcmp(optarg, "ebug") == 0) {
213 debug++;
214 break;
215 }
216 usage();
217 /* NOTREACHED */
218 break;
219
220 #ifdef DIAGNOSTICS
221 case 'D':
222 /*
223 * Check for desired diagnostics capabilities.
224 */
225 if (!strcmp(optarg, "report")) {
226 diagnostic |= TD_REPORT|TD_OPTIONS;
227 } else if (!strcmp(optarg, "exercise")) {
228 diagnostic |= TD_EXERCISE;
229 } else if (!strcmp(optarg, "netdata")) {
230 diagnostic |= TD_NETDATA;
231 } else if (!strcmp(optarg, "ptydata")) {
232 diagnostic |= TD_PTYDATA;
233 } else if (!strcmp(optarg, "options")) {
234 diagnostic |= TD_OPTIONS;
235 } else {
236 usage();
237 /* NOT REACHED */
238 }
239 break;
240 #endif /* DIAGNOSTICS */
241
242 #ifdef ENCRYPTION
243 case 'e':
244 if (strcmp(optarg, "debug") == 0) {
245 EncryptDebug(1);
246 break;
247 }
248 usage();
249 /* NOTREACHED */
250 break;
251 #endif /* ENCRYPTION */
252
253 case 'g':
254 gettyname = optarg;
255 break;
256
257 case 'h':
258 hostinfo = 0;
259 break;
260
261 #ifdef KRB5
262 case 'H':
263 {
264 require_hwpreauth = 1;
265 break;
266 }
267 #endif /* KRB5 */
268
269
270 #ifdef LINEMODE
271 case 'l':
272 alwayslinemode = 1;
273 break;
274 #endif /* LINEMODE */
275
276 case 'k':
277 #if defined(LINEMODE) && defined(KLUDGELINEMODE)
278 lmodetype = NO_AUTOKLUDGE;
279 #else
280 /* ignore -k option if built without kludge linemode */
281 #endif /* defined(LINEMODE) && defined(KLUDGELINEMODE) */
282 break;
283
284 case 'n':
285 keepalive = 0;
286 break;
287
288
289 #ifdef KRB5
290 case 'R':
291 {
292 krb5_error_code retval;
293
294 if (telnet_context == 0) {
295 retval = krb5_init_context(&telnet_context);
296 if (retval) {
297 com_err("telnetd", retval,
298 "while initializing krb5");
299 exit(1);
300 }
301 }
302 krb5_set_default_realm(telnet_context, optarg);
303 break;
304 }
305 #endif /* KRB5 */
306
307 #ifdef SECURELOGIN
308 case 's':
309 /* Secure login required */
310 require_secure_login = 1;
311 break;
312 #endif /* SECURELOGIN */
313 case 'S':
314 fprintf(stderr, "%s%s\n", "TOS option unavailable; ",
315 "-S flag not supported\n");
316 break;
317
318 case 'u':
319 fprintf(stderr, "telnetd: -u option unneeded\n");
320 break;
321
322 case 'U':
323 registerd_host_only = 1;
324 break;
325
326 #ifdef AUTHENTICATION
327 case 'X':
328 /*
329 * Check for invalid authentication types
330 */
331 auth_disable_name(optarg);
332 break;
333 #endif /* AUTHENTICATION */
334
335 case '4':
336 family = AF_INET;
337 break;
338
339 case '6':
340 family = AF_INET6;
341 break;
342
343 default:
344 fprintf(stderr, "telnetd: %c: unknown option\n", ch);
345 /* FALLTHROUGH */
346 case '?':
347 usage();
348 /* NOTREACHED */
349 }
350 }
351
352 argc -= optind;
353 argv += optind;
354
355 if (debug) {
356 int s, ns, error;
357 socklen_t foo;
358 const char *service = "telnet";
359 struct addrinfo hints, *res;
360
361 if (argc > 1) {
362 usage();
363 /* NOT REACHED */
364 } else if (argc == 1)
365 service = *argv;
366
367 memset(&hints, 0, sizeof(hints));
368 hints.ai_flags = AI_PASSIVE;
369 hints.ai_family = family;
370 hints.ai_socktype = SOCK_STREAM;
371 hints.ai_protocol = 0;
372 error = getaddrinfo(NULL, service, &hints, &res);
373
374 if (error) {
375 fprintf(stderr, "tcp/%s: %s\n", service, gai_strerror(error));
376 exit(1);
377 }
378
379 s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
380 if (s < 0) {
381 perror("telnetd: socket");
382 exit(1);
383 }
384 (void) setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
385 (char *)&on, sizeof(on));
386 if (bind(s, res->ai_addr, res->ai_addrlen) < 0) {
387 perror("bind");
388 exit(1);
389 }
390 if (listen(s, 1) < 0) {
391 perror("listen");
392 exit(1);
393 }
394 foo = res->ai_addrlen;
395 ns = accept(s, res->ai_addr, &foo);
396 if (ns < 0) {
397 perror("accept");
398 exit(1);
399 }
400 (void) dup2(ns, 0);
401 (void) close(ns);
402 (void) close(s);
403 freeaddrinfo(res);
404 } else if (argc > 0) {
405 usage();
406 /* NOT REACHED */
407 }
408
409 openlog("telnetd", LOG_PID, LOG_DAEMON);
410 fromlen = sizeof (from);
411 if (getpeername(0, (struct sockaddr *)&from, &fromlen) < 0) {
412 fprintf(stderr, "%s: ", progname);
413 perror("getpeername");
414 _exit(1);
415 }
416 if (keepalive &&
417 setsockopt(0, SOL_SOCKET, SO_KEEPALIVE,
418 (char *)&on, sizeof (on)) < 0) {
419 syslog(LOG_WARNING, "setsockopt (SO_KEEPALIVE): %m");
420 }
421
422 #if defined(IPPROTO_IP) && defined(IP_TOS)
423 if (((struct sockaddr *)&from)->sa_family == AF_INET) {
424 if (tos < 0)
425 tos = 020; /* Low Delay bit */
426 if (tos
427 && (setsockopt(0, IPPROTO_IP, IP_TOS,
428 (char *)&tos, sizeof(tos)) < 0)
429 && (errno != ENOPROTOOPT) )
430 syslog(LOG_WARNING, "setsockopt (IP_TOS): %m");
431 }
432 #endif /* defined(IPPROTO_IP) && defined(IP_TOS) */
433
434 net = 0;
435 doit((struct sockaddr *)&from);
436 /* NOTREACHED */
437 #ifdef __GNUC__
438 exit(0);
439 #endif
440 } /* end of main */
441
442 void
usage(void)443 usage(void)
444 {
445 fprintf(stderr, "Usage: telnetd");
446 #ifdef AUTHENTICATION
447 fprintf(stderr, " [-a (debug|other|user|valid|off|none)]\n\t");
448 #endif
449 fprintf(stderr, " [-debug]");
450 #ifdef DIAGNOSTICS
451 fprintf(stderr, " [-D (options|report|exercise|netdata|ptydata)]\n\t");
452 #endif
453 #ifdef ENCRYPTION
454 fprintf(stderr, " [-edebug]");
455 #endif
456 fprintf(stderr, " [-h]");
457 #if defined(LINEMODE) && defined(KLUDGELINEMODE)
458 fprintf(stderr, " [-k]");
459 #endif
460 #ifdef LINEMODE
461 fprintf(stderr, " [-l]");
462 #endif
463 fprintf(stderr, " [-n]");
464 fprintf(stderr, "\n\t");
465 #ifdef SECURELOGIN
466 fprintf(stderr, " [-s]");
467 #endif
468 #ifdef AUTHENTICATION
469 fprintf(stderr, " [-X auth-type]");
470 #endif
471 fprintf(stderr, " [-u utmp_hostname_length] [-U]");
472 fprintf(stderr, " [port]\n");
473 exit(1);
474 }
475
476 /*
477 * getterminaltype
478 *
479 * Ask the other end to send along its terminal type and speed.
480 * Output is the variable terminaltype filled in.
481 */
482 static unsigned char ttytype_sbbuf[] = {
483 IAC, SB, TELOPT_TTYPE, TELQUAL_SEND, IAC, SE
484 };
485
486 int
getterminaltype(char * name,size_t l)487 getterminaltype(char *name, size_t l)
488 {
489 int retval = -1;
490
491 settimer(baseline);
492 #ifdef AUTHENTICATION
493 /*
494 * Handle the Authentication option before we do anything else.
495 */
496 if (auth_level >= 0) {
497 send_do(TELOPT_AUTHENTICATION, 1);
498 while (his_will_wont_is_changing(TELOPT_AUTHENTICATION))
499 ttloop();
500 if (his_state_is_will(TELOPT_AUTHENTICATION)) {
501 retval = auth_wait(name, l);
502 }
503 }
504 #endif
505
506 #ifdef ENCRYPTION
507 send_will(TELOPT_ENCRYPT, 1);
508 #endif /* ENCRYPTION */
509 send_do(TELOPT_TTYPE, 1);
510 send_do(TELOPT_TSPEED, 1);
511 send_do(TELOPT_XDISPLOC, 1);
512 send_do(TELOPT_NEW_ENVIRON, 1);
513 send_do(TELOPT_OLD_ENVIRON, 1);
514 while (
515 #ifdef ENCRYPTION
516 his_do_dont_is_changing(TELOPT_ENCRYPT) ||
517 #endif /* ENCRYPTION */
518 his_will_wont_is_changing(TELOPT_TTYPE) ||
519 his_will_wont_is_changing(TELOPT_TSPEED) ||
520 his_will_wont_is_changing(TELOPT_XDISPLOC) ||
521 his_will_wont_is_changing(TELOPT_NEW_ENVIRON) ||
522 his_will_wont_is_changing(TELOPT_OLD_ENVIRON)) {
523 ttloop();
524 }
525 if (his_state_is_will(TELOPT_TSPEED)) {
526 static unsigned char sb[] =
527 { IAC, SB, TELOPT_TSPEED, TELQUAL_SEND, IAC, SE };
528
529 output_datalen((const char *)sb, sizeof sb);
530 DIAG(TD_OPTIONS, printsub('>', sb + 2, sizeof sb - 2););
531 }
532 #ifdef ENCRYPTION
533 /*
534 * Wait for the negotiation of what type of encryption we can
535 * send with. If autoencrypt is not set, this will just return.
536 */
537 if (his_state_is_will(TELOPT_ENCRYPT)) {
538 encrypt_wait();
539 }
540 #endif /* ENCRYPTION */
541 if (his_state_is_will(TELOPT_XDISPLOC)) {
542 static unsigned char sb[] =
543 { IAC, SB, TELOPT_XDISPLOC, TELQUAL_SEND, IAC, SE };
544
545 output_datalen((const char *)sb, sizeof sb);
546 DIAG(TD_OPTIONS, printsub('>', sb + 2, sizeof sb - 2););
547 }
548 if (his_state_is_will(TELOPT_NEW_ENVIRON)) {
549 static unsigned char sb[] =
550 { IAC, SB, TELOPT_NEW_ENVIRON, TELQUAL_SEND, IAC, SE };
551
552 output_datalen((const char *)sb, sizeof sb);
553 DIAG(TD_OPTIONS, printsub('>', sb + 2, sizeof sb - 2););
554 }
555 else if (his_state_is_will(TELOPT_OLD_ENVIRON)) {
556 static unsigned char sb[] =
557 { IAC, SB, TELOPT_OLD_ENVIRON, TELQUAL_SEND, IAC, SE };
558
559 output_datalen((const char *)sb, sizeof sb);
560 DIAG(TD_OPTIONS, printsub('>', sb + 2, sizeof sb - 2););
561 }
562 if (his_state_is_will(TELOPT_TTYPE)) {
563
564 output_datalen((const char *)ttytype_sbbuf, sizeof ttytype_sbbuf);
565 DIAG(TD_OPTIONS, printsub('>', ttytype_sbbuf + 2,
566 sizeof ttytype_sbbuf - 2););
567 }
568 if (his_state_is_will(TELOPT_TSPEED)) {
569 while (sequenceIs(tspeedsubopt, baseline))
570 ttloop();
571 }
572 if (his_state_is_will(TELOPT_XDISPLOC)) {
573 while (sequenceIs(xdisplocsubopt, baseline))
574 ttloop();
575 }
576 if (his_state_is_will(TELOPT_NEW_ENVIRON)) {
577 while (sequenceIs(environsubopt, baseline))
578 ttloop();
579 }
580 if (his_state_is_will(TELOPT_OLD_ENVIRON)) {
581 while (sequenceIs(oenvironsubopt, baseline))
582 ttloop();
583 }
584 if (his_state_is_will(TELOPT_TTYPE)) {
585 char first[256], last[256];
586
587 while (sequenceIs(ttypesubopt, baseline))
588 ttloop();
589
590 /*
591 * If the other side has already disabled the option, then
592 * we have to just go with what we (might) have already gotten.
593 */
594 if (his_state_is_will(TELOPT_TTYPE) && !terminaltypeok(terminaltype)) {
595 (void) strlcpy(first, terminaltype, sizeof(first));
596 for(;;) {
597 /*
598 * Save the unknown name, and request the next name.
599 */
600 (void) strlcpy(last, terminaltype, sizeof(last));
601 _gettermname();
602 if (terminaltypeok(terminaltype))
603 break;
604 if ((strncmp(last, terminaltype, sizeof(last)) == 0) ||
605 his_state_is_wont(TELOPT_TTYPE)) {
606 /*
607 * We've hit the end. If this is the same as
608 * the first name, just go with it.
609 */
610 if (strncmp(first, terminaltype, sizeof(first)) == 0)
611 break;
612 /*
613 * Get the terminal name one more time, so that
614 * RFC1091 compliant telnets will cycle back to
615 * the start of the list.
616 */
617 _gettermname();
618 if (strncmp(first, terminaltype, sizeof(first)) != 0) {
619 (void) strlcpy(terminaltype, first, sizeof(terminaltype));
620 }
621 break;
622 }
623 }
624 }
625 }
626 return(retval);
627 } /* end of getterminaltype */
628
629 void
_gettermname(void)630 _gettermname(void)
631 {
632 /*
633 * If the client turned off the option,
634 * we can't send another request, so we
635 * just return.
636 */
637 if (his_state_is_wont(TELOPT_TTYPE))
638 return;
639 settimer(baseline);
640 output_datalen((const char *)ttytype_sbbuf, sizeof ttytype_sbbuf);
641 DIAG(TD_OPTIONS, printsub('>', ttytype_sbbuf + 2,
642 sizeof ttytype_sbbuf - 2););
643 while (sequenceIs(ttypesubopt, baseline))
644 ttloop();
645 }
646
647 int
terminaltypeok(char * s)648 terminaltypeok(char *s)
649 {
650 char buf[1024];
651
652 /*
653 * tgetent() will return 1 if the type is known, and
654 * 0 if it is not known. If it returns -1, it couldn't
655 * open the database. But if we can't open the database,
656 * it won't help to say we failed, because we won't be
657 * able to verify anything else. So, we treat -1 like 1.
658 */
659 if (tgetent(buf, s) == 0)
660 return(0);
661 return(1);
662 }
663
664 char *hostname;
665 char host_name[MAXHOSTNAMELEN + 1];
666 char remote_host_name[MAXHOSTNAMELEN + 1];
667
668 static void telnet(int, int) __dead;
669
670 /*
671 * Get a pty, scan input lines.
672 */
673 static void
doit(struct sockaddr * who)674 doit(struct sockaddr *who)
675 {
676 char *host;
677 int error;
678 int level;
679 int ptynum;
680 int flags;
681 char user_name[256];
682
683 /*
684 * Initialize the slc mapping table.
685 */
686 get_slc_defaults();
687
688 /*
689 * Find an available pty to use.
690 */
691 pty = getpty(&ptynum);
692 if (pty < 0)
693 fatal(net, "All network ports in use");
694
695 flags = registerd_host_only ? NI_NAMEREQD : 0;
696
697 /* get name of connected client */
698 error = getnameinfo(who, who->sa_len, remote_host_name,
699 sizeof(remote_host_name), NULL, 0, flags);
700
701 if (error) {
702 fatal(net, "Couldn't resolve your address into a host name.\r\n\
703 Please contact your net administrator");
704 #ifdef __GNUC__
705 host = NULL; /* XXX gcc */
706 #endif
707 }
708
709 remote_host_name[sizeof(remote_host_name)-1] = 0;
710 host = remote_host_name;
711
712 (void)gethostname(host_name, sizeof(host_name));
713 host_name[sizeof(host_name) - 1] = '\0';
714 hostname = host_name;
715
716 #if defined(AUTHENTICATION) || defined(ENCRYPTION)
717 auth_encrypt_init(hostname, host, "TELNETD", 1);
718 #endif
719
720 init_env();
721 /*
722 * get terminal type.
723 */
724 *user_name = 0;
725 level = getterminaltype(user_name, sizeof(user_name));
726 setenv("TERM", terminaltype[0] ? terminaltype : "network", 1);
727
728 /*
729 * Start up the login process on the slave side of the terminal
730 */
731 startslave(host, level, user_name);
732
733 telnet(net, pty); /* begin server processing */
734 /*NOTREACHED*/
735 } /* end of doit */
736
737
738 /*
739 * Main loop. Select from pty and network, and
740 * hand data to telnet receiver finite state machine.
741 */
742 static void
telnet(int f,int p)743 telnet(int f, int p)
744 {
745 int on = 1;
746 #define TABBUFSIZ 512
747 char defent[TABBUFSIZ];
748 char defstrs[TABBUFSIZ];
749 #undef TABBUFSIZ
750 char *HE, *HN, *IF, *ptyibuf2ptr;
751 const char *IM;
752 struct pollfd set[2];
753
754 /*
755 * Do some tests where it is desirable to wait for a response.
756 * Rather than doing them slowly, one at a time, do them all
757 * at once.
758 */
759 if (my_state_is_wont(TELOPT_SGA))
760 send_will(TELOPT_SGA, 1);
761 /*
762 * Is the client side a 4.2 (NOT 4.3) system? We need to know this
763 * because 4.2 clients are unable to deal with TCP urgent data.
764 *
765 * To find out, we send out a "DO ECHO". If the remote system
766 * answers "WILL ECHO" it is probably a 4.2 client, and we note
767 * that fact ("WILL ECHO" ==> that the client will echo what
768 * WE, the server, sends it; it does NOT mean that the client will
769 * echo the terminal input).
770 */
771 send_do(TELOPT_ECHO, 1);
772
773 #ifdef LINEMODE
774 if (his_state_is_wont(TELOPT_LINEMODE)) {
775 /* Query the peer for linemode support by trying to negotiate
776 * the linemode option.
777 */
778 linemode = 0;
779 editmode = 0;
780 send_do(TELOPT_LINEMODE, 1); /* send do linemode */
781 }
782 #endif /* LINEMODE */
783
784 /*
785 * Send along a couple of other options that we wish to negotiate.
786 */
787 send_do(TELOPT_NAWS, 1);
788 send_will(TELOPT_STATUS, 1);
789 flowmode = 1; /* default flow control state */
790 restartany = -1; /* uninitialized... */
791 send_do(TELOPT_LFLOW, 1);
792
793 /*
794 * Spin, waiting for a response from the DO ECHO. However,
795 * some REALLY DUMB telnets out there might not respond
796 * to the DO ECHO. So, we spin looking for NAWS, (most dumb
797 * telnets so far seem to respond with WONT for a DO that
798 * they don't understand...) because by the time we get the
799 * response, it will already have processed the DO ECHO.
800 * Kludge upon kludge.
801 */
802 while (his_will_wont_is_changing(TELOPT_NAWS))
803 ttloop();
804
805 /*
806 * But...
807 * The client might have sent a WILL NAWS as part of its
808 * startup code; if so, we'll be here before we get the
809 * response to the DO ECHO. We'll make the assumption
810 * that any implementation that understands about NAWS
811 * is a modern enough implementation that it will respond
812 * to our DO ECHO request; hence we'll do another spin
813 * waiting for the ECHO option to settle down, which is
814 * what we wanted to do in the first place...
815 */
816 if (his_want_state_is_will(TELOPT_ECHO) &&
817 his_state_is_will(TELOPT_NAWS)) {
818 while (his_will_wont_is_changing(TELOPT_ECHO))
819 ttloop();
820 }
821 /*
822 * On the off chance that the telnet client is broken and does not
823 * respond to the DO ECHO we sent, (after all, we did send the
824 * DO NAWS negotiation after the DO ECHO, and we won't get here
825 * until a response to the DO NAWS comes back) simulate the
826 * receipt of a will echo. This will also send a WONT ECHO
827 * to the client, since we assume that the client failed to
828 * respond because it believes that it is already in DO ECHO
829 * mode, which we do not want.
830 */
831 if (his_want_state_is_will(TELOPT_ECHO)) {
832 DIAG(TD_OPTIONS,
833 {output_data("td: simulating recv\r\n");});
834 willoption(TELOPT_ECHO);
835 }
836
837 /*
838 * Finally, to clean things up, we turn on our echo. This
839 * will break stupid 4.2 telnets out of local terminal echo.
840 */
841
842 if (my_state_is_wont(TELOPT_ECHO))
843 send_will(TELOPT_ECHO, 1);
844
845 /*
846 * Turn on packet mode
847 */
848 (void) ioctl(p, TIOCPKT, (char *)&on);
849
850 #if defined(LINEMODE) && defined(KLUDGELINEMODE)
851 /*
852 * Continuing line mode support. If client does not support
853 * real linemode, attempt to negotiate kludge linemode by sending
854 * the do timing mark sequence.
855 */
856 if (lmodetype < REAL_LINEMODE)
857 send_do(TELOPT_TM, 1);
858 #endif /* defined(LINEMODE) && defined(KLUDGELINEMODE) */
859
860 /*
861 * Call telrcv() once to pick up anything received during
862 * terminal type negotiation, 4.2/4.3 determination, and
863 * linemode negotiation.
864 */
865 telrcv();
866
867 (void) ioctl(f, FIONBIO, (char *)&on);
868 (void) ioctl(p, FIONBIO, (char *)&on);
869
870 (void) setsockopt(f, SOL_SOCKET, SO_OOBINLINE, (char *)&on, sizeof on);
871
872 (void) signal(SIGTSTP, SIG_IGN);
873 /*
874 * Ignoring SIGTTOU keeps the kernel from blocking us
875 * in ttioct() in /sys/tty.c.
876 */
877 (void) signal(SIGTTOU, SIG_IGN);
878
879 (void) signal(SIGCHLD, cleanup);
880
881
882 {
883 int t;
884 t = open(_PATH_TTY, O_RDWR);
885 if (t >= 0) {
886 (void) ioctl(t, TIOCNOTTY, (char *)0);
887 (void) close(t);
888 }
889 }
890
891
892 /*
893 * Show banner that getty never gave.
894 *
895 * We put the banner in the pty input buffer. This way, it
896 * gets carriage return null processing, etc., just like all
897 * other pty --> client data.
898 */
899
900 if (getent(defent, gettyname) == 1) {
901 char *cp=defstrs;
902
903 HE = getstr("he", &cp);
904 HN = getstr("hn", &cp);
905 IM = getstr("im", &cp);
906 IF = getstr("if", &cp);
907 if (HN && *HN)
908 (void)strlcpy(host_name, HN, sizeof(host_name));
909 if (IM == 0)
910 IM = "";
911 } else {
912 IM = DEFAULT_IM;
913 HE = 0;
914 IF = NULL;
915 }
916 edithost(HE, host_name);
917 ptyibuf2ptr = ptyibuf2;
918 if (hostinfo) {
919 if (IF) {
920 char buf[_POSIX2_LINE_MAX];
921 FILE *fd;
922
923 if ((fd = fopen(IF, "r")) != NULL) {
924 while (fgets(buf, sizeof(buf) - 1, fd) != NULL)
925 ptyibuf2ptr = putf(buf, ptyibuf2ptr);
926 fclose(fd);
927 }
928 }
929 if (*IM)
930 ptyibuf2ptr = putf(IM, ptyibuf2ptr);
931 }
932
933 if (pcc)
934 strncpy(ptyibuf2ptr, ptyip, pcc+1);
935 ptyip = ptyibuf2;
936 pcc = strlen(ptyip);
937 #ifdef LINEMODE
938 /*
939 * Last check to make sure all our states are correct.
940 */
941 init_termbuf();
942 localstat();
943 #endif /* LINEMODE */
944
945 DIAG(TD_REPORT,
946 {output_data("td: Entering processing loop\r\n");});
947
948
949 set[0].fd = f;
950 set[1].fd = p;
951 for (;;) {
952 int c;
953
954 if (ncc < 0 && pcc < 0)
955 break;
956
957 /*
958 * Never look for input if there's still
959 * stuff in the corresponding output buffer
960 */
961 set[0].events = 0;
962 set[1].events = 0;
963 if (nfrontp - nbackp || pcc > 0)
964 set[0].events |= POLLOUT;
965 else
966 set[1].events |= POLLIN;
967 if (pfrontp - pbackp || ncc > 0)
968 set[1].events |= POLLOUT;
969 else
970 set[0].events |= POLLIN;
971 if (!SYNCHing)
972 set[0].events |= POLLPRI;
973
974 if ((c = poll(set, 2, INFTIM)) < 1) {
975 if (c == -1) {
976 if (errno == EINTR) {
977 continue;
978 }
979 }
980 sleep(5);
981 continue;
982 }
983
984 /*
985 * Any urgent data?
986 */
987 if (set[0].revents & POLLPRI) {
988 SYNCHing = 1;
989 }
990
991 /*
992 * Something to read from the network...
993 */
994 if (set[0].revents & POLLIN) {
995 ncc = read(f, netibuf, sizeof (netibuf));
996 if (ncc < 0 && errno == EWOULDBLOCK)
997 ncc = 0;
998 else {
999 if (ncc <= 0) {
1000 break;
1001 }
1002 netip = netibuf;
1003 }
1004 DIAG((TD_REPORT | TD_NETDATA),
1005 {output_data("td: netread %d chars\r\n", ncc);});
1006 DIAG(TD_NETDATA, printdata("nd", netip, ncc));
1007 }
1008
1009 /*
1010 * Something to read from the pty...
1011 */
1012 if (set[1].revents & POLLIN) {
1013 pcc = read(p, ptyibuf, BUFSIZ);
1014 /*
1015 * On some systems, if we try to read something
1016 * off the master side before the slave side is
1017 * opened, we get EIO.
1018 */
1019 if (pcc < 0 && (errno == EWOULDBLOCK ||
1020 errno == EAGAIN ||
1021 errno == EIO)) {
1022 pcc = 0;
1023 } else {
1024 if (pcc <= 0)
1025 break;
1026 #ifdef LINEMODE
1027 /*
1028 * If ioctl from pty, pass it through net
1029 */
1030 if (ptyibuf[0] & TIOCPKT_IOCTL) {
1031 copy_termbuf(ptyibuf+1, pcc-1);
1032 localstat();
1033 pcc = 1;
1034 }
1035 #endif /* LINEMODE */
1036 if (ptyibuf[0] & TIOCPKT_FLUSHWRITE) {
1037 netclear(); /* clear buffer back */
1038 /*
1039 * There are client telnets on some
1040 * operating systems get screwed up
1041 * royally if we send them urgent
1042 * mode data.
1043 */
1044 output_data("%c%c", IAC, DM);
1045 neturg = nfrontp - 1; /* off by one XXX */
1046 DIAG(TD_OPTIONS,
1047 printoption("td: send IAC", DM));
1048 }
1049 if (his_state_is_will(TELOPT_LFLOW) &&
1050 (ptyibuf[0] &
1051 (TIOCPKT_NOSTOP|TIOCPKT_DOSTOP))) {
1052 int newflow =
1053 ptyibuf[0] & TIOCPKT_DOSTOP ? 1 : 0;
1054 if (newflow != flowmode) {
1055 flowmode = newflow;
1056 (void) output_data(
1057 "%c%c%c%c%c%c",
1058 IAC, SB, TELOPT_LFLOW,
1059 flowmode ? LFLOW_ON
1060 : LFLOW_OFF,
1061 IAC, SE);
1062 DIAG(TD_OPTIONS, printsub('>',
1063 (unsigned char *)nfrontp - 4,
1064 4););
1065 }
1066 }
1067 pcc--;
1068 ptyip = ptyibuf+1;
1069 }
1070 }
1071
1072 while (pcc > 0) {
1073 if ((&netobuf[BUFSIZ] - nfrontp) < 2)
1074 break;
1075 c = *ptyip++ & 0377, pcc--;
1076 if (c == IAC)
1077 output_data("%c", c);
1078 output_data("%c", c);
1079 if ((c == '\r') && (my_state_is_wont(TELOPT_BINARY))) {
1080 if (pcc > 0 && ((*ptyip & 0377) == '\n')) {
1081 output_data("%c", *ptyip++ & 0377);
1082 pcc--;
1083 } else
1084 output_datalen("\0", 1);
1085 }
1086 }
1087
1088 if ((set[0].revents & POLLOUT) && (nfrontp - nbackp) > 0)
1089 netflush();
1090 if (ncc > 0)
1091 telrcv();
1092 if ((set[1].revents & POLLOUT) && (pfrontp - pbackp) > 0)
1093 ptyflush();
1094 }
1095 cleanup(0);
1096 } /* end of telnet */
1097
1098 /*
1099 * Send interrupt to process on other side of pty.
1100 * If it is in raw mode, just write NULL;
1101 * otherwise, write intr char.
1102 */
1103 void
interrupt(void)1104 interrupt(void)
1105 {
1106 ptyflush(); /* half-hearted */
1107
1108 (void) ioctl(pty, TIOCSIG, (char *)SIGINT);
1109 }
1110
1111 /*
1112 * Send quit to process on other side of pty.
1113 * If it is in raw mode, just write NULL;
1114 * otherwise, write quit char.
1115 */
1116 void
sendbrk(void)1117 sendbrk(void)
1118 {
1119 ptyflush(); /* half-hearted */
1120 (void) ioctl(pty, TIOCSIG, (char *)SIGQUIT);
1121 }
1122
1123 void
sendsusp(void)1124 sendsusp(void)
1125 {
1126 ptyflush(); /* half-hearted */
1127 (void) ioctl(pty, TIOCSIG, (char *)SIGTSTP);
1128 }
1129
1130 /*
1131 * When we get an AYT, if ^T is enabled, use that. Otherwise,
1132 * just send back "[Yes]".
1133 */
1134 void
recv_ayt(void)1135 recv_ayt(void)
1136 {
1137 if (slctab[SLC_AYT].sptr && *slctab[SLC_AYT].sptr != _POSIX_VDISABLE) {
1138 (void) ioctl(pty, TIOCSIG, (char *)SIGINFO);
1139 return;
1140 }
1141 (void) output_data("\r\n[Yes]\r\n");
1142 }
1143
1144 void
doeof(void)1145 doeof(void)
1146 {
1147 init_termbuf();
1148
1149 #if defined(LINEMODE) && (VEOF == VMIN)
1150 if (!tty_isediting()) {
1151 extern char oldeofc;
1152 *pfrontp++ = oldeofc;
1153 return;
1154 }
1155 #endif
1156 *pfrontp++ = slctab[SLC_EOF].sptr ?
1157 (unsigned char)*slctab[SLC_EOF].sptr : '\004';
1158 }
1159