xref: /illumos-gate/usr/src/cmd/last/last.c (revision 299c9e70)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2017 Olaf Bohlen
 *
 * Copyright (c) 2013 Gary Mills
 *
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 *	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T
 *	  All Rights Reserved
 */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

/*
 * last
 */
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>
#include <signal.h>
#include <sys/stat.h>
#include <pwd.h>
#include <fcntl.h>
#include <utmpx.h>
#include <locale.h>
#include <ctype.h>

/*
 * Use the full lengths from utmpx for NMAX, LMAX and HMAX .
 */
#define	NMAX	(sizeof (((struct utmpx *)0)->ut_user))
#define	LMAX	(sizeof (((struct utmpx *)0)->ut_line))
#define	HMAX	(sizeof (((struct utmpx *)0)->ut_host))

/* Print minimum field widths. */
#define	LOGIN_WIDTH	8
#define	LINE_WIDTH	12

#define	SECDAY	(24*60*60)
#define	CHUNK_SIZE 256

#define	lineq(a, b)	(strncmp(a, b, LMAX) == 0)
#define	nameq(a, b)	(strncmp(a, b, NMAX) == 0)
#define	hosteq(a, b)	(strncmp(a, b, HMAX) == 0)
#define	linehostnameq(a, b, c, d) \
	    (lineq(a, b)&&hosteq(a+LMAX+1, c)&&nameq(a+LMAX+HMAX+2, d))

#define	USAGE	"usage: last [-n number] [-f filename] [-a ] [ -l ] [name |\
 tty] ...\n"

/* Beware: These are set in main() to exclude the executable name.  */
static char	**argv;
static int	argc;
static char	**names;
static int	names_num;

static struct	utmpx buf[128];

/*
 * ttnames and logouts are allocated in the blocks of
 * CHUNK_SIZE lines whenever needed. The count of the
 * current size is maintained in the variable "lines"
 * The variable bootxtime is used to hold the time of
 * the last BOOT_TIME
 * All elements of the logouts are initialised to bootxtime
 * everytime the buffer is reallocated.
 */

static char	**ttnames;
static time_t	*logouts;
static time_t	bootxtime;
static int	lines;
static char	timef[128];
static char	hostf[HMAX + 1];

static char *strspl(char *, char *);
static void onintr(int);
static void reallocate_buffer();
static void memory_alloc(int);
static int want(struct utmpx *, char **, char **);
static void record_time(time_t *, int *, int, struct utmpx *);

int
main(int ac, char **av)
{
	int i, j;
	int aflag = 0;
	int lflag = 0;  /* parameter -l, long format with seconds and years */
	int fpos;	/* current position in time format buffer */
	int chrcnt;	/* # of chars formatted by current sprintf */
	int bl, wtmp;
	char *ct;
	char *ut_host;
	char *ut_user;
	struct utmpx *bp;
	time_t otime;
	struct stat stb;
	int print = 0;
	char *crmsg = (char *)0;
	long outrec = 0;
	long maxrec = 0x7fffffffL;
	char *wtmpfile = "/var/adm/wtmpx";
	size_t hostf_len;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)		/* Should be defined by cc -D */
#define	TEXT_DOMAIN "SYS_TEST"		/* Use this only if it weren't. */
#endif
	(void) textdomain(TEXT_DOMAIN);

	(void) time(&buf[0].ut_xtime);
	ac--, av++;
	argc = ac;
	argv = av;
	names = malloc(argc * sizeof (char *));
	if (names == NULL) {
		perror("last");
		exit(2);
	}
	names_num = 0;
	for (i = 0; i < argc; i++) {
		if (argv[i][0] == '-') {

			/* -[0-9]*   sets max # records to print */
			if (isdigit(argv[i][1])) {
				maxrec = atoi(argv[i]+1);
				continue;
			}

			for (j = 1; argv[i][j] != '\0'; ++j) {
				switch (argv[i][j]) {

				/* -f name sets filename of wtmp file */
				case 'f':
					if (argv[i][j+1] != '\0') {
						wtmpfile = &argv[i][j+1];
					} else if (i+1 < argc) {
						wtmpfile = argv[++i];
					} else {
						(void) fprintf(stderr,
						    gettext("last: argument to "
						    "-f is missing\n"));
						(void) fprintf(stderr,
						    gettext(USAGE));
						exit(1);
					}
					goto next_word;

				/* -n number sets max # records to print */
				case 'n': {
					char *arg;

					if (argv[i][j+1] != '\0') {
						arg = &argv[i][j+1];
					} else if (i+1 < argc) {
						arg = argv[++i];
					} else {
						(void) fprintf(stderr,
						    gettext("last: argument to "
						    "-n is missing\n"));
						(void) fprintf(stderr,
						    gettext(USAGE));
						exit(1);
					}

					if (!isdigit(*arg)) {
						(void) fprintf(stderr,
						    gettext("last: argument to "
						    "-n is not a number\n"));
						(void) fprintf(stderr,
						    gettext(USAGE));
						exit(1);
					}
					maxrec = atoi(arg);
					goto next_word;
				}

				/* -a displays hostname last on the line */
				case 'a':
					aflag++;
					break;

				/* -l turns on long dates and times */
				case 'l':
					lflag++;
					break;

				default:
					(void) fprintf(stderr, gettext(USAGE));
					exit(1);
				}
			}

next_word:
			continue;
		}

		if (strlen(argv[i]) > 2 || strcmp(argv[i], "~") == 0 ||
		    getpwnam(argv[i]) != NULL) {
			/* Not a tty number. */
			names[names_num] = argv[i];
			++names_num;
		} else {
			/* tty number.  Prepend "tty". */
			names[names_num] = strspl("tty", argv[i]);
			++names_num;
		}
	}

	wtmp = open(wtmpfile, 0);
	if (wtmp < 0) {
		perror(wtmpfile);
		exit(1);
	}
	(void) fstat(wtmp, &stb);
	bl = (stb.st_size + sizeof (buf)-1) / sizeof (buf);
	if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
		(void) signal(SIGINT, onintr);
		(void) signal(SIGQUIT, onintr);
	}
	lines = CHUNK_SIZE;
	ttnames = calloc(lines, sizeof (char *));
	logouts = calloc(lines, sizeof (time_t));
	if (ttnames == NULL || logouts == NULL) {
		(void) fprintf(stderr, gettext("Out of memory \n "));
		exit(2);
	}
		for (bl--; bl >= 0; bl--) {
		(void) lseek(wtmp, (off_t)(bl * sizeof (buf)), 0);
		bp = &buf[read(wtmp, buf, sizeof (buf)) / sizeof (buf[0]) - 1];
		for (; bp >= buf; bp--) {
			if (want(bp, &ut_host, &ut_user)) {
				for (i = 0; i <= lines; i++) {
				if (i == lines)
					reallocate_buffer();
				if (ttnames[i] == NULL) {
					memory_alloc(i);
					/*
					 * LMAX+HMAX+NMAX+3 bytes have been
					 * allocated for ttnames[i].
					 * If bp->ut_line is longer than LMAX,
					 * ut_host is longer than HMAX,
					 * and ut_user is longer than NMAX,
					 * truncate it to fit ttnames[i].
					 */
					(void) strlcpy(ttnames[i], bp->ut_line,
					    LMAX+1);
					(void) strlcpy(ttnames[i]+LMAX+1,
					    ut_host, HMAX+1);
					(void) strlcpy(ttnames[i]+LMAX+HMAX+2,
					    ut_user, NMAX+1);
						record_time(&otime, &print,
						    i, bp);
						break;
					} else if (linehostnameq(ttnames[i],
					    bp->ut_line, ut_host, ut_user)) {
						record_time(&otime,
						    &print, i, bp);
						break;
					}
				}
			}
			if (print) {
				if (strncmp(bp->ut_line, "ftp", 3) == 0)
					bp->ut_line[3] = '\0';
				if (strncmp(bp->ut_line, "uucp", 4) == 0)
					bp->ut_line[4] = '\0';

				ct = ctime(&bp->ut_xtime);
				(void) printf(gettext("%-*.*s  %-*.*s "),
				    LOGIN_WIDTH, NMAX, bp->ut_name,
				    LINE_WIDTH, LMAX, bp->ut_line);
				hostf_len = strlen(bp->ut_host);
				(void) snprintf(hostf, sizeof (hostf),
				    "%-*.*s", hostf_len, hostf_len,
				    bp->ut_host);
				/* write seconds and year if -l specified */
				if (lflag > 0) {
					fpos = snprintf(timef, sizeof (timef),
					    "%10.10s %13.13s ",
					    ct, 11 + ct);
				} else {
					fpos = snprintf(timef, sizeof (timef),
					    "%10.10s %5.5s ",
					    ct, 11 + ct);
				}

				if (!lineq(bp->ut_line, "system boot") &&
				    !lineq(bp->ut_line, "system down")) {
					if (otime == 0 &&
					    bp->ut_type == USER_PROCESS) {

	if (fpos < sizeof (timef)) {
		/* timef still has room */
		(void) snprintf(timef + fpos, sizeof (timef) - fpos,
		    gettext("  still logged in"));
	}

					} else {
					time_t delta;
					if (otime < 0) {
						otime = -otime;
						/*
						 * TRANSLATION_NOTE
						 * See other notes on "down"
						 * and "- %5.5s".
						 * "-" means "until".  This
						 * is displayed after the
						 * starting time as in:
						 * 	16:20 - down
						 * You probably don't want to
						 * translate this.  Should you
						 * decide to translate this,
						 * translate "- %5.5s" too.
						 */

	if (fpos < sizeof (timef)) {
		/* timef still has room */
		chrcnt = snprintf(timef + fpos, sizeof (timef) - fpos,
		    gettext("- %s"), crmsg);
		fpos += chrcnt;
	}

					} else {

	if (fpos < sizeof (timef)) {
		/* timef still has room */
		if (lflag > 0) {
			chrcnt = snprintf(timef + fpos, sizeof (timef) - fpos,
			    gettext("- %8.8s"), ctime(&otime) + 11);
		} else {
			chrcnt = snprintf(timef + fpos, sizeof (timef) - fpos,
			    gettext("- %5.5s"), ctime(&otime) + 11);
		}
		fpos += chrcnt;
	}

					}
					delta = otime - bp->ut_xtime;
					if (delta < SECDAY) {

	if (fpos < sizeof (timef)) {
		/* timef still has room */
		if (lflag > 0) {
			(void) snprintf(timef + fpos, sizeof (timef) - fpos,
			    gettext("  (%8.8s)"), asctime(gmtime(&delta)) + 11);
		} else {
			(void) snprintf(timef + fpos, sizeof (timef) - fpos,
			    gettext("  (%5.5s)"), asctime(gmtime(&delta)) + 11);
		}

	}

					} else {

	if (fpos < sizeof (timef)) {
		/* timef still has room */
		if (lflag > 0) {
			(void) snprintf(timef + fpos, sizeof (timef) - fpos,
			    gettext(" (%ld+%8.8s)"), delta / SECDAY,
			    asctime(gmtime(&delta)) + 11);
		} else {
			(void) snprintf(timef + fpos, sizeof (timef) - fpos,
			    gettext(" (%ld+%5.5s)"), delta / SECDAY,
			    asctime(gmtime(&delta)) + 11);
		}
	}

					}
					}
				}
				if (lflag > 0) {
					if (aflag)
						(void) printf("%-.*s %-.*s\n",
						    strlen(timef), timef,
						    strlen(hostf), hostf);
					else
						(void) printf(
						    "%-16.16s %-.*s\n", hostf,
						    strlen(timef), timef);
				} else {
					if (aflag)
						(void) printf(
						    "%-35.35s %-.*s\n", timef,
						    strlen(hostf), hostf);
					else
						(void) printf(
						    "%-16.16s %-.35s\n", hostf,
						    timef);
				}
				(void) fflush(stdout);
				if (++outrec >= maxrec)
					exit(0);
			}
			/*
			 * when the system is down or crashed.
			 */
			if (bp->ut_type == BOOT_TIME) {
				for (i = 0; i < lines; i++)
					logouts[i] = -bp->ut_xtime;
				bootxtime = -bp->ut_xtime;
				/*
				 * TRANSLATION_NOTE
				 * Translation of this "down " will replace
				 * the %s in "- %s".  "down" is used instead
				 * of the real time session was ended, probably
				 * because the session ended by a sudden crash.
				 */
				crmsg = gettext("down ");
			}
			print = 0;	/* reset the print flag */
		}
	}
	ct = ctime(&buf[0].ut_xtime);
	if (lflag > 0) {
		(void) printf(gettext("\nwtmp begins %10.10s %13.13s \n"), ct,
		    ct + 11);
	} else {
		(void) printf(gettext("\nwtmp begins %10.10s %5.5s \n"), ct,
		    ct + 11);
	}

	/* free() called to prevent lint warning about names */
	free(names);

	return (0);
}

static void
reallocate_buffer()
{
	int j;
	static char	**tmpttnames;
	static time_t	*tmplogouts;

	lines += CHUNK_SIZE;
	tmpttnames = realloc(ttnames, sizeof (char *)*lines);
	tmplogouts = realloc(logouts, sizeof (time_t)*lines);
	if (tmpttnames == NULL || tmplogouts == NULL) {
		(void) fprintf(stderr, gettext("Out of memory \n"));
		exit(2);
	} else {
		ttnames = tmpttnames;
		logouts = tmplogouts;
	}
	for (j = lines-CHUNK_SIZE; j < lines; j++) {
		ttnames[j] = NULL;
		logouts[j] = bootxtime;
	}
}

static void
memory_alloc(int i)
{
	ttnames[i] = (char *)malloc(LMAX + HMAX + NMAX + 3);
	if (ttnames[i] == NULL) {
		(void) fprintf(stderr, gettext("Out of memory \n "));
		exit(2);
	}
}

static void
onintr(int signo)
{
	char *ct;

	if (signo == SIGQUIT)
		(void) signal(SIGQUIT, (void(*)())onintr);
	ct = ctime(&buf[0].ut_xtime);
	(void) printf(gettext("\ninterrupted %10.10s %5.5s \n"), ct, ct + 11);
	(void) fflush(stdout);
	if (signo == SIGINT)
		exit(1);
}

static int
want(struct utmpx *bp, char **host, char **user)
{
	char **name;
	int i;
	char *zerostr = "\0";

	*host = zerostr; *user = zerostr;

		/* if ut_line = dtremote for the users who did dtremote login */
	if (strncmp(bp->ut_line, "dtremote", 8) == 0) {
		*host = bp->ut_host;
		*user = bp->ut_user;
	}
		/* if ut_line = dtlocal for the users who did a dtlocal login */
	else if (strncmp(bp->ut_line, "dtlocal", 7) == 0) {
		*host = bp->ut_host;
		*user = bp->ut_user;
	}
		/*
		 * Both dtremote and dtlocal can have multiple entries in
		 * /var/adm/wtmpx with these values, so the user and host
		 * entries are also checked
		 */
	if ((bp->ut_type == BOOT_TIME) || (bp->ut_type == DOWN_TIME))
		(void) strcpy(bp->ut_user, "reboot");

	if (bp->ut_type != USER_PROCESS && bp->ut_type != DEAD_PROCESS &&
	    bp->ut_type != BOOT_TIME && bp->ut_type != DOWN_TIME)
		return (0);

	if (bp->ut_user[0] == '.')
		return (0);

	if (names_num == 0) {
		if (bp->ut_line[0] != '\0')
			return (1);
	} else {
		name = names;
		for (i = 0; i < names_num; i++, name++) {
			if (nameq(*name, bp->ut_name) ||
			    lineq(*name, bp->ut_line) ||
			    (lineq(*name, "ftp") &&
			    (strncmp(bp->ut_line, "ftp", 3) == 0))) {
				return (1);
			}
		}
	}
	return (0);
}

static char *
strspl(char *left, char *right)
{
	size_t ressize = strlen(left) + strlen(right) + 1;

	char *res = malloc(ressize);

	if (res == NULL) {
		perror("last");
		exit(2);
	}
	(void) strlcpy(res, left, ressize);
	(void) strlcat(res, right, ressize);
	return (res);
}

static void
record_time(time_t *otime, int *print, int i, struct utmpx *bp)
{
	*otime = logouts[i];
	logouts[i] = bp->ut_xtime;
	if ((bp->ut_type == USER_PROCESS && bp->ut_user[0] != '\0') ||
	    (bp->ut_type == BOOT_TIME) || (bp->ut_type == DOWN_TIME))
		*print = 1;
	else
		*print = 0;
}