1 /* $NetBSD: sys_term.c,v 1.51 2025/06/27 21:36:23 andvar Exp $ */ 2 3 /* 4 * Copyright (c) 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 #if 0 35 static char sccsid[] = "@(#)sys_term.c 8.4+1 (Berkeley) 5/30/95"; 36 #else 37 __RCSID("$NetBSD: sys_term.c,v 1.51 2025/06/27 21:36:23 andvar Exp $"); 38 #endif 39 #endif /* not lint */ 40 41 #include "telnetd.h" 42 #include "pathnames.h" 43 44 #include <util.h> 45 #include <vis.h> 46 47 #ifdef SUPPORT_UTMP 48 #include <utmp.h> 49 #endif 50 #ifdef SUPPORT_UTMPX 51 #include <utmpx.h> 52 #endif 53 54 struct termios termbuf, termbuf2; /* pty control structure */ 55 56 void getptyslave(void); 57 int cleanopen(char *); 58 char **addarg(char **, const char *); 59 void scrub_env(void); 60 int getent(char *, char *); 61 char *getstr(const char *, char **); 62 #ifdef KRB5 63 extern void kerberos5_cleanup(void); 64 #endif 65 66 /* 67 * init_termbuf() 68 * copy_termbuf(cp) 69 * set_termbuf() 70 * 71 * These three routines are used to get and set the "termbuf" structure 72 * to and from the kernel. init_termbuf() gets the current settings. 73 * copy_termbuf() hands in a new "termbuf" to write to the kernel, and 74 * set_termbuf() writes the structure into the kernel. 75 */ 76 77 void 78 init_termbuf(void) 79 { 80 (void) tcgetattr(pty, &termbuf); 81 termbuf2 = termbuf; 82 } 83 84 #if defined(LINEMODE) && defined(TIOCPKT_IOCTL) 85 void 86 copy_termbuf(char *cp, int len) 87 { 88 if ((size_t)len > sizeof(termbuf)) 89 len = sizeof(termbuf); 90 memmove((char *)&termbuf, cp, len); 91 termbuf2 = termbuf; 92 } 93 #endif /* defined(LINEMODE) && defined(TIOCPKT_IOCTL) */ 94 95 void 96 set_termbuf(void) 97 { 98 /* 99 * Only make the necessary changes. 100 */ 101 if (memcmp((char *)&termbuf, (char *)&termbuf2, sizeof(termbuf))) 102 (void) tcsetattr(pty, TCSANOW, &termbuf); 103 } 104 105 106 /* 107 * spcset(func, valp, valpp) 108 * 109 * This function takes various special characters (func), and 110 * sets *valp to the current value of that character, and 111 * *valpp to point to where in the "termbuf" structure that 112 * value is kept. 113 * 114 * It returns the SLC_ level of support for this function. 115 */ 116 117 118 int 119 spcset(int func, cc_t *valp, cc_t **valpp) 120 { 121 122 #define setval(a, b) *valp = termbuf.c_cc[a]; \ 123 *valpp = &termbuf.c_cc[a]; \ 124 return(b); 125 #define defval(a) *valp = ((cc_t)a); *valpp = (cc_t *)0; return(SLC_DEFAULT); 126 127 switch(func) { 128 case SLC_EOF: 129 setval(VEOF, SLC_VARIABLE); 130 case SLC_EC: 131 setval(VERASE, SLC_VARIABLE); 132 case SLC_EL: 133 setval(VKILL, SLC_VARIABLE); 134 case SLC_IP: 135 setval(VINTR, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT); 136 case SLC_ABORT: 137 setval(VQUIT, SLC_VARIABLE|SLC_FLUSHIN|SLC_FLUSHOUT); 138 case SLC_XON: 139 setval(VSTART, SLC_VARIABLE); 140 case SLC_XOFF: 141 setval(VSTOP, SLC_VARIABLE); 142 case SLC_EW: 143 setval(VWERASE, SLC_VARIABLE); 144 case SLC_RP: 145 setval(VREPRINT, SLC_VARIABLE); 146 case SLC_LNEXT: 147 setval(VLNEXT, SLC_VARIABLE); 148 case SLC_AO: 149 setval(VDISCARD, SLC_VARIABLE|SLC_FLUSHOUT); 150 case SLC_SUSP: 151 setval(VSUSP, SLC_VARIABLE|SLC_FLUSHIN); 152 case SLC_FORW1: 153 setval(VEOL, SLC_VARIABLE); 154 case SLC_FORW2: 155 setval(VEOL2, SLC_VARIABLE); 156 case SLC_AYT: 157 setval(VSTATUS, SLC_VARIABLE); 158 159 case SLC_BRK: 160 case SLC_SYNCH: 161 case SLC_EOR: 162 defval(0); 163 164 default: 165 *valp = 0; 166 *valpp = 0; 167 return(SLC_NOSUPPORT); 168 } 169 } 170 171 172 /* 173 * getpty() 174 * 175 * Allocate a pty. As a side effect, the external character 176 * array "line" contains the name of the slave side. 177 * 178 * Returns the file descriptor of the opened pty. 179 */ 180 181 static int ptyslavefd; /* for cleanopen() */ 182 183 int 184 getpty(int *ptynum) 185 { 186 int ptyfd; 187 188 ptyfd = openpty(ptynum, &ptyslavefd, line, NULL, NULL); 189 if (ptyfd == 0) 190 return *ptynum; 191 ptyslavefd = -1; 192 return (-1); 193 } 194 195 #ifdef LINEMODE 196 /* 197 * tty_flowmode() Find out if flow control is enabled or disabled. 198 * tty_linemode() Find out if linemode (external processing) is enabled. 199 * tty_setlinemod(on) Turn on/off linemode. 200 * tty_isecho() Find out if echoing is turned on. 201 * tty_setecho(on) Enable/disable character echoing. 202 * tty_israw() Find out if terminal is in RAW mode. 203 * tty_binaryin(on) Turn on/off BINARY on input. 204 * tty_binaryout(on) Turn on/off BINARY on output. 205 * tty_isediting() Find out if line editing is enabled. 206 * tty_istrapsig() Find out if signal trapping is enabled. 207 * tty_setedit(on) Turn on/off line editing. 208 * tty_setsig(on) Turn on/off signal trapping. 209 * tty_issofttab() Find out if tab expansion is enabled. 210 * tty_setsofttab(on) Turn on/off soft tab expansion. 211 * tty_islitecho() Find out if typed control chars are echoed literally 212 * tty_setlitecho() Turn on/off literal echo of control chars 213 * tty_tspeed(val) Set transmit speed to val. 214 * tty_rspeed(val) Set receive speed to val. 215 */ 216 217 218 int 219 tty_linemode(void) 220 { 221 return(termbuf.c_lflag & EXTPROC); 222 } 223 224 void 225 tty_setlinemode(int on) 226 { 227 set_termbuf(); 228 (void) ioctl(pty, TIOCEXT, (char *)&on); 229 init_termbuf(); 230 } 231 #endif /* LINEMODE */ 232 233 int 234 tty_isecho(void) 235 { 236 return (termbuf.c_lflag & ECHO); 237 } 238 239 int 240 tty_flowmode(void) 241 { 242 return((termbuf.c_iflag & IXON) ? 1 : 0); 243 } 244 245 int 246 tty_restartany(void) 247 { 248 return((termbuf.c_iflag & IXANY) ? 1 : 0); 249 } 250 251 void 252 tty_setecho(int on) 253 { 254 if (on) 255 termbuf.c_lflag |= ECHO; 256 else 257 termbuf.c_lflag &= ~ECHO; 258 } 259 260 int 261 tty_israw(void) 262 { 263 return(!(termbuf.c_lflag & ICANON)); 264 } 265 266 void 267 tty_binaryin(int on) 268 { 269 if (on) { 270 termbuf.c_iflag &= ~ISTRIP; 271 } else { 272 termbuf.c_iflag |= ISTRIP; 273 } 274 } 275 276 void 277 tty_binaryout(int on) 278 { 279 if (on) { 280 termbuf.c_cflag &= ~(CSIZE|PARENB); 281 termbuf.c_cflag |= CS8; 282 termbuf.c_oflag &= ~OPOST; 283 } else { 284 termbuf.c_cflag &= ~CSIZE; 285 termbuf.c_cflag |= CS7|PARENB; 286 termbuf.c_oflag |= OPOST; 287 } 288 } 289 290 int 291 tty_isbinaryin(void) 292 { 293 return(!(termbuf.c_iflag & ISTRIP)); 294 } 295 296 int 297 tty_isbinaryout(void) 298 { 299 return(!(termbuf.c_oflag&OPOST)); 300 } 301 302 #ifdef LINEMODE 303 int 304 tty_isediting(void) 305 { 306 return(termbuf.c_lflag & ICANON); 307 } 308 309 int 310 tty_istrapsig(void) 311 { 312 return(termbuf.c_lflag & ISIG); 313 } 314 315 void 316 tty_setedit(int on) 317 { 318 if (on) 319 termbuf.c_lflag |= ICANON; 320 else 321 termbuf.c_lflag &= ~ICANON; 322 } 323 324 void 325 tty_setsig(int on) 326 { 327 if (on) 328 termbuf.c_lflag |= ISIG; 329 else 330 termbuf.c_lflag &= ~ISIG; 331 } 332 #endif /* LINEMODE */ 333 334 int 335 tty_issofttab(void) 336 { 337 # ifdef OXTABS 338 return (termbuf.c_oflag & OXTABS); 339 # endif 340 # ifdef TABDLY 341 return ((termbuf.c_oflag & TABDLY) == TAB3); 342 # endif 343 } 344 345 void 346 tty_setsofttab(int on) 347 { 348 if (on) { 349 # ifdef OXTABS 350 termbuf.c_oflag |= OXTABS; 351 # endif 352 # ifdef TABDLY 353 termbuf.c_oflag &= ~TABDLY; 354 termbuf.c_oflag |= TAB3; 355 # endif 356 } else { 357 # ifdef OXTABS 358 termbuf.c_oflag &= ~OXTABS; 359 # endif 360 # ifdef TABDLY 361 termbuf.c_oflag &= ~TABDLY; 362 termbuf.c_oflag |= TAB0; 363 # endif 364 } 365 } 366 367 int 368 tty_islitecho(void) 369 { 370 # ifdef ECHOCTL 371 return (!(termbuf.c_lflag & ECHOCTL)); 372 # endif 373 # ifdef TCTLECH 374 return (!(termbuf.c_lflag & TCTLECH)); 375 # endif 376 # if !defined(ECHOCTL) && !defined(TCTLECH) 377 return (0); /* assumes ctl chars are echoed '^x' */ 378 # endif 379 } 380 381 void 382 tty_setlitecho(int on) 383 { 384 # ifdef ECHOCTL 385 if (on) 386 termbuf.c_lflag &= ~ECHOCTL; 387 else 388 termbuf.c_lflag |= ECHOCTL; 389 # endif 390 # ifdef TCTLECH 391 if (on) 392 termbuf.c_lflag &= ~TCTLECH; 393 else 394 termbuf.c_lflag |= TCTLECH; 395 # endif 396 } 397 398 int 399 tty_iscrnl(void) 400 { 401 return (termbuf.c_iflag & ICRNL); 402 } 403 404 void 405 tty_tspeed(int val) 406 { 407 cfsetospeed(&termbuf, val); 408 } 409 410 void 411 tty_rspeed(int val) 412 { 413 cfsetispeed(&termbuf, val); 414 } 415 416 417 418 419 /* 420 * getptyslave() 421 * 422 * Open the slave side of the pty, and do any initialization 423 * that is necessary. The return value is a file descriptor 424 * for the slave side. 425 */ 426 extern int def_tspeed, def_rspeed; 427 extern int def_row, def_col; 428 429 void 430 getptyslave(void) 431 { 432 int t = -1; 433 434 #ifdef LINEMODE 435 int waslm; 436 #endif 437 struct winsize ws; 438 /* 439 * Opening the slave side may cause initialization of the 440 * kernel tty structure. We need remember the state of 441 * if linemode was turned on 442 * terminal window size 443 * terminal speed 444 * so that we can re-set them if we need to. 445 */ 446 #ifdef LINEMODE 447 waslm = tty_linemode(); 448 #endif 449 450 /* 451 * Make sure that we don't have a controlling tty, and 452 * that we are the session (process group) leader. 453 */ 454 t = open(_PATH_TTY, O_RDWR); 455 if (t >= 0) { 456 (void) ioctl(t, TIOCNOTTY, (char *)0); 457 (void) close(t); 458 } 459 460 461 462 t = cleanopen(line); 463 if (t < 0) 464 fatalperror(net, line); 465 466 467 /* 468 * set up the tty modes as we like them to be. 469 */ 470 init_termbuf(); 471 if (def_row || def_col) { 472 memset((char *)&ws, 0, sizeof(ws)); 473 ws.ws_col = def_col; 474 ws.ws_row = def_row; 475 (void)ioctl(t, TIOCSWINSZ, (char *)&ws); 476 } 477 478 /* 479 * Settings for sgtty based systems 480 */ 481 482 /* 483 * Settings for all other termios/termio based 484 * systems, other than 4.4BSD. In 4.4BSD the 485 * kernel does the initial terminal setup. 486 */ 487 tty_rspeed((def_rspeed > 0) ? def_rspeed : 9600); 488 tty_tspeed((def_tspeed > 0) ? def_tspeed : 9600); 489 #ifdef LINEMODE 490 if (waslm) 491 tty_setlinemode(1); 492 #endif /* LINEMODE */ 493 494 /* 495 * Set the tty modes, and make this our controlling tty. 496 */ 497 set_termbuf(); 498 if (login_tty(t) == -1) 499 fatalperror(net, "login_tty"); 500 if (net > 2) 501 (void) close(net); 502 if (pty > 2) { 503 (void) close(pty); 504 pty = -1; 505 } 506 } 507 508 /* 509 * Open the specified slave side of the pty, 510 * making sure that we have a clean tty. 511 */ 512 int 513 cleanopen(char *ttyline) 514 { 515 return ptyslavefd; 516 } 517 518 /* 519 * startslave(host) 520 * 521 * Given a hostname, do whatever 522 * is necessary to startup the login process on the slave side of the pty. 523 */ 524 525 /* ARGSUSED */ 526 void 527 startslave(char *host, int autologin, char *autoname) 528 { 529 int i; 530 531 #ifdef AUTHENTICATION 532 if (!autoname || !autoname[0]) 533 autologin = 0; 534 535 if (autologin < auth_level) { 536 fatal(net, "Authorization failed"); 537 exit(1); 538 } 539 #endif 540 541 542 if ((i = fork()) < 0) 543 fatalperror(net, "fork"); 544 if (i) { 545 } else { 546 getptyslave(); 547 start_login(host, autologin, autoname); 548 /*NOTREACHED*/ 549 } 550 } 551 552 char *envinit[3]; 553 554 void 555 init_env(void) 556 { 557 char **envp; 558 559 envp = envinit; 560 if ((*envp = getenv("TZ"))) 561 *envp++ -= 3; 562 *envp = 0; 563 environ = envinit; 564 } 565 566 567 /* 568 * start_login(host) 569 * 570 * Assuming that we are now running as a child processes, this 571 * function will turn us into the login process. 572 */ 573 extern char *gettyname; 574 575 void 576 start_login(char *host, int autologin, char *name) 577 { 578 char **argv; 579 #define TABBUFSIZ 512 580 char defent[TABBUFSIZ]; 581 char defstrs[TABBUFSIZ]; 582 #undef TABBUFSIZ 583 const char *loginprog = NULL; 584 extern struct sockaddr_storage from; 585 char buf[sizeof(from) * 4 + 1]; 586 char *user; 587 588 user = getenv("USER"); 589 user = (user != NULL) ? strdup(user) : NULL; 590 591 scrub_env(); 592 593 /* 594 * -a : pass on the address of the host. 595 * -h : pass on name of host. 596 * WARNING: -h and -a are accepted by login 597 * if and only if getuid() == 0. 598 * -p : don't clobber the environment (so terminal type stays set). 599 * 600 * -f : force this login, he has already been authenticated 601 */ 602 argv = addarg(0, "login"); 603 604 argv = addarg(argv, "-a"); 605 (void)strvisx(buf, (const char *)(const void *)&from, sizeof(from), 606 VIS_WHITE); 607 argv = addarg(argv, buf); 608 609 argv = addarg(argv, "-h"); 610 argv = addarg(argv, host); 611 612 argv = addarg(argv, "-p"); 613 #ifdef LINEMODE 614 /* 615 * Set the environment variable "LINEMODE" to either 616 * "real" or "kludge" if we are operating in either 617 * real or kludge linemode. 618 */ 619 if (lmodetype == REAL_LINEMODE) 620 setenv("LINEMODE", "real", 1); 621 # ifdef KLUDGELINEMODE 622 else if (lmodetype == KLUDGE_LINEMODE || lmodetype == KLUDGE_OK) 623 setenv("LINEMODE", "kludge", 1); 624 # endif 625 #endif 626 #ifdef SECURELOGIN 627 /* 628 * don't worry about the -f that might get sent. 629 * A -s is supposed to override it anyhow. 630 */ 631 if (require_secure_login) 632 argv = addarg(argv, "-s"); 633 #endif 634 #ifdef AUTHENTICATION 635 if (auth_level >= 0 && autologin == AUTH_VALID) { 636 argv = addarg(argv, "-f"); 637 argv = addarg(argv, "--"); 638 argv = addarg(argv, name); 639 } else 640 #endif 641 if (user != NULL) { 642 argv = addarg(argv, "--"); 643 argv = addarg(argv, user); 644 /* 645 * Assume that login will set the USER variable 646 * correctly. For SysV systems, this means that 647 * USER will no longer be set, just LOGNAME by 648 * login. (The problem is that if the auto-login 649 * fails, and the user then specifies a different 650 * account name, he can get logged in with both 651 * LOGNAME and USER in his environment, but the 652 * USER value will be wrong. 653 */ 654 unsetenv("USER"); 655 } 656 if (getent(defent, gettyname) == 1) { 657 char *cp = defstrs; 658 659 loginprog = getstr("lo", &cp); 660 } 661 if (loginprog == NULL) 662 loginprog = _PATH_LOGIN; 663 closelog(); 664 /* 665 * This sleep(1) is in here so that telnetd can 666 * finish up with the tty. There's a race condition 667 * the login banner message gets lost... 668 */ 669 sleep(1); 670 execv(loginprog, argv); 671 672 syslog(LOG_ERR, "%s: %m", loginprog); 673 fatalperror(net, loginprog); 674 /*NOTREACHED*/ 675 } 676 677 char ** 678 addarg(char **argv, const char *val) 679 { 680 char **cpp; 681 char **nargv; 682 683 if (argv == NULL) { 684 /* 685 * 10 entries, a leading length, and a null 686 */ 687 argv = malloc(sizeof(*argv) * 12); 688 if (argv == NULL) 689 return(NULL); 690 *argv++ = (char *)10; 691 *argv = (char *)0; 692 } 693 for (cpp = argv; *cpp; cpp++) 694 ; 695 if (cpp == &argv[(long)argv[-1]]) { 696 --argv; 697 nargv = realloc(argv, sizeof(*argv) * ((long)(*argv) + 10 + 2)); 698 if (nargv == NULL) { 699 fatal(net, "not enough memory"); 700 /*NOTREACHED*/ 701 } 702 argv = nargv; 703 *argv = (char *)((long)(*argv) + 10); 704 argv++; 705 cpp = &argv[(long)argv[-1] - 10]; 706 } 707 *cpp++ = __UNCONST(val); 708 *cpp = 0; 709 return(argv); 710 } 711 712 /* 713 * scrub_env() 714 * 715 * We only accept the environment variables listed below. 716 */ 717 718 void 719 scrub_env(void) 720 { 721 static const char *reject[] = { 722 "TERMCAP=/", 723 NULL 724 }; 725 726 static const char *acceptstr[] = { 727 "XAUTH=", "XAUTHORITY=", "DISPLAY=", 728 "TERM=", 729 "EDITOR=", 730 "PAGER=", 731 "LOGNAME=", 732 "POSIXLY_CORRECT=", 733 "TERMCAP=", 734 "PRINTER=", 735 NULL 736 }; 737 738 char **cpp, **cpp2; 739 const char **p; 740 741 for (cpp2 = cpp = environ; *cpp; cpp++) { 742 int reject_it = 0; 743 744 for(p = reject; *p; p++) 745 if(strncmp(*cpp, *p, strlen(*p)) == 0) { 746 reject_it = 1; 747 break; 748 } 749 if (reject_it) 750 continue; 751 752 for(p = acceptstr; *p; p++) 753 if(strncmp(*cpp, *p, strlen(*p)) == 0) 754 break; 755 if(*p != NULL) 756 *cpp2++ = *cpp; 757 } 758 *cpp2 = NULL; 759 } 760 761 /* 762 * cleanup() 763 * 764 * This is the routine to call when we are all through, to 765 * clean up anything that needs to be cleaned up. 766 */ 767 /* ARGSUSED */ 768 void 769 cleanup(int sig) 770 { 771 char *p, c; 772 773 p = line + sizeof(_PATH_DEV) - 1; 774 #ifdef SUPPORT_UTMP 775 if (logout(p)) 776 logwtmp(p, "", ""); 777 #endif 778 #ifdef SUPPORT_UTMPX 779 if (logoutx(p, 0, DEAD_PROCESS)) 780 logwtmpx(p, "", "", 0, DEAD_PROCESS); 781 #endif 782 (void)chmod(line, 0666); 783 (void)chown(line, 0, 0); 784 c = *p; *p = 'p'; 785 (void)chmod(line, 0666); 786 (void)chown(line, 0, 0); 787 *p = c; 788 if (ttyaction(line, "telnetd", "root")) 789 syslog(LOG_ERR, "%s: ttyaction failed", line); 790 (void) shutdown(net, 2); 791 exit(1); 792 } 793
Indexes created Sun Sep 21 14:09:52 GMT 2025