/*
* Berkeley last for Linux. Currently maintained by poe@daimi.aau.dk at
* ftp://ftp.daimi.aau.dk/pub/linux/poe/admutil*
*
* Copyright (c) 1987 Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice and this paragraph are
* duplicated in all such forms and that any documentation,
* advertising materials, and other materials related to such
* distribution and use acknowledge that the software was developed
* by the University of California, Berkeley. The name of the
* University may not be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
/* 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
* - added Native Language Support
*/
/* 2001-02-14 Marek Zelem <marek@fornax.sk>
* - using mmap() on Linux - great speed improvement
*/
/*
* This command is deprecated. The utility is in maintenance mode,
* meaning we keep them in source tree for backward compatibility
* only. Do not waste time making this command better, unless the
* fix is about security or other very critical issue.
*
* See Documentation/deprecated.txt for more information.
*/
/*
* last
*/
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <signal.h>
#include <string.h>
#include <time.h>
#include <utmp.h>
#include <stdio.h>
#include <getopt.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "closestream.h"
#include "pathnames.h"
#include "nls.h"
#include "xalloc.h"
#include "c.h"
#define SECDAY (24*60*60) /* seconds in a day */
#define NO 0 /* false/no */
#define YES 1 /* true/yes */
static struct utmp utmpbuf;
#define HMAX (int)sizeof(utmpbuf.ut_host) /* size of utmp host field */
#define LMAX (int)sizeof(utmpbuf.ut_line) /* size of utmp tty field */
#define NMAX (int)sizeof(utmpbuf.ut_name) /* size of utmp name field */
/* maximum sizes used for printing */
/* probably we want a two-pass version that computes the right length */
#define P_HMAX min(HMAX, 16)
#define P_LMAX min(LMAX, 8)
#define P_NMAX min(NMAX, 16)
typedef struct arg {
char *name; /* argument */
#define HOST_TYPE -2
#define TTY_TYPE -3
#define USER_TYPE -4
#define INET_TYPE -5
int type; /* type of arg */
struct arg *next; /* linked list pointer */
} ARG;
ARG *arglist; /* head of linked list */
typedef struct ttytab {
long logout; /* log out time */
char tty[LMAX + 1]; /* terminal name */
struct ttytab *next; /* linked list pointer */
} TTY;
TTY *ttylist; /* head of linked list */
static long currentout, /* current logout value */
maxrec; /* records to display */
static char *file = _PATH_WTMP; /* wtmp file */
static int doyear = 0; /* output year in dates */
static int dolong = 0; /* print also ip-addr */
static void wtmp(void);
static void addarg(int, char *);
static void hostconv(char *);
static void onintr(int);
static int want(struct utmp *, int);
TTY *addtty(char *);
static char *ttyconv(char *);
int
main(int argc, char **argv) {
int ch;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((ch = getopt(argc, argv, "0123456789yli:f:h:t:")) != -1)
switch((char)ch) {
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
/*
* kludge: last was originally designed to take
* a number after a dash.
*/
if (!maxrec)
maxrec = atol(argv[optind - 1] + 1);
break;
case 'f':
file = optarg;
break;
case 'h':
hostconv(optarg);
addarg(HOST_TYPE, optarg);
break;
case 't':
addarg(TTY_TYPE, ttyconv(optarg));
break;
case 'y':
doyear = 1;
break;
case 'l':
dolong = 1;
break;
case 'i':
addarg(INET_TYPE, optarg);
break;
case '?':
default:
fputs(_("usage: last [-#] [-f file] [-t tty] [-h hostname] [user ...]\n"), stderr);
exit(EXIT_FAILURE);
}
for (argv += optind; *argv; ++argv) {
#define COMPATIBILITY
#ifdef COMPATIBILITY
/* code to allow "last p5" to work */
addarg(TTY_TYPE, ttyconv(*argv));
#endif
addarg(USER_TYPE, *argv);
}
wtmp();
return EXIT_SUCCESS;
}
static char *utmp_ctime(struct utmp *u)
{
time_t t = (time_t) u->ut_time;
return ctime(&t);
}
/*
* print_partial_line --
* print the first part of each output line according to specified format
*/
static void
print_partial_line(struct utmp *bp) {
char *ct;
ct = utmp_ctime(bp);
printf("%-*.*s %-*.*s ", P_NMAX, P_NMAX, bp->ut_name,
P_LMAX, P_LMAX, bp->ut_line);
if (dolong) {
if (bp->ut_addr) {
struct in_addr foo;
foo.s_addr = bp->ut_addr;
printf("%-*.*s ", P_HMAX, P_HMAX, inet_ntoa(foo));
} else {
printf("%-*.*s ", P_HMAX, P_HMAX, "");
}
} else {
printf("%-*.*s ", P_HMAX, P_HMAX, bp->ut_host);
}
if (doyear) {
printf("%10.10s %4.4s %5.5s ", ct, ct + 20, ct + 11);
} else {
printf("%10.10s %5.5s ", ct, ct + 11);
}
}
/*
* wtmp --
* read through the wtmp file
*/
static void
wtmp(void) {
register struct utmp *bp; /* current structure */
register TTY *T; /* tty list entry */
long delta; /* time difference */
char *crmsg = NULL;
char *ct = NULL;
int fd;
struct utmp *utl;
struct stat st;
int utl_len;
int listnr = 0;
int i;
utmpname(file);
{
#if defined(_HAVE_UT_TV)
struct timeval tv;
gettimeofday(&tv, NULL);
utmpbuf.ut_tv.tv_sec = tv.tv_sec;
utmpbuf.ut_tv.tv_usec = tv.tv_usec;
#else
time_t t;
time(&t);
utmpbuf.ut_time = t;
#endif
}
(void)signal(SIGINT, onintr);
(void)signal(SIGQUIT, onintr);
if ((fd = open(file,O_RDONLY)) < 0)
err(EXIT_FAILURE, _("cannot open %s"), file);
fstat(fd, &st);
utl_len = st.st_size;
utl = mmap(NULL, utl_len, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_FILE, fd, 0);
if (utl == NULL)
err(EXIT_FAILURE, _("%s: mmap failed"), file);
listnr = utl_len/sizeof(struct utmp);
if(listnr)
ct = utmp_ctime(&utl[0]);
for(i = listnr - 1; i >= 0; i--) {
bp = utl+i;
/*
* if the terminal line is '~', the machine stopped.
* see utmp(5) for more info.
*/
if (!strncmp(bp->ut_line, "~", LMAX)) {
/*
* utmp(5) also mentions that the user
* name should be 'shutdown' or 'reboot'.
* Not checking the name causes e.g. runlevel
* changes to be displayed as 'crash'. -thaele
*/
if (!strncmp(bp->ut_user, "reboot", NMAX) ||
!strncmp(bp->ut_user, "shutdown", NMAX)) {
/* everybody just logged out */
for (T = ttylist; T; T = T->next)
T->logout = -bp->ut_time;
}
currentout = -bp->ut_time;
crmsg = (strncmp(bp->ut_name, "shutdown", NMAX)
? "crash" : "down ");
if (!bp->ut_name[0])
(void)strcpy(bp->ut_name, "reboot");
if (want(bp, NO)) {
ct = utmp_ctime(bp);
if(bp->ut_type != LOGIN_PROCESS) {
print_partial_line(bp);
putchar('\n');
}
if (maxrec && !--maxrec)
return;
}
continue;
}
/* find associated tty */
for (T = ttylist;; T = T->next) {
if (!T) {
/* add new one */
T = addtty(bp->ut_line);
break;
}
if (!strncmp(T->tty, bp->ut_line, LMAX))
break;
}
if (bp->ut_name[0] && bp->ut_type != LOGIN_PROCESS
&& bp->ut_type != DEAD_PROCESS
&& want(bp, YES)) {
print_partial_line(bp);
if (!T->logout)
puts(_(" still logged in"));
else {
if (T->logout < 0) {
T->logout = -T->logout;
printf("- %s", crmsg);
}
else
printf("- %5.5s", ctime(&T->logout)+11);
delta = T->logout - bp->ut_time;
if (delta < SECDAY)
printf(" (%5.5s)\n", asctime(gmtime(&delta))+11);
else
printf(" (%ld+%5.5s)\n", delta / SECDAY, asctime(gmtime(&delta))+11);
}
if (maxrec != -1 && !--maxrec)
return;
}
T->logout = bp->ut_time;
utmpbuf.ut_time = bp->ut_time;
}
munmap(utl,utl_len);
close(fd);
if(ct) printf(_("\nwtmp begins %s"), ct); /* ct already ends in \n */
}
/*
* want --
* see if want this entry
*/
static int
want(struct utmp *bp, int check) {
register ARG *step;
if (check) {
/*
* when uucp and ftp log in over a network, the entry in
* the utmp file is the name plus their process id. See
* etc/ftpd.c and usr.bin/uucp/uucpd.c for more information.
*/
if (!strncmp(bp->ut_line, "ftp", sizeof("ftp") - 1))
bp->ut_line[3] = '\0';
else if (!strncmp(bp->ut_line, "uucp", sizeof("uucp") - 1))
bp->ut_line[4] = '\0';
}
if (!arglist)
return YES;
for (step = arglist; step; step = step->next)
switch(step->type) {
case HOST_TYPE:
if (!strncmp(step->name, bp->ut_host, HMAX))
return YES;
break;
case TTY_TYPE:
if (!strncmp(step->name, bp->ut_line, LMAX))
return YES;
break;
case USER_TYPE:
if (!strncmp(step->name, bp->ut_name, NMAX))
return YES;
break;
case INET_TYPE:
if ((in_addr_t) bp->ut_addr == inet_addr(step->name))
return YES;
break;
default:
abort();
}
return NO;
}
/*
* addarg --
* add an entry to a linked list of arguments
*/
static void
addarg(int type, char *arg) {
register ARG *cur;
cur = xmalloc(sizeof(ARG));
cur->next = arglist;
cur->type = type;
cur->name = arg;
arglist = cur;
}
/*
* addtty --
* add an entry to a linked list of ttys
*/
TTY *
addtty(char *ttyname) {
register TTY *cur;
cur = xmalloc(sizeof(TTY));
cur->next = ttylist;
cur->logout = currentout;
memcpy(cur->tty, ttyname, LMAX);
return(ttylist = cur);
}
/*
* hostconv --
* convert the hostname to search pattern; if the supplied host name
* has a domain attached that is the same as the current domain, rip
* off the domain suffix since that's what login(1) does.
*/
static void
hostconv(char *arg) {
static int first = 1;
static char *hostdot, *name;
char *argdot;
if (!(argdot = strchr(arg, '.')))
return;
if (first) {
first = 0;
name = xgethostname();
if (!name)
err(EXIT_FAILURE, _("gethostname failed"));
hostdot = strchr(name, '.');
}
if (hostdot && !strcmp(hostdot, argdot))
*argdot = '\0';
}
/*
* ttyconv --
* convert tty to correct name.
*/
static char *
ttyconv(char *arg) {
char *mval;
/*
* kludge -- we assume that all tty's end with
* a two character suffix.
*/
if (strlen(arg) == 2) {
/* either 6 for "ttyxx" or 8 for "console" */
mval = xmalloc(8);
if (!strncmp(arg, "co", 2))
(void)strcpy(mval, "console");
else {
(void)strcpy(mval, "tty");
(void)strncpy(mval + 3, arg, 4);
}
return mval;
}
if (!strncmp(arg, "/dev/", sizeof("/dev/") - 1))
return arg + 5;
return arg;
}
/*
* onintr --
* on interrupt, we inform the user how far we've gotten
*/
static void
onintr(int signo) {
char *ct;
ct = utmp_ctime(&utmpbuf);
printf(_("\ninterrupted %10.10s %5.5s \n"), ct, ct + 11);
if (signo == SIGINT)
_exit(EXIT_FAILURE);
fflush(stdout); /* fix required for rsh */
}
