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 (tcsetattr(STDIN_FILENO, TCSANOW, &tmode) < 0) { 384 syslog(LOG_ERR, "tcsetattr %s: %m", ttyn); 385 exit(1); 386 } 387 signal(SIGINT, SIG_DFL); 388 for (i = 0; environ[i] != NULL; i++) 389 env[i] = environ[i]; 390 makeenv(&env[i]); 391 392 limit.rlim_max = RLIM_INFINITY; 393 limit.rlim_cur = RLIM_INFINITY; 394 (void)setrlimit(RLIMIT_CPU, &limit); 395 execle(LO, "login", AL ? "-fp" : "-p", name, 396 NULL, env); 397 syslog(LOG_ERR, "%s: %m", LO); 398 exit(1); 399 } 400 alarm(0); 401 signal(SIGALRM, SIG_DFL); 402 signal(SIGINT, SIG_IGN); 403 if (NX && *NX) { 404 tname = NX; 405 dogettytab(); 406 } 407 } 408 } 409 410 static int 411 opentty(const char *tty, int flags) 412 { 413 int failopenlogged = 0, i, saved_errno; 414 415 while ((i = open(tty, flags)) == -1) 416 { 417 saved_errno = errno; 418 if (!failopenlogged) { 419 syslog(LOG_ERR, "open %s: %m", tty); 420 failopenlogged = 1; 421 } 422 if (saved_errno == ENOENT) 423 return 0; 424 sleep(60); 425 } 426 if (login_tty(i) < 0) { 427 if (daemon(0,0) < 0) { 428 syslog(LOG_ERR,"daemon: %m"); 429 close(i); 430 return 0; 431 } 432 if (login_tty(i) < 0) { 433 syslog(LOG_ERR, "login_tty %s: %m", tty); 434 close(i); 435 return 0; 436 } 437 } 438 return 1; 439 } 440 441 static void 442 defttymode(void) 443 { 444 struct termios def; 445 446 /* Start with default tty settings. */ 447 if (tcgetattr(STDIN_FILENO, &tmode) < 0) { 448 syslog(LOG_ERR, "tcgetattr %s: %m", ttyn); 449 exit(1); 450 } 451 omode = tmode; /* fill c_cc for dogettytab() */ 452 dogettytab(); 453 /* 454 * Don't rely on the driver too much, and initialize crucial 455 * things according to <sys/ttydefaults.h>. Avoid clobbering 456 * the c_cc[] settings however, the console drivers might wish 457 * to leave their idea of the preferred VERASE key value 458 * there. 459 */ 460 cfmakesane(&def); 461 tmode.c_iflag = def.c_iflag; 462 tmode.c_oflag = def.c_oflag; 463 tmode.c_lflag = def.c_lflag; 464 tmode.c_cflag = def.c_cflag; 465 if (NC) 466 tmode.c_cflag |= CLOCAL; 467 omode = tmode; 468 } 469 470 static void 471 setttymode(int raw) 472 { 473 int off = 0; 474 475 (void)tcflush(STDIN_FILENO, TCIOFLUSH); /* clear out the crap */ 476 ioctl(STDIN_FILENO, FIONBIO, &off); /* turn off non-blocking mode */ 477 ioctl(STDIN_FILENO, FIOASYNC, &off); /* ditto for async mode */ 478 479 if (IS) 480 cfsetispeed(&tmode, speed(IS)); 481 else if (SP) 482 cfsetispeed(&tmode, speed(SP)); 483 if (OS) 484 cfsetospeed(&tmode, speed(OS)); 485 else if (SP) 486 cfsetospeed(&tmode, speed(SP)); 487 set_flags(0); 488 setchars(); 489 if (raw) 490 cfmakeraw(&tmode); 491 if (tcsetattr(STDIN_FILENO, TCSANOW, &tmode) < 0) { 492 syslog(LOG_ERR, "tcsetattr %s: %m", ttyn); 493 exit(1); 494 } 495 } 496 497 498 static int 499 getname(void) 500 { 501 int c; 502 char *np; 503 unsigned char cs; 504 int ppp_state = 0; 505 int ppp_connection = 0; 506 507 /* 508 * Interrupt may happen if we use CBREAK mode 509 */ 510 if (setjmp(intrupt)) { 511 signal(SIGINT, SIG_IGN); 512 return (0); 513 } 514 signal(SIGINT, interrupt); 515 set_flags(1); 516 prompt(); 517 oflush(); 518 if (PF > 0) { 519 sleep(PF); 520 PF = 0; 521 } 522 if (tcsetattr(STDIN_FILENO, TCSANOW, &tmode) < 0) { 523 syslog(LOG_ERR, "%s: %m", ttyn); 524 exit(1); 525 } 526 crmod = digit = lower = upper = 0; 527 np = name; 528 for (;;) { 529 oflush(); 530 if (read(STDIN_FILENO, &cs, 1) <= 0) 531 exit(0); 532 if ((c = cs&0177) == 0) 533 return (0); 534 535 /* PPP detection state machine.. 536 Look for sequences: 537 PPP_FRAME, PPP_STATION, PPP_ESCAPE, PPP_CONTROL_ESCAPED or 538 PPP_FRAME, PPP_STATION, PPP_CONTROL (deviant from RFC) 539 See RFC1662. 540 Derived from code from Michael Hancock, <michaelh@cet.co.jp> 541 and Erik 'PPP' Olson, <eriko@wrq.com> 542 */ 543 544 if (PP && (cs == PPP_FRAME)) { 545 ppp_state = 1; 546 } else if (ppp_state == 1 && cs == PPP_STATION) { 547 ppp_state = 2; 548 } else if (ppp_state == 2 && cs == PPP_ESCAPE) { 549 ppp_state = 3; 550 } else if ((ppp_state == 2 && cs == PPP_CONTROL) 551 || (ppp_state == 3 && cs == PPP_CONTROL_ESCAPED)) { 552 ppp_state = 4; 553 } else if (ppp_state == 4 && cs == PPP_LCP_HI) { 554 ppp_state = 5; 555 } else if (ppp_state == 5 && cs == PPP_LCP_LOW) { 556 ppp_connection = 1; 557 break; 558 } else { 559 ppp_state = 0; 560 } 561 562 if (c == EOT || c == CTRL('d')) 563 exit(0); 564 if (c == '\r' || c == '\n' || np >= &name[sizeof name-1]) { 565 putf("\r\n"); 566 break; 567 } 568 if (islower(c)) 569 lower = 1; 570 else if (isupper(c)) 571 upper = 1; 572 else if (c == ERASE || c == '\b' || c == 0177) { 573 if (np > name) { 574 np--; 575 if (cfgetospeed(&tmode) >= 1200) 576 puts("\b \b"); 577 else 578 putchr(cs); 579 } 580 continue; 581 } else if (c == KILL || c == CTRL('u')) { 582 putchr('\r'); 583 if (cfgetospeed(&tmode) < 1200) 584 putchr('\n'); 585 /* this is the way they do it down under ... */ 586 else if (np > name) 587 puts(" \r"); 588 prompt(); 589 digit = lower = upper = 0; 590 np = name; 591 continue; 592 } else if (isdigit(c)) 593 digit = 1; 594 if (IG && (c <= ' ' || c > 0176)) 595 continue; 596 *np++ = c; 597 putchr(cs); 598 } 599 signal(SIGINT, SIG_IGN); 600 *np = 0; 601 if (c == '\r') 602 crmod = 1; 603 if ((upper && !lower && !LC) || UC) 604 for (np = name; *np; np++) 605 if (isupper(*np)) 606 *np = tolower(*np); 607 return (1 + ppp_connection); 608 } 609 610 static void 611 putpad(const char *s) 612 { 613 int pad = 0; 614 speed_t ospeed = cfgetospeed(&tmode); 615 616 if (isdigit(*s)) { 617 while (isdigit(*s)) { 618 pad *= 10; 619 pad += *s++ - '0'; 620 } 621 pad *= 10; 622 if (*s == '.' && isdigit(s[1])) { 623 pad += s[1] - '0'; 624 s += 2; 625 } 626 } 627 628 puts(s); 629 /* 630 * If no delay needed, or output speed is 631 * not comprehensible, then don't try to delay. 632 */ 633 if (pad == 0 || ospeed <= 0) 634 return; 635 636 /* 637 * Round up by a half a character frame, and then do the delay. 638 * Too bad there are no user program accessible programmed delays. 639 * Transmitting pad characters slows many terminals down and also 640 * loads the system. 641 */ 642 pad = (pad * ospeed + 50000) / 100000; 643 while (pad--) 644 putchr(*PC); 645 } 646 647 static void 648 puts(const char *s) 649 { 650 while (*s) 651 putchr(*s++); 652 } 653 654 static char outbuf[OBUFSIZ]; 655 static int obufcnt = 0; 656 657 static void 658 putchr(int cc) 659 { 660 char c; 661 662 c = cc; 663 if (!NP) { 664 c |= partab[c&0177] & 0200; 665 if (OP) 666 c ^= 0200; 667 } 668 if (!UB) { 669 outbuf[obufcnt++] = c; 670 if (obufcnt >= OBUFSIZ) 671 oflush(); 672 } else 673 write(STDOUT_FILENO, &c, 1); 674 } 675 676 static void 677 oflush(void) 678 { 679 if (obufcnt) 680 write(STDOUT_FILENO, outbuf, obufcnt); 681 obufcnt = 0; 682 } 683 684 static void 685 prompt(void) 686 { 687 688 putf(LM); 689 if (CO) 690 putchr('\n'); 691 } 692 693 694 static char * 695 get_line(int fd) 696 { 697 size_t i = 0; 698 static char linebuf[512]; 699 700 /* 701 * This is certainly slow, but it avoids having to include 702 * stdio.h unnecessarily. Issue files should be small anyway. 703 */ 704 while (i < (sizeof linebuf - 3) && read(fd, linebuf+i, 1)==1) { 705 if (linebuf[i] == '\n') { 706 /* Don't rely on newline mode, assume raw */ 707 linebuf[i++] = '\r'; 708 linebuf[i++] = '\n'; 709 linebuf[i] = '\0'; 710 return linebuf; 711 } 712 ++i; 713 } 714 linebuf[i] = '\0'; 715 return i ? linebuf : 0; 716 } 717 718 static void 719 putf(const char *cp) 720 { 721 time_t t; 722 char *slash, db[100]; 723 724 static struct utsname kerninfo; 725 726 if (!*kerninfo.sysname) 727 uname(&kerninfo); 728 729 while (*cp) { 730 if (*cp != '%') { 731 putchr(*cp++); 732 continue; 733 } 734 switch (*++cp) { 735 736 case 't': 737 slash = strrchr(ttyn, '/'); 738 if (slash == NULL) 739 puts(ttyn); 740 else 741 puts(&slash[1]); 742 break; 743 744 case 'h': 745 puts(editedhost); 746 break; 747 748 case 'd': { 749 t = (time_t)0; 750 (void)time(&t); 751 if (Lo) 752 (void)setlocale(LC_TIME, Lo); 753 (void)strftime(db, sizeof(db), DF, localtime(&t)); 754 puts(db); 755 break; 756 757 case 's': 758 puts(kerninfo.sysname); 759 break; 760 761 case 'm': 762 puts(kerninfo.machine); 763 break; 764 765 case 'r': 766 puts(kerninfo.release); 767 break; 768 769 case 'v': 770 puts(kerninfo.version); 771 break; 772 } 773 774 case '%': 775 putchr('%'); 776 break; 777 } 778 cp++; 779 } 780 } 781 782 /* 783 * Read a gettytab database entry and perform necessary quirks. 784 */ 785 static void 786 dogettytab(void) 787 { 788 /* Read the database entry. */ 789 gettable(tname, tabent); 790 791 /* 792 * Avoid inheriting the parity values from the default entry 793 * if any of them is set in the current entry. 794 * Mixing different parity settings is unreasonable. 795 */ 796 if (OPset || EPset || APset || NPset) 797 OPset = EPset = APset = NPset = 1; 798 799 /* Fill in default values for unset capabilities. */ 800 setdefaults(); 801 } 802