1 /*
2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * @(#)sys_term.c 8.4+1 (Berkeley) 5/30/95
30 * $FreeBSD: src/crypto/telnet/telnetd/sys_term.c,v 1.7.2.5 2002/06/17 02:48:02 jmallett Exp $
31 */
32
33 #include <sys/types.h>
34 #include <sys/tty.h>
35 #include <libutil.h>
36 #include <stdlib.h>
37 #include <utmpx.h>
38
39 #include "telnetd.h"
40 #include "pathnames.h"
41
42 #ifdef AUTHENTICATION
43 #include <libtelnet/auth.h>
44 extern int auth_level;
45 #endif
46
47 int cleanopen(char *);
48 void scrub_env(void);
49
50 char *envinit[3];
51 extern char **environ;
52
53 #define SCPYN(a, b) (void) strncpy(a, b, sizeof(a))
54 #define SCMPN(a, b) strncmp(a, b, sizeof(a))
55
56 #ifdef t_erase
57 #undef t_erase
58 #undef t_kill
59 #undef t_intrc
60 #undef t_quitc
61 #undef t_startc
62 #undef t_stopc
63 #undef t_eofc
64 #undef t_brkc
65 #undef t_suspc
66 #undef t_dsuspc
67 #undef t_rprntc
68 #undef t_flushc
69 #undef t_werasc
70 #undef t_lnextc
71 #endif
72
73 #ifndef USE_TERMIO
74 struct termbuf {
75 struct sgttyb sg;
76 struct tchars tc;
77 struct ltchars ltc;
78 int state;
79 int lflags;
80 } termbuf, termbuf2;
81 # define cfsetospeed(tp, val) (tp)->sg.sg_ospeed = (val)
82 # define cfsetispeed(tp, val) (tp)->sg.sg_ispeed = (val)
83 # define cfgetospeed(tp) (tp)->sg.sg_ospeed
84 # define cfgetispeed(tp) (tp)->sg.sg_ispeed
85 #else /* USE_TERMIO */
86 # ifndef TCSANOW
87 # ifdef TCSETS
88 # define TCSANOW TCSETS
89 # define TCSADRAIN TCSETSW
90 # define tcgetattr(f, t) ioctl(f, TCGETS, (char *)t)
91 # else
92 # ifdef TCSETA
93 # define TCSANOW TCSETA
94 # define TCSADRAIN TCSETAW
95 # define tcgetattr(f, t) ioctl(f, TCGETA, (char *)t)
96 # else
97 # define TCSANOW TIOCSETA
98 # define TCSADRAIN TIOCSETAW
99 # define tcgetattr(f, t) ioctl(f, TIOCGETA, (char *)t)
100 # endif
101 # endif
102 # define tcsetattr(f, a, t) ioctl(f, a, t)
103 # define cfsetospeed(tp, val) (tp)->c_cflag &= ~CBAUD; \
104 (tp)->c_cflag |= (val)
105 # define cfgetospeed(tp) ((tp)->c_cflag & CBAUD)
106 # ifdef CIBAUD
107 # define cfsetispeed(tp, val) (tp)->c_cflag &= ~CIBAUD; \
108 (tp)->c_cflag |= ((val)<<IBSHIFT)
109 # define cfgetispeed(tp) (((tp)->c_cflag & CIBAUD)>>IBSHIFT)
110 # else
111 # define cfsetispeed(tp, val) (tp)->c_cflag &= ~CBAUD; \
112 (tp)->c_cflag |= (val)
113 # define cfgetispeed(tp) ((tp)->c_cflag & CBAUD)
114 # endif
115 # endif /* TCSANOW */
116 struct termios termbuf, termbuf2; /* pty control structure */
117 #endif /* USE_TERMIO */
118
119 int cleanopen(char *);
120 void scrub_env(void);
121 static char **addarg(char **, const char *);
122
123 /*
124 * init_termbuf()
125 * copy_termbuf(cp)
126 * set_termbuf()
127 *
128 * These three routines are used to get and set the "termbuf" structure
129 * to and from the kernel. init_termbuf() gets the current settings.
130 * copy_termbuf() hands in a new "termbuf" to write to the kernel, and
131 * set_termbuf() writes the structure into the kernel.
132 */
133
134 void
init_termbuf(void)135 init_termbuf(void)
136 {
137 #ifndef USE_TERMIO
138 (void) ioctl(pty, TIOCGETP, (char *)&termbuf.sg);
139 (void) ioctl(pty, TIOCGETC, (char *)&termbuf.tc);
140 (void) ioctl(pty, TIOCGLTC, (char *)&termbuf.ltc);
141 # ifdef TIOCGSTATE
142 (void) ioctl(pty, TIOCGSTATE, (char *)&termbuf.state);
143 # endif
144 #else
145 (void) tcgetattr(pty, &termbuf);
146 #endif
147 termbuf2 = termbuf;
148 }
149
150 #if defined(LINEMODE) && defined(TIOCPKT_IOCTL)
151 void
copy_termbuf(char * cp,size_t len)152 copy_termbuf(char *cp, size_t len)
153 {
154 if (len > sizeof(termbuf))
155 len = sizeof(termbuf);
156 memmove((char *)&termbuf, cp, len);
157 termbuf2 = termbuf;
158 }
159 #endif /* defined(LINEMODE) && defined(TIOCPKT_IOCTL) */
160
161 void
set_termbuf(void)162 set_termbuf(void)
163 {
164 /*
165 * Only make the necessary changes.
166 */
167 #ifndef USE_TERMIO
168 if (memcmp((char *)&termbuf.sg, (char *)&termbuf2.sg,
169 sizeof(termbuf.sg)))
170 (void) ioctl(pty, TIOCSETN, (char *)&termbuf.sg);
171 if (memcmp((char *)&termbuf.tc, (char *)&termbuf2.tc,
172 sizeof(termbuf.tc)))
173 (void) ioctl(pty, TIOCSETC, (char *)&termbuf.tc);
174 if (memcmp((char *)&termbuf.ltc, (char *)&termbuf2.ltc,
175 sizeof(termbuf.ltc)))
176 (void) ioctl(pty, TIOCSLTC, (char *)&termbuf.ltc);
177 if (termbuf.lflags != termbuf2.lflags)
178 (void) ioctl(pty, TIOCLSET, (char *)&termbuf.lflags);
179 #else /* USE_TERMIO */
180 if (memcmp((char *)&termbuf, (char *)&termbuf2, sizeof(termbuf)))
181 (void) tcsetattr(pty, TCSANOW, &termbuf);
182 #endif /* USE_TERMIO */
183 }
184
185
186 /*
187 * spcset(func, valp, valpp)
188 *
189 * This function takes various special characters (func), and
190 * sets *valp to the current value of that character, and
191 * *valpp to point to where in the "termbuf" structure that
192 * value is kept.
193 *
194 * It returns the SLC_ level of support for this function.
195 */
196
197 #ifndef USE_TERMIO
198 int
spcset(int func,cc_t * valp,cc_t ** valpp)199 spcset(int func, cc_t *valp, cc_t **valpp)
200 {
201 switch(func) {
202 case SLC_EOF:
203 *valp = termbuf.tc.t_eofc;
204 *valpp = (cc_t *)&termbuf.tc.t_eofc;
205 return(SLC_VARIABLE);
206 case SLC_EC:
207 *valp = termbuf.sg.sg_erase;
208 *valpp = (cc_t *)&termbuf.sg.sg_erase;
209 return(SLC_VARIABLE);
210 case SLC_EL:
211 *valp = termbuf.sg.sg_kill;
212 *valpp = (cc_t *)&termbuf.sg.sg_kill;
213 return(SLC_VARIABLE);
214 case SLC_IP:
215 *valp = termbuf.tc.t_intrc;
216 *valpp = (cc_t *)&termbuf.tc.t_intrc;
217 return(SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
218 case SLC_ABORT:
219 *valp = termbuf.tc.t_quitc;
220 *valpp = (cc_t *)&termbuf.tc.t_quitc;
221 return(SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
222 case SLC_XON:
223 *valp = termbuf.tc.t_startc;
224 *valpp = (cc_t *)&termbuf.tc.t_startc;
225 return(SLC_VARIABLE);
226 case SLC_XOFF:
227 *valp = termbuf.tc.t_stopc;
228 *valpp = (cc_t *)&termbuf.tc.t_stopc;
229 return(SLC_VARIABLE);
230 case SLC_AO:
231 *valp = termbuf.ltc.t_flushc;
232 *valpp = (cc_t *)&termbuf.ltc.t_flushc;
233 return(SLC_VARIABLE);
234 case SLC_SUSP:
235 *valp = termbuf.ltc.t_suspc;
236 *valpp = (cc_t *)&termbuf.ltc.t_suspc;
237 return(SLC_VARIABLE);
238 case SLC_EW:
239 *valp = termbuf.ltc.t_werasc;
240 *valpp = (cc_t *)&termbuf.ltc.t_werasc;
241 return(SLC_VARIABLE);
242 case SLC_RP:
243 *valp = termbuf.ltc.t_rprntc;
244 *valpp = (cc_t *)&termbuf.ltc.t_rprntc;
245 return(SLC_VARIABLE);
246 case SLC_LNEXT:
247 *valp = termbuf.ltc.t_lnextc;
248 *valpp = (cc_t *)&termbuf.ltc.t_lnextc;
249 return(SLC_VARIABLE);
250 case SLC_FORW1:
251 *valp = termbuf.tc.t_brkc;
252 *valpp = (cc_t *)&termbuf.ltc.t_lnextc;
253 return(SLC_VARIABLE);
254 case SLC_BRK:
255 case SLC_SYNCH:
256 case SLC_AYT:
257 case SLC_EOR:
258 *valp = (cc_t)0;
259 *valpp = NULL;
260 return(SLC_DEFAULT);
261 default:
262 *valp = (cc_t)0;
263 *valpp = NULL;
264 return(SLC_NOSUPPORT);
265 }
266 }
267
268 #else /* USE_TERMIO */
269
270
271 #define setval(a, b) *valp = termbuf.c_cc[a]; \
272 *valpp = &termbuf.c_cc[a]; \
273 return(b);
274 #define defval(a) *valp = ((cc_t)a); *valpp = NULL; return(SLC_DEFAULT);
275
276 int
spcset(int func,cc_t * valp,cc_t ** valpp)277 spcset(int func, cc_t *valp, cc_t **valpp)
278 {
279 switch(func) {
280 case SLC_EOF:
281 setval(VEOF, SLC_VARIABLE);
282 case SLC_EC:
283 setval(VERASE, SLC_VARIABLE);
284 case SLC_EL:
285 setval(VKILL, SLC_VARIABLE);
286 case SLC_IP:
287 setval(VINTR, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
288 case SLC_ABORT:
289 setval(VQUIT, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT);
290 case SLC_XON:
291 #ifdef VSTART
292 setval(VSTART, SLC_VARIABLE);
293 #else
294 defval(0x13);
295 #endif
296 case SLC_XOFF:
297 #ifdef VSTOP
298 setval(VSTOP, SLC_VARIABLE);
299 #else
300 defval(0x11);
301 #endif
302 case SLC_EW:
303 #ifdef VWERASE
304 setval(VWERASE, SLC_VARIABLE);
305 #else
306 defval(0);
307 #endif
308 case SLC_RP:
309 #ifdef VREPRINT
310 setval(VREPRINT, SLC_VARIABLE);
311 #else
312 defval(0);
313 #endif
314 case SLC_LNEXT:
315 #ifdef VLNEXT
316 setval(VLNEXT, SLC_VARIABLE);
317 #else
318 defval(0);
319 #endif
320 case SLC_AO:
321 #if !defined(VDISCARD) && defined(VFLUSHO)
322 # define VDISCARD VFLUSHO
323 #endif
324 #ifdef VDISCARD
325 setval(VDISCARD, SLC_VARIABLE|SLC_FLUSHOUT);
326 #else
327 defval(0);
328 #endif
329 case SLC_SUSP:
330 #ifdef VSUSP
331 setval(VSUSP, SLC_VARIABLE|SLC_FLUSHIN);
332 #else
333 defval(0);
334 #endif
335 #ifdef VEOL
336 case SLC_FORW1:
337 setval(VEOL, SLC_VARIABLE);
338 #endif
339 #ifdef VEOL2
340 case SLC_FORW2:
341 setval(VEOL2, SLC_VARIABLE);
342 #endif
343 case SLC_AYT:
344 #ifdef VSTATUS
345 setval(VSTATUS, SLC_VARIABLE);
346 #else
347 defval(0);
348 #endif
349
350 case SLC_BRK:
351 case SLC_SYNCH:
352 case SLC_EOR:
353 defval(0);
354
355 default:
356 *valp = 0;
357 *valpp = NULL;
358 return(SLC_NOSUPPORT);
359 }
360 }
361 #endif /* USE_TERMIO */
362
363 /*
364 * getpty()
365 *
366 * Allocate a pty. As a side effect, the external character
367 * array "line" contains the name of the slave side.
368 *
369 * Returns the file descriptor of the opened pty.
370 */
371 char alpha[] = "0123456789abcdefghijklmnopqrstuv";
372 char line[16];
373
374 int
getpty(int * ptynum __unused)375 getpty(int *ptynum __unused)
376 {
377 int p;
378 const char *cp;
379 char *p1, *p2;
380 int i;
381
382 (void) strcpy(line, _PATH_DEV);
383 (void) strcat(line, "ptyXX");
384 p1 = &line[8];
385 p2 = &line[9];
386
387 for (cp = "pqrsPQRS"; *cp; cp++) {
388 struct stat stb;
389
390 *p1 = *cp;
391 *p2 = '0';
392 /*
393 * This stat() check is just to keep us from
394 * looping through all 256 combinations if there
395 * aren't that many ptys available.
396 */
397 if (stat(line, &stb) < 0)
398 break;
399 for (i = 0; i < 32; i++) {
400 *p2 = alpha[i];
401 p = open(line, 2);
402 if (p > 0) {
403 line[5] = 't';
404 chown(line, 0, 0);
405 chmod(line, 0600);
406 return(p);
407 }
408 }
409 }
410 return(-1);
411 }
412
413 #ifdef LINEMODE
414 /*
415 * tty_flowmode() Find out if flow control is enabled or disabled.
416 * tty_linemode() Find out if linemode (external processing) is enabled.
417 * tty_setlinemod(on) Turn on/off linemode.
418 * tty_isecho() Find out if echoing is turned on.
419 * tty_setecho(on) Enable/disable character echoing.
420 * tty_israw() Find out if terminal is in RAW mode.
421 * tty_binaryin(on) Turn on/off BINARY on input.
422 * tty_binaryout(on) Turn on/off BINARY on output.
423 * tty_isediting() Find out if line editing is enabled.
424 * tty_istrapsig() Find out if signal trapping is enabled.
425 * tty_setedit(on) Turn on/off line editing.
426 * tty_setsig(on) Turn on/off signal trapping.
427 * tty_issofttab() Find out if tab expansion is enabled.
428 * tty_setsofttab(on) Turn on/off soft tab expansion.
429 * tty_islitecho() Find out if typed control chars are echoed literally
430 * tty_setlitecho() Turn on/off literal echo of control chars
431 * tty_tspeed(val) Set transmit speed to val.
432 * tty_rspeed(val) Set receive speed to val.
433 */
434
435
436 int
tty_linemode(void)437 tty_linemode(void)
438 {
439 #ifndef USE_TERMIO
440 return(termbuf.state & TS_EXTPROC);
441 #else
442 return(termbuf.c_lflag & EXTPROC);
443 #endif
444 }
445
446 void
tty_setlinemode(int on)447 tty_setlinemode(int on)
448 {
449 #ifdef TIOCEXT
450 set_termbuf();
451 (void) ioctl(pty, TIOCEXT, (char *)&on);
452 init_termbuf();
453 #else /* !TIOCEXT */
454 # ifdef EXTPROC
455 if (on)
456 termbuf.c_lflag |= EXTPROC;
457 else
458 termbuf.c_lflag &= ~EXTPROC;
459 # endif
460 #endif /* TIOCEXT */
461 }
462 #endif /* LINEMODE */
463
464 int
tty_isecho(void)465 tty_isecho(void)
466 {
467 #ifndef USE_TERMIO
468 return (termbuf.sg.sg_flags & ECHO);
469 #else
470 return (termbuf.c_lflag & ECHO);
471 #endif
472 }
473
474 int
tty_flowmode(void)475 tty_flowmode(void)
476 {
477 #ifndef USE_TERMIO
478 return(((termbuf.tc.t_startc) > 0 && (termbuf.tc.t_stopc) > 0) ? 1 : 0);
479 #else
480 return((termbuf.c_iflag & IXON) ? 1 : 0);
481 #endif
482 }
483
484 int
tty_restartany(void)485 tty_restartany(void)
486 {
487 #ifndef USE_TERMIO
488 # ifdef DECCTQ
489 return((termbuf.lflags & DECCTQ) ? 0 : 1);
490 # else
491 return(-1);
492 # endif
493 #else
494 return((termbuf.c_iflag & IXANY) ? 1 : 0);
495 #endif
496 }
497
498 void
tty_setecho(int on)499 tty_setecho(int on)
500 {
501 #ifndef USE_TERMIO
502 if (on)
503 termbuf.sg.sg_flags |= ECHO|CRMOD;
504 else
505 termbuf.sg.sg_flags &= ~(ECHO|CRMOD);
506 #else
507 if (on)
508 termbuf.c_lflag |= ECHO;
509 else
510 termbuf.c_lflag &= ~ECHO;
511 #endif
512 }
513
514 int
tty_israw(void)515 tty_israw(void)
516 {
517 #ifndef USE_TERMIO
518 return(termbuf.sg.sg_flags & RAW);
519 #else
520 return(!(termbuf.c_lflag & ICANON));
521 #endif
522 }
523
524 #ifdef AUTHENTICATION
525 #if defined(NO_LOGIN_F) && defined(LOGIN_R)
526 int
tty_setraw(int on)527 tty_setraw(int on)
528 {
529 # ifndef USE_TERMIO
530 if (on)
531 termbuf.sg.sg_flags |= RAW;
532 else
533 termbuf.sg.sg_flags &= ~RAW;
534 # else
535 if (on)
536 termbuf.c_lflag &= ~ICANON;
537 else
538 termbuf.c_lflag |= ICANON;
539 # endif
540 }
541 #endif
542 #endif /* AUTHENTICATION */
543
544 void
tty_binaryin(int on)545 tty_binaryin(int on)
546 {
547 #ifndef USE_TERMIO
548 if (on)
549 termbuf.lflags |= LPASS8;
550 else
551 termbuf.lflags &= ~LPASS8;
552 #else
553 if (on) {
554 termbuf.c_iflag &= ~ISTRIP;
555 } else {
556 termbuf.c_iflag |= ISTRIP;
557 }
558 #endif
559 }
560
561 void
tty_binaryout(int on)562 tty_binaryout(int on)
563 {
564 #ifndef USE_TERMIO
565 if (on)
566 termbuf.lflags |= LLITOUT;
567 else
568 termbuf.lflags &= ~LLITOUT;
569 #else
570 if (on) {
571 termbuf.c_cflag &= ~(CSIZE|PARENB);
572 termbuf.c_cflag |= CS8;
573 termbuf.c_oflag &= ~OPOST;
574 } else {
575 termbuf.c_cflag &= ~CSIZE;
576 termbuf.c_cflag |= CS7|PARENB;
577 termbuf.c_oflag |= OPOST;
578 }
579 #endif
580 }
581
582 int
tty_isbinaryin(void)583 tty_isbinaryin(void)
584 {
585 #ifndef USE_TERMIO
586 return(termbuf.lflags & LPASS8);
587 #else
588 return(!(termbuf.c_iflag & ISTRIP));
589 #endif
590 }
591
592 int
tty_isbinaryout(void)593 tty_isbinaryout(void)
594 {
595 #ifndef USE_TERMIO
596 return(termbuf.lflags & LLITOUT);
597 #else
598 return(!(termbuf.c_oflag&OPOST));
599 #endif
600 }
601
602 #ifdef LINEMODE
603 int
tty_isediting(void)604 tty_isediting(void)
605 {
606 #ifndef USE_TERMIO
607 return(!(termbuf.sg.sg_flags & (CBREAK|RAW)));
608 #else
609 return(termbuf.c_lflag & ICANON);
610 #endif
611 }
612
613 int
tty_istrapsig(void)614 tty_istrapsig(void)
615 {
616 #ifndef USE_TERMIO
617 return(!(termbuf.sg.sg_flags&RAW));
618 #else
619 return(termbuf.c_lflag & ISIG);
620 #endif
621 }
622
623 void
tty_setedit(int on)624 tty_setedit(int on)
625 {
626 #ifndef USE_TERMIO
627 if (on)
628 termbuf.sg.sg_flags &= ~CBREAK;
629 else
630 termbuf.sg.sg_flags |= CBREAK;
631 #else
632 if (on)
633 termbuf.c_lflag |= ICANON;
634 else
635 termbuf.c_lflag &= ~ICANON;
636 #endif
637 }
638
639 void
tty_setsig(int on)640 tty_setsig(int on)
641 {
642 #ifndef USE_TERMIO
643 if (on)
644 ;
645 #else
646 if (on)
647 termbuf.c_lflag |= ISIG;
648 else
649 termbuf.c_lflag &= ~ISIG;
650 #endif
651 }
652 #endif /* LINEMODE */
653
654 int
tty_issofttab(void)655 tty_issofttab(void)
656 {
657 #ifndef USE_TERMIO
658 return (termbuf.sg.sg_flags & XTABS);
659 #else
660 # ifdef OXTABS
661 return (termbuf.c_oflag & OXTABS);
662 # endif
663 # ifdef TABDLY
664 return ((termbuf.c_oflag & TABDLY) == TAB3);
665 # endif
666 #endif
667 }
668
669 void
tty_setsofttab(int on)670 tty_setsofttab(int on)
671 {
672 #ifndef USE_TERMIO
673 if (on)
674 termbuf.sg.sg_flags |= XTABS;
675 else
676 termbuf.sg.sg_flags &= ~XTABS;
677 #else
678 if (on) {
679 # ifdef OXTABS
680 termbuf.c_oflag |= OXTABS;
681 # endif
682 # ifdef TABDLY
683 termbuf.c_oflag &= ~TABDLY;
684 termbuf.c_oflag |= TAB3;
685 # endif
686 } else {
687 # ifdef OXTABS
688 termbuf.c_oflag &= ~OXTABS;
689 # endif
690 # ifdef TABDLY
691 termbuf.c_oflag &= ~TABDLY;
692 termbuf.c_oflag |= TAB0;
693 # endif
694 }
695 #endif
696 }
697
698 int
tty_islitecho(void)699 tty_islitecho(void)
700 {
701 #ifndef USE_TERMIO
702 return (!(termbuf.lflags & LCTLECH));
703 #else
704 # ifdef ECHOCTL
705 return (!(termbuf.c_lflag & ECHOCTL));
706 # endif
707 # ifdef TCTLECH
708 return (!(termbuf.c_lflag & TCTLECH));
709 # endif
710 # if !defined(ECHOCTL) && !defined(TCTLECH)
711 return (0); /* assumes ctl chars are echoed '^x' */
712 # endif
713 #endif
714 }
715
716 void
tty_setlitecho(int on)717 tty_setlitecho(int on)
718 {
719 #ifndef USE_TERMIO
720 if (on)
721 termbuf.lflags &= ~LCTLECH;
722 else
723 termbuf.lflags |= LCTLECH;
724 #else
725 # ifdef ECHOCTL
726 if (on)
727 termbuf.c_lflag &= ~ECHOCTL;
728 else
729 termbuf.c_lflag |= ECHOCTL;
730 # endif
731 # ifdef TCTLECH
732 if (on)
733 termbuf.c_lflag &= ~TCTLECH;
734 else
735 termbuf.c_lflag |= TCTLECH;
736 # endif
737 #endif
738 }
739
740 int
tty_iscrnl(void)741 tty_iscrnl(void)
742 {
743 #ifndef USE_TERMIO
744 return (termbuf.sg.sg_flags & CRMOD);
745 #else
746 return (termbuf.c_iflag & ICRNL);
747 #endif
748 }
749
750 /*
751 * Try to guess whether speeds are "encoded" (4.2BSD) or just numeric (4.4BSD).
752 */
753 #if B4800 != 4800
754 #define DECODE_BAUD
755 #endif
756
757 #ifdef DECODE_BAUD
758
759 /*
760 * A table of available terminal speeds
761 */
762 struct termspeeds {
763 int speed;
764 int value;
765 } termspeeds[] = {
766 { 0, B0 }, { 50, B50 }, { 75, B75 },
767 { 110, B110 }, { 134, B134 }, { 150, B150 },
768 { 200, B200 }, { 300, B300 }, { 600, B600 },
769 { 1200, B1200 }, { 1800, B1800 }, { 2400, B2400 },
770 { 4800, B4800 },
771 #ifdef B7200
772 { 7200, B7200 },
773 #endif
774 { 9600, B9600 },
775 #ifdef B14400
776 { 14400, B14400 },
777 #endif
778 #ifdef B19200
779 { 19200, B19200 },
780 #endif
781 #ifdef B28800
782 { 28800, B28800 },
783 #endif
784 #ifdef B38400
785 { 38400, B38400 },
786 #endif
787 #ifdef B57600
788 { 57600, B57600 },
789 #endif
790 #ifdef B115200
791 { 115200, B115200 },
792 #endif
793 #ifdef B230400
794 { 230400, B230400 },
795 #endif
796 { -1, 0 }
797 };
798 #endif /* DECODE_BAUD */
799
800 void
tty_tspeed(int val)801 tty_tspeed(int val)
802 {
803 #ifdef DECODE_BAUD
804 struct termspeeds *tp;
805
806 for (tp = termspeeds; (tp->speed != -1) && (val > tp->speed); tp++)
807 ;
808 if (tp->speed == -1) /* back up to last valid value */
809 --tp;
810 cfsetospeed(&termbuf, tp->value);
811 #else /* DECODE_BAUD */
812 cfsetospeed(&termbuf, val);
813 #endif /* DECODE_BAUD */
814 }
815
816 void
tty_rspeed(int val)817 tty_rspeed(int val)
818 {
819 #ifdef DECODE_BAUD
820 struct termspeeds *tp;
821
822 for (tp = termspeeds; (tp->speed != -1) && (val > tp->speed); tp++)
823 ;
824 if (tp->speed == -1) /* back up to last valid value */
825 --tp;
826 cfsetispeed(&termbuf, tp->value);
827 #else /* DECODE_BAUD */
828 cfsetispeed(&termbuf, val);
829 #endif /* DECODE_BAUD */
830 }
831
832 /*
833 * getptyslave()
834 *
835 * Open the slave side of the pty, and do any initialization
836 * that is necessary.
837 */
838 static void
getptyslave(void)839 getptyslave(void)
840 {
841 int t = -1;
842 char erase;
843
844 # ifdef LINEMODE
845 int waslm;
846 # endif
847 # ifdef TIOCGWINSZ
848 struct winsize ws;
849 extern int def_row, def_col;
850 # endif
851 extern int def_tspeed, def_rspeed;
852 /*
853 * Opening the slave side may cause initilization of the
854 * kernel tty structure. We need remember the state of
855 * if linemode was turned on
856 * terminal window size
857 * terminal speed
858 * erase character
859 * so that we can re-set them if we need to.
860 */
861 # ifdef LINEMODE
862 waslm = tty_linemode();
863 # endif
864 erase = termbuf.c_cc[VERASE];
865
866 /*
867 * Make sure that we don't have a controlling tty, and
868 * that we are the session (process group) leader.
869 */
870 # ifdef TIOCNOTTY
871 t = open(_PATH_TTY, O_RDWR);
872 if (t >= 0) {
873 (void) ioctl(t, TIOCNOTTY, NULL);
874 (void) close(t);
875 }
876 # endif
877
878 t = cleanopen(line);
879 if (t < 0)
880 fatalperror(net, line);
881
882
883 /*
884 * set up the tty modes as we like them to be.
885 */
886 init_termbuf();
887 # ifdef TIOCGWINSZ
888 if (def_row || def_col) {
889 memset((char *)&ws, 0, sizeof(ws));
890 ws.ws_col = def_col;
891 ws.ws_row = def_row;
892 (void)ioctl(t, TIOCSWINSZ, (char *)&ws);
893 }
894 # endif
895
896 /*
897 * Settings for sgtty based systems
898 */
899 # ifndef USE_TERMIO
900 termbuf.sg.sg_flags |= CRMOD|ANYP|ECHO|XTABS;
901 # endif /* USE_TERMIO */
902
903 /*
904 * Settings for all other termios/termio based
905 * systems, other than 4.4BSD. In 4.4BSD the
906 * kernel does the initial terminal setup.
907 */
908 tty_rspeed((def_rspeed > 0) ? def_rspeed : 9600);
909 tty_tspeed((def_tspeed > 0) ? def_tspeed : 9600);
910 if (erase)
911 termbuf.c_cc[VERASE] = erase;
912 # ifdef LINEMODE
913 if (waslm)
914 tty_setlinemode(1);
915 # endif /* LINEMODE */
916
917 /*
918 * Set the tty modes, and make this our controlling tty.
919 */
920 set_termbuf();
921 if (login_tty(t) == -1)
922 fatalperror(net, "login_tty");
923 if (net > 2)
924 (void) close(net);
925 #ifdef AUTHENTICATION
926 #if defined(NO_LOGIN_F) && defined(LOGIN_R)
927 /*
928 * Leave the pty open so that we can write out the rlogin
929 * protocol for /bin/login, if the authentication works.
930 */
931 #else
932 if (pty > 2) {
933 (void) close(pty);
934 pty = -1;
935 }
936 #endif
937 #endif /* AUTHENTICATION */
938 }
939
940 #ifndef O_NOCTTY
941 #define O_NOCTTY 0
942 #endif
943 /*
944 * Open the specified slave side of the pty,
945 * making sure that we have a clean tty.
946 */
947 int
cleanopen(char * li)948 cleanopen(char *li)
949 {
950 int t;
951
952 /*
953 * Make sure that other people can't open the
954 * slave side of the connection.
955 */
956 (void) chown(li, 0, 0);
957 (void) chmod(li, 0600);
958
959 (void) revoke(li);
960
961 t = open(line, O_RDWR|O_NOCTTY);
962
963 if (t < 0)
964 return(-1);
965
966 return(t);
967 }
968
969 /*
970 * startslave(host)
971 *
972 * Given a hostname, do whatever
973 * is necessary to startup the login process on the slave side of the pty.
974 */
975
976 /* ARGSUSED */
977 void
startslave(char * host,int autologin,char * autoname)978 startslave(char *host, int autologin, char *autoname)
979 {
980 int i;
981
982 #ifdef AUTHENTICATION
983 if (!autoname || !autoname[0])
984 autologin = 0;
985
986 if (autologin < auth_level) {
987 fatalmsg(net, "Authorization failed");
988 exit(1);
989 }
990 #endif
991
992
993 if ((i = fork()) < 0)
994 fatalperror(net, "fork");
995 if (i) {
996 } else {
997 getptyslave();
998 start_login(host, autologin, autoname);
999 /*NOTREACHED*/
1000 }
1001 }
1002
1003 void
init_env(void)1004 init_env(void)
1005 {
1006 char **envp;
1007
1008 envp = envinit;
1009 if ((*envp = getenv("TZ")))
1010 *envp++ -= 3;
1011 *envp = NULL;
1012 environ = envinit;
1013 }
1014
1015
1016 /*
1017 * start_login(host)
1018 *
1019 * Assuming that we are now running as a child processes, this
1020 * function will turn us into the login process.
1021 */
1022
1023 #ifndef AUTHENTICATION
1024 #define undef1 __unused
1025 #else
1026 #define undef1
1027 #endif
1028
1029 void
start_login(char * host undef1,int autologin undef1,char * name undef1)1030 start_login(char *host undef1, int autologin undef1, char *name undef1)
1031 {
1032 char **argv;
1033
1034 scrub_env();
1035
1036 /*
1037 * -h : pass on name of host.
1038 * WARNING: -h is accepted by login if and only if
1039 * getuid() == 0.
1040 * -p : don't clobber the environment (so terminal type stays set).
1041 *
1042 * -f : force this login, he has already been authenticated
1043 */
1044 argv = addarg(0, "login");
1045
1046 #if !defined(NO_LOGIN_H)
1047 #ifdef AUTHENTICATION
1048 # if defined(NO_LOGIN_F) && defined(LOGIN_R)
1049 /*
1050 * Don't add the "-h host" option if we are going
1051 * to be adding the "-r host" option down below...
1052 */
1053 if ((auth_level < 0) || (autologin != AUTH_VALID))
1054 # endif
1055 {
1056 argv = addarg(argv, "-h");
1057 argv = addarg(argv, host);
1058 }
1059 #endif /* AUTHENTICATION */
1060 #endif
1061 #if !defined(NO_LOGIN_P)
1062 argv = addarg(argv, "-p");
1063 #endif
1064 #ifdef LINEMODE
1065 /*
1066 * Set the environment variable "LINEMODE" to either
1067 * "real" or "kludge" if we are operating in either
1068 * real or kludge linemode.
1069 */
1070 if (lmodetype == REAL_LINEMODE) {
1071 if (setenv("LINEMODE", "real", 1) == -1)
1072 syslog(LOG_ERR, "setenv: cannot set LINEMODE=real: %m");
1073 }
1074 # ifdef KLUDGELINEMODE
1075 else if (lmodetype == KLUDGE_LINEMODE || lmodetype == KLUDGE_OK) {
1076 if (setenv("LINEMODE", "kludge", 1) == -1)
1077 syslog(LOG_ERR, "setenv: cannot set LINEMODE=kludge: %m");
1078 }
1079 # endif
1080 #endif
1081 #ifdef BFTPDAEMON
1082 /*
1083 * Are we working as the bftp daemon? If so, then ask login
1084 * to start bftp instead of shell.
1085 */
1086 if (bftpd) {
1087 argv = addarg(argv, "-e");
1088 argv = addarg(argv, BFTPPATH);
1089 } else
1090 #endif
1091 #ifdef AUTHENTICATION
1092 if (auth_level >= 0 && autologin == AUTH_VALID) {
1093 # if !defined(NO_LOGIN_F)
1094 argv = addarg(argv, "-f");
1095 argv = addarg(argv, "--");
1096 argv = addarg(argv, name);
1097 # else
1098 # if defined(LOGIN_R)
1099 /*
1100 * We don't have support for "login -f", but we
1101 * can fool /bin/login into thinking that we are
1102 * rlogind, and allow us to log in without a
1103 * password. The rlogin protocol expects
1104 * local-user\0remote-user\0term/speed\0
1105 */
1106
1107 if (pty > 2) {
1108 char *cp;
1109 char speed[128];
1110 int isecho, israw, xpty, len;
1111 extern int def_rspeed;
1112 # ifndef LOGIN_HOST
1113 /*
1114 * Tell login that we are coming from "localhost".
1115 * If we passed in the real host name, then the
1116 * user would have to allow .rhost access from
1117 * every machine that they want authenticated
1118 * access to work from, which sort of defeats
1119 * the purpose of an authenticated login...
1120 * So, we tell login that the session is coming
1121 * from "localhost", and the user will only have
1122 * to have "localhost" in their .rhost file.
1123 */
1124 # define LOGIN_HOST "localhost"
1125 # endif
1126 argv = addarg(argv, "-r");
1127 argv = addarg(argv, LOGIN_HOST);
1128
1129 xpty = pty;
1130 pty = 0;
1131 init_termbuf();
1132 isecho = tty_isecho();
1133 israw = tty_israw();
1134 if (isecho || !israw) {
1135 tty_setecho(0); /* Turn off echo */
1136 tty_setraw(1); /* Turn on raw */
1137 set_termbuf();
1138 }
1139 len = strlen(name)+1;
1140 write(xpty, name, len);
1141 write(xpty, name, len);
1142 snprintf(speed, sizeof(speed),
1143 "%s/%d", (cp = getenv("TERM")) ? cp : "",
1144 (def_rspeed > 0) ? def_rspeed : 9600);
1145 len = strlen(speed)+1;
1146 write(xpty, speed, len);
1147
1148 if (isecho || !israw) {
1149 init_termbuf();
1150 tty_setecho(isecho);
1151 tty_setraw(israw);
1152 set_termbuf();
1153 if (!israw) {
1154 /*
1155 * Write a newline to ensure
1156 * that login will be able to
1157 * read the line...
1158 */
1159 write(xpty, "\n", 1);
1160 }
1161 }
1162 pty = xpty;
1163 }
1164 # else
1165 argv = addarg(argv, "--");
1166 argv = addarg(argv, name);
1167 # endif
1168 # endif
1169 } else
1170 #endif
1171 if (getenv("USER")) {
1172 argv = addarg(argv, "--");
1173 argv = addarg(argv, getenv("USER"));
1174 #if defined(LOGIN_ARGS) && defined(NO_LOGIN_P)
1175 {
1176 char **cpp;
1177 for (cpp = environ; *cpp; cpp++)
1178 argv = addarg(argv, *cpp);
1179 }
1180 #endif
1181 /*
1182 * Assume that login will set the USER variable
1183 * correctly. For SysV systems, this means that
1184 * USER will no longer be set, just LOGNAME by
1185 * login. (The problem is that if the auto-login
1186 * fails, and the user then specifies a different
1187 * account name, he can get logged in with both
1188 * LOGNAME and USER in his environment, but the
1189 * USER value will be wrong.
1190 */
1191 unsetenv("USER");
1192 }
1193 #ifdef AUTHENTICATION
1194 #if defined(NO_LOGIN_F) && defined(LOGIN_R)
1195 if (pty > 2)
1196 close(pty);
1197 #endif
1198 #endif /* AUTHENTICATION */
1199 closelog();
1200
1201 if (altlogin == NULL) {
1202 altlogin = _PATH_LOGIN;
1203 }
1204 execv(altlogin, argv);
1205
1206 syslog(LOG_ERR, "%s: %m", altlogin);
1207 fatalperror(net, altlogin);
1208 /*NOTREACHED*/
1209 }
1210
1211 static char **
addarg(char ** argv,const char * val)1212 addarg(char **argv, const char *val)
1213 {
1214 char **cpp;
1215
1216 if (argv == NULL) {
1217 /*
1218 * 10 entries, a leading length, and a null
1219 */
1220 argv = (char **)malloc(sizeof(*argv) * 12);
1221 if (argv == NULL)
1222 return(NULL);
1223 *argv++ = (char *)10;
1224 *argv = NULL;
1225 }
1226 for (cpp = argv; *cpp; cpp++)
1227 ;
1228 if (cpp == &argv[(long)argv[-1]]) {
1229 --argv;
1230 *argv = (char *)((long)(*argv) + 10);
1231 argv = (char **)realloc(argv, sizeof(*argv)*((long)(*argv) + 2));
1232 if (argv == NULL)
1233 return(NULL);
1234 argv++;
1235 cpp = &argv[(long)argv[-1] - 10];
1236 }
1237 *cpp++ = strdup(val);
1238 *cpp = NULL;
1239 return(argv);
1240 }
1241
1242 /*
1243 * scrub_env()
1244 *
1245 * We only accept the environment variables listed below.
1246 */
1247 void
scrub_env(void)1248 scrub_env(void)
1249 {
1250 static const char *rej[] = {
1251 "TERMCAP=/",
1252 NULL
1253 };
1254
1255 static const char *acc[] = {
1256 "XAUTH=", "XAUTHORITY=", "DISPLAY=",
1257 "TERM=",
1258 "EDITOR=",
1259 "PAGER=",
1260 "LOGNAME=",
1261 "POSIXLY_CORRECT=",
1262 "PRINTER=",
1263 NULL
1264 };
1265
1266 char **cpp, **cpp2;
1267 const char **p;
1268 char ** new_environ;
1269 size_t count;
1270
1271 /* Allocate space for scrubbed environment. */
1272 for (count = 1, cpp = environ; *cpp; count++, cpp++)
1273 continue;
1274 if ((new_environ = malloc(count * sizeof(char *))) == NULL) {
1275 environ = NULL;
1276 return;
1277 }
1278
1279 for (cpp2 = new_environ, cpp = environ; *cpp; cpp++) {
1280 int reject_it = 0;
1281
1282 for(p = rej; *p; p++)
1283 if(strncmp(*cpp, *p, strlen(*p)) == 0) {
1284 reject_it = 1;
1285 break;
1286 }
1287 if (reject_it)
1288 continue;
1289
1290 for(p = acc; *p; p++)
1291 if(strncmp(*cpp, *p, strlen(*p)) == 0)
1292 break;
1293 if(*p != NULL) {
1294 if ((*cpp2++ = strdup(*cpp)) == NULL) {
1295 environ = new_environ;
1296 return;
1297 }
1298 }
1299 }
1300 *cpp2 = NULL;
1301 environ = new_environ;
1302 }
1303
1304 /*
1305 * cleanup()
1306 *
1307 * This is the routine to call when we are all through, to
1308 * clean up anything that needs to be cleaned up.
1309 */
1310 /* ARGSUSED */
1311 void
cleanup(int sig __unused)1312 cleanup(int sig __unused)
1313 {
1314 char *p;
1315 sigset_t mask;
1316
1317 p = line + sizeof(_PATH_DEV) - 1;
1318 /*
1319 * Block all signals before clearing the utmpx entry. We don't want to
1320 * be called again after calling logout() and then not add the wtmpx
1321 * entry because of not finding the corresponding entry in utmpx.
1322 */
1323 sigfillset(&mask);
1324 sigprocmask(SIG_SETMASK, &mask, NULL);
1325 if (logoutx(p, 0, DEAD_PROCESS))
1326 logwtmpx(p, "", "", 0, DEAD_PROCESS);
1327 (void)chmod(line, 0666);
1328 (void)chown(line, 0, 0);
1329 *p = 'p';
1330 (void)chmod(line, 0666);
1331 (void)chown(line, 0, 0);
1332 (void) shutdown(net, SHUT_RDWR);
1333 _exit(1);
1334 }
1335