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