1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 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. 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 * @(#)from: main.c 8.1 (Berkeley) 6/20/93 32 * $FreeBSD: head/libexec/getty/main.c 329992 2018-02-25 20:15:06Z trasz $ 33 */ 34 35 #include <sys/param.h> 36 #include <sys/ioctl.h> 37 #include <sys/time.h> 38 #include <sys/resource.h> 39 #include <sys/stat.h> 40 #include <sys/ttydefaults.h> 41 #include <sys/utsname.h> 42 43 #include <ctype.h> 44 #include <errno.h> 45 #include <fcntl.h> 46 #include <locale.h> 47 #include <libutil.h> 48 #include <setjmp.h> 49 #include <signal.h> 50 #include <stdlib.h> 51 #include <string.h> 52 #include <syslog.h> 53 #include <termios.h> 54 #include <time.h> 55 #include <unistd.h> 56 57 #include "gettytab.h" 58 #include "extern.h" 59 #include "pathnames.h" 60 61 /* 62 * Set the amount of running time that getty should accumulate 63 * before deciding that something is wrong and exit. 64 */ 65 #define GETTY_TIMEOUT 60 /* seconds */ 66 67 #undef CTRL 68 #define CTRL(x) (x&037) 69 70 /* defines for auto detection of incoming PPP calls (->PAP/CHAP) */ 71 72 #define PPP_FRAME 0x7e /* PPP Framing character */ 73 #define PPP_STATION 0xff /* "All Station" character */ 74 #define PPP_ESCAPE 0x7d /* Escape Character */ 75 #define PPP_CONTROL 0x03 /* PPP Control Field */ 76 #define PPP_CONTROL_ESCAPED 0x23 /* PPP Control Field, escaped */ 77 #define PPP_LCP_HI 0xc0 /* LCP protocol - high byte */ 78 #define PPP_LCP_LOW 0x21 /* LCP protocol - low byte */ 79 80 /* original mode; flags've been reset using values from <sys/ttydefaults.h> */ 81 struct termios omode; 82 /* current mode */ 83 struct termios tmode; 84 85 static int crmod, digit, lower, upper; 86 87 char hostname[MAXHOSTNAMELEN]; 88 static char name[MAXLOGNAME*3]; 89 static char dev[] = _PATH_DEV; 90 static char ttyn[32]; 91 92 #define OBUFSIZ 128 93 #define TABBUFSIZ 512 94 95 static char defent[TABBUFSIZ]; 96 static char tabent[TABBUFSIZ]; 97 static const char *tname; 98 99 static char *env[128]; 100 101 static char partab[] = { 102 0001,0201,0201,0001,0201,0001,0001,0201, 103 0202,0004,0003,0205,0005,0206,0201,0001, 104 0201,0001,0001,0201,0001,0201,0201,0001, 105 0001,0201,0201,0001,0201,0001,0001,0201, 106 0200,0000,0000,0200,0000,0200,0200,0000, 107 0000,0200,0200,0000,0200,0000,0000,0200, 108 0000,0200,0200,0000,0200,0000,0000,0200, 109 0200,0000,0000,0200,0000,0200,0200,0000, 110 0200,0000,0000,0200,0000,0200,0200,0000, 111 0000,0200,0200,0000,0200,0000,0000,0200, 112 0000,0200,0200,0000,0200,0000,0000,0200, 113 0200,0000,0000,0200,0000,0200,0200,0000, 114 0000,0200,0200,0000,0200,0000,0000,0200, 115 0200,0000,0000,0200,0000,0200,0200,0000, 116 0200,0000,0000,0200,0000,0200,0200,0000, 117 0000,0200,0200,0000,0200,0000,0000,0201 118 }; 119 120 #define ERASE tmode.c_cc[VERASE] 121 #define KILL tmode.c_cc[VKILL] 122 #define EOT tmode.c_cc[VEOF] 123 124 #define puts Gputs 125 126 static void defttymode(void); 127 static void dingdong(int); 128 static void dogettytab(void); 129 static int getname(void); 130 static void interrupt(int); 131 static void oflush(void); 132 static void prompt(void); 133 static void putchr(int); 134 static void putf(const char *); 135 static void putpad(const char *); 136 static void puts(const char *); 137 static void timeoverrun(int); 138 static char *get_line(int); 139 static void setttymode(int); 140 static int opentty(const char *, int); 141 142 static jmp_buf timeout; 143 144 static void 145 dingdong(int signo __unused) 146 { 147 alarm(0); 148 longjmp(timeout, 1); 149 } 150 151 static jmp_buf intrupt; 152 153 static void 154 interrupt(int signo __unused) 155 { 156 longjmp(intrupt, 1); 157 } 158 159 /* 160 * Action to take when getty is running too long. 161 */ 162 static void 163 timeoverrun(int signo __unused) 164 { 165 166 syslog(LOG_ERR, "getty exiting due to excessive running time"); 167 exit(1); 168 } 169 170 int 171 main(int argc, char *argv[]) 172 { 173 int first_sleep = 1, first_time = 1; 174 struct rlimit limit; 175 int rval; 176 177 signal(SIGINT, SIG_IGN); 178 signal(SIGQUIT, SIG_IGN); 179 180 openlog("getty", LOG_CONS|LOG_PID, LOG_AUTH); 181 gethostname(hostname, sizeof(hostname) - 1); 182 hostname[sizeof(hostname) - 1] = '\0'; 183 if (hostname[0] == '\0') 184 strcpy(hostname, "Amnesiac"); 185 186 /* 187 * Limit running time to deal with broken or dead lines. 188 */ 189 (void)signal(SIGXCPU, timeoverrun); 190 limit.rlim_max = RLIM_INFINITY; 191 limit.rlim_cur = GETTY_TIMEOUT; 192 (void)setrlimit(RLIMIT_CPU, &limit); 193 194 gettable("default", defent); 195 gendefaults(); 196 tname = "default"; 197 if (argc > 1) 198 tname = argv[1]; 199 200 /* 201 * The following is a work around for vhangup interactions 202 * which cause great problems getting window systems started. 203 * If the tty line is "-", we do the old style getty presuming 204 * that the file descriptors are already set up for us. 205 * J. Gettys - MIT Project Athena. 206 */ 207 if (argc <= 2 || strcmp(argv[2], "-") == 0) 208 strcpy(ttyn, ttyname(STDIN_FILENO)); 209 else { 210 strcpy(ttyn, dev); 211 strncat(ttyn, argv[2], sizeof(ttyn)-sizeof(dev)); 212 if (strcmp(argv[0], "+") != 0) { 213 chown(ttyn, 0, 0); 214 chmod(ttyn, 0600); 215 revoke(ttyn); 216 217 /* 218 * Do the first scan through gettytab. 219 * Terminal mode parameters will be wrong until 220 * defttymode() called, but they're irrelevant for 221 * the initial setup of the terminal device. 222 */ 223 dogettytab(); 224 225 /* 226 * Init or answer modem sequence has been specified. 227 */ 228 if (IC || AC) { 229 if (!opentty(ttyn, O_RDWR|O_NONBLOCK)) 230 exit(1); 231 defttymode(); 232 setttymode(1); 233 } 234 235 if (IC) { 236 if (getty_chat(IC, CT, DC) > 0) { 237 syslog(LOG_ERR, "modem init problem on %s", ttyn); 238 (void)tcsetattr(STDIN_FILENO, TCSANOW, &tmode); 239 exit(1); 240 } 241 } 242 243 if (AC) { 244 fd_set rfds; 245 struct timeval to; 246 int i; 247 248 FD_ZERO(&rfds); 249 FD_SET(0, &rfds); 250 to.tv_sec = RT; 251 to.tv_usec = 0; 252 i = select(32, &rfds, NULL, NULL, RT ? &to : NULL); 253 if (i < 0) { 254 syslog(LOG_ERR, "select %s: %m", ttyn); 255 } else if (i == 0) { 256 syslog(LOG_NOTICE, "recycle tty %s", ttyn); 257 (void)tcsetattr(STDIN_FILENO, TCSANOW, &tmode); 258 exit(0); /* recycle for init */ 259 } 260 i = getty_chat(AC, CT, DC); 261 if (i > 0) { 262 syslog(LOG_ERR, "modem answer problem on %s", ttyn); 263 (void)tcsetattr(STDIN_FILENO, TCSANOW, &tmode); 264 exit(1); 265 } 266 } else { /* maybe blocking open */ 267 if (!opentty(ttyn, O_RDWR | (NC ? O_NONBLOCK : 0 ))) 268 exit(1); 269 } 270 } 271 } 272 273 defttymode(); 274 for (;;) { 275 276 /* 277 * if a delay was specified then sleep for that 278 * number of seconds before writing the initial prompt 279 */ 280 if (first_sleep && DE) { 281 sleep(DE); 282 /* remove any noise */ 283 (void)tcflush(STDIN_FILENO, TCIOFLUSH); 284 } 285 first_sleep = 0; 286 287 setttymode(0); 288 if (AB) { 289 tname = autobaud(); 290 dogettytab(); 291 continue; 292 } 293 if (PS) { 294 tname = portselector(); 295 dogettytab(); 296 continue; 297 } 298 if (CL && *CL) 299 putpad(CL); 300 edithost(HE); 301 302 /* if this is the first time through this, and an 303 issue file has been given, then send it */ 304 if (first_time && IF) { 305 int fd; 306 307 if ((fd = open(IF, O_RDONLY)) != -1) { 308 char * cp; 309 310 while ((cp = get_line(fd)) != NULL) { 311 putf(cp); 312 } 313 close(fd); 314 } 315 } 316 first_time = 0; 317 318 if (IMP && *IMP && !(PL && PP)) 319 system(IMP); 320 if (IM && *IM && !(PL && PP)) 321 putf(IM); 322 if (setjmp(timeout)) { 323 cfsetispeed(&tmode, B0); 324 cfsetospeed(&tmode, B0); 325 (void)tcsetattr(STDIN_FILENO, TCSANOW, &tmode); 326 exit(1); 327 } 328 if (TO) { 329 signal(SIGALRM, dingdong); 330 alarm(TO); 331 } 332 333 rval = 0; 334 if (AL) { 335 const char *p = AL; 336 char *q = name; 337 338 while (*p && q < &name[sizeof name - 1]) { 339 if (isupper(*p)) 340 upper = 1; 341 else if (islower(*p)) 342 lower = 1; 343 else if (isdigit(*p)) 344 digit = 1; 345 *q++ = *p++; 346 } 347 } else if (!(PL && PP)) 348 rval = getname(); 349 if (rval == 2 || (PL && PP)) { 350 oflush(); 351 alarm(0); 352 limit.rlim_max = RLIM_INFINITY; 353 limit.rlim_cur = RLIM_INFINITY; 354 (void)setrlimit(RLIMIT_CPU, &limit); 355 execle(PP, "ppplogin", ttyn, NULL, env); 356 syslog(LOG_ERR, "%s: %m", PP); 357 exit(1); 358 } else if (rval || AL) { 359 int i; 360 361 oflush(); 362 alarm(0); 363 signal(SIGALRM, SIG_DFL); 364 if (name[0] == '\0') 365 continue; 366 if (name[0] == '-') { 367 puts("user names may not start with '-'."); 368 continue; 369 } 370 if (!(upper || lower || digit)) { 371 if (AL) { 372 syslog(LOG_ERR, 373 "invalid auto-login name: %s", AL); 374 exit(1); 375 } else 376 continue; 377 } 378 set_flags(2); 379 if (crmod) { 380 tmode.c_iflag |= ICRNL; 381 tmode.c_oflag |= ONLCR; 382 } 383 #if REALLY_OLD_TTYS 384 if (upper || UC) 385 tmode.sg_flags |= LCASE; 386 if (lower || LC) 387 tmode.sg_flags &= ~LCASE; 388 #endif 389 if (tcsetattr(STDIN_FILENO, TCSANOW, &tmode) < 0) { 390 syslog(LOG_ERR, "tcsetattr %s: %m", ttyn); 391 exit(1); 392 } 393 signal(SIGINT, SIG_DFL); 394 for (i = 0; environ[i] != NULL; i++) 395 env[i] = environ[i]; 396 makeenv(&env[i]); 397 398 limit.rlim_max = RLIM_INFINITY; 399 limit.rlim_cur = RLIM_INFINITY; 400 (void)setrlimit(RLIMIT_CPU, &limit); 401 execle(LO, "login", AL ? "-fp" : "-p", name, 402 NULL, env); 403 syslog(LOG_ERR, "%s: %m", LO); 404 exit(1); 405 } 406 alarm(0); 407 signal(SIGALRM, SIG_DFL); 408 signal(SIGINT, SIG_IGN); 409 if (NX && *NX) { 410 tname = NX; 411 dogettytab(); 412 } 413 } 414 } 415 416 static int 417 opentty(const char *tty, int flags) 418 { 419 int failopenlogged = 0, i, saved_errno; 420 421 while ((i = open(tty, flags)) == -1) 422 { 423 saved_errno = errno; 424 if (!failopenlogged) { 425 syslog(LOG_ERR, "open %s: %m", tty); 426 failopenlogged = 1; 427 } 428 if (saved_errno == ENOENT) 429 return 0; 430 sleep(60); 431 } 432 if (login_tty(i) < 0) { 433 if (daemon(0,0) < 0) { 434 syslog(LOG_ERR,"daemon: %m"); 435 close(i); 436 return 0; 437 } 438 if (login_tty(i) < 0) { 439 syslog(LOG_ERR, "login_tty %s: %m", tty); 440 close(i); 441 return 0; 442 } 443 } 444 return 1; 445 } 446 447 static void 448 defttymode(void) 449 { 450 struct termios def; 451 452 /* Start with default tty settings. */ 453 if (tcgetattr(STDIN_FILENO, &tmode) < 0) { 454 syslog(LOG_ERR, "tcgetattr %s: %m", ttyn); 455 exit(1); 456 } 457 omode = tmode; /* fill c_cc for dogettytab() */ 458 dogettytab(); 459 /* 460 * Don't rely on the driver too much, and initialize crucial 461 * things according to <sys/ttydefaults.h>. Avoid clobbering 462 * the c_cc[] settings however, the console drivers might wish 463 * to leave their idea of the preferred VERASE key value 464 * there. 465 */ 466 cfmakesane(&def); 467 tmode.c_iflag = def.c_iflag; 468 tmode.c_oflag = def.c_oflag; 469 tmode.c_lflag = def.c_lflag; 470 tmode.c_cflag = def.c_cflag; 471 if (NC) 472 tmode.c_cflag |= CLOCAL; 473 omode = tmode; 474 } 475 476 static void 477 setttymode(int raw) 478 { 479 int off = 0; 480 481 (void)tcflush(STDIN_FILENO, TCIOFLUSH); /* clear out the crap */ 482 ioctl(STDIN_FILENO, FIONBIO, &off); /* turn off non-blocking mode */ 483 ioctl(STDIN_FILENO, FIOASYNC, &off); /* ditto for async mode */ 484 485 if (IS) 486 cfsetispeed(&tmode, speed(IS)); 487 else if (SP) 488 cfsetispeed(&tmode, speed(SP)); 489 if (OS) 490 cfsetospeed(&tmode, speed(OS)); 491 else if (SP) 492 cfsetospeed(&tmode, speed(SP)); 493 set_flags(0); 494 setchars(); 495 if (raw) 496 cfmakeraw(&tmode); 497 if (tcsetattr(STDIN_FILENO, TCSANOW, &tmode) < 0) { 498 syslog(LOG_ERR, "tcsetattr %s: %m", ttyn); 499 exit(1); 500 } 501 } 502 503 504 static int 505 getname(void) 506 { 507 int c; 508 char *np; 509 unsigned char cs; 510 int ppp_state = 0; 511 int ppp_connection = 0; 512 513 /* 514 * Interrupt may happen if we use CBREAK mode 515 */ 516 if (setjmp(intrupt)) { 517 signal(SIGINT, SIG_IGN); 518 return (0); 519 } 520 signal(SIGINT, interrupt); 521 set_flags(1); 522 prompt(); 523 oflush(); 524 if (PF > 0) { 525 sleep(PF); 526 PF = 0; 527 } 528 if (tcsetattr(STDIN_FILENO, TCSANOW, &tmode) < 0) { 529 syslog(LOG_ERR, "%s: %m", ttyn); 530 exit(1); 531 } 532 crmod = digit = lower = upper = 0; 533 np = name; 534 for (;;) { 535 oflush(); 536 if (read(STDIN_FILENO, &cs, 1) <= 0) 537 exit(0); 538 if ((c = cs&0177) == 0) 539 return (0); 540 541 /* PPP detection state machine.. 542 Look for sequences: 543 PPP_FRAME, PPP_STATION, PPP_ESCAPE, PPP_CONTROL_ESCAPED or 544 PPP_FRAME, PPP_STATION, PPP_CONTROL (deviant from RFC) 545 See RFC1662. 546 Derived from code from Michael Hancock, <michaelh@cet.co.jp> 547 and Erik 'PPP' Olson, <eriko@wrq.com> 548 */ 549 550 if (PP && (cs == PPP_FRAME)) { 551 ppp_state = 1; 552 } else if (ppp_state == 1 && cs == PPP_STATION) { 553 ppp_state = 2; 554 } else if (ppp_state == 2 && cs == PPP_ESCAPE) { 555 ppp_state = 3; 556 } else if ((ppp_state == 2 && cs == PPP_CONTROL) 557 || (ppp_state == 3 && cs == PPP_CONTROL_ESCAPED)) { 558 ppp_state = 4; 559 } else if (ppp_state == 4 && cs == PPP_LCP_HI) { 560 ppp_state = 5; 561 } else if (ppp_state == 5 && cs == PPP_LCP_LOW) { 562 ppp_connection = 1; 563 break; 564 } else { 565 ppp_state = 0; 566 } 567 568 if (c == EOT || c == CTRL('d')) 569 exit(0); 570 if (c == '\r' || c == '\n' || np >= &name[sizeof name-1]) { 571 putf("\r\n"); 572 break; 573 } 574 if (islower(c)) 575 lower = 1; 576 else if (isupper(c)) 577 upper = 1; 578 else if (c == ERASE || c == '\b' || c == 0177) { 579 if (np > name) { 580 np--; 581 if (cfgetospeed(&tmode) >= 1200) 582 puts("\b \b"); 583 else 584 putchr(cs); 585 } 586 continue; 587 } else if (c == KILL || c == CTRL('u')) { 588 putchr('\r'); 589 if (cfgetospeed(&tmode) < 1200) 590 putchr('\n'); 591 /* this is the way they do it down under ... */ 592 else if (np > name) 593 puts(" \r"); 594 prompt(); 595 digit = lower = upper = 0; 596 np = name; 597 continue; 598 } else if (isdigit(c)) 599 digit = 1; 600 if (IG && (c <= ' ' || c > 0176)) 601 continue; 602 *np++ = c; 603 putchr(cs); 604 } 605 signal(SIGINT, SIG_IGN); 606 *np = 0; 607 if (c == '\r') 608 crmod = 1; 609 if ((upper && !lower && !LC) || UC) 610 for (np = name; *np; np++) 611 if (isupper(*np)) 612 *np = tolower(*np); 613 return (1 + ppp_connection); 614 } 615 616 static void 617 putpad(const char *s) 618 { 619 int pad = 0; 620 speed_t ospeed = cfgetospeed(&tmode); 621 622 if (isdigit(*s)) { 623 while (isdigit(*s)) { 624 pad *= 10; 625 pad += *s++ - '0'; 626 } 627 pad *= 10; 628 if (*s == '.' && isdigit(s[1])) { 629 pad += s[1] - '0'; 630 s += 2; 631 } 632 } 633 634 puts(s); 635 /* 636 * If no delay needed, or output speed is 637 * not comprehensible, then don't try to delay. 638 */ 639 if (pad == 0 || ospeed <= 0) 640 return; 641 642 /* 643 * Round up by a half a character frame, and then do the delay. 644 * Too bad there are no user program accessible programmed delays. 645 * Transmitting pad characters slows many terminals down and also 646 * loads the system. 647 */ 648 pad = (pad * ospeed + 50000) / 100000; 649 while (pad--) 650 putchr(*PC); 651 } 652 653 static void 654 puts(const char *s) 655 { 656 while (*s) 657 putchr(*s++); 658 } 659 660 static char outbuf[OBUFSIZ]; 661 static int obufcnt = 0; 662 663 static void 664 putchr(int cc) 665 { 666 char c; 667 668 c = cc; 669 if (!NP) { 670 c |= partab[c&0177] & 0200; 671 if (OP) 672 c ^= 0200; 673 } 674 if (!UB) { 675 outbuf[obufcnt++] = c; 676 if (obufcnt >= OBUFSIZ) 677 oflush(); 678 } else 679 write(STDOUT_FILENO, &c, 1); 680 } 681 682 static void 683 oflush(void) 684 { 685 if (obufcnt) 686 write(STDOUT_FILENO, outbuf, obufcnt); 687 obufcnt = 0; 688 } 689 690 static void 691 prompt(void) 692 { 693 694 putf(LM); 695 if (CO) 696 putchr('\n'); 697 } 698 699 700 static char * 701 get_line(int fd) 702 { 703 size_t i = 0; 704 static char linebuf[512]; 705 706 /* 707 * This is certainly slow, but it avoids having to include 708 * stdio.h unnecessarily. Issue files should be small anyway. 709 */ 710 while (i < (sizeof linebuf - 3) && read(fd, linebuf+i, 1)==1) { 711 if (linebuf[i] == '\n') { 712 /* Don't rely on newline mode, assume raw */ 713 linebuf[i++] = '\r'; 714 linebuf[i++] = '\n'; 715 linebuf[i] = '\0'; 716 return linebuf; 717 } 718 ++i; 719 } 720 linebuf[i] = '\0'; 721 return i ? linebuf : 0; 722 } 723 724 static void 725 putf(const char *cp) 726 { 727 time_t t; 728 char *slash, db[100]; 729 730 static struct utsname kerninfo; 731 732 if (!*kerninfo.sysname) 733 uname(&kerninfo); 734 735 while (*cp) { 736 if (*cp != '%') { 737 putchr(*cp++); 738 continue; 739 } 740 switch (*++cp) { 741 742 case 't': 743 slash = strrchr(ttyn, '/'); 744 if (slash == NULL) 745 puts(ttyn); 746 else 747 puts(&slash[1]); 748 break; 749 750 case 'h': 751 puts(editedhost); 752 break; 753 754 case 'd': { 755 t = (time_t)0; 756 (void)time(&t); 757 if (Lo) 758 (void)setlocale(LC_TIME, Lo); 759 (void)strftime(db, sizeof(db), DF, localtime(&t)); 760 puts(db); 761 break; 762 763 case 's': 764 puts(kerninfo.sysname); 765 break; 766 767 case 'm': 768 puts(kerninfo.machine); 769 break; 770 771 case 'r': 772 puts(kerninfo.release); 773 break; 774 775 case 'v': 776 puts(kerninfo.version); 777 break; 778 } 779 780 case '%': 781 putchr('%'); 782 break; 783 } 784 cp++; 785 } 786 } 787 788 /* 789 * Read a gettytab database entry and perform necessary quirks. 790 */ 791 static void 792 dogettytab(void) 793 { 794 /* Read the database entry. */ 795 gettable(tname, tabent); 796 797 /* 798 * Avoid inheriting the parity values from the default entry 799 * if any of them is set in the current entry. 800 * Mixing different parity settings is unreasonable. 801 */ 802 if (OPset || EPset || APset || NPset) 803 OPset = EPset = APset = NPset = 1; 804 805 /* Fill in default values for unset capabilities. */ 806 setdefaults(); 807 } 808