![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys_term.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 sys_term.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: static char sccsid[] = "@(#)sys_term.c 5.10 (Berkeley) 6/30/90";
22: #endif /* not lint */
23:
24: #include "telnetd.h"
25: #include "pathnames.h"
26:
27: #ifdef NEWINIT
28: #include <initreq.h>
29: #else /* NEWINIT*/
30: #include <utmp.h>
31: struct utmp wtmp;
32:
33: # ifndef CRAY
34: char wtmpf[] = "/usr/adm/wtmp";
35: char utmpf[] = "/etc/utmp";
36: # else /* CRAY */
37: char wtmpf[] = "/etc/wtmp";
38: # endif /* CRAY */
39: #endif /* NEWINIT */
40:
41: #define SCPYN(a, b) (void) strncpy(a, b, sizeof(a))
42: #define SCMPN(a, b) strncmp(a, b, sizeof(a))
43:
44: #ifdef STREAMS
45: #include <sys/stream.h>
46: #endif
47: #include <sys/tty.h>
48: #ifdef t_erase
49: #undef t_erase
50: #undef t_kill
51: #undef t_intrc
52: #undef t_quitc
53: #undef t_startc
54: #undef t_stopc
55: #undef t_eofc
56: #undef t_brkc
57: #undef t_suspc
58: #undef t_dsuspc
59: #undef t_rprntc
60: #undef t_flushc
61: #undef t_werasc
62: #undef t_lnextc
63: #endif
64:
65: #if defined(UNICOS5) && defined(CRAY2) && !defined(EXTPROC)
66: # define EXTPROC 0400
67: #endif
68:
69: #ifndef USE_TERMIO
70: struct termbuf {
71: struct sgttyb sg;
72: struct tchars tc;
73: struct ltchars ltc;
74: int state;
75: int lflags;
76: } termbuf, termbuf2;
77: #else /* USE_TERMIO */
78: # ifdef SYSV_TERMIO
79: # define termios termio
80: # endif
81: # ifndef TCSETA
82: # ifdef TCSETS
83: # define TCSETA TCSETS
84: # define TCGETA TCGETS
85: # else
86: # define TCSETA TIOCSETAW
87: # define TCGETA TIOCGETA
88: # endif
89: # endif /* 4.4BSD */
90: struct termios termbuf, termbuf2; /* pty control structure */
91: #endif /* USE_TERMIO */
92:
93: /*
94: * init_termbuf()
95: * copy_termbuf(cp)
96: * set_termbuf()
97: *
98: * These three routines are used to get and set the "termbuf" structure
99: * to and from the kernel. init_termbuf() gets the current settings.
100: * copy_termbuf() hands in a new "termbuf" to write to the kernel, and
101: * set_termbuf() writes the structure into the kernel.
102: */
103:
104: init_termbuf()
105: {
106: #ifndef USE_TERMIO
107: (void) ioctl(pty, TIOCGETP, (char *)&termbuf.sg);
108: (void) ioctl(pty, TIOCGETC, (char *)&termbuf.tc);
109: (void) ioctl(pty, TIOCGLTC, (char *)&termbuf.ltc);
110: # ifdef TIOCGSTATE
111: (void) ioctl(pty, TIOCGSTATE, (char *)&termbuf.state);
112: # endif
113: #else
114: (void) ioctl(pty, TCGETA, (char *)&termbuf);
115: #endif
116: termbuf2 = termbuf;
117: }
118:
119: #if defined(LINEMODE) && defined(TIOCPKT_IOCTL)
120: copy_termbuf(cp, len)
121: char *cp;
122: int len;
123: {
124: if (len > sizeof(termbuf))
125: len = sizeof(termbuf);
126: bcopy(cp, (char *)&termbuf, len);
127: termbuf2 = termbuf;
128: }
129: #endif /* defined(LINEMODE) && defined(TIOCPKT_IOCTL) */
130:
131: set_termbuf()
132: {
133: /*
134: * Only make the necessary changes.
135: */
136: #ifndef USE_TERMIO
137: if (bcmp((char *)&termbuf.sg, (char *)&termbuf2.sg, sizeof(termbuf.sg)))
138: (void) ioctl(pty, TIOCSETP, (char *)&termbuf.sg);
139: if (bcmp((char *)&termbuf.tc, (char *)&termbuf2.tc, sizeof(termbuf.tc)))
140: (void) ioctl(pty, TIOCSETC, (char *)&termbuf.tc);
141: if (bcmp((char *)&termbuf.ltc, (char *)&termbuf2.ltc,
142: sizeof(termbuf.ltc)))
143: (void) ioctl(pty, TIOCSLTC, (char *)&termbuf.ltc);
144: if (termbuf.lflags != termbuf2.lflags)
145: (void) ioctl(pty, TIOCLSET, (char *)&termbuf.lflags);
146: #else /* USE_TERMIO */
147: if (bcmp((char *)&termbuf, (char *)&termbuf2, sizeof(termbuf)))
148: (void) ioctl(pty, TCSETA, (char *)&termbuf);
149: # if defined(CRAY2) && defined(UNCIOS5)
150: needtermstat = 1;
151: # endif
152: #endif /* USE_TERMIO */
153: }
154:
155:
156: /*
157: * spcset(func, valp, valpp)
158: *
159: * This function takes various special characters (func), and
160: * sets *valp to the current value of that character, and
161: * *valpp to point to where in the "termbuf" structure that
162: * value is kept.
163: *
164: * It returns the SLC_ level of support for this function.
165: */
166:
167: #ifndef USE_TERMIO
168: spcset(func, valp, valpp)
169: int func;
170: cc_t *valp;
171: cc_t **valpp;
172: {
173: switch(func) {
174: case SLC_EOF:
175: *valp = termbuf.tc.t_eofc;
176: *valpp = (cc_t *)&termbuf.tc.t_eofc;
177: return(SLC_VARIABLE);
178: case SLC_EC:
179: *valp = termbuf.sg.sg_erase;
180: *valpp = (cc_t *)&termbuf.sg.sg_erase;
181: return(SLC_VARIABLE);
182: case SLC_EL:
183: *valp = termbuf.sg.sg_kill;
184: *valpp = (cc_t *)&termbuf.sg.sg_kill;
185: return(SLC_VARIABLE);
186: case SLC_IP:
187: *valp = termbuf.tc.t_intrc;
188: *valpp = (cc_t *)&termbuf.tc.t_intrc;
189: return(SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
190: case SLC_ABORT:
191: *valp = termbuf.tc.t_quitc;
192: *valpp = (cc_t *)&termbuf.tc.t_quitc;
193: return(SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
194: case SLC_XON:
195: *valp = termbuf.tc.t_startc;
196: *valpp = (cc_t *)&termbuf.tc.t_startc;
197: return(SLC_VARIABLE);
198: case SLC_XOFF:
199: *valp = termbuf.tc.t_stopc;
200: *valpp = (cc_t *)&termbuf.tc.t_stopc;
201: return(SLC_VARIABLE);
202: case SLC_AO:
203: *valp = termbuf.ltc.t_flushc;
204: *valpp = (cc_t *)&termbuf.ltc.t_flushc;
205: return(SLC_VARIABLE);
206: case SLC_SUSP:
207: *valp = termbuf.ltc.t_suspc;
208: *valpp = (cc_t *)&termbuf.ltc.t_suspc;
209: return(SLC_VARIABLE);
210: case SLC_EW:
211: *valp = termbuf.ltc.t_werasc;
212: *valpp = (cc_t *)&termbuf.ltc.t_werasc;
213: return(SLC_VARIABLE);
214: case SLC_RP:
215: *valp = termbuf.ltc.t_rprntc;
216: *valpp = (cc_t *)&termbuf.ltc.t_rprntc;
217: return(SLC_VARIABLE);
218: case SLC_LNEXT:
219: *valp = termbuf.ltc.t_lnextc;
220: *valpp = (cc_t *)&termbuf.ltc.t_lnextc;
221: return(SLC_VARIABLE);
222: case SLC_FORW1:
223: *valp = termbuf.tc.t_brkc;
224: *valpp = (cc_t *)&termbuf.ltc.t_lnextc;
225: return(SLC_VARIABLE);
226: case SLC_BRK:
227: case SLC_SYNCH:
228: case SLC_AYT:
229: case SLC_EOR:
230: *valp = (cc_t)0;
231: *valpp = (cc_t *)0;
232: return(SLC_DEFAULT);
233: default:
234: *valp = (cc_t)0;
235: *valpp = (cc_t *)0;
236: return(SLC_NOSUPPORT);
237: }
238: }
239:
240: #else /* USE_TERMIO */
241:
242: spcset(func, valp, valpp)
243: int func;
244: cc_t *valp;
245: cc_t **valpp;
246: {
247:
248: #define setval(a, b) *valp = termbuf.c_cc[a]; \
249: *valpp = &termbuf.c_cc[a]; \
250: return(b);
251: #define defval(a) *valp = ((cc_t)a); *valpp = (cc_t *)0; return(SLC_DEFAULT);
252:
253: switch(func) {
254: case SLC_EOF:
255: setval(VEOF, SLC_VARIABLE);
256: case SLC_EC:
257: setval(VERASE, SLC_VARIABLE);
258: case SLC_EL:
259: setval(VKILL, SLC_VARIABLE);
260: case SLC_IP:
261: setval(VINTR, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
262: case SLC_ABORT:
263: setval(VQUIT, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
264: case SLC_XON:
265: #ifdef VSTART
266: setval(VSTART, SLC_VARIABLE);
267: #else
268: defval(0x13);
269: #endif
270: case SLC_XOFF:
271: #ifdef VSTOP
272: setval(VSTOP, SLC_VARIABLE);
273: #else
274: defval(0x11);
275: #endif
276: case SLC_EW:
277: #ifdef VWERASE
278: setval(VWERASE, SLC_VARIABLE);
279: #else
280: defval(0);
281: #endif
282: case SLC_RP:
283: #ifdef VREPRINT
284: setval(VREPRINT, SLC_VARIABLE);
285: #else
286: defval(0);
287: #endif
288: case SLC_LNEXT:
289: #ifdef VLNEXT
290: setval(VLNEXT, SLC_VARIABLE);
291: #else
292: defval(0);
293: #endif
294: case SLC_AO:
295: #ifdef VFLUSHO
296: setval(VFLUSHO, SLC_VARIABLE|SLC_FLUSHOUT);
297: #else
298: defval(0);
299: #endif
300: case SLC_SUSP:
301: #ifdef VSUSP
302: setval(VSUSP, SLC_VARIABLE|SLC_FLUSHIN);
303: #else
304: defval(0);
305: #endif
306: #ifdef VEOL
307: case SLC_FORW1:
308: setval(VEOL, SLC_VARIABLE);
309: #endif
310: #ifdef VEOL2
311: case SLC_FORW2:
312: setval(VEOL2, SLC_VARIABLE);
313: #endif
314:
315: case SLC_BRK:
316: case SLC_SYNCH:
317: case SLC_AYT:
318: case SLC_EOR:
319: defval(0);
320:
321: default:
322: *valp = 0;
323: *valpp = 0;
324: return(SLC_NOSUPPORT);
325: }
326: }
327: #endif /* USE_TERMIO */
328:
329: #ifdef CRAY
330: /*
331: * getnpty()
332: *
333: * Return the number of pty's configured into the system.
334: */
335: getnpty()
336: {
337: #ifdef _SC_CRAY_NPTY
338: return sysconf(_SC_CRAY_NPTY);
339: #else
340: return 128;
341: #endif /* _SC_CRAY_NPTY */
342: }
343: #endif /* CRAY */
344:
345: /*
346: * getpty()
347: *
348: * Allocate a pty. As a side effect, the external character
349: * array "line" contains the name of the slave side.
350: *
351: * Returns the file descriptor of the opened pty.
352: */
353: char *line = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
354:
355: getpty()
356: {
357: register int p;
358: #ifndef CRAY
359: register char c, *p1, *p2;
360: register int i;
361:
362: (void) sprintf(line, "/dev/ptyXX");
363: p1 = &line[8];
364: p2 = &line[9];
365:
366: for (c = 'p'; c <= 's'; c++) {
367: struct stat stb;
368:
369: *p1 = c;
370: *p2 = '0';
371: if (stat(line, &stb) < 0)
372: break;
373: for (i = 0; i < 16; i++) {
374: *p2 = "0123456789abcdef"[i];
375: p = open(line, 2);
376: if (p > 0) {
377: line[5] = 't';
378: return(p);
379: }
380: }
381: }
382: #else /* CRAY */
383: register int npty;
384: extern lowpty, highpty;
385:
386: for (npty = lowpty; npty <= highpty; npty++) {
387: (void) sprintf(line, "/dev/pty/%03d", npty);
388: p = open(line, 2);
389: if (p < 0)
390: continue;
391: (void) sprintf(line, "/dev/ttyp%03d", npty);
392: if (access(line, 6) == 0)
393: return(p);
394: else {
395: /* no tty side to pty so skip it */
396: (void) close(p);
397: }
398: }
399: #endif /* CRAY */
400: return(-1);
401: }
402:
403: #ifdef LINEMODE
404: /*
405: * tty_flowmode() Find out if flow control is enabled or disabled.
406: * tty_linemode() Find out if linemode (external processing) is enabled.
407: * tty_setlinemod(on) Turn on/off linemode.
408: * tty_isecho() Find out if echoing is turned on.
409: * tty_setecho(on) Enable/disable character echoing.
410: * tty_israw() Find out if terminal is in RAW mode.
411: * tty_binaryin(on) Turn on/off BINARY on input.
412: * tty_binaryout(on) Turn on/off BINARY on output.
413: * tty_isediting() Find out if line editing is enabled.
414: * tty_istrapsig() Find out if signal trapping is enabled.
415: * tty_setedit(on) Turn on/off line editing.
416: * tty_setsig(on) Turn on/off signal trapping.
417: * tty_issofttab() Find out if tab expansion is enabled.
418: * tty_setsofttab(on) Turn on/off soft tab expansion.
419: * tty_islitecho() Find out if typed control chars are echoed literally
420: * tty_setlitecho() Turn on/off literal echo of control chars
421: * tty_tspeed(val) Set transmit speed to val.
422: * tty_rspeed(val) Set receive speed to val.
423: */
424:
425: tty_flowmode()
426: {
427: #ifndef USE_TERMIO
428: return((termbuf.tc.t_startc) > 0 && (termbuf.tc.t_stopc) > 0);
429: #else
430: return(termbuf.c_iflag & IXON ? 1 : 0);
431: #endif
432: }
433:
434: tty_linemode()
435: {
436: #ifndef USE_TERMIO
437: return(termbuf.state & TS_EXTPROC);
438: #else
439: return(termbuf.c_lflag & EXTPROC);
440: #endif
441: }
442:
443: tty_setlinemode(on)
444: int on;
445: {
446: #ifdef TIOCEXT
447: (void) ioctl(pty, TIOCEXT, (char *)&on);
448: #else /* !TIOCEXT */
449: #ifdef EXTPROC
450: if (on)
451: termbuf.c_lflag |= EXTPROC;
452: else
453: termbuf.c_lflag &= ~EXTPROC;
454: #endif
455: set_termbuf();
456: #endif /* TIOCEXT */
457: }
458:
459: tty_isecho()
460: {
461: #ifndef USE_TERMIO
462: return (termbuf.sg.sg_flags & ECHO);
463: #else
464: return (termbuf.c_lflag & ECHO);
465: #endif
466: }
467: #endif /* LINEMODE */
468:
469: tty_setecho(on)
470: {
471: #ifndef USE_TERMIO
472: if (on)
473: termbuf.sg.sg_flags |= ECHO|CRMOD;
474: else
475: termbuf.sg.sg_flags &= ~(ECHO|CRMOD);
476: #else
477: if (on)
478: termbuf.c_lflag |= ECHO;
479: else
480: termbuf.c_lflag &= ~ECHO;
481: #endif
482: }
483:
484: #if defined(LINEMODE) && defined(KLUDGELINEMODE)
485: tty_israw()
486: {
487: #ifndef USE_TERMIO
488: return(termbuf.sg.sg_flags & RAW);
489: #else
490: return(!(termbuf.c_lflag & ICANON));
491: #endif
492: }
493: #endif /* defined(LINEMODE) && defined(KLUDGELINEMODE) */
494:
495: tty_binaryin(on)
496: {
497: #ifndef USE_TERMIO
498: if (on)
499: termbuf.lflags |= LPASS8;
500: else
501: termbuf.lflags &= ~LPASS8;
502: #else
503: if (on) {
504: termbuf.c_lflag &= ~ISTRIP;
505: } else {
506: termbuf.c_lflag |= ISTRIP;
507: }
508: #endif
509: }
510:
511: tty_binaryout(on)
512: {
513: #ifndef USE_TERMIO
514: if (on)
515: termbuf.lflags |= LLITOUT;
516: else
517: termbuf.lflags &= ~LLITOUT;
518: #else
519: if (on) {
520: termbuf.c_cflag &= ~(CSIZE|PARENB);
521: termbuf.c_cflag |= CS8;
522: termbuf.c_oflag &= ~OPOST;
523: } else {
524: termbuf.c_cflag &= ~CSIZE;
525: termbuf.c_cflag |= CS7|PARENB;
526: termbuf.c_oflag |= OPOST;
527: }
528: #endif
529: }
530:
531: tty_isbinaryin()
532: {
533: #ifndef USE_TERMIO
534: return(termbuf.lflags & LPASS8);
535: #else
536: return(!(termbuf.c_iflag & ISTRIP));
537: #endif
538: }
539:
540: tty_isbinaryout()
541: {
542: #ifndef USE_TERMIO
543: return(termbuf.lflags & LLITOUT);
544: #else
545: return(!(termbuf.c_oflag&OPOST));
546: #endif
547: }
548:
549: #ifdef LINEMODE
550: tty_isediting()
551: {
552: #ifndef USE_TERMIO
553: return(!(termbuf.sg.sg_flags & (CBREAK|RAW)));
554: #else
555: return(termbuf.c_lflag & ICANON);
556: #endif
557: }
558:
559: tty_istrapsig()
560: {
561: #ifndef USE_TERMIO
562: return(!(termbuf.sg.sg_flags&RAW));
563: #else
564: return(termbuf.c_lflag & ISIG);
565: #endif
566: }
567:
568: tty_setedit(on)
569: int on;
570: {
571: #ifndef USE_TERMIO
572: if (on)
573: termbuf.sg.sg_flags &= ~CBREAK;
574: else
575: termbuf.sg.sg_flags |= CBREAK;
576: #else
577: if (on)
578: termbuf.c_lflag |= ICANON;
579: else
580: termbuf.c_lflag &= ~ICANON;
581: #endif
582: }
583:
584: tty_setsig(on)
585: int on;
586: {
587: #ifndef USE_TERMIO
588: if (on)
589: ;
590: #else
591: if (on)
592: termbuf.c_lflag |= ISIG;
593: else
594: termbuf.c_lflag &= ~ISIG;
595: #endif
596: }
597: #endif /* LINEMODE */
598:
599: tty_issofttab()
600: {
601: #ifndef USE_TERMIO
602: return (termbuf.sg.sg_flags & XTABS);
603: #else
604: # ifdef OXTABS
605: return (termbuf.c_oflag & OXTABS);
606: # endif
607: # ifdef TABDLY
608: return ((termbuf.c_oflag & TABDLY) == TAB3);
609: # endif
610: #endif
611: }
612:
613: tty_setsofttab(on)
614: int on;
615: {
616: #ifndef USE_TERMIO
617: if (on)
618: termbuf.sg.sg_flags |= XTABS;
619: else
620: termbuf.sg.sg_flags &= ~XTABS;
621: #else
622: if (on) {
623: # ifdef OXTABS
624: termbuf.c_oflag |= OXTABS;
625: # endif
626: # ifdef TABDLY
627: termbuf.c_oflag &= ~TABDLY;
628: termbuf.c_oflag |= TAB3;
629: # endif
630: } else {
631: # ifdef OXTABS
632: termbuf.c_oflag &= ~OXTABS;
633: # endif
634: # ifdef TABDLY
635: termbuf.c_oflag &= ~TABDLY;
636: termbuf.c_oflag |= TAB0;
637: # endif
638: }
639: #endif
640: }
641:
642: tty_islitecho()
643: {
644: #ifndef USE_TERMIO
645: return (!(termbuf.sg.sg_flags & CTLECH));
646: #else
647: # ifdef ECHOCTL
648: return (!(termbuf.c_lflag & ECHOCTL));
649: # endif
650: # ifdef TCTLECH
651: return (!(termbuf.c_lflag & TCTLECH));
652: # endif
653: # if !defined(ECHOCTL) && !defined(TCTLECH)
654: return (0); /* assumes ctl chars are echoed '^x' */
655: # endif
656: #endif
657: }
658:
659: tty_setlitecho(on)
660: int on;
661: {
662: #ifndef USE_TERMIO
663: if (on)
664: termbuf.sg.sg_flags &= ~CTLECH;
665: else
666: termbuf.sg.sg_flags |= CTLECH;
667: #else
668: # ifdef ECHOCTL
669: if (on)
670: termbuf.c_lflag &= ~ECHOCTL;
671: else
672: termbuf.c_lflag |= ECHOCTL;
673: # endif
674: # ifdef TCTLECH
675: if (on)
676: termbuf.c_lflag &= ~TCTLECH;
677: else
678: termbuf.c_lflag |= TCTLECH;
679: # endif
680: #endif
681: }
682:
683: /*
684: * A table of available terminal speeds
685: */
686: struct termspeeds {
687: int speed;
688: int value;
689: } termspeeds[] = {
690: { 0, B0 }, { 50, B50 }, { 75, B75 },
691: { 110, B110 }, { 134, B134 }, { 150, B150 },
692: { 200, B200 }, { 300, B300 }, { 600, B600 },
693: { 1200, B1200 }, { 1800, B1800 }, { 2400, B2400 },
694: { 4800, B4800 }, { 9600, B9600 }, { 19200, B9600 },
695: { 38400, B9600 }, { -1, B9600 }
696: };
697:
698: tty_tspeed(val)
699: {
700: register struct termspeeds *tp;
701:
702: for (tp = termspeeds; (tp->speed != -1) && (val > tp->speed); tp++)
703: ;
704: #ifndef USE_TERMIO
705: termbuf.sg.sg_ospeed = tp->value;
706: #else
707: # ifdef CBAUD
708: termbuf.c_cflag &= ~CBAUD;
709: termbuf.c_cflag |= tp->value;
710: # else
711: termbuf.c_ospeed = tp->value;
712: # endif
713: #endif
714: }
715:
716: tty_rspeed(val)
717: {
718: register struct termspeeds *tp;
719:
720: for (tp = termspeeds; (tp->speed != -1) && (val > tp->speed); tp++)
721: ;
722: #ifndef USE_TERMIO
723: termbuf.sg.sg_ispeed = tp->value;
724: #else
725: # ifdef CBAUD
726: termbuf.c_cflag &= ~CBAUD;
727: termbuf.c_cflag |= tp->value;
728: # else
729: termbuf.c_ispeed = tp->value;
730: # endif
731: #endif
732: }
733:
734: #if defined(CRAY2) && defined(UNICOS5)
735: tty_isnewmap()
736: {
737: return((termbuf.c_oflag & OPOST) && (termbuf.c_oflag & ONLCR) &&
738: !(termbuf.c_oflag & ONLRET));
739: }
740: #endif
741:
742: #ifdef CRAY
743: # ifndef NEWINIT
744: extern struct utmp wtmp;
745: extern char wtmpf[];
746: # else /* NEWINIT */
747: int gotalarm;
748: /* ARGSUSED */
749: void
750: nologinproc(sig)
751: int sig;
752: {
753: gotalarm++;
754: }
755: # endif /* NEWINIT */
756: #endif /* CRAY */
757:
758: /*
759: * getptyslave()
760: *
761: * Open the slave side of the pty, and do any initialization
762: * that is necessary. The return value is a file descriptor
763: * for the slave side.
764: */
765: getptyslave()
766: {
767: register int t = -1;
768:
769: #ifndef CRAY
770: /*
771: * Disassociate self from control terminal and open ttyp side.
772: * Set important flags on ttyp and ptyp.
773: */
774: t = open(_PATH_TTY, O_RDWR);
775: if (t >= 0) {
776: (void) ioctl(t, TIOCNOTTY, (char *)0);
777: (void) close(t);
778: }
779:
780: t = open(line, O_RDWR);
781: if (t < 0)
782: fatalperror(net, line);
783: if (fchmod(t, 0))
784: fatalperror(net, line);
785: #if BSD <= 43
786: (void) signal(SIGHUP, SIG_IGN);
787: vhangup();
788: (void) signal(SIGHUP, SIG_DFL);
789: t = open(line, O_RDWR);
790: if (t < 0)
791: fatalperror(net, line);
792: #endif
793:
794: init_termbuf();
795: #ifndef USE_TERMIO
796: termbuf.sg.sg_flags |= CRMOD|ANYP|ECHO|XTABS;
797: termbuf.sg.sg_ospeed = termbuf.sg.sg_ispeed = B9600;
798: #else
799: termbuf.c_lflag |= ECHO;
800: #ifndef OXTABS
801: #define OXTABS 0
802: #endif
803: termbuf.c_oflag |= ONLCR|OXTABS;
804: termbuf.c_iflag |= ICRNL;
805: termbuf.c_iflag &= ~IXOFF;
806: # ifdef CBAUD
807: termbuf.c_cflag &= ~CBAUD;
808: termbuf.c_cflag |= B9600;
809: # else /* CBAUD */
810: termbuf.c_ospeed = termbuf.c_ispeed = B9600;
811: # endif /* CBAUD */
812: #endif
813: set_termbuf();
814: #else /* CRAY */
815: (void) chown(line, 0, 0);
816: (void) chmod(line, 0600);
817: #endif /* CRAY */
818: return(t);
819: }
820:
821: #ifdef NEWINIT
822: char *gen_id = "fe";
823: #endif
824:
825: /*
826: * startslave(t, host)
827: *
828: * Given a file descriptor (t) for a tty, and a hostname, do whatever
829: * is necessary to startup the login process on the slave side of the pty.
830: */
831:
832: /* ARGSUSED */
833: startslave(t, host)
834: int t;
835: char *host;
836: {
837: register int i;
838: long time();
839:
840: #ifndef NEWINIT
841: # ifdef CRAY
842: utmp_sig_init();
843: # endif /* CRAY */
844:
845: if ((i = fork()) < 0)
846: fatalperror(net, "fork");
847: if (i) {
848: # ifdef CRAY
849: /*
850: * Cray parent will create utmp entry for child and send
851: * signal to child to tell when done. Child waits for signal
852: * before doing anything important.
853: */
854: register int pid = i;
855:
856: setpgrp();
857: utmp_sig_reset(); /* reset handler to default */
858: /*
859: * Create utmp entry for child
860: */
861: (void) time(&wtmp.ut_time);
862: wtmp.ut_type = LOGIN_PROCESS;
863: wtmp.ut_pid = pid;
864: SCPYN(wtmp.ut_user, "LOGIN");
865: SCPYN(wtmp.ut_host, host);
866: SCPYN(wtmp.ut_line, line + sizeof("/dev/") - 1);
867: SCPYN(wtmp.ut_id, wtmp.ut_line+3);
868: pututline(&wtmp);
869: endutent();
870: if ((i = open(wtmpf, O_WRONLY|O_APPEND)) >= 0) {
871: (void) write(i, (char *)&wtmp, sizeof(struct utmp));
872: (void) close(i);
873: }
874: utmp_sig_notify(pid);
875: # endif /* CRAY */
876: (void) close(t);
877: } else {
878: start_login(t, host);
879: /*NOTREACHED*/
880: }
881: #else /* NEWINIT */
882:
883: extern char *ptyip;
884: struct init_request request;
885: void nologinproc();
886: register int n;
887:
888: /*
889: * Init will start up login process if we ask nicely. We only wait
890: * for it to start up and begin normal telnet operation.
891: */
892: if ((i = open(INIT_FIFO, O_WRONLY)) < 0) {
893: char tbuf[128];
894: (void) sprintf(tbuf, "Can't open %s\n", INIT_FIFO);
895: fatalperror(net, tbuf);
896: }
897: memset((char *)&request, 0, sizeof(request));
898: request.magic = INIT_MAGIC;
899: SCPYN(request.gen_id, gen_id);
900: SCPYN(request.tty_id, &line[8]);
901: SCPYN(request.host, host);
902: SCPYN(request.term_type, terminaltype);
903: #if !defined(UNICOS5)
904: request.signal = SIGCLD;
905: request.pid = getpid();
906: #endif
907: #ifdef BFTPDAEMON
908: /*
909: * Are we working as the bftp daemon?
910: */
911: if (bftpd) {
912: SCPYN(request.exec_name, BFTPPATH);
913: }
914: #endif /* BFTPDAEMON */
915: if (write(i, (char *)&request, sizeof(request)) < 0) {
916: char tbuf[128];
917: (void) sprintf(tbuf, "Can't write to %s\n", INIT_FIFO);
918: fatalperror(net, tbuf);
919: }
920: (void) close(i);
921: (void) signal(SIGALRM, nologinproc);
922: for (i = 0; ; i++) {
923: char tbuf[128];
924: alarm(15);
925: n = read(pty, ptyip, BUFSIZ);
926: if (i == 3 || n >= 0 || !gotalarm)
927: break;
928: gotalarm = 0;
929: sprintf(tbuf, "telnetd: waiting for /etc/init to start login process on %s\r\n", line);
930: (void) write(net, tbuf, strlen(tbuf));
931: }
932: if (n < 0 && gotalarm)
933: fatal(net, "/etc/init didn't start login process");
934: pcc += n;
935: alarm(0);
936: (void) signal(SIGALRM, SIG_DFL);
937:
938: return;
939: #endif /* NEWINIT */
940: }
941:
942: char *envinit[3];
943: extern char **environ;
944:
945: init_env()
946: {
947: extern char *getenv();
948: char **envp;
949:
950: envp = envinit;
951: if (*envp = getenv("TZ"))
952: *envp++ -= 3;
953: #ifdef CRAY
954: else
955: *envp++ = "TZ=GMT0";
956: #endif
957: *envp = 0;
958: environ = envinit;
959: }
960:
961: #ifdef CRAY
962: /*
963: * These are environment variable that we
964: * don't put on the argument line.
965: */
966: char *invalid[] = {
967: "USER=", /* Set up by login */
968: "HOME=", /* Set up by login */
969: "LOGNAME=", /* Set up by login */
970: "TMPDIR=", /* Set up by login */
971: "SHELL=", /* Set up by login */
972: "PATH=", /* Set up by login */
973: "MAIL=", /* Set up by login */
974: "TZ=", /* Login gets it from the environment */
975: "TERM=", /* Login gets it from the environment */
976: 0
977: };
978: #endif
979:
980: #ifndef NEWINIT
981:
982: /*
983: * start_login(t, host)
984: *
985: * Assuming that we are now running as a child processes, this
986: * function will turn us into the login process.
987: */
988:
989: start_login(t, host)
990: int t;
991: char *host;
992: {
993: register char *cp;
994: register char **argv;
995: char **addarg();
996: #ifdef CRAY
997: register char **cpp, **cpp2;
998: utmp_sig_wait();
999: # ifndef TCVHUP
1000: setpgrp();
1001: # endif
1002: t = open(line, 2); /* open ttyp */
1003: if (t < 0)
1004: fatalperror(net, line);
1005: # ifdef TCVHUP
1006: /*
1007: * Hangup anybody else using this ttyp, then reopen it for
1008: * ourselves.
1009: */
1010: (void) chown(line, 0, 0);
1011: (void) chmod(line, 0600);
1012: (void) signal(SIGHUP, SIG_IGN);
1013: (void) ioctl(t, TCVHUP, (char *)0);
1014: (void) signal(SIGHUP, SIG_DFL);
1015: setpgrp();
1016: i = open(line, 2);
1017: if (i < 0)
1018: fatalperror(net, line);
1019: (void) close(t);
1020: t = i;
1021: # endif /* TCVHUP */
1022: /*
1023: * set ttyp modes as we like them to be
1024: */
1025: init_termbuf();
1026: termbuf.c_oflag = OPOST|ONLCR|TAB3;
1027: termbuf.c_iflag = IGNPAR|ISTRIP|ICRNL|IXON;
1028: termbuf.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK;
1029: termbuf.c_cflag = EXTB|HUPCL|CS8;
1030: set_termbuf();
1031: #endif /* CRAY */
1032:
1033: /*
1034: * set up standard paths before forking to login
1035: */
1036: #if BSD > 43
1037: if (login_tty(t) == -1)
1038: fatalperror(net, "login_tty");
1039: #else
1040: (void) dup2(t, 0);
1041: (void) dup2(t, 1);
1042: (void) dup2(t, 2);
1043: (void) close(t);
1044: #endif
1045: if (net > 2)
1046: (void) close(net);
1047: if (pty > 2)
1048: (void) close(pty);
1049: /*
1050: * -h : pass on name of host.
1051: * WARNING: -h is accepted by login if and only if
1052: * getuid() == 0.
1053: * -p : don't clobber the environment (so terminal type stays set).
1054: */
1055: argv = addarg(0, "login");
1056: argv = addarg(argv, "-h");
1057: argv = addarg(argv, host);
1058: #if !defined(CRAY) && !defined(NO_LOGIN_P)
1059: argv = addarg(argv, "-p");
1060: #endif
1061: #ifdef BFTPDAEMON
1062: /*
1063: * Are we working as the bftp daemon? If so, then ask login
1064: * to start bftp instead of shell.
1065: */
1066: if (bftpd) {
1067: argv = addarg(argv, "-e");
1068: argv = addarg(argv, BFTPPATH);
1069: } else
1070: #endif
1071: if (getenv("USER")) {
1072: argv = addarg(argv, getenv("USER"));
1073: }
1074: #ifdef CRAY
1075: for (cpp = environ; *cpp; cpp++) {
1076: for (cpp2 = invalid; *cpp2; cpp2++)
1077: if (strncmp(*cpp2, *cpp, strlen(*cpp2)) == 0)
1078: break;
1079: if (*cpp2)
1080: continue;
1081: argv = addarg(argv, *cpp);
1082: }
1083: #endif
1084:
1085: execv(_PATH_LOGIN, argv);
1086:
1087: syslog(LOG_ERR, "%s: %m\n", _PATH_LOGIN);
1088: fatalperror(net, _PATH_LOGIN);
1089: /*NOTREACHED*/
1090: }
1091:
1092: char **
1093: addarg(argv, val)
1094: register char **argv;
1095: register char *val;
1096: {
1097: register char **cpp;
1098: char *malloc();
1099:
1100: if (argv == NULL) {
1101: /*
1102: * 10 entries, a leading length, and a null
1103: */
1104: argv = (char **)malloc(sizeof(*argv) * 12);
1105: if (argv == NULL)
1106: return(NULL);
1107: *argv++ = (char *)10;
1108: *argv = (char *)0;
1109: }
1110: for (cpp = argv; *cpp; cpp++)
1111: ;
1112: if (cpp == &argv[(int)argv[-1]]) {
1113: --argv;
1114: *argv = (char *)((int)(*argv) + 10);
1115: argv = (char **)realloc(argv, (int)(*argv) + 2);
1116: if (argv == NULL)
1117: return(NULL);
1118: argv++;
1119: cpp = &argv[(int)argv[-1] - 10];
1120: }
1121: *cpp++ = val;
1122: *cpp = 0;
1123: return(argv);
1124: }
1125: #endif NEWINIT
1126:
1127: /*
1128: * cleanup()
1129: *
1130: * This is the routine to call when we are all through, to
1131: * clean up anything that needs to be cleaned up.
1132: */
1133: cleanup()
1134: {
1135:
1136: #ifndef CRAY
1137: # if BSD > 43
1138: char *p;
1139:
1140: p = line + sizeof("/dev/") - 1;
1141: if (logout(p))
1142: logwtmp(p, "", "");
1143: (void)chmod(line, 0666);
1144: (void)chown(line, 0, 0);
1145: *p = 'p';
1146: (void)chmod(line, 0666);
1147: (void)chown(line, 0, 0);
1148: # else
1149: rmut();
1150: vhangup(); /* XXX */
1151: # endif
1152: (void) shutdown(net, 2);
1153: #else /* CRAY */
1154: # ifndef NEWINIT
1155: rmut(line);
1156: (void) shutdown(net, 2);
1157: kill(0, SIGHUP);
1158: # else /* NEWINIT */
1159: (void) shutdown(net, 2);
1160: # endif /* NEWINT */
1161: #endif /* CRAY */
1162: exit(1);
1163: }
1164:
1165: #if defined(CRAY) && !defined(NEWINIT)
1166: /*
1167: * _utmp_sig_rcv
1168: * utmp_sig_init
1169: * utmp_sig_wait
1170: * These three functions are used to coordinate the handling of
1171: * the utmp file between the server and the soon-to-be-login shell.
1172: * The server actually creates the utmp structure, the child calls
1173: * utmp_sig_wait(), until the server calls utmp_sig_notify() and
1174: * signals the future-login shell to proceed.
1175: */
1176: static int caught=0; /* NZ when signal intercepted */
1177: static void (*func)(); /* address of previous handler */
1178:
1179: void
1180: _utmp_sig_rcv(sig)
1181: int sig;
1182: {
1183: caught = 1;
1184: (void) signal(SIGUSR1, func);
1185: }
1186:
1187: utmp_sig_init()
1188: {
1189: /*
1190: * register signal handler for UTMP creation
1191: */
1192: if ((int)(func = signal(SIGUSR1, _utmp_sig_rcv)) == -1)
1193: fatalperror(net, "telnetd/signal");
1194: }
1195:
1196: utmp_sig_reset()
1197: {
1198: (void) signal(SIGUSR1, func); /* reset handler to default */
1199: }
1200:
1201: utmp_sig_wait()
1202: {
1203: /*
1204: * Wait for parent to write our utmp entry.
1205: */
1206: sigoff();
1207: while (caught == 0) {
1208: pause(); /* wait until we get a signal (sigon) */
1209: sigoff(); /* turn off signals while we check caught */
1210: }
1211: sigon(); /* turn on signals again */
1212: }
1213:
1214: utmp_sig_notify(pid)
1215: {
1216: kill(pid, SIGUSR1);
1217: }
1218: #endif /* defined(CRAY) && !defined(NEWINIT) */
1219:
1220: /*
1221: * rmut()
1222: *
1223: * This is the function called by cleanup() to
1224: * remove the utmp entry for this person.
1225: */
1226:
1227: #if !defined(CRAY) && BSD <= 43
1228: rmut()
1229: {
1230: register f;
1231: int found = 0;
1232: struct utmp *u, *utmp;
1233: int nutmp;
1234: struct stat statbf;
1235: char *malloc();
1236: long time();
1237: off_t lseek();
1238:
1239: f = open(utmpf, O_RDWR);
1240: if (f >= 0) {
1241: (void) fstat(f, &statbf);
1242: utmp = (struct utmp *)malloc((unsigned)statbf.st_size);
1243: if (!utmp)
1244: syslog(LOG_ERR, "utmp malloc failed");
1245: if (statbf.st_size && utmp) {
1246: nutmp = read(f, (char *)utmp, (int)statbf.st_size);
1247: nutmp /= sizeof(struct utmp);
1248:
1249: for (u = utmp ; u < &utmp[nutmp] ; u++) {
1250: if (SCMPN(u->ut_line, line+5) ||
1251: u->ut_name[0]==0)
1252: continue;
1253: (void) lseek(f, ((long)u)-((long)utmp), L_SET);
1254: SCPYN(u->ut_name, "");
1255: SCPYN(u->ut_host, "");
1256: (void) time(&u->ut_time);
1257: (void) write(f, (char *)u, sizeof(wtmp));
1258: found++;
1259: }
1260: }
1261: (void) close(f);
1262: }
1263: if (found) {
1264: f = open(wtmpf, O_WRONLY|O_APPEND);
1265: if (f >= 0) {
1266: SCPYN(wtmp.ut_line, line+5);
1267: SCPYN(wtmp.ut_name, "");
1268: SCPYN(wtmp.ut_host, "");
1269: (void) time(&wtmp.ut_time);
1270: (void) write(f, (char *)&wtmp, sizeof(wtmp));
1271: (void) close(f);
1272: }
1273: }
1274: (void) chmod(line, 0666);
1275: (void) chown(line, 0, 0);
1276: line[strlen("/dev/")] = 'p';
1277: (void) chmod(line, 0666);
1278: (void) chown(line, 0, 0);
1279: } /* end of rmut */
1280: #endif /* CRAY */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.