![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to telnetd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / libexec / telnetd|
Return to telnetd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / libexec / telnetd |
1.1 root 1: /*
2: * Copyright (c) 1989 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted provided
6: * that: (1) source distributions retain this entire copyright notice and
7: * comment, and (2) distributions including binaries display the following
8: * acknowledgement: ``This product includes software developed by the
9: * University of California, Berkeley and its contributors'' in the
10: * documentation or other materials provided with the distribution and in
11: * all advertising materials mentioning features or use of this software.
12: * Neither the name of the University nor the names of its contributors may
13: * be used to endorse or promote products derived from this software without
14: * specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: char copyright[] =
22: "@(#) Copyright (c) 1989 Regents of the University of California.\n\
23: All rights reserved.\n";
24: #endif /* not lint */
25:
26: #ifndef lint
27: static char sccsid[] = "@(#)telnetd.c 5.46 (Berkeley) 6/28/90";
28: #endif /* not lint */
29:
30: #include "telnetd.h"
31:
32: /*
33: * I/O data buffers,
34: * pointers, and counters.
35: */
36: char ptyibuf[BUFSIZ], *ptyip = ptyibuf;
37: char ptyibuf2[BUFSIZ];
38:
39: #ifdef CRAY
40: int hostinfo = 1; /* do we print login banner? */
41: #endif
42:
43: #ifdef CRAY
44: extern int newmap; /* nonzero if \n maps to ^M^J */
45: int lowpty = 0, highpty; /* low, high pty numbers */
46: #endif /* CRAY */
47:
48: int debug = 0;
49: char *progname;
50:
51: #if defined(NEED_GETTOS)
52: struct tosent {
53: char *t_name; /* name */
54: char **t_aliases; /* alias list */
55: char *t_proto; /* protocol */
56: int t_tos; /* Type Of Service bits */
57: };
58:
59: struct tosent *
60: gettosbyname(name, proto)
61: char *name, *proto;
62: {
63: static struct tosent te;
64: static char *aliasp = 0;
65:
66: te.t_name = name;
67: te.t_aliases = &aliasp;
68: te.t_proto = proto;
69: te.t_tos = 020; /* Low Delay bit */
70: return(&te);
71: }
72: #endif
73:
74: main(argc, argv)
75: char *argv[];
76: {
77: struct sockaddr_in from;
78: int on = 1, fromlen;
79: #if defined(HAS_IP_TOS) || defined(NEED_GETTOS)
80: struct tosent *tp;
81: #endif /* defined(HAS_IP_TOS) || defined(NEED_GETTOS) */
82:
83: pfrontp = pbackp = ptyobuf;
84: netip = netibuf;
85: nfrontp = nbackp = netobuf;
86:
87: progname = *argv;
88:
89: #ifdef CRAY
90: /*
91: * Get number of pty's before trying to process options,
92: * which may include changing pty range.
93: */
94: highpty = getnpty();
95: #endif /* CRAY */
96:
97: top:
98: argc--, argv++;
99:
100: if (argc > 0 && strcmp(*argv, "-debug") == 0) {
101: debug++;
102: goto top;
103: }
104:
105: #ifdef LINEMODE
106: if (argc > 0 && !strcmp(*argv, "-l")) {
107: alwayslinemode = 1;
108: goto top;
109: }
110: #endif /* LINEMODE */
111:
112: #ifdef CRAY
113: if (argc > 0 && !strcmp(*argv, "-h")) {
114: hostinfo = 0;
115: goto top;
116: }
117:
118: if (argc > 0 && !strncmp(*argv, "-r", 2)) {
119: char *strchr();
120: char *c;
121:
122: /*
123: * Allow the specification of alterations to the pty search
124: * range. It is legal to specify only one, and not change the
125: * other from its default.
126: */
127: *argv += 2;
128: if (**argv == '\0' && argc)
129: argv++, argc--;
130: c = strchr(*argv, '-');
131: if (c) {
132: *c++ = '\0';
133: highpty = atoi(c);
134: }
135: if (**argv != '\0')
136: lowpty = atoi(*argv);
137: if ((lowpty > highpty) || (lowpty < 0) || (highpty > 32767)) {
138: usage();
139: /* NOT REACHED */
140: }
141: goto top;
142: }
143: # ifdef NEWINIT
144: if (argc > 0 && !strncmp(*argv, "-I", 2)) {
145: extern char *gen_id;
146:
147: *argv += 2;
148: if (**argv == '\0') {
149: if (argc < 2) {
150: usage();
151: /* NOT REACHED */
152: }
153: argv++, argc--;
154: if (**argv == '\0') {
155: usage();
156: /* NOT REACHED */
157: }
158: }
159: gen_id = *argv;
160: goto top;
161: }
162: # endif /* NEWINIT */
163: #endif /* CRAY */
164:
165: #ifdef DIAGNOSTICS
166: /*
167: * Check for desired diagnostics capabilities.
168: */
169: if (argc > 0 && !strncmp(*argv, "-D", 2)) {
170: *argv += 2;
171: if (**argv == '\0') {
172: if (argc < 2) {
173: usage();
174: /* NOT REACHED */
175: }
176: argv++, argc--;
177: if (**argv == '\0') {
178: usage();
179: /* NOT REACHED */
180: }
181: }
182: if (!strcmp(*argv, "report")) {
183: diagnostic |= TD_REPORT|TD_OPTIONS;
184: } else if (!strcmp(*argv, "exercise")) {
185: diagnostic |= TD_EXERCISE;
186: } else if (!strcmp(*argv, "netdata")) {
187: diagnostic |= TD_NETDATA;
188: } else if (!strcmp(*argv, "ptydata")) {
189: diagnostic |= TD_PTYDATA;
190: } else if (!strcmp(*argv, "options")) {
191: diagnostic |= TD_OPTIONS;
192: } else {
193: usage();
194: /* NOT REACHED */
195: }
196: goto top;
197: }
198: #endif /* DIAGNOSTICS */
199:
200: #ifdef BFTPDAEMON
201: /*
202: * Check for bftp daemon
203: */
204: if (argc > 0 && !strncmp(*argv, "-B", 2)) {
205: bftpd++;
206: goto top;
207: }
208: #endif /* BFTPDAEMON */
209:
210: if (argc > 0 && **argv == '-') {
211: fprintf(stderr, "telnetd: %s: unknown option\n", *argv+1);
212: usage();
213: /* NOT REACHED */
214: }
215:
216: if (debug) {
217: int s, ns, foo;
218: struct servent *sp;
219: static struct sockaddr_in sin = { AF_INET };
220:
221: if (argc > 1) {
222: usage();
223: /* NOT REACHED */
224: } else if (argc == 1) {
225: if (sp = getservbyname(*argv, "tcp")) {
226: sin.sin_port = sp->s_port;
227: } else {
228: sin.sin_port = atoi(*argv);
229: if ((int)sin.sin_port <= 0) {
230: fprintf(stderr, "telnetd: %s: bad port #\n", *argv);
231: usage();
232: /* NOT REACHED */
233: }
234: sin.sin_port = htons((u_short)sin.sin_port);
235: }
236: } else {
237: sp = getservbyname("telnet", "tcp");
238: if (sp == 0) {
239: fprintf(stderr, "telnetd: tcp/telnet: unknown service\n");
240: exit(1);
241: }
242: sin.sin_port = sp->s_port;
243: }
244:
245: s = socket(AF_INET, SOCK_STREAM, 0);
246: if (s < 0) {
247: perror("telnetd: socket");;
248: exit(1);
249: }
250: (void) setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
251: if (bind(s, (struct sockaddr *)&sin, sizeof sin) < 0) {
252: perror("bind");
253: exit(1);
254: }
255: if (listen(s, 1) < 0) {
256: perror("listen");
257: exit(1);
258: }
259: foo = sizeof sin;
260: ns = accept(s, (struct sockaddr *)&sin, &foo);
261: if (ns < 0) {
262: perror("accept");
263: exit(1);
264: }
265: (void) dup2(ns, 0);
266: (void) close(ns);
267: (void) close(s);
268: } else if (argc > 0) {
269: usage();
270: /* NOT REACHED */
271: }
272:
273: openlog("telnetd", LOG_PID | LOG_ODELAY, LOG_DAEMON);
274: fromlen = sizeof (from);
275: if (getpeername(0, (struct sockaddr *)&from, &fromlen) < 0) {
276: fprintf(stderr, "%s: ", progname);
277: perror("getpeername");
278: _exit(1);
279: }
280: if (setsockopt(0, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof (on)) < 0) {
281: syslog(LOG_WARNING, "setsockopt (SO_KEEPALIVE): %m");
282: }
283:
284: #if defined(HAS_IP_TOS) || defined(NEED_GETTOS)
285: if ((tp = gettosbyname("telnet", "tcp")) &&
286: (setsockopt(0, IPPROTO_IP, IP_TOS, &tp->t_tos, sizeof(int)) < 0))
287: syslog(LOG_WARNING, "setsockopt (IP_TOS): %m");
288: #endif /* defined(HAS_IP_TOS) || defined(NEED_GETTOS) */
289: net = 0;
290: doit(&from);
291: /* NOTREACHED */
292: } /* end of main */
293:
294: usage()
295: {
296: fprintf(stderr, "Usage: telnetd [-debug] [-h]");
297: #ifdef NEWINIT
298: fprintf(stderr, " [-Iinitid]");
299: #endif /* NEWINIT */
300: #ifdef DIAGNOSTICS
301: fprintf(stderr, " [-D (options|report|exercise|netdata|ptydata)]");
302: #endif /* DIAGNOSTICS */
303: #ifdef LINEMODE
304: fprintf(stderr, " [-l]");
305: #endif
306: #ifdef CRAY
307: fprintf(stderr, " [-r[lowpty]-[highpty]]");
308: #endif
309: #ifdef BFTPDAEMON
310: fprintf(stderr, " [-B]");
311: #endif /* BFTPDAEMON */
312: fprintf(stderr, " [port]\n");
313: exit(1);
314: }
315:
316: void cleanup();
317:
318: /*
319: * getterminaltype
320: *
321: * Ask the other end to send along its terminal type and speed.
322: * Output is the variable terminaltype filled in.
323: */
324: static char ttytype_sbbuf[] = { IAC, SB, TELOPT_TTYPE, TELQUAL_SEND, IAC, SE };
325: void
326: getterminaltype()
327: {
328: void ttloop();
329:
330: settimer(baseline);
331: send_do(TELOPT_TTYPE, 1);
332: send_do(TELOPT_TSPEED, 1);
333: send_do(TELOPT_XDISPLOC, 1);
334: send_do(TELOPT_ENVIRON, 1);
335: while (his_will_wont_is_changing(TELOPT_TTYPE) ||
336: his_will_wont_is_changing(TELOPT_TSPEED) ||
337: his_will_wont_is_changing(TELOPT_XDISPLOC) ||
338: his_will_wont_is_changing(TELOPT_ENVIRON)) {
339: ttloop();
340: }
341: if (his_state_is_will(TELOPT_TSPEED)) {
342: static char sbbuf[] = { IAC, SB, TELOPT_TSPEED, TELQUAL_SEND, IAC, SE };
343:
344: bcopy(sbbuf, nfrontp, sizeof sbbuf);
345: nfrontp += sizeof sbbuf;
346: }
347: if (his_state_is_will(TELOPT_XDISPLOC)) {
348: static char sbbuf[] = { IAC, SB, TELOPT_XDISPLOC, TELQUAL_SEND, IAC, SE };
349:
350: bcopy(sbbuf, nfrontp, sizeof sbbuf);
351: nfrontp += sizeof sbbuf;
352: }
353: if (his_state_is_will(TELOPT_ENVIRON)) {
354: static char sbbuf[] = { IAC, SB, TELOPT_ENVIRON, TELQUAL_SEND, IAC, SE };
355:
356: bcopy(sbbuf, nfrontp, sizeof sbbuf);
357: nfrontp += sizeof sbbuf;
358: }
359: if (his_state_is_will(TELOPT_TTYPE)) {
360:
361: bcopy(ttytype_sbbuf, nfrontp, sizeof ttytype_sbbuf);
362: nfrontp += sizeof ttytype_sbbuf;
363: }
364: if (his_state_is_will(TELOPT_TSPEED)) {
365: while (sequenceIs(tspeedsubopt, baseline))
366: ttloop();
367: }
368: if (his_state_is_will(TELOPT_XDISPLOC)) {
369: while (sequenceIs(xdisplocsubopt, baseline))
370: ttloop();
371: }
372: if (his_state_is_will(TELOPT_ENVIRON)) {
373: while (sequenceIs(environsubopt, baseline))
374: ttloop();
375: }
376: if (his_state_is_will(TELOPT_TTYPE)) {
377: char first[256], last[256];
378:
379: while (sequenceIs(ttypesubopt, baseline))
380: ttloop();
381:
382: /*
383: * If the other side has already disabled the option, then
384: * we have to just go with what we (might) have already gotten.
385: */
386: if (his_state_is_will(TELOPT_TTYPE) && !terminaltypeok(terminaltype)) {
387: (void) strncpy(first, terminaltype, sizeof(first));
388: for(;;) {
389: /*
390: * Save the unknown name, and request the next name.
391: */
392: (void) strncpy(last, terminaltype, sizeof(last));
393: _gettermname();
394: if (terminaltypeok(terminaltype))
395: break;
396: if ((strncmp(last, terminaltype, sizeof(last)) == 0) ||
397: his_state_is_wont(TELOPT_TTYPE)) {
398: /*
399: * We've hit the end. If this is the same as
400: * the first name, just go with it.
401: */
402: if (strncmp(first, terminaltype, sizeof(first) == 0))
403: break;
404: /*
405: * Get the terminal name one more time, so that
406: * RFC1091 compliant telnets will cycle back to
407: * the start of the list.
408: */
409: _gettermname();
410: if (strncmp(first, terminaltype, sizeof(first) != 0))
411: (void) strncpy(terminaltype, first, sizeof(first));
412: break;
413: }
414: }
415: }
416: }
417: } /* end of getterminaltype */
418:
419: _gettermname()
420: {
421: /*
422: * If the client turned off the option,
423: * we can't send another request, so we
424: * just return.
425: */
426: if (his_state_is_wont(TELOPT_TTYPE))
427: return;
428: settimer(baseline);
429: bcopy(ttytype_sbbuf, nfrontp, sizeof ttytype_sbbuf);
430: nfrontp += sizeof ttytype_sbbuf;
431: while (sequenceIs(ttypesubopt, baseline))
432: ttloop();
433: }
434:
435: terminaltypeok(s)
436: char *s;
437: {
438: char buf[1024];
439:
440: if (terminaltype == NULL)
441: return(1);
442:
443: /*
444: * tgetent() will return 1 if the type is known, and
445: * 0 if it is not known. If it returns -1, it couldn't
446: * open the database. But if we can't open the database,
447: * it won't help to say we failed, because we won't be
448: * able to verify anything else. So, we treat -1 like 1.
449: */
450: if (tgetent(buf, s) == 0)
451: return(0);
452: return(1);
453: }
454:
455: /*
456: * Get a pty, scan input lines.
457: */
458: doit(who)
459: struct sockaddr_in *who;
460: {
461: char *host, *inet_ntoa();
462: int t;
463: struct hostent *hp;
464: #if BSD > 43
465: extern char *line;
466:
467: if (openpty(&pty, &t, line, NULL, NULL) == -1)
468: fatal(net, "All network ports in use");
469: init_termbuf();
470: #else
471:
472: /*
473: * Find an available pty to use.
474: */
475: pty = getpty();
476: if (pty < 0)
477: fatal(net, "All network ports in use");
478:
479: t = getptyslave();
480: #endif
481:
482: /* get name of connected client */
483: hp = gethostbyaddr((char *)&who->sin_addr, sizeof (struct in_addr),
484: who->sin_family);
485: if (hp)
486: host = hp->h_name;
487: else
488: host = inet_ntoa(who->sin_addr);
489:
490: init_env();
491: /*
492: * get terminal type.
493: */
494: getterminaltype();
495: setenv("TERM", terminaltype ? terminaltype : "network", 1);
496:
497: /*
498: * Start up the login process on the slave side of the terminal
499: */
500: startslave(t, host);
501:
502: telnet(net, pty); /* begin server processing */
503: /*NOTREACHED*/
504: } /* end of doit */
505:
506: #ifndef MAXHOSTNAMELEN
507: #define MAXHOSTNAMELEN 64
508: #endif MAXHOSTNAMELEN
509: /*
510: * Main loop. Select from pty and network, and
511: * hand data to telnet receiver finite state machine.
512: */
513: telnet(f, p)
514: int f, p;
515: {
516: int on = 1;
517: char hostname[MAXHOSTNAMELEN];
518: #if defined(CRAY2) && defined(UNICOS5)
519: int termstat();
520: int interrupt(), sendbrk();
521: #endif
522: #define TABBUFSIZ 512
523: char defent[TABBUFSIZ];
524: char defstrs[TABBUFSIZ];
525: #undef TABBUFSIZ
526: char *HE;
527: char *HN;
528: char *IM;
529: void netflush();
530:
531: /*
532: * Initialize the slc mapping table.
533: */
534: get_slc_defaults();
535:
536: /*
537: * Do some tests where it is desireable to wait for a response.
538: * Rather than doing them slowly, one at a time, do them all
539: * at once.
540: */
541: if (my_state_is_wont(TELOPT_SGA))
542: send_will(TELOPT_SGA, 1);
543: /*
544: * Is the client side a 4.2 (NOT 4.3) system? We need to know this
545: * because 4.2 clients are unable to deal with TCP urgent data.
546: *
547: * To find out, we send out a "DO ECHO". If the remote system
548: * answers "WILL ECHO" it is probably a 4.2 client, and we note
549: * that fact ("WILL ECHO" ==> that the client will echo what
550: * WE, the server, sends it; it does NOT mean that the client will
551: * echo the terminal input).
552: */
553: send_do(TELOPT_ECHO, 1);
554:
555: #ifdef LINEMODE
556: if (his_state_is_wont(TELOPT_LINEMODE)) {
557: /* Query the peer for linemode support by trying to negotiate
558: * the linemode option.
559: */
560: linemode = 0;
561: editmode = 0;
562: send_do(TELOPT_LINEMODE, 1); /* send do linemode */
563: }
564: #endif /* LINEMODE */
565:
566: /*
567: * Send along a couple of other options that we wish to negotiate.
568: */
569: send_do(TELOPT_NAWS, 1);
570: send_will(TELOPT_STATUS, 1);
571: flowmode = 1; /* default flow control state */
572: send_do(TELOPT_LFLOW, 1);
573:
574: /*
575: * Spin, waiting for a response from the DO ECHO. However,
576: * some REALLY DUMB telnets out there might not respond
577: * to the DO ECHO. So, we spin looking for NAWS, (most dumb
578: * telnets so far seem to respond with WONT for a DO that
579: * they don't understand...) because by the time we get the
580: * response, it will already have processed the DO ECHO.
581: * Kludge upon kludge.
582: */
583: while (his_will_wont_is_changing(TELOPT_NAWS))
584: ttloop();
585:
586: /*
587: * But...
588: * The client might have sent a WILL NAWS as part of its
589: * startup code; if so, we'll be here before we get the
590: * response to the DO ECHO. We'll make the assumption
591: * that any implementation that understands about NAWS
592: * is a modern enough implementation that it will respond
593: * to our DO ECHO request; hence we'll do another spin
594: * waiting for the ECHO option to settle down, which is
595: * what we wanted to do in the first place...
596: */
597: if (his_want_state_is_will(TELOPT_ECHO) &&
598: his_state_is_will(TELOPT_NAWS)) {
599: while (his_will_wont_is_changing(TELOPT_ECHO))
600: ttloop();
601: }
602: /*
603: * On the off chance that the telnet client is broken and does not
604: * respond to the DO ECHO we sent, (after all, we did send the
605: * DO NAWS negotiation after the DO ECHO, and we won't get here
606: * until a response to the DO NAWS comes back) simulate the
607: * receipt of a will echo. This will also send a WONT ECHO
608: * to the client, since we assume that the client failed to
609: * respond because it believes that it is already in DO ECHO
610: * mode, which we do not want.
611: */
612: if (his_want_state_is_will(TELOPT_ECHO)) {
613: #ifdef DIAGNOSTICS
614: if (diagnostic & TD_OPTIONS) {
615: sprintf(nfrontp, "td: simulating recv\r\n");
616: nfrontp += strlen(nfrontp);
617: }
618: #endif /* DIAGNOSTICS */
619: willoption(TELOPT_ECHO);
620: }
621:
622: /*
623: * Finally, to clean things up, we turn on our echo. This
624: * will break stupid 4.2 telnets out of local terminal echo.
625: */
626:
627: if (my_state_is_wont(TELOPT_ECHO))
628: send_will(TELOPT_ECHO, 1);
629:
630: /*
631: * Turn on packet mode, and default to line at at time mode.
632: */
633: (void) ioctl(p, TIOCPKT, (char *)&on);
634: #ifdef LINEMODE
635: tty_setlinemode(1);
636:
637: # ifdef KLUDGELINEMODE
638: /*
639: * Continuing line mode support. If client does not support
640: * real linemode, attempt to negotiate kludge linemode by sending
641: * the do timing mark sequence.
642: */
643: if (lmodetype < REAL_LINEMODE)
644: send_do(TELOPT_TM, 1);
645: # endif /* KLUDGELINEMODE */
646: #endif /* LINEMODE */
647:
648: /*
649: * Call telrcv() once to pick up anything received during
650: * terminal type negotiation, 4.2/4.3 determination, and
651: * linemode negotiation.
652: */
653: telrcv();
654:
655: (void) ioctl(f, FIONBIO, (char *)&on);
656: (void) ioctl(p, FIONBIO, (char *)&on);
657: #if defined(CRAY2) && defined(UNICOS5)
658: init_termdriver(f, p, interrupt, sendbrk);
659: #endif
660:
661: #if defined(SO_OOBINLINE)
662: (void) setsockopt(net, SOL_SOCKET, SO_OOBINLINE, &on, sizeof on);
663: #endif /* defined(SO_OOBINLINE) */
664:
665: #ifdef SIGTSTP
666: (void) signal(SIGTSTP, SIG_IGN);
667: #endif
668: #ifdef SIGTTOU
669: /*
670: * Ignoring SIGTTOU keeps the kernel from blocking us
671: * in ttioct() in /sys/tty.c.
672: */
673: (void) signal(SIGTTOU, SIG_IGN);
674: #endif
675:
676: (void) signal(SIGCHLD, cleanup);
677:
678: #if defined(CRAY2) && defined(UNICOS5)
679: /*
680: * Cray-2 will send a signal when pty modes are changed by slave
681: * side. Set up signal handler now.
682: */
683: if ((int)signal(SIGUSR1, termstat) < 0)
684: perror("signal");
685: else if (ioctl(p, TCSIGME, (char *)SIGUSR1) < 0)
686: perror("ioctl:TCSIGME");
687: /*
688: * Make processing loop check terminal characteristics early on.
689: */
690: termstat();
691: #endif
692:
693: #ifdef NO_SETSID
694: (void) setpgrp(0, 0);
695: #else
696: (void) setsid();
697: #endif
698: #if defined(TIOCSCTTY) && defined(CRAY)
699: ioctl(p, TIOCSCTTY, 0);
700: #endif
701:
702: /*
703: * Show banner that getty never gave.
704: *
705: * We put the banner in the pty input buffer. This way, it
706: * gets carriage return null processing, etc., just like all
707: * other pty --> client data.
708: */
709:
710: (void) gethostname(hostname, sizeof (hostname));
711:
712: if (getent(defent, "default") == 1) {
713: char *getstr();
714: char *cp=defstrs;
715:
716: HE = getstr("he", &cp);
717: HN = getstr("hn", &cp);
718: IM = getstr("im", &cp);
719: if (HN && *HN)
720: (void) strcpy(hostname, HN);
721: if (IM == 0)
722: IM = "";
723: } else {
724: #ifdef CRAY
725: if (hostinfo == 0)
726: IM = 0;
727: else
728: #endif
729: IM = DEFAULT_IM;
730: HE = 0;
731: }
732: edithost(HE, hostname);
733: if (IM && *IM)
734: putf(IM, ptyibuf2);
735:
736: if (pcc)
737: (void) strncat(ptyibuf2, ptyip, pcc+1);
738: ptyip = ptyibuf2;
739: pcc = strlen(ptyip);
740: #ifdef LINEMODE
741: /*
742: * Last check to make sure all our states are correct.
743: */
744: init_termbuf();
745: localstat();
746: #endif /* LINEMODE */
747:
748: #ifdef DIAGNOSTICS
749: if (diagnostic & TD_REPORT) {
750: sprintf(nfrontp, "td: Entering processing loop\r\n");
751: nfrontp += strlen(nfrontp);
752: }
753: #endif /* DIAGNOSTICS */
754:
755: for (;;) {
756: fd_set ibits, obits, xbits;
757: register int c;
758:
759: if (ncc < 0 && pcc < 0)
760: break;
761:
762: #if defined(CRAY2) && defined(UNICOS5)
763: if (needtermstat)
764: _termstat();
765: #endif /* defined(CRAY2) && defined(UNICOS5) */
766: FD_ZERO(&ibits);
767: FD_ZERO(&obits);
768: FD_ZERO(&xbits);
769: /*
770: * Never look for input if there's still
771: * stuff in the corresponding output buffer
772: */
773: if (nfrontp - nbackp || pcc > 0) {
774: FD_SET(f, &obits);
775: } else {
776: FD_SET(p, &ibits);
777: }
778: if (pfrontp - pbackp || ncc > 0) {
779: FD_SET(p, &obits);
780: } else {
781: FD_SET(f, &ibits);
782: }
783: if (!SYNCHing) {
784: FD_SET(f, &xbits);
785: }
786: if ((c = select(16, &ibits, &obits, &xbits,
787: (struct timeval *)0)) < 1) {
788: if (c == -1) {
789: if (errno == EINTR) {
790: continue;
791: }
792: }
793: sleep(5);
794: continue;
795: }
796:
797: /*
798: * Any urgent data?
799: */
800: if (FD_ISSET(net, &xbits)) {
801: SYNCHing = 1;
802: }
803:
804: /*
805: * Something to read from the network...
806: */
807: if (FD_ISSET(net, &ibits)) {
808: #if !defined(SO_OOBINLINE)
809: /*
810: * In 4.2 (and 4.3 beta) systems, the
811: * OOB indication and data handling in the kernel
812: * is such that if two separate TCP Urgent requests
813: * come in, one byte of TCP data will be overlaid.
814: * This is fatal for Telnet, but we try to live
815: * with it.
816: *
817: * In addition, in 4.2 (and...), a special protocol
818: * is needed to pick up the TCP Urgent data in
819: * the correct sequence.
820: *
821: * What we do is: if we think we are in urgent
822: * mode, we look to see if we are "at the mark".
823: * If we are, we do an OOB receive. If we run
824: * this twice, we will do the OOB receive twice,
825: * but the second will fail, since the second
826: * time we were "at the mark", but there wasn't
827: * any data there (the kernel doesn't reset
828: * "at the mark" until we do a normal read).
829: * Once we've read the OOB data, we go ahead
830: * and do normal reads.
831: *
832: * There is also another problem, which is that
833: * since the OOB byte we read doesn't put us
834: * out of OOB state, and since that byte is most
835: * likely the TELNET DM (data mark), we would
836: * stay in the TELNET SYNCH (SYNCHing) state.
837: * So, clocks to the rescue. If we've "just"
838: * received a DM, then we test for the
839: * presence of OOB data when the receive OOB
840: * fails (and AFTER we did the normal mode read
841: * to clear "at the mark").
842: */
843: if (SYNCHing) {
844: int atmark;
845:
846: (void) ioctl(net, SIOCATMARK, (char *)&atmark);
847: if (atmark) {
848: ncc = recv(net, netibuf, sizeof (netibuf), MSG_OOB);
849: if ((ncc == -1) && (errno == EINVAL)) {
850: ncc = read(net, netibuf, sizeof (netibuf));
851: if (sequenceIs(didnetreceive, gotDM)) {
852: SYNCHing = stilloob(net);
853: }
854: }
855: } else {
856: ncc = read(net, netibuf, sizeof (netibuf));
857: }
858: } else {
859: ncc = read(net, netibuf, sizeof (netibuf));
860: }
861: settimer(didnetreceive);
862: #else /* !defined(SO_OOBINLINE)) */
863: ncc = read(net, netibuf, sizeof (netibuf));
864: #endif /* !defined(SO_OOBINLINE)) */
865: if (ncc < 0 && errno == EWOULDBLOCK)
866: ncc = 0;
867: else {
868: if (ncc <= 0) {
869: break;
870: }
871: netip = netibuf;
872: }
873: #ifdef DIAGNOSTICS
874: if (diagnostic & (TD_REPORT | TD_NETDATA)) {
875: sprintf(nfrontp, "td: netread %d chars\r\n", ncc);
876: nfrontp += strlen(nfrontp);
877: }
878: if (diagnostic & TD_NETDATA) {
879: printdata("nd", netip, ncc);
880: }
881: #endif /* DIAGNOSTICS */
882: }
883:
884: /*
885: * Something to read from the pty...
886: */
887: if (FD_ISSET(p, &ibits)) {
888: pcc = read(p, ptyibuf, BUFSIZ);
889: if (pcc < 0 && errno == EWOULDBLOCK)
890: pcc = 0;
891: else {
892: if (pcc <= 0)
893: break;
894: #if !defined(CRAY2) || !defined(UNICOS5)
895: #ifdef LINEMODE
896: /*
897: * If ioctl from pty, pass it through net
898: */
899: if (ptyibuf[0] & TIOCPKT_IOCTL) {
900: copy_termbuf(ptyibuf+1, pcc-1);
901: localstat();
902: pcc = 1;
903: }
904: #endif LINEMODE
905: if (ptyibuf[0] & TIOCPKT_FLUSHWRITE) {
906: netclear(); /* clear buffer back */
907: #ifdef notdef
908: /*
909: * We really should have this in, but
910: * there are client telnets on some
911: * operating systems get screwed up
912: * royally if we send them urgent
913: * mode data. So, for now, we'll not
914: * do this...
915: */
916: *nfrontp++ = IAC;
917: *nfrontp++ = DM;
918: neturg = nfrontp-1; /* off by one XXX */
919: #endif
920: }
921: if (his_state_is_will(TELOPT_LFLOW) &&
922: (ptyibuf[0] &
923: (TIOCPKT_NOSTOP|TIOCPKT_DOSTOP))) {
924: (void) sprintf(nfrontp, "%c%c%c%c%c%c",
925: IAC, SB, TELOPT_LFLOW,
926: ptyibuf[0] & TIOCPKT_DOSTOP ? 1 : 0,
927: IAC, SE);
928: nfrontp += 6;
929: }
930: pcc--;
931: ptyip = ptyibuf+1;
932: #else /* defined(CRAY2) && defined(UNICOS5) */
933: if (!uselinemode) {
934: unpcc = pcc;
935: unptyip = ptyibuf;
936: pcc = term_output(&unptyip, ptyibuf2,
937: &unpcc, BUFSIZ);
938: ptyip = ptyibuf2;
939: } else
940: ptyip = ptyibuf;
941: #endif /* defined(CRAY2) && defined(UNICOS5) */
942: }
943: }
944:
945: while (pcc > 0) {
946: if ((&netobuf[BUFSIZ] - nfrontp) < 2)
947: break;
948: c = *ptyip++ & 0377, pcc--;
949: if (c == IAC)
950: *nfrontp++ = c;
951: #if defined(CRAY2) && defined(UNICOS5)
952: else if (c == '\n' &&
953: my_state_is_wont(TELOPT_BINARY) && newmap)
954: *nfrontp++ = '\r';
955: #endif /* defined(CRAY2) && defined(UNICOS5) */
956: *nfrontp++ = c;
957: if ((c == '\r') && (my_state_is_wont(TELOPT_BINARY))) {
958: if (pcc > 0 && ((*ptyip & 0377) == '\n')) {
959: *nfrontp++ = *ptyip++ & 0377;
960: pcc--;
961: } else
962: *nfrontp++ = '\0';
963: }
964: }
965: #if defined(CRAY2) && defined(UNICOS5)
966: /*
967: * If chars were left over from the terminal driver,
968: * note their existence.
969: */
970: if (!uselinemode && unpcc) {
971: pcc = unpcc;
972: unpcc = 0;
973: ptyip = unptyip;
974: }
975: #endif /* defined(CRAY2) && defined(UNICOS5) */
976:
977: if (FD_ISSET(f, &obits) && (nfrontp - nbackp) > 0)
978: netflush();
979: if (ncc > 0)
980: telrcv();
981: if (FD_ISSET(p, &obits) && (pfrontp - pbackp) > 0)
982: ptyflush();
983: }
984: cleanup();
985: } /* end of telnet */
986:
987: #ifndef TCSIG
988: # ifdef TIOCSIG
989: # define TCSIG TIOCSIG
990: # endif
991: #endif
992:
993: /*
994: * Send interrupt to process on other side of pty.
995: * If it is in raw mode, just write NULL;
996: * otherwise, write intr char.
997: */
998: interrupt()
999: {
1000: ptyflush(); /* half-hearted */
1001:
1002: #ifdef TCSIG
1003: (void) ioctl(pty, TCSIG, (char *)SIGINT);
1004: #else /* TCSIG */
1005: init_termbuf();
1006: *pfrontp++ = slctab[SLC_IP].sptr ?
1007: (unsigned char)*slctab[SLC_IP].sptr : '\177';
1008: #endif /* TCSIG */
1009: }
1010:
1011: /*
1012: * Send quit to process on other side of pty.
1013: * If it is in raw mode, just write NULL;
1014: * otherwise, write quit char.
1015: */
1016: sendbrk()
1017: {
1018: ptyflush(); /* half-hearted */
1019: #ifdef TCSIG
1020: (void) ioctl(pty, TCSIG, (char *)SIGQUIT);
1021: #else /* TCSIG */
1022: init_termbuf();
1023: *pfrontp++ = slctab[SLC_ABORT].sptr ?
1024: (unsigned char)*slctab[SLC_ABORT].sptr : '\034';
1025: #endif /* TCSIG */
1026: }
1027:
1028: sendsusp()
1029: {
1030: #ifdef SIGTSTP
1031: ptyflush(); /* half-hearted */
1032: # ifdef TCSIG
1033: (void) ioctl(pty, TCSIG, (char *)SIGTSTP);
1034: # else /* TCSIG */
1035: *pfrontp++ = slctab[SLC_SUSP].sptr ?
1036: (unsigned char)*slctab[SLC_SUSP].sptr : '\032';
1037: # endif /* TCSIG */
1038: #endif /* SIGTSTP */
1039: }
1040:
1041: doeof()
1042: {
1043: #if defined(USE_TERMIO) && defined(SYSV_TERMIO)
1044: extern char oldeofc;
1045: #endif
1046: init_termbuf();
1047:
1048: #if defined(USE_TERMIO) && defined(SYSV_TERMIO)
1049: if (!tty_isediting()) {
1050: *pfrontp++ = oldeofc;
1051: return;
1052: }
1053: #endif
1054: *pfrontp++ = slctab[SLC_EOF].sptr ?
1055: (unsigned char)*slctab[SLC_EOF].sptr : '\004';
1056: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.