libexec/getty/main.c

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