Home | History | Annotate | Line # | Download | only in getty
main.c revision 1.44 
      1 /*	$NetBSD: main.c,v 1.44 2003/05/20 19:20:03 thorpej Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1980, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *	This product includes software developed by the University of
     18  *	California, Berkeley and its contributors.
     19  * 4. Neither the name of the University nor the names of its contributors
     20  *    may be used to endorse or promote products derived from this software
     21  *    without specific prior written permission.
     22  *
     23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33  * SUCH DAMAGE.
     34  */
     35 
     36 #include <sys/cdefs.h>
     37 
     38 #ifndef lint
     39 __COPYRIGHT("@(#) Copyright (c) 1980, 1993\n\
     40 	The Regents of the University of California.  All rights reserved.\n");
     41 #endif /* not lint */
     42 
     43 #ifndef lint
     44 #if 0
     45 static char sccsid[] = "from: @(#)main.c	8.1 (Berkeley) 6/20/93";
     46 #else
     47 __RCSID("$NetBSD: main.c,v 1.44 2003/05/20 19:20:03 thorpej Exp $");
     48 #endif
     49 #endif /* not lint */
     50 
     51 #include <sys/param.h>
     52 #include <sys/stat.h>
     53 #include <termios.h>
     54 #include <sys/ioctl.h>
     55 #include <sys/resource.h>
     56 #include <sys/utsname.h>
     57 
     58 #include <errno.h>
     59 #include <fcntl.h>
     60 #include <time.h>
     61 #include <ctype.h>
     62 #include <fcntl.h>
     63 #include <pwd.h>
     64 #include <setjmp.h>
     65 #include <signal.h>
     66 #include <stdlib.h>
     67 #include <string.h>
     68 #include <syslog.h>
     69 #include <time.h>
     70 #include <unistd.h>
     71 #include <util.h>
     72 #include <limits.h>
     73 #include <ttyent.h>
     74 #include <termcap.h>
     75 
     76 #include "gettytab.h"
     77 #include "pathnames.h"
     78 #include "extern.h"
     79 
     80 extern char **environ;
     81 extern char editedhost[];
     82 
     83 /*
     84  * Set the amount of running time that getty should accumulate
     85  * before deciding that something is wrong and exit.
     86  */
     87 #define GETTY_TIMEOUT	60 /* seconds */
     88 
     89 /* defines for auto detection of incoming PPP calls (->PAP/CHAP) */
     90 
     91 #define PPP_FRAME           0x7e  /* PPP Framing character */
     92 #define PPP_STATION         0xff  /* "All Station" character */
     93 #define PPP_ESCAPE          0x7d  /* Escape Character */
     94 #define PPP_CONTROL         0x03  /* PPP Control Field */
     95 #define PPP_CONTROL_ESCAPED 0x23  /* PPP Control Field, escaped */
     96 #define PPP_LCP_HI          0xc0  /* LCP protocol - high byte */
     97 #define PPP_LCP_LOW         0x21  /* LCP protocol - low byte */
     98 
     99 struct termios tmode, omode;
    100 
    101 int crmod, digit, lower, upper;
    102 
    103 char	hostname[MAXHOSTNAMELEN + 1];
    104 struct	utsname kerninfo;
    105 char	name[LOGIN_NAME_MAX];
    106 char	dev[] = _PATH_DEV;
    107 char	ttyn[32];
    108 char	lockfile[512];
    109 uid_t	ttyowner;
    110 char	*rawttyn;
    111 
    112 #define	OBUFSIZ		128
    113 #define	TABBUFSIZ	512
    114 
    115 char	defent[TABBUFSIZ];
    116 char	tabent[TABBUFSIZ];
    117 
    118 char	*env[128];
    119 
    120 const char partab[] = {
    121 	0001,0201,0201,0001,0201,0001,0001,0201,
    122 	0202,0004,0003,0205,0005,0206,0201,0001,
    123 	0201,0001,0001,0201,0001,0201,0201,0001,
    124 	0001,0201,0201,0001,0201,0001,0001,0201,
    125 	0200,0000,0000,0200,0000,0200,0200,0000,
    126 	0000,0200,0200,0000,0200,0000,0000,0200,
    127 	0000,0200,0200,0000,0200,0000,0000,0200,
    128 	0200,0000,0000,0200,0000,0200,0200,0000,
    129 	0200,0000,0000,0200,0000,0200,0200,0000,
    130 	0000,0200,0200,0000,0200,0000,0000,0200,
    131 	0000,0200,0200,0000,0200,0000,0000,0200,
    132 	0200,0000,0000,0200,0000,0200,0200,0000,
    133 	0000,0200,0200,0000,0200,0000,0000,0200,
    134 	0200,0000,0000,0200,0000,0200,0200,0000,
    135 	0200,0000,0000,0200,0000,0200,0200,0000,
    136 	0000,0200,0200,0000,0200,0000,0000,0201
    137 };
    138 
    139 #define	ERASE	tmode.c_cc[VERASE]
    140 #define	KILL	tmode.c_cc[VKILL]
    141 #define	EOT	tmode.c_cc[VEOF]
    142 
    143 static void	clearscreen(void);
    144 
    145 jmp_buf timeout;
    146 
    147 static void
    148 dingdong(int signo)
    149 {
    150 
    151 	alarm(0);
    152 	signal(SIGALRM, SIG_DFL);
    153 	longjmp(timeout, 1);
    154 }
    155 
    156 jmp_buf	intrupt;
    157 
    158 static void
    159 interrupt(int signo)
    160 {
    161 
    162 	signal(SIGINT, interrupt);
    163 	longjmp(intrupt, 1);
    164 }
    165 
    166 /*
    167  * Action to take when getty is running too long.
    168  */
    169 static void
    170 timeoverrun(int signo)
    171 {
    172 
    173 	syslog(LOG_ERR, "getty exiting due to excessive running time");
    174 	exit(1);
    175 }
    176 
    177 int		main(int, char *[]);
    178 static int	getname(void);
    179 static void	oflush(void);
    180 static void	prompt(void);
    181 static void	putchr(int);
    182 static void	putf(const char *);
    183 static void	putpad(const char *);
    184 static void	xputs(const char *);
    185 
    186 int
    187 main(int argc, char *argv[])
    188 {
    189 	const char *progname;
    190 	char *tname;
    191 	int repcnt = 0, failopenlogged = 0, uugetty = 0, first_time = 1;
    192 	struct rlimit limit;
    193 	struct passwd *pw;
    194         int rval;
    195 
    196 #ifdef __GNUC__
    197 	(void)&tname;		/* XXX gcc -Wall */
    198 #endif
    199 
    200 	signal(SIGINT, SIG_IGN);
    201 /*
    202 	signal(SIGQUIT, SIG_DFL);
    203 */
    204 	openlog("getty", LOG_PID, LOG_AUTH);
    205 	gethostname(hostname, sizeof(hostname));
    206 	hostname[sizeof(hostname) - 1] = '\0';
    207 	if (hostname[0] == '\0')
    208 		strlcpy(hostname, "Amnesiac", sizeof(hostname));
    209 	uname(&kerninfo);
    210 
    211 	progname = getprogname();
    212 	if (progname[0] == 'u' && progname[1] == 'u')
    213 		uugetty = 1;
    214 
    215 	/*
    216 	 * Find id of uucp login (if present) so we can chown tty properly.
    217 	 */
    218 	if (uugetty && (pw = getpwnam("uucp")))
    219 		ttyowner = pw->pw_uid;
    220 	else
    221 		ttyowner = 0;
    222 
    223 	/*
    224 	 * Limit running time to deal with broken or dead lines.
    225 	 */
    226 	(void)signal(SIGXCPU, timeoverrun);
    227 	limit.rlim_max = RLIM_INFINITY;
    228 	limit.rlim_cur = GETTY_TIMEOUT;
    229 	(void)setrlimit(RLIMIT_CPU, &limit);
    230 
    231 	/*
    232 	 * The following is a work around for vhangup interactions
    233 	 * which cause great problems getting window systems started.
    234 	 * If the tty line is "-", we do the old style getty presuming
    235 	 * that the file descriptors are already set up for us.
    236 	 * J. Gettys - MIT Project Athena.
    237 	 */
    238 	if (argc <= 2 || strcmp(argv[2], "-") == 0) {
    239 	    strlcpy(ttyn, ttyname(0), sizeof(ttyn));
    240 	}
    241 	else {
    242 	    int i;
    243 
    244 	    rawttyn = argv[2];
    245 	    strlcpy(ttyn, dev, sizeof(ttyn));
    246 	    strlcat(ttyn, argv[2], sizeof(ttyn));
    247 
    248 	    if (uugetty)  {
    249 		chown(ttyn, ttyowner, 0);
    250 		strlcpy(lockfile, _PATH_LOCK, sizeof(lockfile));
    251 		strlcat(lockfile, argv[2], sizeof(lockfile));
    252 		/* wait for lockfiles to go away before we try to open */
    253 		if ( pidlock(lockfile, 0, 0, 0) != 0 )  {
    254 		    syslog(LOG_ERR, "%s: can't create lockfile", ttyn);
    255 		    exit(1);
    256 		}
    257 		unlink(lockfile);
    258 	    }
    259 	    if (strcmp(argv[0], "+") != 0) {
    260 		chown(ttyn, ttyowner, 0);
    261 		chmod(ttyn, 0600);
    262 		revoke(ttyn);
    263 		if (ttyaction(ttyn, "getty", "root"))
    264 			syslog(LOG_WARNING, "%s: ttyaction failed", ttyn);
    265 		/*
    266 		 * Delay the open so DTR stays down long enough to be detected.
    267 		 */
    268 		sleep(2);
    269 		while ((i = open(ttyn, O_RDWR)) == -1) {
    270 			if ((repcnt % 10 == 0) &&
    271 			    (errno != ENXIO || !failopenlogged)) {
    272 				syslog(LOG_WARNING, "%s: %m", ttyn);
    273 				closelog();
    274 				failopenlogged = 1;
    275 			}
    276 			repcnt++;
    277 			sleep(60);
    278 		}
    279 		if (uugetty && pidlock(lockfile, 0, 0, 0) != 0)  {
    280 			syslog(LOG_ERR, "%s: can't create lockfile", ttyn);
    281 			exit(1);
    282 		}
    283 		(void) chown(lockfile, ttyowner, 0);
    284 		login_tty(i);
    285 	    }
    286 	}
    287 
    288 	/* Start with default tty settings */
    289 	if (tcgetattr(0, &tmode) < 0) {
    290 		syslog(LOG_ERR, "%s: %m", ttyn);
    291 		exit(1);
    292 	}
    293 	omode = tmode;
    294 
    295 	gettable("default", defent);
    296 	gendefaults();
    297 	tname = "default";
    298 	if (argc > 1)
    299 		tname = argv[1];
    300 	for (;;) {
    301 		int off;
    302 
    303 		gettable(tname, tabent);
    304 		if (OPset || EPset || APset)
    305 			APset++, OPset++, EPset++;
    306 		setdefaults();
    307 		off = 0;
    308 		(void)tcflush(0, TCIOFLUSH);	/* clear out the crap */
    309 		ioctl(0, FIONBIO, &off);	/* turn off non-blocking mode */
    310 		ioctl(0, FIOASYNC, &off);	/* ditto for async mode */
    311 
    312 		if (IS)
    313 			cfsetispeed(&tmode, IS);
    314 		else if (SP)
    315 			cfsetispeed(&tmode, SP);
    316 		if (OS)
    317 			cfsetospeed(&tmode, OS);
    318 		else if (SP)
    319 			cfsetospeed(&tmode, SP);
    320 		setflags(0);
    321 		setchars();
    322 		if (tcsetattr(0, TCSANOW, &tmode) < 0) {
    323 			syslog(LOG_ERR, "%s: %m", ttyn);
    324 			exit(1);
    325 		}
    326 		if (AB) {
    327 			tname = autobaud();
    328 			continue;
    329 		}
    330 		if (PS) {
    331 			tname = portselector();
    332 			continue;
    333 		}
    334 		if (CS)
    335 			clearscreen();
    336 		if (CL && *CL)
    337 			putpad(CL);
    338 		edithost(HE);
    339 
    340                 /*
    341                  * If this is the first time through this, and an
    342                  * issue file has been given, then send it.
    343                  */
    344 		if (first_time != 0 && IF != NULL) {
    345 			char buf[_POSIX2_LINE_MAX];
    346 			FILE *fd;
    347 
    348 			if ((fd = fopen(IF, "r")) != NULL) {
    349 				while (fgets(buf, sizeof(buf) - 1, fd) != NULL)
    350 					putf(buf);
    351 				fclose(fd);
    352 			}
    353 		}
    354 		first_time = 0;
    355 
    356 		if (IM && *IM)
    357 			putf(IM);
    358 		oflush();
    359 		if (setjmp(timeout)) {
    360 			tmode.c_ispeed = tmode.c_ospeed = 0;
    361 			(void)tcsetattr(0, TCSANOW, &tmode);
    362 			exit(1);
    363 		}
    364 		if (TO) {
    365 			signal(SIGALRM, dingdong);
    366 			alarm(TO);
    367 		}
    368 		if (NN) {
    369 			name[0] = '\0';
    370 			lower = 1;
    371 			upper = digit = 0;
    372 		} else if (AL) {
    373 			const char *p = AL;
    374 			char *q = name;
    375 
    376 			while (*p && q < &name[sizeof name - 1]) {
    377 				if (isupper(*p))
    378 					upper = 1;
    379 				else if (islower(*p))
    380 					lower = 1;
    381 				else if (isdigit(*p))
    382 					digit++;
    383 				*q++ = *p++;
    384 			}
    385 		} else if ((rval = getname()) == 2) {
    386 		        execle(PP, "ppplogin", ttyn, (char *) 0, env);
    387 		        syslog(LOG_ERR, "%s: %m", PP);
    388 		        exit(1);
    389 		}
    390 
    391 		if (rval || AL || NN) {
    392 			int i;
    393 
    394 			oflush();
    395 			alarm(0);
    396 			signal(SIGALRM, SIG_DFL);
    397 			if (name[0] == '-') {
    398 				xputs("user names may not start with '-'.");
    399 				continue;
    400 			}
    401 			if (!(upper || lower || digit))
    402 				continue;
    403 			setflags(2);
    404 			if (crmod) {
    405 				tmode.c_iflag |= ICRNL;
    406 				tmode.c_oflag |= ONLCR;
    407 			}
    408 #if XXX
    409 			if (upper || UC)
    410 				tmode.sg_flags |= LCASE;
    411 			if (lower || LC)
    412 				tmode.sg_flags &= ~LCASE;
    413 #endif
    414 			if (tcsetattr(0, TCSANOW, &tmode) < 0) {
    415 				syslog(LOG_ERR, "%s: %m", ttyn);
    416 				exit(1);
    417 			}
    418 			signal(SIGINT, SIG_DFL);
    419 			for (i = 0; environ[i] != (char *)0; i++)
    420 				env[i] = environ[i];
    421 			makeenv(&env[i]);
    422 
    423 			limit.rlim_max = RLIM_INFINITY;
    424 			limit.rlim_cur = RLIM_INFINITY;
    425 			(void)setrlimit(RLIMIT_CPU, &limit);
    426 			if (NN)
    427 				execle(LO, "login", AL ? "-fp" : "-p",
    428 				    NULL, env);
    429 			else
    430 				execle(LO, "login", AL ? "-fp" : "-p",
    431 				    "--", name, NULL, env);
    432 			syslog(LOG_ERR, "%s: %m", LO);
    433 			exit(1);
    434 		}
    435 		alarm(0);
    436 		signal(SIGALRM, SIG_DFL);
    437 		signal(SIGINT, SIG_IGN);
    438 		if (NX && *NX)
    439 			tname = NX;
    440 		unlink(lockfile);
    441 	}
    442 }
    443 
    444 static int
    445 getname(void)
    446 {
    447 	int c;
    448 	char *np;
    449 	unsigned char cs;
    450 	int ppp_state, ppp_connection;
    451 
    452 	/*
    453 	 * Interrupt may happen if we use CBREAK mode
    454 	 */
    455 	if (setjmp(intrupt)) {
    456 		signal(SIGINT, SIG_IGN);
    457 		return (0);
    458 	}
    459 	signal(SIGINT, interrupt);
    460 	setflags(1);
    461 	prompt();
    462 	if (PF > 0) {
    463 		oflush();
    464 		sleep(PF);
    465 		PF = 0;
    466 	}
    467 	if (tcsetattr(0, TCSANOW, &tmode) < 0) {
    468 		syslog(LOG_ERR, "%s: %m", ttyn);
    469 		exit(1);
    470 	}
    471 	crmod = digit = lower = upper = 0;
    472         ppp_state = ppp_connection = 0;
    473 	np = name;
    474 	for (;;) {
    475 		oflush();
    476 		if (read(STDIN_FILENO, &cs, 1) <= 0)
    477 			exit(0);
    478 		if ((c = cs&0177) == 0)
    479 			return (0);
    480 
    481 		/*
    482 		 * PPP detection state machine..
    483 		 * Look for sequences:
    484 		 * PPP_FRAME, PPP_STATION, PPP_ESCAPE, PPP_CONTROL_ESCAPED or
    485 		 * PPP_FRAME, PPP_STATION, PPP_CONTROL (deviant from RFC)
    486 		 * See RFC1662.
    487 		 * Derived from code from Michael Hancock <michaelh (at) cet.co.jp>
    488 		 * and Erik 'PPP' Olson <eriko (at) wrq.com>
    489 		 */
    490 		if (PP && cs == PPP_FRAME) {
    491 			ppp_state = 1;
    492 		} else if (ppp_state == 1 && cs == PPP_STATION) {
    493 			ppp_state = 2;
    494 		} else if (ppp_state == 2 && cs == PPP_ESCAPE) {
    495 			ppp_state = 3;
    496 		} else if ((ppp_state == 2 && cs == PPP_CONTROL) ||
    497 		    (ppp_state == 3 && cs == PPP_CONTROL_ESCAPED)) {
    498 			ppp_state = 4;
    499 		} else if (ppp_state == 4 && cs == PPP_LCP_HI) {
    500 			ppp_state = 5;
    501 		} else if (ppp_state == 5 && cs == PPP_LCP_LOW) {
    502 			ppp_connection = 1;
    503 			break;
    504 		} else {
    505 			ppp_state = 0;
    506 		}
    507 
    508 		if (c == EOT)
    509 			exit(1);
    510 		if (c == '\r' || c == '\n' ||
    511 		    np >= &name[LOGIN_NAME_MAX - 1]) {
    512 			*np = '\0';
    513 			putf("\r\n");
    514 			break;
    515 		}
    516 		if (islower(c))
    517 			lower = 1;
    518 		else if (isupper(c))
    519 			upper = 1;
    520 		else if (c == ERASE || c == '#' || c == '\b') {
    521 			if (np > name) {
    522 				np--;
    523 				if (cfgetospeed(&tmode) >= 1200)
    524 					xputs("\b \b");
    525 				else
    526 					putchr(cs);
    527 			}
    528 			continue;
    529 		} else if (c == KILL || c == '@') {
    530 			putchr(cs);
    531 			putchr('\r');
    532 			if (cfgetospeed(&tmode) < 1200)
    533 				putchr('\n');
    534 			/* this is the way they do it down under ... */
    535 			else if (np > name)
    536 				xputs(
    537 				    "                                     \r");
    538 			prompt();
    539 			np = name;
    540 			continue;
    541 		} else if (isdigit(c))
    542 			digit++;
    543 		if (IG && (c <= ' ' || c > 0176))
    544 			continue;
    545 		*np++ = c;
    546 		putchr(cs);
    547 
    548 		/*
    549 		 * An MS-Windows direct connect PPP "client" won't send its
    550 		 * first PPP packet until we respond to its "CLIENT" poll
    551 		 * with a CRLF sequence.  We cater to yet another broken
    552 		 * implementation of a previously-standard protocol...
    553 		 */
    554 		*np = '\0';
    555 		if (strstr(name, "CLIENT"))
    556 		       putf("\r\n");
    557 	}
    558 	signal(SIGINT, SIG_IGN);
    559 	*np = 0;
    560 	if (c == '\r')
    561 		crmod = 1;
    562 	if ((upper && !lower && !LC) || UC)
    563 		for (np = name; *np; np++)
    564 			if (isupper(*np))
    565 				*np = tolower(*np);
    566 	return (1 + ppp_connection);
    567 }
    568 
    569 static void
    570 putpad(const char *s)
    571 {
    572 	int pad = 0;
    573 	speed_t ospeed = cfgetospeed(&tmode);
    574 
    575 	if (isdigit(*s)) {
    576 		while (isdigit(*s)) {
    577 			pad *= 10;
    578 			pad += *s++ - '0';
    579 		}
    580 		pad *= 10;
    581 		if (*s == '.' && isdigit(s[1])) {
    582 			pad += s[1] - '0';
    583 			s += 2;
    584 		}
    585 	}
    586 
    587 	xputs(s);
    588 	/*
    589 	 * If no delay needed, or output speed is
    590 	 * not comprehensible, then don't try to delay.
    591 	 */
    592 	if (pad == 0 || ospeed <= 0)
    593 		return;
    594 
    595 	/*
    596 	 * Round up by a half a character frame, and then do the delay.
    597 	 * Too bad there are no user program accessible programmed delays.
    598 	 * Transmitting pad characters slows many terminals down and also
    599 	 * loads the system.
    600 	 */
    601 	pad = (pad * ospeed + 50000) / 100000;
    602 	while (pad--)
    603 		putchr(*PC);
    604 }
    605 
    606 static void
    607 xputs(const char *s)
    608 {
    609 	while (*s)
    610 		putchr(*s++);
    611 }
    612 
    613 char	outbuf[OBUFSIZ];
    614 int	obufcnt = 0;
    615 
    616 static void
    617 putchr(int cc)
    618 {
    619 	char c;
    620 
    621 	c = cc;
    622 	if (!NP) {
    623 		c |= partab[c&0177] & 0200;
    624 		if (OP)
    625 			c ^= 0200;
    626 	}
    627 	if (!UB) {
    628 		outbuf[obufcnt++] = c;
    629 		if (obufcnt >= OBUFSIZ)
    630 			oflush();
    631 	} else
    632 		write(STDOUT_FILENO, &c, 1);
    633 }
    634 
    635 static void
    636 oflush(void)
    637 {
    638 	if (obufcnt)
    639 		write(STDOUT_FILENO, outbuf, obufcnt);
    640 	obufcnt = 0;
    641 }
    642 
    643 static void
    644 prompt(void)
    645 {
    646 
    647 	putf(LM);
    648 	if (CO)
    649 		putchr('\n');
    650 }
    651 
    652 static void
    653 putf(const char *cp)
    654 {
    655 	time_t t;
    656 	char *slash, db[100];
    657 
    658 	while (*cp) {
    659 		if (*cp != '%') {
    660 			putchr(*cp++);
    661 			continue;
    662 		}
    663 		switch (*++cp) {
    664 
    665 		case 't':
    666 			slash = strrchr(ttyn, '/');
    667 			if (slash == NULL)
    668 				xputs(ttyn);
    669 			else
    670 				xputs(&slash[1]);
    671 			break;
    672 
    673 		case 'h':
    674 			xputs(editedhost);
    675 			break;
    676 
    677 		case 'd':
    678 			(void)time(&t);
    679 			(void)strftime(db, sizeof(db),
    680 			    /* SCCS eats %M% */
    681 			    "%l:%M" "%p on %A, %d %B %Y", localtime(&t));
    682 			xputs(db);
    683 			break;
    684 
    685 		case 's':
    686 			xputs(kerninfo.sysname);
    687 			break;
    688 
    689 		case 'm':
    690 			xputs(kerninfo.machine);
    691 			break;
    692 
    693 		case 'r':
    694 			xputs(kerninfo.release);
    695 			break;
    696 
    697 		case 'v':
    698 			xputs(kerninfo.version);
    699 			break;
    700 
    701 		case '%':
    702 			putchr('%');
    703 			break;
    704 		}
    705 		if (*cp)
    706 			cp++;
    707 	}
    708 }
    709 
    710 static void
    711 clearscreen(void)
    712 {
    713 	struct ttyent *typ;
    714 	struct tinfo *tinfo;
    715 	char *cs;
    716 
    717 	if (rawttyn == NULL)
    718 		return;
    719 
    720 	typ = getttynam(rawttyn);
    721 
    722 	if ((typ == NULL) || (typ->ty_type == NULL) ||
    723 	    (typ->ty_type[0] == 0))
    724 		return;
    725 
    726 	if (t_getent(&tinfo, typ->ty_type) <= 0)
    727 		return;
    728 
    729 	cs = t_agetstr(tinfo, "cl");
    730 	if (cs == NULL)
    731 		return;
    732 
    733 	putpad(cs);
    734 }
    735