1 /* $NetBSD: main.c,v 1.36 2001/01/10 00:36:44 lukem Exp $ */ 2 3 /*- 4 * Copyright (c) 1980, 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. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #include <sys/cdefs.h> 37 38 #ifndef lint 39 __COPYRIGHT("@(#) Copyright (c) 1980, 1993\n\ 40 The Regents of the University of California. All rights reserved.\n"); 41 #endif /* not lint */ 42 43 #ifndef lint 44 #if 0 45 static char sccsid[] = "from: @(#)main.c 8.1 (Berkeley) 6/20/93"; 46 #else 47 __RCSID("$NetBSD: main.c,v 1.36 2001/01/10 00:36:44 lukem Exp $"); 48 #endif 49 #endif /* not lint */ 50 51 #include <sys/param.h> 52 #include <sys/stat.h> 53 #include <termios.h> 54 #include <sys/ioctl.h> 55 #include <sys/resource.h> 56 #include <sys/utsname.h> 57 58 #include <errno.h> 59 #include <fcntl.h> 60 #include <time.h> 61 #include <ctype.h> 62 #include <fcntl.h> 63 #include <pwd.h> 64 #include <setjmp.h> 65 #include <signal.h> 66 #include <stdlib.h> 67 #include <string.h> 68 #include <syslog.h> 69 #include <time.h> 70 #include <unistd.h> 71 #include <util.h> 72 #include <limits.h> 73 #include <ttyent.h> 74 #include <termcap.h> 75 76 #include "gettytab.h" 77 #include "pathnames.h" 78 #include "extern.h" 79 80 extern char *__progname; 81 82 /* 83 * Set the amount of running time that getty should accumulate 84 * before deciding that something is wrong and exit. 85 */ 86 #define GETTY_TIMEOUT 60 /* seconds */ 87 88 /* defines for auto detection of incoming PPP calls (->PAP/CHAP) */ 89 90 #define PPP_FRAME 0x7e /* PPP Framing character */ 91 #define PPP_STATION 0xff /* "All Station" character */ 92 #define PPP_ESCAPE 0x7d /* Escape Character */ 93 #define PPP_CONTROL 0x03 /* PPP Control Field */ 94 #define PPP_CONTROL_ESCAPED 0x23 /* PPP Control Field, escaped */ 95 #define PPP_LCP_HI 0xc0 /* LCP protocol - high byte */ 96 #define PPP_LCP_LOW 0x21 /* LCP protocol - low byte */ 97 98 struct termios tmode, omode; 99 100 int crmod, digit, lower, upper; 101 102 char hostname[MAXHOSTNAMELEN + 1]; 103 struct utsname kerninfo; 104 char name[LOGIN_NAME_MAX]; 105 char dev[] = _PATH_DEV; 106 char ttyn[32]; 107 char lockfile[512]; 108 uid_t ttyowner; 109 char *rawttyn; 110 111 #define OBUFSIZ 128 112 #define TABBUFSIZ 512 113 114 char defent[TABBUFSIZ]; 115 char tabent[TABBUFSIZ]; 116 117 char *env[128]; 118 119 char partab[] = { 120 0001,0201,0201,0001,0201,0001,0001,0201, 121 0202,0004,0003,0205,0005,0206,0201,0001, 122 0201,0001,0001,0201,0001,0201,0201,0001, 123 0001,0201,0201,0001,0201,0001,0001,0201, 124 0200,0000,0000,0200,0000,0200,0200,0000, 125 0000,0200,0200,0000,0200,0000,0000,0200, 126 0000,0200,0200,0000,0200,0000,0000,0200, 127 0200,0000,0000,0200,0000,0200,0200,0000, 128 0200,0000,0000,0200,0000,0200,0200,0000, 129 0000,0200,0200,0000,0200,0000,0000,0200, 130 0000,0200,0200,0000,0200,0000,0000,0200, 131 0200,0000,0000,0200,0000,0200,0200,0000, 132 0000,0200,0200,0000,0200,0000,0000,0200, 133 0200,0000,0000,0200,0000,0200,0200,0000, 134 0200,0000,0000,0200,0000,0200,0200,0000, 135 0000,0200,0200,0000,0200,0000,0000,0201 136 }; 137 138 #define ERASE tmode.c_cc[VERASE] 139 #define KILL tmode.c_cc[VKILL] 140 #define EOT tmode.c_cc[VEOF] 141 142 static void dingdong __P((int)); 143 static void interrupt __P((int)); 144 static void clearscreen __P((void)); 145 void timeoverrun __P((int)); 146 147 jmp_buf timeout; 148 149 static void 150 dingdong(signo) 151 int signo; 152 { 153 154 alarm(0); 155 signal(SIGALRM, SIG_DFL); 156 longjmp(timeout, 1); 157 } 158 159 jmp_buf intrupt; 160 161 static void 162 interrupt(signo) 163 int signo; 164 { 165 166 signal(SIGINT, interrupt); 167 longjmp(intrupt, 1); 168 } 169 170 /* 171 * Action to take when getty is running too long. 172 */ 173 void 174 timeoverrun(signo) 175 int signo; 176 { 177 178 syslog(LOG_ERR, "getty exiting due to excessive running time"); 179 exit(1); 180 } 181 182 int main __P((int, char **)); 183 static int getname __P((void)); 184 static void oflush __P((void)); 185 static void prompt __P((void)); 186 static void putchr __P((int)); 187 static void putf __P((const char *)); 188 static void putpad __P((const char *)); 189 static void xputs __P((const char *)); 190 191 int 192 main(argc, argv) 193 int argc; 194 char *argv[]; 195 { 196 extern char **environ; 197 char *tname; 198 int repcnt = 0, failopenlogged = 0, uugetty = 0, first_time = 1; 199 struct rlimit limit; 200 struct passwd *pw; 201 int rval; 202 203 #ifdef __GNUC__ 204 (void)&tname; /* XXX gcc -Wall */ 205 #endif 206 207 signal(SIGINT, SIG_IGN); 208 /* 209 signal(SIGQUIT, SIG_DFL); 210 */ 211 openlog("getty", LOG_PID, LOG_AUTH); 212 gethostname(hostname, sizeof(hostname)); 213 hostname[sizeof(hostname) - 1] = '\0'; 214 if (hostname[0] == '\0') 215 strcpy(hostname, "Amnesiac"); 216 uname(&kerninfo); 217 218 if (__progname[0] == 'u' && __progname[1] == 'u') 219 uugetty = 1; 220 221 /* 222 * Find id of uucp login (if present) so we can chown tty properly. 223 */ 224 if (uugetty && (pw = getpwnam("uucp"))) 225 ttyowner = pw->pw_uid; 226 else 227 ttyowner = 0; 228 229 /* 230 * Limit running time to deal with broken or dead lines. 231 */ 232 (void)signal(SIGXCPU, timeoverrun); 233 limit.rlim_max = RLIM_INFINITY; 234 limit.rlim_cur = GETTY_TIMEOUT; 235 (void)setrlimit(RLIMIT_CPU, &limit); 236 237 /* 238 * The following is a work around for vhangup interactions 239 * which cause great problems getting window systems started. 240 * If the tty line is "-", we do the old style getty presuming 241 * that the file descriptors are already set up for us. 242 * J. Gettys - MIT Project Athena. 243 */ 244 if (argc <= 2 || strcmp(argv[2], "-") == 0) { 245 strlcpy(ttyn, ttyname(0), sizeof(ttyn)); 246 } 247 else { 248 int i; 249 250 rawttyn = argv[2]; 251 strlcpy(ttyn, dev, sizeof(ttyn)); 252 strlcat(ttyn, argv[2], sizeof(ttyn)); 253 254 if (uugetty) { 255 chown(ttyn, ttyowner, 0); 256 strcpy(lockfile, _PATH_LOCK); 257 strlcat(lockfile, argv[2], sizeof(lockfile)); 258 /* wait for lockfiles to go away before we try to open */ 259 if ( pidlock(lockfile, 0, 0, 0) != 0 ) { 260 syslog(LOG_ERR, "%s: can't create lockfile", ttyn); 261 exit(1); 262 } 263 unlink(lockfile); 264 } 265 if (strcmp(argv[0], "+") != 0) { 266 chown(ttyn, ttyowner, 0); 267 chmod(ttyn, 0600); 268 revoke(ttyn); 269 if (ttyaction(ttyn, "getty", "root")) 270 syslog(LOG_WARNING, "%s: ttyaction failed", ttyn); 271 /* 272 * Delay the open so DTR stays down long enough to be detected. 273 */ 274 sleep(2); 275 while ((i = open(ttyn, O_RDWR)) == -1) { 276 if ((repcnt % 10 == 0) && 277 (errno != ENXIO || !failopenlogged)) { 278 syslog(LOG_WARNING, "%s: %m", ttyn); 279 closelog(); 280 failopenlogged = 1; 281 } 282 repcnt++; 283 sleep(60); 284 } 285 if (uugetty && pidlock(lockfile, 0, 0, 0) != 0) { 286 syslog(LOG_ERR, "%s: can't create lockfile", ttyn); 287 exit(1); 288 } 289 (void) chown(lockfile, ttyowner, 0); 290 login_tty(i); 291 } 292 } 293 294 /* Start with default tty settings */ 295 if (tcgetattr(0, &tmode) < 0) { 296 syslog(LOG_ERR, "%s: %m", ttyn); 297 exit(1); 298 } 299 omode = tmode; 300 301 gettable("default", defent); 302 gendefaults(); 303 tname = "default"; 304 if (argc > 1) 305 tname = argv[1]; 306 for (;;) { 307 int off; 308 309 gettable(tname, tabent); 310 if (OPset || EPset || APset) 311 APset++, OPset++, EPset++; 312 setdefaults(); 313 off = 0; 314 (void)tcflush(0, TCIOFLUSH); /* clear out the crap */ 315 ioctl(0, FIONBIO, &off); /* turn off non-blocking mode */ 316 ioctl(0, FIOASYNC, &off); /* ditto for async mode */ 317 318 if (IS) 319 cfsetispeed(&tmode, IS); 320 else if (SP) 321 cfsetispeed(&tmode, SP); 322 if (OS) 323 cfsetospeed(&tmode, OS); 324 else if (SP) 325 cfsetospeed(&tmode, SP); 326 setflags(0); 327 setchars(); 328 if (tcsetattr(0, TCSANOW, &tmode) < 0) { 329 syslog(LOG_ERR, "%s: %m", ttyn); 330 exit(1); 331 } 332 if (AB) { 333 tname = autobaud(); 334 continue; 335 } 336 if (PS) { 337 tname = portselector(); 338 continue; 339 } 340 if (CS) 341 clearscreen(); 342 if (CL && *CL) 343 putpad(CL); 344 edithost(HE); 345 346 /* 347 * If this is the first time through this, and an 348 * issue file has been given, then send it. 349 */ 350 if (first_time != 0 && IF != NULL) { 351 char buf[_POSIX2_LINE_MAX]; 352 FILE *fd; 353 354 if ((fd = fopen(IF, "r")) != NULL) { 355 while (fgets(buf, sizeof(buf) - 1, fd) != NULL) 356 putf(buf); 357 fclose(fd); 358 } 359 } 360 first_time = 0; 361 362 if (IM && *IM) 363 putf(IM); 364 oflush(); 365 if (setjmp(timeout)) { 366 tmode.c_ispeed = tmode.c_ospeed = 0; 367 (void)tcsetattr(0, TCSANOW, &tmode); 368 exit(1); 369 } 370 if (TO) { 371 signal(SIGALRM, dingdong); 372 alarm(TO); 373 } 374 if (AL) { 375 const char *p = AL; 376 char *q = name; 377 378 while (*p && q < &name[sizeof name - 1]) { 379 if (isupper(*p)) 380 upper = 1; 381 else if (islower(*p)) 382 lower = 1; 383 else if (isdigit(*p)) 384 digit++; 385 *q++ = *p++; 386 } 387 } else if ((rval = getname()) == 2) { 388 execle(PP, "ppplogin", ttyn, (char *) 0, env); 389 syslog(LOG_ERR, "%s: %m", PP); 390 exit(1); 391 } 392 393 if (rval || AL) { 394 int i; 395 396 oflush(); 397 alarm(0); 398 signal(SIGALRM, SIG_DFL); 399 if (name[0] == '-') { 400 xputs("user names may not start with '-'."); 401 continue; 402 } 403 if (!(upper || lower || digit)) 404 continue; 405 setflags(2); 406 if (crmod) { 407 tmode.c_iflag |= ICRNL; 408 tmode.c_oflag |= ONLCR; 409 } 410 #if XXX 411 if (upper || UC) 412 tmode.sg_flags |= LCASE; 413 if (lower || LC) 414 tmode.sg_flags &= ~LCASE; 415 #endif 416 if (tcsetattr(0, TCSANOW, &tmode) < 0) { 417 syslog(LOG_ERR, "%s: %m", ttyn); 418 exit(1); 419 } 420 signal(SIGINT, SIG_DFL); 421 for (i = 0; environ[i] != (char *)0; i++) 422 env[i] = environ[i]; 423 makeenv(&env[i]); 424 425 limit.rlim_max = RLIM_INFINITY; 426 limit.rlim_cur = RLIM_INFINITY; 427 (void)setrlimit(RLIMIT_CPU, &limit); 428 execle(LO, "login", AL ? "-fp" : "-p", "--", name, 429 (char *)0, env); 430 syslog(LOG_ERR, "%s: %m", LO); 431 exit(1); 432 } 433 alarm(0); 434 signal(SIGALRM, SIG_DFL); 435 signal(SIGINT, SIG_IGN); 436 if (NX && *NX) 437 tname = NX; 438 unlink(lockfile); 439 } 440 } 441 442 static int 443 getname() 444 { 445 int c; 446 char *np; 447 unsigned char cs; 448 int ppp_state, ppp_connection; 449 450 /* 451 * Interrupt may happen if we use CBREAK mode 452 */ 453 if (setjmp(intrupt)) { 454 signal(SIGINT, SIG_IGN); 455 return (0); 456 } 457 signal(SIGINT, interrupt); 458 setflags(1); 459 prompt(); 460 if (PF > 0) { 461 oflush(); 462 sleep(PF); 463 PF = 0; 464 } 465 if (tcsetattr(0, TCSANOW, &tmode) < 0) { 466 syslog(LOG_ERR, "%s: %m", ttyn); 467 exit(1); 468 } 469 crmod = digit = lower = upper = 0; 470 ppp_state = ppp_connection = 0; 471 np = name; 472 for (;;) { 473 oflush(); 474 if (read(STDIN_FILENO, &cs, 1) <= 0) 475 exit(0); 476 if ((c = cs&0177) == 0) 477 return (0); 478 479 /* 480 * PPP detection state machine.. 481 * Look for sequences: 482 * PPP_FRAME, PPP_STATION, PPP_ESCAPE, PPP_CONTROL_ESCAPED or 483 * PPP_FRAME, PPP_STATION, PPP_CONTROL (deviant from RFC) 484 * See RFC1662. 485 * Derived from code from Michael Hancock <michaelh@cet.co.jp> 486 * and Erik 'PPP' Olson <eriko@wrq.com> 487 */ 488 if (PP && cs == PPP_FRAME) { 489 ppp_state = 1; 490 } else if (ppp_state == 1 && cs == PPP_STATION) { 491 ppp_state = 2; 492 } else if (ppp_state == 2 && cs == PPP_ESCAPE) { 493 ppp_state = 3; 494 } else if ((ppp_state == 2 && cs == PPP_CONTROL) || 495 (ppp_state == 3 && cs == PPP_CONTROL_ESCAPED)) { 496 ppp_state = 4; 497 } else if (ppp_state == 4 && cs == PPP_LCP_HI) { 498 ppp_state = 5; 499 } else if (ppp_state == 5 && cs == PPP_LCP_LOW) { 500 ppp_connection = 1; 501 break; 502 } else { 503 ppp_state = 0; 504 } 505 506 if (c == EOT) 507 exit(1); 508 if (c == '\r' || c == '\n' || 509 np >= &name[LOGIN_NAME_MAX - 1]) { 510 *np = '\0'; 511 putf("\r\n"); 512 break; 513 } 514 if (islower(c)) 515 lower = 1; 516 else if (isupper(c)) 517 upper = 1; 518 else if (c == ERASE || c == '#' || c == '\b') { 519 if (np > name) { 520 np--; 521 if (cfgetospeed(&tmode) >= 1200) 522 xputs("\b \b"); 523 else 524 putchr(cs); 525 } 526 continue; 527 } else if (c == KILL || c == '@') { 528 putchr(cs); 529 putchr('\r'); 530 if (cfgetospeed(&tmode) < 1200) 531 putchr('\n'); 532 /* this is the way they do it down under ... */ 533 else if (np > name) 534 xputs( 535 " \r"); 536 prompt(); 537 np = name; 538 continue; 539 } else if (isdigit(c)) 540 digit++; 541 if (IG && (c <= ' ' || c > 0176)) 542 continue; 543 *np++ = c; 544 putchr(cs); 545 } 546 signal(SIGINT, SIG_IGN); 547 *np = 0; 548 if (c == '\r') 549 crmod = 1; 550 if ((upper && !lower && !LC) || UC) 551 for (np = name; *np; np++) 552 if (isupper(*np)) 553 *np = tolower(*np); 554 return (1 + ppp_connection); 555 } 556 557 static void 558 putpad(s) 559 const char *s; 560 { 561 int pad = 0; 562 speed_t ospeed = cfgetospeed(&tmode); 563 564 if (isdigit(*s)) { 565 while (isdigit(*s)) { 566 pad *= 10; 567 pad += *s++ - '0'; 568 } 569 pad *= 10; 570 if (*s == '.' && isdigit(s[1])) { 571 pad += s[1] - '0'; 572 s += 2; 573 } 574 } 575 576 xputs(s); 577 /* 578 * If no delay needed, or output speed is 579 * not comprehensible, then don't try to delay. 580 */ 581 if (pad == 0 || ospeed <= 0) 582 return; 583 584 /* 585 * Round up by a half a character frame, and then do the delay. 586 * Too bad there are no user program accessible programmed delays. 587 * Transmitting pad characters slows many terminals down and also 588 * loads the system. 589 */ 590 pad = (pad * ospeed + 50000) / 100000; 591 while (pad--) 592 putchr(*PC); 593 } 594 595 static void 596 xputs(s) 597 const char *s; 598 { 599 while (*s) 600 putchr(*s++); 601 } 602 603 char outbuf[OBUFSIZ]; 604 int obufcnt = 0; 605 606 static void 607 putchr(cc) 608 int cc; 609 { 610 char c; 611 612 c = cc; 613 if (!NP) { 614 c |= partab[c&0177] & 0200; 615 if (OP) 616 c ^= 0200; 617 } 618 if (!UB) { 619 outbuf[obufcnt++] = c; 620 if (obufcnt >= OBUFSIZ) 621 oflush(); 622 } else 623 write(STDOUT_FILENO, &c, 1); 624 } 625 626 static void 627 oflush() 628 { 629 if (obufcnt) 630 write(STDOUT_FILENO, outbuf, obufcnt); 631 obufcnt = 0; 632 } 633 634 static void 635 prompt() 636 { 637 638 putf(LM); 639 if (CO) 640 putchr('\n'); 641 } 642 643 static void 644 putf(cp) 645 const char *cp; 646 { 647 extern char editedhost[]; 648 time_t t; 649 char *slash, db[100]; 650 651 while (*cp) { 652 if (*cp != '%') { 653 putchr(*cp++); 654 continue; 655 } 656 switch (*++cp) { 657 658 case 't': 659 slash = strrchr(ttyn, '/'); 660 if (slash == NULL) 661 xputs(ttyn); 662 else 663 xputs(&slash[1]); 664 break; 665 666 case 'h': 667 xputs(editedhost); 668 break; 669 670 case 'd': 671 (void)time(&t); 672 (void)strftime(db, sizeof(db), 673 /* SCCS eats %M% */ 674 "%l:%M" "%p on %A, %d %B %Y", localtime(&t)); 675 xputs(db); 676 break; 677 678 case 's': 679 xputs(kerninfo.sysname); 680 break; 681 682 case 'm': 683 xputs(kerninfo.machine); 684 break; 685 686 case 'r': 687 xputs(kerninfo.release); 688 break; 689 690 case 'v': 691 xputs(kerninfo.version); 692 break; 693 694 case '%': 695 putchr('%'); 696 break; 697 } 698 if (*cp) 699 cp++; 700 } 701 } 702 703 static void 704 clearscreen() 705 { 706 struct ttyent *typ; 707 struct tinfo *tinfo; 708 char *buffer = NULL; 709 char *area = NULL; 710 char *cs; 711 712 if (rawttyn == NULL) 713 return; 714 715 typ = getttynam(rawttyn); 716 717 if ((typ == NULL) || (typ->ty_type == NULL) || 718 (typ->ty_type[0] == 0)) 719 return; 720 721 if (t_getent(&tinfo, typ->ty_type) <= 0) 722 return; 723 724 cs = t_agetstr(tinfo, "cl", &buffer, &area); 725 if (cs == NULL) 726 return; 727 728 putpad(cs); 729 free(buffer); 730 } 731