![[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 [Research Unix] / researchv10no / ipc / servers|
Return to telnetd.c CVS log | Up to [Research Unix] / researchv10no / ipc / servers |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)telnetd.c 4.26 (Berkeley) 83/08/06";
3: #endif
4:
5: /*
6: * Stripped-down telnet server.
7: */
8: #include <stdio.h>
9: #include <sys/param.h>
10: #include <sys/types.h>
11: #include <sys/stat.h>
12:
13: #include <errno.h>
14: #include <pwd.h>
15: #include <signal.h>
16: #include <sgtty.h>
17: #include <stdio.h>
18: #include <wait.h>
19: #include <sys/ttyld.h>
20: #include <sys/stream.h>
21: #include "telnet.h"
22:
23: #define BELL '\07'
24: #define DEBUG if (debug)
25:
26: /* option settings (remote and local) */
27: static char hisopts[256];
28: static char myopts[256];
29:
30: /* formats for option messages */
31: static char doopt[] = { IAC, DO, '%', 'c', 0 };
32: static char dont[] = { IAC, DONT, '%', 'c', 0 };
33: static char will[] = { IAC, WILL, '%', 'c', 0 };
34: static char wont[] = { IAC, WONT, '%', 'c', 0 };
35:
36: static int ptfd, netfd; /* fd's to pt and tcp */
37: static int done; /* true if session is to be ended */
38: static int debug; /* true if debugging is to be output */
39: static struct sgttyb ptb; /* result of an IOCGETP on the pt */
40: static struct tchars ptt; /* result of an IOCGETC on the pt */
41:
42: /* predefined */
43: static reapchild();
44: static catchint();
45:
46: /* imported */
47: extern char **environ;
48: extern int errno;
49: extern char *strrchr(), *strchr();
50:
51:
52: /*
53: * The following macros and routines are used to
54: * manage the I/O buffers. They're a cross between
55: * stream buffers and standard I/O.
56: */
57: struct buffer {
58: char *b_rp; /* read pointer */
59: char *b_wp; /* write pointer */
60: char b_buf[BUFSIZ]; /* the buffer */
61: };
62: struct buffer ptibuf, *ptin = &ptibuf;
63: struct buffer ptobuf, *ptout = &ptobuf;
64: struct buffer netibuf, *netin = &netibuf;
65: struct buffer netobuf, *netout = &netobuf;
66:
67: #define binit(bp) (bp->b_rp = bp->b_wp = bp->b_buf)
68: #define bytes_filled(bp) (bp->b_wp - bp->b_rp)
69: #define space_left(bp) (bp->b_buf+sizeof(bp->b_buf) - bp->b_wp)
70: #define bput(bp, c) (*(bp->b_wp++) = c)
71: #define bget(bp) (*(bp->b_rp++) & 0377)
72:
73: /* read whatever the buffer can take */
74: static int
75: bread(bp, fd)
76: struct buffer *bp;
77: int fd;
78: {
79: int cc;
80:
81: /* normalize the buffer */
82: if (bytes_filled(bp) == 0)
83: bp->b_rp = bp->b_wp = bp->b_buf;
84:
85: /* fill it */
86: cc = read(fd, bp->b_wp, space_left(bp));
87: if (cc > 0)
88: bp->b_wp += cc;
89: return cc;
90: }
91:
92: /* read at most n bytes */
93: static int
94: breadn(bp, fd, n)
95: struct buffer *bp;
96: int fd, n;
97: {
98: int cc;
99:
100: /* normalize the buffer */
101: if (bytes_filled(bp) == 0)
102: bp->b_rp = bp->b_wp = bp->b_buf;
103: if (n > space_left(bp))
104: n = space_left(bp);
105:
106: /* fill it */
107: cc = read(fd, bp->b_wp, n);
108: if (cc > 0)
109: bp->b_wp += cc;
110: return cc;
111: }
112:
113: /* empty the buffer */
114: static int
115: bwrite(bp, fd)
116: struct buffer *bp;
117: int fd;
118: {
119: int cc;
120:
121:
122: cc = write(fd, bp->b_rp, bytes_filled(bp));
123:
124: /* normalize the buffer */
125: if (cc == bytes_filled(bp))
126: binit(bp);
127: return cc;
128: }
129: static int
130: bputs(bp, s)
131: struct buffer *bp;
132: char *s;
133: {
134: while (*s)
135: bput(bp, *s++);
136: }
137:
138: /*
139: * Establish a tcp socket and fork off a process for each connection.
140: */
141: main(argc, argv)
142: char *argv[];
143: {
144: int finish();
145: int f;
146:
147: doit(0);
148: rmut();
149: /*NOTREACHED*/
150: }
151:
152: /*
153: * Get a pt. Put a login on one side and a telnet receiver on
154: * the other.
155: */
156: static
157: doit(f)
158: int f;
159: {
160: int pfd[2];
161: # define TERMEND pfd[0]
162: # define PROCEND pfd[1]
163: extern int tty_ld, mesg_ld;
164:
165: /* get a pt pair */
166: if (pipe(pfd) < 0)
167: fatalperror(f, "out of pipes", errno);
168:
169: /* make it really look like a terminal */
170: if (ioctl(TERMEND, FIOPUSHLD, (struct sgttyb *)&mesg_ld)<0)
171: fatalperror(f, "can't push mesgld", errno);
172: if (ioctl(PROCEND, FIOPUSHLD, (struct sgttyb *)&tty_ld)<0)
173: fatalperror(f, "can't push ttyld", errno);
174:
175: /* prepare for the death of a child */
176: signal(SIGCHLD, catchint);
177: signal(SIGHUP, catchint);
178: signal(SIGPIPE, catchint);
179: switch (fork()) {
180: case -1:
181: fatalperror(f, "fork", errno);
182: case 0:
183: /* a process which is the remote login */
184: getty(PROCEND);
185: default:
186: /* the protocol process */
187: close(PROCEND);
188: netfd = f;
189: ptfd = TERMEND;
190: telnet();
191: }
192: /*NOTREACHED*/
193: }
194:
195: static
196: fatal(f, msg)
197: int f;
198: char *msg;
199: {
200: char buf[BUFSIZ];
201:
202: (void) sprintf(buf, "telnetd: %s.\n", msg);
203: (void) write(f, buf, strlen(buf));
204: rmut();
205: exit(1);
206: }
207: static
208: finish()
209: {
210: if (debug) fprintf(stderr, "pipe closed\n");
211: rmut();
212: exit(1);
213: }
214:
215: static
216: fatalperror(f, msg, errno)
217: int f;
218: char *msg;
219: int errno;
220: {
221: char buf[BUFSIZ];
222: extern char *sys_errlist[];
223:
224: (void) sprintf(buf, "%s: %s", msg, sys_errlist[errno]);
225: fatal(f, buf);
226: }
227:
228: static
229: terminate(s)
230: char *s;
231: {
232: DEBUG fprintf(stderr, "session on terminated because of %s\n", s);
233: done = 1;
234: }
235:
236: /* loop on input from the pt and the network */
237: static
238: telnet()
239: {
240: int n;
241: fd_set ibits, obits;
242:
243: binit(ptin);
244: binit(ptout);
245: binit(netin);
246: binit(netout);
247:
248: /* Request to do remote echo. */
249: dooption(TELOPT_ECHO);
250: myopts[TELOPT_ECHO] = 1;
251:
252: while(!done) {
253: FD_ZERO(ibits);
254: FD_ZERO(obits);
255:
256: /* process anything sitting in the input buffers */
257: if (bytes_filled(ptin) > 0)
258: ptprocess();
259: if (bytes_filled(netin) > 0)
260: netprocess();
261:
262: /* select for read only if there's room to read into */
263: if (space_left(netin) > 0)
264: FD_SET(netfd, ibits);
265: if (space_left(ptin) > 0)
266: FD_SET(ptfd, ibits);
267:
268: /* select for write only if there's something to write */
269: if (bytes_filled(ptout) > 0)
270: FD_SET(ptfd, obits);
271: if (bytes_filled(netout) > 0)
272: FD_SET(netfd, obits);
273:
274: n = select(NOFILE, &ibits, &obits, 100000);
275: if (n < 0)
276: break;
277: else if (n == 0)
278: continue;
279:
280: /* fill input buffers */
281: if (FD_ISSET(netfd, ibits))
282: netrcv();
283: if (FD_ISSET(ptfd, ibits))
284: ptrcv();
285:
286: /* flush output buffers */
287: if (FD_ISSET(netfd, obits) && bytes_filled(netout) > 0)
288: netflush();
289: if (FD_ISSET(ptfd, obits) && bytes_filled(ptout) > 0)
290: ptflush();
291: }
292: rmut();
293: exit(0);
294: }
295:
296:
297: /* read from the pt */
298: static
299: ptrcv()
300: {
301: static struct mesg m;
302: static int size = 0;
303:
304: /* get the header if we don't already have one */
305: if (size <= 0) {
306: if (read(ptfd, (char *)&m, MSGHLEN) != MSGHLEN) {
307: terminate("pt read");
308: return;
309: }
310: size = (m.losize & 0377) + ((m.hisize & 0377) << 8);
311: }
312: switch(m.type) {
313: case M_HANGUP:
314: terminate("pt hangup");
315: size=0;
316: break;
317: case M_DATA:
318: size=datamesg(size);
319: break;
320: case M_IOCTL:
321: ioctlmesg(size);
322: size=0;
323: break;
324: case M_IOCACK:
325: fprintf(stderr, "IOCACK\n");
326: flushmesg(size);
327: size=0;
328: break;
329: case M_IOCNAK:
330: fprintf(stderr, "IOCNAK\n");
331: flushmesg(size);
332: size=0;
333: break;
334: default:
335: othermesg(m, size);
336: size=0;
337: break;
338: }
339: }
340:
341: /* flush a message from the pt */
342: static
343: flushmesg(size)
344: {
345: char buf[64];
346: int cc;
347: /* flush it */
348: while (size > 0) {
349: fprintf(stderr, "flush\n");
350: cc = size > sizeof(buf) ? sizeof(buf) : size;
351: cc = read(ptfd, buf, cc);
352: if (cc < 0) {
353: terminate("pt read");
354: return;
355: }
356: size -= cc;
357: }
358: }
359:
360: /* handle an ioctl message from the pt */
361: static
362: ioctlmesg(size)
363: {
364: struct mesg rm;
365: union stmsg s;
366: int cc;
367:
368: if (size > 0) {
369: cc = read(ptfd, (char *)&s, size > sizeof(s) ? sizeof(s) : size);
370: if (cc < 0) {
371: terminate("pt read");
372: return;
373: }
374: if (size > cc)
375: flushmesg(size - cc);
376: }
377: rm.type = M_IOCACK;
378: switch (s.ioc0.com) {
379:
380: case TIOCSETN:
381: case TIOCSETP:
382: size = 0;
383: break;
384:
385: case TIOCGETP:
386: s.ioc1.sb.sg_ispeed = B9600;
387: s.ioc1.sb.sg_ospeed = B9600;
388: ptb = s.ioc1.sb; /* sic; remember what ttyld said */
389: /* leave size as it was */
390: break;
391:
392: default:
393: rm.type = M_IOCNAK;
394: size = 0;
395: break;
396: }
397: rm.magic = MSGMAGIC;
398: rm.losize = size;
399: rm.hisize = size>>8;
400: if (write(ptfd, (char *)&rm, MSGHLEN) != MSGHLEN) {
401: terminate("pt write");
402: return;
403: }
404: if (size > 0)
405: if (write(ptfd, (char *)&s, size) != size) {
406: terminate("pt write");
407: return;
408: }
409: }
410:
411: /* read bytes from the pt and write to the network connection */
412: static
413: datamesg(size)
414: {
415: int cc;
416:
417: cc = breadn(ptin, ptfd, size);
418: if (cc < 0)
419: terminate("pt read");
420: else
421: size -= cc;
422: return (size);
423: }
424:
425: /* handle an unrecognized type of message */
426: static
427: othermesg(m, size)
428: struct mesg m;
429: {
430: char buf[132];
431: int rcc, wcc;
432:
433: wcc = write(ptfd, (char *)&m, MSGHLEN);
434: if (wcc != MSGHLEN) {
435: terminate("pt write");
436: return;
437: }
438: while (size > 0) {
439: rcc = read(ptfd, buf, size > sizeof(buf) ? sizeof(buf) : size);
440: if (rcc <= 0) {
441: terminate("pt read");
442: return;
443: }
444: wcc = write(ptfd, buf, rcc);
445: if (wcc != rcc) {
446: terminate("pt write");
447: return;
448: }
449: size -= rcc;
450: }
451: }
452:
453: /* set pt mode */
454: static
455: mode(on, off)
456: int on, off;
457: {
458: ptflush();
459: ptb.sg_flags |= on;
460: ptb.sg_flags &= ~off;
461: if(ioctl(ptfd, TIOCSETP, &ptb)<0)
462: terminate("setting mode of pt");
463: }
464:
465: /* flush the pt's output buffer */
466: ptflush()
467: {
468: struct mesg rm;
469: int size;
470:
471: if ((size = bytes_filled(ptout)) > 0) {
472: rm.type = M_DATA;
473: rm.magic = MSGMAGIC;
474: rm.losize = size;
475: rm.hisize = size>>8;
476: if (write(ptfd, (char *)&rm, MSGHLEN) < MSGHLEN)
477: terminate("pt write");
478: else if (bwrite(ptout, ptfd) <= 0)
479: terminate("pt write");
480: }
481: }
482:
483: /* process bytes from the pt */
484: static
485: ptprocess()
486: {
487: register int c;
488:
489: while(bytes_filled(ptin) && space_left(netout) > 1) {
490: c = bget(ptin);
491: if (c == IAC)
492: bput(netout, c);
493: bput(netout, c);
494: }
495: }
496:
497: /* read bytes from the net */
498: static
499: netrcv()
500: {
501: if (bread(netin, netfd) < 0)
502: terminate("net read");
503: }
504:
505: /* flush the netwrk's output buffer */
506: netflush()
507: {
508: if (bwrite(netout, netfd) < 0)
509: terminate("net write");
510: }
511:
512: /*
513: * State for recv fsm
514: */
515: #define TS_DATA 0 /* base state */
516: #define TS_IAC 1 /* look for double IAC's */
517: #define TS_CR 2 /* CR-LF ->'s CR */
518: #define TS_BEGINNEG 3 /* throw away begin's... */
519: #define TS_ENDNEG 4 /* ...end's (suboption negotiation) */
520: #define TS_WILL 5 /* will option negotiation */
521: #define TS_WONT 6 /* wont " */
522: #define TS_DO 7 /* do " */
523: #define TS_DONT 8 /* dont " */
524:
525: static
526: netprocess()
527: {
528: static int state = TS_DATA;
529: register int c;
530: char buf[10];
531:
532: while (bytes_filled(netin)) {
533: c = bget(netin);
534: switch (state) {
535:
536: case TS_DATA:
537: if (c == IAC) {
538: state = TS_IAC;
539: break;
540: }
541: bput(ptout, c);
542: if (!myopts[TELOPT_BINARY] && c == '\r')
543: state = TS_CR;
544: break;
545:
546: case TS_CR:
547: if (c && c != '\n')
548: bput(ptout, c);
549: state = TS_DATA;
550: break;
551:
552: case TS_IAC:
553: switch (c) {
554:
555: /*
556: * Send the process on the pty side an
557: * interrupt. Do this with a NULL or
558: * interrupt char; depending on the tty mode.
559: */
560: case BREAK:
561: case IP:
562: interrupt();
563: break;
564:
565: /*
566: * Are You There?
567: */
568: case AYT:
569: bput(ptout, BELL);
570: break;
571:
572: /*
573: * Erase Character and
574: * Erase Line
575: */
576: case EC:
577: case EL:
578: ptflush();
579: bput(ptout, (c == EC) ? ptb.sg_erase : ptb.sg_kill);
580: break;
581:
582: /*
583: * Check for urgent data...
584: */
585: case DM:
586: break;
587:
588: /*
589: * Begin option subnegotiation...
590: */
591: case SB:
592: state = TS_BEGINNEG;
593: continue;
594:
595: case WILL:
596: case WONT:
597: case DO:
598: case DONT:
599: state = TS_WILL + (c - WILL);
600: continue;
601:
602: case IAC:
603: bput(ptout, c);
604: break;
605: }
606: state = TS_DATA;
607: break;
608:
609: case TS_BEGINNEG:
610: if (c == IAC)
611: state = TS_ENDNEG;
612: break;
613:
614: case TS_ENDNEG:
615: state = c == SE ? TS_DATA : TS_BEGINNEG;
616: break;
617:
618: case TS_WILL:
619: if (!hisopts[c])
620: willoption(c);
621: state = TS_DATA;
622: continue;
623:
624: case TS_WONT:
625: if (hisopts[c])
626: wontoption(c);
627: state = TS_DATA;
628: continue;
629:
630: case TS_DO:
631: if (!myopts[c])
632: dooption(c);
633: state = TS_DATA;
634: continue;
635:
636: case TS_DONT:
637: if (myopts[c]) {
638: myopts[c] = 0;
639: sprintf(buf, wont, c);
640: bputs(netout, buf);
641: }
642: state = TS_DATA;
643: continue;
644:
645: default:
646: printf("telnetd: panic state=%d\n", state);
647: exit(1);
648: }
649: }
650: }
651:
652: static
653: willoption(option)
654: int option;
655: {
656: char *fmt;
657: char buf[10];
658:
659: switch (option) {
660:
661: case TELOPT_BINARY:
662: mode(RAW, 0);
663: goto common;
664:
665: case TELOPT_ECHO:
666: mode(0, ECHO|CRMOD);
667: /*FALL THRU*/
668:
669: case TELOPT_SGA:
670: common:
671: hisopts[option] = 1;
672: fmt = doopt;
673: break;
674:
675: case TELOPT_TM:
676: fmt = dont;
677: break;
678:
679: default:
680: fmt = dont;
681: break;
682: }
683: sprintf(buf, fmt, option);
684: bputs(netout, buf);
685: }
686:
687: static
688: wontoption(option)
689: int option;
690: {
691: char *fmt;
692: char buf[10];
693:
694: switch (option) {
695:
696: case TELOPT_ECHO:
697: mode(ECHO|CRMOD, 0);
698: goto common;
699:
700: case TELOPT_BINARY:
701: mode(0, RAW);
702: /*FALL THRU*/
703:
704: case TELOPT_SGA:
705: common:
706: hisopts[option] = 0;
707: fmt = dont;
708: break;
709:
710: default:
711: fmt = dont;
712: }
713: sprintf(buf, fmt, option);
714: bputs(netout, buf);
715: }
716:
717: static
718: dooption(option)
719: int option;
720: {
721: char *fmt;
722: char buf[10];
723:
724: switch (option) {
725:
726: case TELOPT_TM:
727: fmt = wont;
728: break;
729:
730: case TELOPT_ECHO:
731: mode(ECHO|CRMOD, 0);
732: goto common;
733:
734: case TELOPT_BINARY:
735: mode(RAW, 0);
736: /*FALL THRU*/
737:
738: case TELOPT_SGA:
739: common:
740: fmt = will;
741: break;
742:
743: default:
744: fmt = wont;
745: break;
746: }
747: sprintf(buf, fmt, option);
748: bputs(netout, buf);
749: }
750:
751: /*
752: * Send interrupt to process on other side of pty.
753: * If it is in raw mode, just write NULL;
754: * otherwise, write intr char.
755: */
756: static
757: interrupt()
758: {
759: ptflush();
760: ioctl(ptfd, TIOCGETC, &ptt);
761: bput(ptout, ptb.sg_flags & RAW ? '\0' : ptt.t_intrc);
762: }
763:
764: static
765: catchint()
766: {
767: terminate("child death");
768: }
769:
770: #include <utmp.h>
771:
772: struct utmp wtmp;
773: char wtmpf[] = "/usr/adm/wtmp";
774: char utmp[] = "/etc/utmp";
775: #define SCPYN(a, b) strncpy(a, b, sizeof (a))
776: #define SCMPN(a, b) strncmp(a, b, sizeof (a))
777:
778: static
779: rmut()
780: {
781: register f;
782: int found = 0;
783: char *line, *dev;
784: long time();
785:
786: dev = NULL;
787: if (dev == NULL)
788: return;
789: line = dev + 5;
790:
791: DEBUG fprintf(stderr, "closing connection on %s\n", line);
792:
793: f = open(utmp, 2);
794: if (f >= 0) {
795: while(read(f, (char *)&wtmp, sizeof (wtmp)) == sizeof (wtmp)) {
796: if (SCMPN(wtmp.ut_line, line) || wtmp.ut_name[0]==0)
797: continue;
798: lseek(f, -(long)sizeof (wtmp), 1);
799: SCPYN(wtmp.ut_name, "");
800: time(&wtmp.ut_time);
801: write(f, (char *)&wtmp, sizeof (wtmp));
802: found++;
803: }
804: close(f);
805: }
806: if (found) {
807: f = open(wtmpf, 1);
808: if (f >= 0) {
809: SCPYN(wtmp.ut_line, line);
810: SCPYN(wtmp.ut_name, "");
811: time(&wtmp.ut_time);
812: lseek(f, (long)0, 2);
813: write(f, (char *)&wtmp, sizeof (wtmp));
814: close(f);
815: }
816: }
817: chown(dev, 0, 0);
818: chmod(dev, 0666);
819: }
820:
821:
822: static
823: getty(f)
824: {
825: int i;
826: struct sgttyb b;
827: char banner[128];
828: char *envp[4];
829: char **p, **passenv();
830: char *whoami();
831:
832: ioctl(f, TIOCSPGRP, 0);
833: signal(SIGTERM, SIG_DFL) ;
834: signal(SIGPIPE, SIG_DFL) ;
835: signal(SIGQUIT, SIG_DFL) ;
836: signal(SIGINT, SIG_DFL) ;
837: signal(SIGALRM, SIG_DFL) ;
838: signal(SIGHUP, SIG_DFL) ;
839: signal(SIGCHLD, SIG_DFL) ;
840: for (i = 0; i < NSYSFILE; i++)
841: if (i != f)
842: close(i);
843: for (i = 0; i < NSYSFILE; i++)
844: dup(f);
845: for (i=NSYSFILE; i<NOFILE; i++)
846: close(i) ;
847: ioctl(0, TIOCGETP, &b);
848: b.sg_flags |= CRMOD|XTABS|ANYP|ECHO;
849: b.sg_erase = '#';
850: b.sg_kill = '@';
851: ioctl(0, TIOCSETP, &b);
852: p = envp;
853: p = passenv(p, "CSOURCE");
854: *p = (char *)0;
855: sprintf(banner, "%s\n", whoami());
856: write (netfd, banner, strlen(banner));
857: execle("/etc/login", "login", 0, envp);
858: execle("/etc/login", "login", 0, envp);
859: fatalperror(2, "/etc/login", errno);
860: exit(1);
861: }
862:
863: char**
864: passenv(ep, var)
865: char **ep;
866: {
867: char *cp;
868: char *getenv();
869:
870: cp = getenv(var);
871: if(cp){
872: *ep = cp-strlen(var)-1;
873: ep++;
874: }
875: return ep;
876: }
877:
878: char *
879: whoami()
880: {
881: static char name[128];
882: int fd, n;
883: char *cp;
884:
885: fd = open("/etc/whoami", 0);
886: if (fd < 0)
887: return ("Kremvax");
888: n = read(fd, name, sizeof(name)-1);
889: if (n <= 0)
890: return ("Kremvax");
891: name[n] = '\0';
892: for (cp=name; *cp; cp++)
893: if (*cp == '\n') {
894: *cp = '\0';
895: break;
896: }
897: return name;
898: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.