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