mirror of
https://github.com/freebsd/freebsd-src
synced 2024-09-06 17:18:32 +00:00
![Warner Losh](/assets/img/avatar_default.png)
We've ifdef'd out the copyright strings for some time now. Go ahead and remove the ifdefs. Plus whatever other detritis was left over from other recent removals. These copyright strings are present in the comments and are largely from CSRG's attempt at adding their copyright to every binary file (which modern interpretations of the license doesn't require). Sponsored by: Netflix
807 lines
17 KiB
C
807 lines
17 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*
|
|
* Copyright (c) 1980, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/time.h>
|
|
#include <sys/resource.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/ttydefaults.h>
|
|
#include <sys/utsname.h>
|
|
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <locale.h>
|
|
#include <libutil.h>
|
|
#include <setjmp.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <syslog.h>
|
|
#include <termios.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
|
|
#include "gettytab.h"
|
|
#include "extern.h"
|
|
#include "pathnames.h"
|
|
|
|
/*
|
|
* Set the amount of running time that getty should accumulate
|
|
* before deciding that something is wrong and exit.
|
|
*/
|
|
#define GETTY_TIMEOUT 60 /* seconds */
|
|
|
|
#undef CTRL
|
|
#define CTRL(x) (x&037)
|
|
|
|
/* defines for auto detection of incoming PPP calls (->PAP/CHAP) */
|
|
|
|
#define PPP_FRAME 0x7e /* PPP Framing character */
|
|
#define PPP_STATION 0xff /* "All Station" character */
|
|
#define PPP_ESCAPE 0x7d /* Escape Character */
|
|
#define PPP_CONTROL 0x03 /* PPP Control Field */
|
|
#define PPP_CONTROL_ESCAPED 0x23 /* PPP Control Field, escaped */
|
|
#define PPP_LCP_HI 0xc0 /* LCP protocol - high byte */
|
|
#define PPP_LCP_LOW 0x21 /* LCP protocol - low byte */
|
|
|
|
/* original mode; flags've been reset using values from <sys/ttydefaults.h> */
|
|
struct termios omode;
|
|
/* current mode */
|
|
struct termios tmode;
|
|
|
|
static int crmod, digit, lower, upper;
|
|
|
|
char hostname[MAXHOSTNAMELEN];
|
|
static char name[MAXLOGNAME*3];
|
|
static char ttyn[32];
|
|
|
|
#define OBUFSIZ 128
|
|
|
|
static const char *tname;
|
|
|
|
static char *env[128];
|
|
|
|
static char partab[] = {
|
|
0001,0201,0201,0001,0201,0001,0001,0201,
|
|
0202,0004,0003,0205,0005,0206,0201,0001,
|
|
0201,0001,0001,0201,0001,0201,0201,0001,
|
|
0001,0201,0201,0001,0201,0001,0001,0201,
|
|
0200,0000,0000,0200,0000,0200,0200,0000,
|
|
0000,0200,0200,0000,0200,0000,0000,0200,
|
|
0000,0200,0200,0000,0200,0000,0000,0200,
|
|
0200,0000,0000,0200,0000,0200,0200,0000,
|
|
0200,0000,0000,0200,0000,0200,0200,0000,
|
|
0000,0200,0200,0000,0200,0000,0000,0200,
|
|
0000,0200,0200,0000,0200,0000,0000,0200,
|
|
0200,0000,0000,0200,0000,0200,0200,0000,
|
|
0000,0200,0200,0000,0200,0000,0000,0200,
|
|
0200,0000,0000,0200,0000,0200,0200,0000,
|
|
0200,0000,0000,0200,0000,0200,0200,0000,
|
|
0000,0200,0200,0000,0200,0000,0000,0201
|
|
};
|
|
|
|
#define ERASE tmode.c_cc[VERASE]
|
|
#define KILL tmode.c_cc[VKILL]
|
|
#define EOT tmode.c_cc[VEOF]
|
|
|
|
#define puts Gputs
|
|
|
|
static void defttymode(void);
|
|
static void dingdong(int);
|
|
static void dogettytab(void);
|
|
static int getname(void);
|
|
static void interrupt(int);
|
|
static void oflush(void);
|
|
static void prompt(void);
|
|
static void putchr(int);
|
|
static void putf(const char *);
|
|
static void putpad(const char *);
|
|
static void puts(const char *);
|
|
static void timeoverrun(int);
|
|
static char *get_line(int);
|
|
static void setttymode(int);
|
|
static int opentty(const char *, int);
|
|
|
|
static jmp_buf timeout;
|
|
|
|
static void
|
|
dingdong(int signo __unused)
|
|
{
|
|
alarm(0);
|
|
longjmp(timeout, 1);
|
|
}
|
|
|
|
static jmp_buf intrupt;
|
|
|
|
static void
|
|
interrupt(int signo __unused)
|
|
{
|
|
longjmp(intrupt, 1);
|
|
}
|
|
|
|
/*
|
|
* Action to take when getty is running too long.
|
|
*/
|
|
static void
|
|
timeoverrun(int signo __unused)
|
|
{
|
|
|
|
syslog(LOG_ERR, "getty exiting due to excessive running time");
|
|
exit(1);
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
int first_sleep = 1, first_time = 1;
|
|
struct rlimit limit;
|
|
int rval;
|
|
|
|
signal(SIGINT, SIG_IGN);
|
|
signal(SIGQUIT, SIG_IGN);
|
|
|
|
openlog("getty", LOG_CONS|LOG_PID, LOG_AUTH);
|
|
gethostname(hostname, sizeof(hostname) - 1);
|
|
hostname[sizeof(hostname) - 1] = '\0';
|
|
if (hostname[0] == '\0')
|
|
snprintf(hostname, sizeof(hostname), "Amnesiac");
|
|
|
|
/*
|
|
* Limit running time to deal with broken or dead lines.
|
|
*/
|
|
(void)signal(SIGXCPU, timeoverrun);
|
|
limit.rlim_max = RLIM_INFINITY;
|
|
limit.rlim_cur = GETTY_TIMEOUT;
|
|
(void)setrlimit(RLIMIT_CPU, &limit);
|
|
|
|
gettable("default");
|
|
gendefaults();
|
|
tname = "default";
|
|
if (argc > 1)
|
|
tname = argv[1];
|
|
|
|
/*
|
|
* The following is a work around for vhangup interactions
|
|
* which cause great problems getting window systems started.
|
|
* If the tty line is "-", we do the old style getty presuming
|
|
* that the file descriptors are already set up for us.
|
|
* J. Gettys - MIT Project Athena.
|
|
*/
|
|
if (argc <= 2 || strcmp(argv[2], "-") == 0) {
|
|
char *n = ttyname(STDIN_FILENO);
|
|
if (n == NULL) {
|
|
syslog(LOG_ERR, "ttyname: %m");
|
|
exit(1);
|
|
}
|
|
snprintf(ttyn, sizeof(ttyn), "%s", n);
|
|
} else {
|
|
snprintf(ttyn, sizeof(ttyn), "%s%s", _PATH_DEV, argv[2]);
|
|
if (strcmp(argv[0], "+") != 0) {
|
|
chown(ttyn, 0, 0);
|
|
chmod(ttyn, 0600);
|
|
revoke(ttyn);
|
|
|
|
/*
|
|
* Do the first scan through gettytab.
|
|
* Terminal mode parameters will be wrong until
|
|
* defttymode() called, but they're irrelevant for
|
|
* the initial setup of the terminal device.
|
|
*/
|
|
dogettytab();
|
|
|
|
/*
|
|
* Init or answer modem sequence has been specified.
|
|
*/
|
|
if (IC || AC) {
|
|
if (!opentty(ttyn, O_RDWR|O_NONBLOCK))
|
|
exit(1);
|
|
defttymode();
|
|
setttymode(1);
|
|
}
|
|
|
|
if (IC) {
|
|
if (getty_chat(IC, CT, DC) > 0) {
|
|
syslog(LOG_ERR, "modem init problem on %s", ttyn);
|
|
(void)tcsetattr(STDIN_FILENO, TCSANOW, &tmode);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
if (AC) {
|
|
fd_set rfds;
|
|
struct timeval to;
|
|
int i;
|
|
|
|
FD_ZERO(&rfds);
|
|
FD_SET(0, &rfds);
|
|
to.tv_sec = RT;
|
|
to.tv_usec = 0;
|
|
i = select(32, &rfds, NULL, NULL, RT ? &to : NULL);
|
|
if (i < 0) {
|
|
syslog(LOG_ERR, "select %s: %m", ttyn);
|
|
} else if (i == 0) {
|
|
syslog(LOG_NOTICE, "recycle tty %s", ttyn);
|
|
(void)tcsetattr(STDIN_FILENO, TCSANOW, &tmode);
|
|
exit(0); /* recycle for init */
|
|
}
|
|
i = getty_chat(AC, CT, DC);
|
|
if (i > 0) {
|
|
syslog(LOG_ERR, "modem answer problem on %s", ttyn);
|
|
(void)tcsetattr(STDIN_FILENO, TCSANOW, &tmode);
|
|
exit(1);
|
|
}
|
|
} else { /* maybe blocking open */
|
|
if (!opentty(ttyn, O_RDWR | (NC ? O_NONBLOCK : 0 )))
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
defttymode();
|
|
for (;;) {
|
|
|
|
/*
|
|
* if a delay was specified then sleep for that
|
|
* number of seconds before writing the initial prompt
|
|
*/
|
|
if (first_sleep && DE) {
|
|
sleep(DE);
|
|
/* remove any noise */
|
|
(void)tcflush(STDIN_FILENO, TCIOFLUSH);
|
|
}
|
|
first_sleep = 0;
|
|
|
|
setttymode(0);
|
|
if (AB) {
|
|
tname = autobaud();
|
|
dogettytab();
|
|
continue;
|
|
}
|
|
if (PS) {
|
|
tname = portselector();
|
|
dogettytab();
|
|
continue;
|
|
}
|
|
if (CL && *CL)
|
|
putpad(CL);
|
|
edithost(HE);
|
|
|
|
/* if this is the first time through this, and an
|
|
issue file has been given, then send it */
|
|
if (first_time && IF) {
|
|
int fd;
|
|
|
|
if ((fd = open(IF, O_RDONLY)) != -1) {
|
|
char * cp;
|
|
|
|
while ((cp = get_line(fd)) != NULL) {
|
|
putf(cp);
|
|
}
|
|
close(fd);
|
|
}
|
|
}
|
|
first_time = 0;
|
|
|
|
if (IMP && *IMP && !(PL && PP))
|
|
system(IMP);
|
|
if (IM && *IM && !(PL && PP))
|
|
putf(IM);
|
|
if (setjmp(timeout)) {
|
|
cfsetispeed(&tmode, B0);
|
|
cfsetospeed(&tmode, B0);
|
|
(void)tcsetattr(STDIN_FILENO, TCSANOW, &tmode);
|
|
exit(1);
|
|
}
|
|
if (TO) {
|
|
signal(SIGALRM, dingdong);
|
|
alarm(TO);
|
|
}
|
|
|
|
rval = 0;
|
|
if (AL) {
|
|
const char *p = AL;
|
|
char *q = name;
|
|
|
|
while (*p && q < &name[sizeof name - 1]) {
|
|
if (isupper(*p))
|
|
upper = 1;
|
|
else if (islower(*p))
|
|
lower = 1;
|
|
else if (isdigit(*p))
|
|
digit = 1;
|
|
*q++ = *p++;
|
|
}
|
|
} else if (!(PL && PP))
|
|
rval = getname();
|
|
if (rval == 2 || (PL && PP)) {
|
|
oflush();
|
|
alarm(0);
|
|
limit.rlim_max = RLIM_INFINITY;
|
|
limit.rlim_cur = RLIM_INFINITY;
|
|
(void)setrlimit(RLIMIT_CPU, &limit);
|
|
execle(PP, "ppplogin", ttyn, (char *) 0, env);
|
|
syslog(LOG_ERR, "%s: %m", PP);
|
|
exit(1);
|
|
} else if (rval || AL) {
|
|
int i;
|
|
|
|
oflush();
|
|
alarm(0);
|
|
signal(SIGALRM, SIG_DFL);
|
|
if (name[0] == '\0')
|
|
continue;
|
|
if (name[0] == '-') {
|
|
puts("user names may not start with '-'.");
|
|
continue;
|
|
}
|
|
if (!(upper || lower || digit)) {
|
|
if (AL) {
|
|
syslog(LOG_ERR,
|
|
"invalid auto-login name: %s", AL);
|
|
exit(1);
|
|
} else
|
|
continue;
|
|
}
|
|
set_flags(2);
|
|
if (crmod) {
|
|
tmode.c_iflag |= ICRNL;
|
|
tmode.c_oflag |= ONLCR;
|
|
}
|
|
#if REALLY_OLD_TTYS
|
|
if (upper || UC)
|
|
tmode.sg_flags |= LCASE;
|
|
if (lower || LC)
|
|
tmode.sg_flags &= ~LCASE;
|
|
#endif
|
|
if (tcsetattr(STDIN_FILENO, TCSANOW, &tmode) < 0) {
|
|
syslog(LOG_ERR, "tcsetattr %s: %m", ttyn);
|
|
exit(1);
|
|
}
|
|
signal(SIGINT, SIG_DFL);
|
|
for (i = 0; environ[i] != (char *)0; i++)
|
|
env[i] = environ[i];
|
|
makeenv(&env[i]);
|
|
|
|
limit.rlim_max = RLIM_INFINITY;
|
|
limit.rlim_cur = RLIM_INFINITY;
|
|
(void)setrlimit(RLIMIT_CPU, &limit);
|
|
execle(LO, "login", AL ? "-fp" : "-p", name,
|
|
(char *) 0, env);
|
|
syslog(LOG_ERR, "%s: %m", LO);
|
|
exit(1);
|
|
}
|
|
alarm(0);
|
|
signal(SIGALRM, SIG_DFL);
|
|
signal(SIGINT, SIG_IGN);
|
|
if (NX && *NX) {
|
|
tname = NX;
|
|
dogettytab();
|
|
}
|
|
}
|
|
}
|
|
|
|
static int
|
|
opentty(const char *tty, int flags)
|
|
{
|
|
int failopenlogged = 0, i, saved_errno;
|
|
|
|
while ((i = open(tty, flags)) == -1)
|
|
{
|
|
saved_errno = errno;
|
|
if (!failopenlogged) {
|
|
syslog(LOG_ERR, "open %s: %m", tty);
|
|
failopenlogged = 1;
|
|
}
|
|
if (saved_errno == ENOENT)
|
|
return 0;
|
|
sleep(60);
|
|
}
|
|
if (login_tty(i) < 0) {
|
|
if (daemon(0,0) < 0) {
|
|
syslog(LOG_ERR,"daemon: %m");
|
|
close(i);
|
|
return 0;
|
|
}
|
|
if (login_tty(i) < 0) {
|
|
syslog(LOG_ERR, "login_tty %s: %m", tty);
|
|
close(i);
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
defttymode(void)
|
|
{
|
|
struct termios def;
|
|
|
|
/* Start with default tty settings. */
|
|
if (tcgetattr(STDIN_FILENO, &tmode) < 0) {
|
|
syslog(LOG_ERR, "tcgetattr %s: %m", ttyn);
|
|
exit(1);
|
|
}
|
|
omode = tmode; /* fill c_cc for dogettytab() */
|
|
dogettytab();
|
|
/*
|
|
* Don't rely on the driver too much, and initialize crucial
|
|
* things according to <sys/ttydefaults.h>. Avoid clobbering
|
|
* the c_cc[] settings however, the console drivers might wish
|
|
* to leave their idea of the preferred VERASE key value
|
|
* there.
|
|
*/
|
|
cfmakesane(&def);
|
|
tmode.c_iflag = def.c_iflag;
|
|
tmode.c_oflag = def.c_oflag;
|
|
tmode.c_lflag = def.c_lflag;
|
|
tmode.c_cflag = def.c_cflag;
|
|
if (NC)
|
|
tmode.c_cflag |= CLOCAL;
|
|
omode = tmode;
|
|
}
|
|
|
|
static void
|
|
setttymode(int raw)
|
|
{
|
|
int off = 0;
|
|
|
|
(void)tcflush(STDIN_FILENO, TCIOFLUSH); /* clear out the crap */
|
|
ioctl(STDIN_FILENO, FIONBIO, &off); /* turn off non-blocking mode */
|
|
ioctl(STDIN_FILENO, FIOASYNC, &off); /* ditto for async mode */
|
|
|
|
if (IS)
|
|
cfsetispeed(&tmode, speed(IS));
|
|
else if (SP)
|
|
cfsetispeed(&tmode, speed(SP));
|
|
if (OS)
|
|
cfsetospeed(&tmode, speed(OS));
|
|
else if (SP)
|
|
cfsetospeed(&tmode, speed(SP));
|
|
set_flags(0);
|
|
setchars();
|
|
if (raw)
|
|
cfmakeraw(&tmode);
|
|
if (tcsetattr(STDIN_FILENO, TCSANOW, &tmode) < 0) {
|
|
syslog(LOG_ERR, "tcsetattr %s: %m", ttyn);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
|
|
static int
|
|
getname(void)
|
|
{
|
|
int c;
|
|
char *np;
|
|
unsigned char cs;
|
|
int ppp_state = 0;
|
|
int ppp_connection = 0;
|
|
|
|
/*
|
|
* Interrupt may happen if we use CBREAK mode
|
|
*/
|
|
if (setjmp(intrupt)) {
|
|
signal(SIGINT, SIG_IGN);
|
|
return (0);
|
|
}
|
|
signal(SIGINT, interrupt);
|
|
set_flags(1);
|
|
prompt();
|
|
oflush();
|
|
if (PF > 0) {
|
|
sleep(PF);
|
|
PF = 0;
|
|
}
|
|
if (tcsetattr(STDIN_FILENO, TCSANOW, &tmode) < 0) {
|
|
syslog(LOG_ERR, "%s: %m", ttyn);
|
|
exit(1);
|
|
}
|
|
crmod = digit = lower = upper = 0;
|
|
np = name;
|
|
for (;;) {
|
|
oflush();
|
|
if (read(STDIN_FILENO, &cs, 1) <= 0)
|
|
exit(0);
|
|
if ((c = cs&0177) == 0)
|
|
return (0);
|
|
|
|
/* PPP detection state machine..
|
|
Look for sequences:
|
|
PPP_FRAME, PPP_STATION, PPP_ESCAPE, PPP_CONTROL_ESCAPED or
|
|
PPP_FRAME, PPP_STATION, PPP_CONTROL (deviant from RFC)
|
|
See RFC1662.
|
|
Derived from code from Michael Hancock, <michaelh@cet.co.jp>
|
|
and Erik 'PPP' Olson, <eriko@wrq.com>
|
|
*/
|
|
|
|
if (PP && (cs == PPP_FRAME)) {
|
|
ppp_state = 1;
|
|
} else if (ppp_state == 1 && cs == PPP_STATION) {
|
|
ppp_state = 2;
|
|
} else if (ppp_state == 2 && cs == PPP_ESCAPE) {
|
|
ppp_state = 3;
|
|
} else if ((ppp_state == 2 && cs == PPP_CONTROL)
|
|
|| (ppp_state == 3 && cs == PPP_CONTROL_ESCAPED)) {
|
|
ppp_state = 4;
|
|
} else if (ppp_state == 4 && cs == PPP_LCP_HI) {
|
|
ppp_state = 5;
|
|
} else if (ppp_state == 5 && cs == PPP_LCP_LOW) {
|
|
ppp_connection = 1;
|
|
break;
|
|
} else {
|
|
ppp_state = 0;
|
|
}
|
|
|
|
if (c == EOT || c == CTRL('d'))
|
|
exit(0);
|
|
if (c == '\r' || c == '\n' || np >= &name[sizeof name-1]) {
|
|
putf("\r\n");
|
|
break;
|
|
}
|
|
if (islower(c))
|
|
lower = 1;
|
|
else if (isupper(c))
|
|
upper = 1;
|
|
else if (c == ERASE || c == '\b' || c == 0177) {
|
|
if (np > name) {
|
|
np--;
|
|
if (cfgetospeed(&tmode) >= 1200)
|
|
puts("\b \b");
|
|
else
|
|
putchr(cs);
|
|
}
|
|
continue;
|
|
} else if (c == KILL || c == CTRL('u')) {
|
|
putchr('\r');
|
|
if (cfgetospeed(&tmode) < 1200)
|
|
putchr('\n');
|
|
/* this is the way they do it down under ... */
|
|
else if (np > name)
|
|
puts(" \r");
|
|
prompt();
|
|
digit = lower = upper = 0;
|
|
np = name;
|
|
continue;
|
|
} else if (isdigit(c))
|
|
digit = 1;
|
|
if (IG && (c <= ' ' || c > 0176))
|
|
continue;
|
|
*np++ = c;
|
|
putchr(cs);
|
|
}
|
|
signal(SIGINT, SIG_IGN);
|
|
*np = 0;
|
|
if (c == '\r')
|
|
crmod = 1;
|
|
if ((upper && !lower && !LC) || UC)
|
|
for (np = name; *np; np++)
|
|
if (isupper(*np))
|
|
*np = tolower(*np);
|
|
return (1 + ppp_connection);
|
|
}
|
|
|
|
static void
|
|
putpad(const char *s)
|
|
{
|
|
int pad = 0;
|
|
speed_t ospeed = cfgetospeed(&tmode);
|
|
|
|
if (isdigit(*s)) {
|
|
while (isdigit(*s)) {
|
|
pad *= 10;
|
|
pad += *s++ - '0';
|
|
}
|
|
pad *= 10;
|
|
if (*s == '.' && isdigit(s[1])) {
|
|
pad += s[1] - '0';
|
|
s += 2;
|
|
}
|
|
}
|
|
|
|
puts(s);
|
|
/*
|
|
* If no delay needed, or output speed is
|
|
* not comprehensible, then don't try to delay.
|
|
*/
|
|
if (pad == 0 || ospeed <= 0)
|
|
return;
|
|
|
|
/*
|
|
* Round up by a half a character frame, and then do the delay.
|
|
* Too bad there are no user program accessible programmed delays.
|
|
* Transmitting pad characters slows many terminals down and also
|
|
* loads the system.
|
|
*/
|
|
pad = (pad * ospeed + 50000) / 100000;
|
|
while (pad--)
|
|
putchr(*PC);
|
|
}
|
|
|
|
static void
|
|
puts(const char *s)
|
|
{
|
|
while (*s)
|
|
putchr(*s++);
|
|
}
|
|
|
|
static char outbuf[OBUFSIZ];
|
|
static int obufcnt = 0;
|
|
|
|
static void
|
|
putchr(int cc)
|
|
{
|
|
char c;
|
|
|
|
c = cc;
|
|
if (!NP) {
|
|
c |= partab[c&0177] & 0200;
|
|
if (OP)
|
|
c ^= 0200;
|
|
}
|
|
if (!UB) {
|
|
outbuf[obufcnt++] = c;
|
|
if (obufcnt >= OBUFSIZ)
|
|
oflush();
|
|
} else
|
|
write(STDOUT_FILENO, &c, 1);
|
|
}
|
|
|
|
static void
|
|
oflush(void)
|
|
{
|
|
if (obufcnt)
|
|
write(STDOUT_FILENO, outbuf, obufcnt);
|
|
obufcnt = 0;
|
|
}
|
|
|
|
static void
|
|
prompt(void)
|
|
{
|
|
|
|
putf(LM);
|
|
if (CO)
|
|
putchr('\n');
|
|
}
|
|
|
|
|
|
static char *
|
|
get_line(int fd)
|
|
{
|
|
size_t i = 0;
|
|
static char linebuf[512];
|
|
|
|
/*
|
|
* This is certainly slow, but it avoids having to include
|
|
* stdio.h unnecessarily. Issue files should be small anyway.
|
|
*/
|
|
while (i < (sizeof linebuf - 3) && read(fd, linebuf+i, 1)==1) {
|
|
if (linebuf[i] == '\n') {
|
|
/* Don't rely on newline mode, assume raw */
|
|
linebuf[i++] = '\r';
|
|
linebuf[i++] = '\n';
|
|
linebuf[i] = '\0';
|
|
return linebuf;
|
|
}
|
|
++i;
|
|
}
|
|
linebuf[i] = '\0';
|
|
return i ? linebuf : 0;
|
|
}
|
|
|
|
static void
|
|
putf(const char *cp)
|
|
{
|
|
time_t t;
|
|
char db[100];
|
|
const char *slash;
|
|
|
|
static struct utsname kerninfo;
|
|
|
|
if (!*kerninfo.sysname)
|
|
uname(&kerninfo);
|
|
|
|
while (*cp) {
|
|
if (*cp != '%') {
|
|
putchr(*cp++);
|
|
continue;
|
|
}
|
|
switch (*++cp) {
|
|
|
|
case 't':
|
|
slash = strrchr(ttyn, '/');
|
|
if (slash == (char *) 0)
|
|
puts(ttyn);
|
|
else
|
|
puts(&slash[1]);
|
|
break;
|
|
|
|
case 'h':
|
|
puts(editedhost);
|
|
break;
|
|
|
|
case 'd':
|
|
t = (time_t)0;
|
|
(void)time(&t);
|
|
if (Lo)
|
|
(void)setlocale(LC_TIME, Lo);
|
|
(void)strftime(db, sizeof(db), DF, localtime(&t));
|
|
puts(db);
|
|
break;
|
|
|
|
case 's':
|
|
puts(kerninfo.sysname);
|
|
break;
|
|
|
|
case 'm':
|
|
puts(kerninfo.machine);
|
|
break;
|
|
|
|
case 'r':
|
|
puts(kerninfo.release);
|
|
break;
|
|
|
|
case 'v':
|
|
puts(kerninfo.version);
|
|
break;
|
|
|
|
case '%':
|
|
putchr('%');
|
|
break;
|
|
}
|
|
cp++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Read a gettytab database entry and perform necessary quirks.
|
|
*/
|
|
static void
|
|
dogettytab(void)
|
|
{
|
|
|
|
/* Read the database entry. */
|
|
gettable(tname);
|
|
|
|
/*
|
|
* Avoid inheriting the parity values from the default entry
|
|
* if any of them is set in the current entry.
|
|
* Mixing different parity settings is unreasonable.
|
|
*/
|
|
if (OPset || EPset || APset || NPset)
|
|
OPset = EPset = APset = NPset = 1;
|
|
|
|
/* Fill in default values for unset capabilities. */
|
|
setdefaults();
|
|
}
|