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