source: trunk/minix/commands/simple/last.c@ 10

/* last - display login history                 Author: Terrence W. Holm */

/* last-        Display the user log-in history.
 *              Last(1) searches backwards through the file of log-in
 *              records (/usr/adm/wtmp), displaying the length of
 *              log-in sessions as requested by the options:
 *
 * Usage:       last [-r] [-count] [-f file] [name] [tty] ...
 *
 *              -r      Search backwards only until the last reboot
 *                      record.
 *
 *              -count  Only print out <count> records. Last(1) stops
 *                      when either -r or -count is satisfied, or at
 *                      the end of the file if neither is given.
 *
 *              -f file Use "file" instead of "/usr/adm/wtmp".
 *
 *              name    Print records for the user "name".
 *
 *              tty     Print records for the terminal "tty". Actually,
 *                      a list of names may be given and all records
 *                      that match either the user or tty name are
 *                      printed. If no names are given then all records
 *                      are displayed.
 *
 *              A sigquit (^\) causes last(1) to display how far it
 *              has gone back in the log-in record file, it then
 *              continues. This is used to check on the progress of
 *              long running searches. A sigint will stop last(1).
 *
 * Author:      Terrence W. Holm        May 1988
 *
 * Revision:
 *              Fred van Kempen, October 1989
 *               -Adapted to MSS.
 *               -Adapted to new utmp database.
 *
 *              Fred van Kempen, December 1989
 *               -Adapted to POSIX (MINIX 1.5)
 *
 *              Fred van Kempen, January 1990
 *               -Final edit for 1.5
 *
 *              Philip Homburg, March 1992
 *               -Include host in output
 *
 *              Kees J. Bot, July 1997
 *               -Approximate system uptime from last reboot record
 */
#include <sys/types.h>
#include <signal.h>
#include <string.h>
#include <utmp.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#include <minix/paths.h>

#define  FALSE  0
#define  TRUE   1
#define  RLOGIN 1

#define  BUFFER_SIZE     4096   /* Room for wtmp records */
#define  MAX_WTMP_COUNT  ( BUFFER_SIZE / sizeof(struct utmp) )

#define  min( a, b )     ( (a < b) ? a : b )
#define  max( a, b )     ( (a > b) ? a : b )


typedef struct logout {         /* A logout time record */
  char line[12];                /* The terminal name */
  long time;                    /* The logout time */
  struct logout *next;          /* Next in linked list */
} logout;


static char *Version = "@(#) LAST 1.7 (10/24/92)";


/* command-line option flags */
char boot_limit = FALSE;        /* stop on latest reboot */
char count_limit = FALSE;       /* stop after print_count */
char tell_uptime = FALSE;       /* tell uptime since last reboot */
int print_count;
char *prog;                     /* name of this program */
int arg_count;                  /* used to select specific */
char **args;                    /* users and ttys */

/* global variables */
long boot_time = 0;             /* Zero means no reboot yet */
char *boot_down;                /* "crash" or "down " flag */
logout *first_link = NULL;      /* List of logout times */
int interrupt = FALSE;          /* If sigint or sigquit occurs */

_PROTOTYPE(int main, (int argc, char **argv));
_PROTOTYPE(void Sigint, (int sig));
_PROTOTYPE(void Sigquit, (int sig));
_PROTOTYPE(void usage, (void));
_PROTOTYPE(void Process, (struct utmp *wtmp));
_PROTOTYPE(int Print_Record, (struct utmp *wtmp));
_PROTOTYPE(void Print_Duration, (long from, long to));
_PROTOTYPE(void Print_Uptime, (void));
_PROTOTYPE(void Record_Logout_Time, (struct utmp *wtmp));

/* Sigint() and Sigquit() Flag occurrence of an interrupt. */
void Sigint(sig)
int sig;
{
  interrupt = SIGINT;
}


void Sigquit(sig)
int sig;
{
  interrupt = SIGQUIT;
}


void usage()
{
  fprintf(stderr,
        "Usage: last [-r] [-u] [-count] [-f file] [name] [tty] ...\n");
  exit(-1);
}


/* A log-in record format file contains four types of records.
 *
 *  [1] generated on a system reboot:
 *
 *      line="~", name="reboot", host="", time=date()
 *
 *
 *  [2] generated after a shutdown:
 *
 *      line="~", name="shutdown", host="", time=date()
 *
 *
 *  [3] generated on a successful login(1)
 *
 *      line=ttyname(), name=cuserid(), host=, time=date()
 *
 *
 *  [4] generated by init(8) on a logout
 *
 *      line=ttyname(), name="", host="", time=date()
 *
 *
 * Note: This version of last(1) does not recognize the '|' and '}' time
 *       change records. Last(1) pairs up line login's and logout's to
 *       generate four types of output lines:
 *
 *        [1] a system reboot or shutdown
 *
 *         reboot    ~       Mon May 16 14:16
 *         shutdown  ~       Mon May 16 14:15
 *
 *        [2] a login with a matching logout
 *
 *         edwin     tty1    Thu May 26 20:05 - 20:32  (00:27)
 *
 *        [3] a login followed by a reboot or shutdown
 *
 *         root      tty0    Mon May 16 13:57 - crash  (00:19)
 *         root      tty1    Mon May 16 13:45 - down   (00:30)
 *
 *        [4] a login not followed by a logout or reboot
 *
 *         terry     tty0    Thu May 26 21:19   still logged in
 */
void Process(wtmp)
struct utmp *wtmp;
{
  logout *link;
  logout *next_link;
  char is_reboot;

  /* suppress the job number on an "ftp" line */
  if (!strncmp(wtmp->ut_line, "ftp", (size_t)3)) strncpy(wtmp->ut_line, "ftp", (size_t)8);

  if (!strcmp(wtmp->ut_line, "~")) {
        /* A reboot or shutdown record  */
        if (boot_limit) exit(0);

        if (Print_Record(wtmp)) putchar('\n');
        boot_time = wtmp->ut_time;

        is_reboot = !strcmp(wtmp->ut_name, "reboot");
        if (is_reboot)
                boot_down = "crash";
        else
                boot_down = "down ";

        if (tell_uptime) {
                if (!is_reboot) {
                        fprintf(stderr,
                "%s: no reboot record added to wtmp file on system boot!\n",
                                prog);
                        exit(1);
                }
                Print_Uptime();
                exit(0);
        }

        /* remove any logout records */
        for (link = first_link; link != NULL; link = next_link) {
                next_link = link->next;
                free(link);
        }
        first_link = NULL;
  } else if (wtmp->ut_name[0] == '\0') {
        /* A logout record */
        Record_Logout_Time(wtmp);
  } else {
        /* A login record */
        for (link = first_link; link != NULL; link = link->next)
                if (!strncmp(link->line, wtmp->ut_line, (size_t)8)) {
                        /* found corresponding logout record */
                        if (Print_Record(wtmp)) {
                                printf("- %.5s ", ctime(&link->time) + 11);
                                Print_Duration(wtmp->ut_time, link->time);
                        }
                        /* record login time */
                        link->time = wtmp->ut_time;
                        return;
                }
        /* could not find a logout record for this login tty */
        if (Print_Record(wtmp))
                if (boot_time == 0)     /* still on */
                        printf("  still logged in\n");
                else {          /* system crashed while on */
                        printf("- %s ", boot_down);
                        Print_Duration(wtmp->ut_time, boot_time);
                }
        Record_Logout_Time(wtmp);       /* Needed in case of 2
                                         * consecutive logins  */
  }
}


/* Print_Record(wtmp) If the record was requested, then print out
 * the user name, terminal, host and time.
 */
int Print_Record(wtmp)
struct utmp *wtmp;
{
  int i;
  char print_flag = FALSE;

  /* just interested in the uptime? */
  if (tell_uptime) return(FALSE);

  /* check if we have already printed the requested number of records */
  if (count_limit && print_count == 0) exit(0);

  for (i = 0; i < arg_count; ++i)
        if (!strncmp(args[i], wtmp->ut_name, sizeof(wtmp->ut_name)) ||
            !strncmp(args[i], wtmp->ut_line, sizeof(wtmp->ut_line)))
                print_flag = TRUE;

  if (arg_count == 0 || print_flag) {
#ifdef RLOGIN
        printf("%-8.8s  %-8.8s %-16.16s %.16s ",
               wtmp->ut_name, wtmp->ut_line, wtmp->ut_host,
               ctime(&wtmp->ut_time));
#else
        printf("%-8.8s  %-8.8s  %.16s ",
               wtmp->ut_name, wtmp->ut_line, ctime(&wtmp->ut_time));
#endif
        --print_count;
        return(TRUE);
  }
  return(FALSE);
}


/* Print_Duration(from, to) Calculate and print the days and hh:mm between
 * the log-in and the log-out.
 */
void Print_Duration(from, to)
long from;
long to;
{
  long delta, days, hours, minutes;

  delta = max(to - from, 0);
  days = delta / (24L * 60L * 60L);
  delta = delta % (24L * 60L * 60L);
  hours = delta / (60L * 60L);
  delta = delta % (60L * 60L);
  minutes = delta / 60L;

  if (days > 0)
        printf("(%ld+", days);
  else
        printf(" (");

  printf("%02ld:%02ld)\n", hours, minutes);
}


/* Print_Uptime() Calculate and print the "uptime" between the last recorded
 * boot and the current time.
 */
void Print_Uptime()
{
#define NLOADS 3
  int nloads;
  double loads[NLOADS];
  char *utmp_file = _PATH_UTMP;
  unsigned nusers;
  struct utmp ut;
  FILE *uf;
  time_t now;
  struct tm *tm;
  unsigned long up;

  /* Count the number of active users in the utmp file. */
  if ((uf = fopen(utmp_file, "r")) == NULL) {
        fprintf(stderr, "%s: %s: %s\n", prog, utmp_file, strerror(errno));
        exit(1);
  }

  nusers = 0;
  while (fread(&ut, sizeof(ut), 1, uf) == 1) {
#ifdef USER_PROCESS
        if (ut.ut_type == USER_PROCESS) nusers++;
#else
        if (ut.ut_name[0] != 0 && ut.ut_line[0] != 0) nusers++;
#endif
  }
  fclose(uf);

  /* Current time. */
  now = time((time_t *) NULL);
  tm = localtime(&now);

  /* Uptime. */
  up = now - boot_time;

  printf(" %d:%02d  up", tm->tm_hour, tm->tm_min);
  if (up >= 24 * 3600L) {
        unsigned long days = up / (24 * 3600L);
        printf(" %lu day%s,", days, days == 1 ? "" : "s");
  }
  printf(" %lu:%02lu,", (up % (24 * 3600L)) / 3600, (up % 3600) / 60);
  printf("  %u user%s", nusers, nusers == 1 ? "" : "s");
  if((nloads = getloadavg(loads, NLOADS)) > 0) {
        int i;
        printf(", load averages:");
        for(i = 0; i < nloads; i++)
                printf("%s %.2f", (i > 0) ? "," : "", loads[i]);
  }
  printf("\n");
}


/* Record_Logout_Time(wtmp) A linked list of "last logout time" is kept.
 * Each element of the list is for one terminal.
 */
void Record_Logout_Time(wtmp)
struct utmp *wtmp;
{
  logout *link;

  /* see if the terminal is already in the list */
  for (link = first_link; link != NULL; link = link->next)
        if (!strncmp(link->line, wtmp->ut_line, (size_t)8)) {
                link->time = wtmp->ut_time;
                return;
        }
  /* allocate a new logout record, for a tty not previously encountered */
  link = (logout *) malloc(sizeof(logout));
  if (link == NULL) {
        fprintf(stderr, "%s: malloc failure\n", prog);
        exit(1);
  }
  strncpy(link->line, wtmp->ut_line, (size_t)8);
  link->time = wtmp->ut_time;
  link->next = first_link;

  first_link = link;
}


int main(argc, argv)
int argc;
char *argv[];
{
  char *wtmp_file = _PATH_WTMP;
  FILE *f;
  long size;                    /* Number of wtmp records in the file    */
  int wtmp_count;               /* How many to read into wtmp_buffer     */
  struct utmp wtmp_buffer[MAX_WTMP_COUNT];

  if ((prog = strrchr(argv[0], '/')) == NULL) prog = argv[0]; else prog++;

  --argc;
  ++argv;

  while (argc > 0 && *argv[0] == '-') {
        if (!strcmp(argv[0], "-r"))
                boot_limit = TRUE;
        else
        if (!strcmp(argv[0], "-u"))
                tell_uptime = TRUE;
        else if (argc > 1 && !strcmp(argv[0], "-f")) {
                wtmp_file = argv[1];
                --argc;
                ++argv;
        } else if ((print_count = atoi(argv[0] + 1)) > 0)
                count_limit = TRUE;
        else
                usage();

        --argc;
        ++argv;
  }

  arg_count = argc;
  args = argv;

  if (!strcmp(prog, "uptime")) tell_uptime = TRUE;

  if ((f = fopen(wtmp_file, "r")) == NULL) {
        perror(wtmp_file);
        exit(1);
  }
  if (fseek(f, 0L, 2) != 0 || (size = ftell(f)) % sizeof(struct utmp) != 0) {
        fprintf(stderr, "%s: invalid wtmp file\n", prog);
        exit(1);
  }
  if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
        signal(SIGINT, Sigint);
        signal(SIGQUIT, Sigquit);
  }
  size /= sizeof(struct utmp);  /* Number of records in wtmp     */

  if (size == 0) wtmp_buffer[0].ut_time = time((time_t *)0);

  while (size > 0) {
        wtmp_count = (int) min(size, MAX_WTMP_COUNT);
        size -= (long) wtmp_count;

        fseek(f, size * sizeof(struct utmp), 0);


        if (fread(&wtmp_buffer[0], sizeof(struct utmp), (size_t)wtmp_count, f)
            != wtmp_count) {
                fprintf(stderr, "%s: read error on wtmp file\n", prog);
                exit(1);
        }
        while (--wtmp_count >= 0) {
                Process(&wtmp_buffer[wtmp_count]);
                if (interrupt) {
                        printf("\ninterrupted %.16s \n",
                           ctime(&wtmp_buffer[wtmp_count].ut_time));

                        if (interrupt == SIGINT) exit(2);

                        interrupt = FALSE;
                        signal(SIGQUIT, Sigquit);
                }
        }

  }                             /* end while(size > 0) */

  if (tell_uptime) {
        fprintf(stderr,
                "%s: no reboot record in wtmp file to compute uptime from\n",
                prog);
        return(1);
  }

  printf("\nwtmp begins %.16s \n", ctime(&wtmp_buffer[0].ut_time));
  return(0);
}