projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
make output line buffered if selecting only some of the entries
[unix-history] / usr / src / usr.bin / last / last.c
diff --git a/usr/src/usr.bin/last/last.c b/usr/src/usr.bin/last/last.c
index bd778db..257485b 100644 (file)
--- a/usr/src/usr.bin/last/last.c
+++ b/usr/src/usr.bin/last/last.c
@@ -1,236 +1,395 @@
 /*
 /*
- * Copyright (c) 1980 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+ * 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.
  */
 
 #ifndef lint
 char copyright[] =
  */
 
 #ifndef lint
 char copyright[] =
-"@(#) Copyright (c) 1980 Regents of the University of California.\n\
+"@(#) Copyright (c) 1987 Regents of the University of California.\n\
  All rights reserved.\n";
  All rights reserved.\n";
-#endif not lint
+#endif /* not lint */
 
 #ifndef lint
 
 #ifndef lint
-static char sccsid[] = "@(#)last.c     5.4 (Berkeley) %G%";
-#endif not lint
+static char sccsid[] = "@(#)last.c     5.16 (Berkeley) %G%";
+#endif /* not lint */
 
 /*
  * last
  */
 
 /*
  * last
  */
-#include <sys/types.h>
+#include <sys/param.h>
 #include <sys/stat.h>
 #include <sys/file.h>
 #include <signal.h>
 #include <time.h>
 #include <sys/stat.h>
 #include <sys/file.h>
 #include <signal.h>
 #include <time.h>
-#include <pwd.h>
 #include <utmp.h>
 #include <utmp.h>
-#include <strings.h>
 #include <stdio.h>
 #include <stdio.h>
-#include <ctype.h>
+#include <paths.h>
 
 
-#define MAXTTYS        200                             /* max ttys last can handle */
-#define SECDAY (24*60*60)                      /* seconds in a day */
-#define NO     0                               /* false/no */
-#define YES    1                               /* true/yes */
+#define        SECDAY  (24*60*60)                      /* seconds in a day */
+#define        NO      0                               /* false/no */
+#define        YES     1                               /* true/yes */
 
 
-static struct utmp     buf[500];               /* utmp read buffer */
-#define HMAX   sizeof(buf[0].ut_host)          /* size of utmp host field */
-#define LMAX   sizeof(buf[0].ut_line)          /* size of utmp tty field */
-#define NMAX   sizeof(buf[0].ut_name)          /* size of utmp name field */
+static struct utmp     buf[1024];              /* utmp read buffer */
 
 
-#define lineq(a,b)     (!strncmp(a,b,LMAX))
-#define nameq(a,b)     (!strncmp(a,b,NMAX))
-#define hosteq(a,b)    (!strncmp(a,b,HMAX))
+typedef struct arg {
+       char    *name;                          /* argument */
+#define        HOST_TYPE       -2
+#define        TTY_TYPE        -3
+#define        USER_TYPE       -4
+       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 */
 
 typedef struct ttytab {
        long    logout;                         /* log out time */
-       char    tty[LMAX + 1];                  /* terminal name */
-} TTYS;
+       char    tty[UT_LINESIZE + 1];           /* terminal name */
+       struct ttytab   *next;                  /* linked list pointer */
+} TTY;
+TTY    *ttylist;                               /* head of linked list */
 
 
-static TTYS    tab[MAXTTYS + 1];               /* tty table */
-static char    **sargs;                        /* start of selections args */
+static long    currentout,                     /* current logout value */
+               maxrec;                         /* records to display */
+static char    *file = _PATH_WTMP;             /* wtmp file */
 
 
-main(argc,argv)
-int    argc;
-char   **argv;
+main(argc, argv)
+       int argc;
+       char **argv;
 {
 {
-       register struct utmp    *bp;            /* current structure */
-       register TTYS   *T;                     /* table entry */
-       register long   maxrec = -1;            /* records to display */
-       register int    indx;                   /* array offsets */
-       struct stat     stb;                    /* stat of file for size */
-       long    delta,                          /* time difference */
-               atol(), lseek(), time();
-       int     bl,                             /* reads to do */
-               bytes,                          /* bytes read */
-               wtmp,                           /* wtmp file descriptor */
-               onintr();
-       char    *ct,                            /* ctime return */
-               *crmsg,                         /* crash message */
-               *file,                          /* user specified file */
-               *asctime(), *ctime(), *strspl();
-
-       file = "/usr/adm/wtmp";
-       for (--argc,sargs = argv = ++argv,indx = 0;indx < argc;++indx) {
-               if (argv[indx][0] == '-' && isdigit(argv[indx][1])) {
-                       if ((maxrec = atol(argv[indx] + 1)) <= 0) {
-                               fputs("last: bad line count value.\n",stderr);
-                               exit(1);
+       extern int optind;
+       extern char *optarg;
+       int ch;
+       long atol();
+       char *p, *ttyconv();
+
+       maxrec = -1;
+       while ((ch = getopt(argc, argv, "0123456789f:h:t:")) != EOF)
+               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 == -1) {
+                               p = argv[optind - 1];
+                               if (p[0] == '-' && p[1] == ch && !p[2])
+                                       maxrec = atol(++p);
+                               else
+                                       maxrec = atol(argv[optind] + 1);
+                               if (!maxrec)
+                                       exit(0);
                        }
                        }
-                       ++sargs;
-                       continue;
+                       break;
+               case 'f':
+                       file = optarg;
+                       break;
+               case 'h':
+                       hostconv(optarg);
+                       addarg(HOST_TYPE, optarg);
+                       break;
+               case 't':
+                       addarg(TTY_TYPE, ttyconv(optarg));
+                       break;
+               case '?':
+               default:
+                       fputs("usage: last [-#] [-f file] [-t tty] [-h hostname] [user ...]\n", stderr);
+                       exit(1);
                }
                }
-               if (!strncmp(argv[indx],"-f",2)) {
-                       if (argv[indx][2]) {
-                               file = argv[indx] + 2;
-                               ++sargs;
-                       }
-                       else if (++indx == argc) {
-                               fputs("last: option requires an argument -- f\n",stderr);
-                               exit(1);
-                       }
-                       else {
-                               file = argv[indx];
-                               sargs += 2;
-                       }
-                       continue;
+
+       if (argc) {
+               setlinebuf(stdout);
+               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);
                }
                }
-               if (strlen(argv[indx]) > 2)
-                       continue;
-               if (!strcmp(argv[indx],"~"))
-                       continue;
-               if (getpwnam(argv[indx]))
-                       continue;
-               argv[indx] = strspl(argv[indx]);
        }
        }
+       wtmp();
+       exit(0);
+}
+
+/*
+ * wtmp --
+ *     read through the wtmp file
+ */
+static
+wtmp()
+{
+       register struct utmp    *bp;            /* current structure */
+       register TTY    *T;                     /* tty list entry */
+       struct stat     stb;                    /* stat of file for size */
+       long    bl, delta,                      /* time difference */
+               lseek(), time();
+       int     bytes, wfd,
+               onintr();
+       char    *ct, *crmsg,
+               *asctime(), *ctime(), *strcpy();
+       TTY     *addtty();
 
 
-       if ((wtmp = open(file,O_RDONLY,0)) < 0 || fstat(wtmp,&stb) == -1) {
+       if ((wfd = open(file, O_RDONLY, 0)) < 0 || fstat(wfd, &stb) == -1) {
                perror(file);
                exit(1);
        }
        bl = (stb.st_size + sizeof(buf) - 1) / sizeof(buf);
 
                perror(file);
                exit(1);
        }
        bl = (stb.st_size + sizeof(buf) - 1) / sizeof(buf);
 
-       time(&buf[0].ut_time);
-       signal(SIGINT,onintr);
-       signal(SIGQUIT,onintr);
+       (void)time(&buf[0].ut_time);
+       (void)signal(SIGINT, onintr);
+       (void)signal(SIGQUIT, onintr);
 
 
-       tab[MAXTTYS].logout = -1;               /* end flag value */
        while (--bl >= 0) {
        while (--bl >= 0) {
-               if (lseek(wtmp,(long)(bl * sizeof(buf)),L_SET) == -1 || (bytes = read(wtmp,(char *)buf,sizeof(buf))) == -1) {
-                       perror(file);
+               if (lseek(wfd, (long)(bl * sizeof(buf)), L_SET) == -1 ||
+                   (bytes = read(wfd, (char *)buf, sizeof(buf))) == -1) {
+                       fprintf(stderr, "last: %s: ", file);
+                       perror((char *)NULL);
                        exit(1);
                }
                        exit(1);
                }
-               for (bp = &buf[bytes / sizeof(buf[0]) - 1];bp >= buf;--bp) {
-                       if (lineq(bp->ut_line,"~")) {
-                               /*
-                                * if the name is empty and the terminal
-                                * line is '~', it's a shutdown of some
-                                * sort; see utmp(5) for more info.
-                                */
-                               for (T = tab;T->logout != -1;++T)
+               for (bp = &buf[bytes / sizeof(buf[0]) - 1]; bp >= buf; --bp) {
+                       /*
+                        * if the terminal line is '~', the machine stopped.
+                        * see utmp(5) for more info.
+                        */
+                       if (bp->ut_line[0] == '~' && !bp->ut_line[1]) {
+                               /* everybody just logged out */
+                               for (T = ttylist; T; T = T->next)
                                        T->logout = -bp->ut_time;
                                        T->logout = -bp->ut_time;
-                               crmsg = nameq(bp->ut_name,"shutdown") ? "down " : "crash";
-                               if (!bp->ut_name[0])
-                                       strcpy(bp->ut_name,"reboot");
-                               if (want(bp,NO)) {
+                               currentout = -bp->ut_time;
+                               crmsg = strncmp(bp->ut_name, "shutdown",
+                                   UT_NAMESIZE) ? "crash" : "shutdown";
+                               if (want(bp, NO)) {
                                        ct = ctime(&bp->ut_time);
                                        ct = ctime(&bp->ut_time);
-                                       printf("%-*.*s  %-*.*s %-*.*s %10.10s %5.5s \n",NMAX,NMAX,bp->ut_name,LMAX,LMAX,bp->ut_line,HMAX,HMAX,bp->ut_host,ct,ct + 11);
+                                       printf("%-*.*s  %-*.*s %-*.*s %10.10s %5.5s \n", UT_NAMESIZE, UT_NAMESIZE, bp->ut_name, UT_LINESIZE, UT_LINESIZE, bp->ut_line, UT_HOSTSIZE, UT_HOSTSIZE, bp->ut_host, ct, ct + 11);
                                        if (maxrec != -1 && !--maxrec)
                                        if (maxrec != -1 && !--maxrec)
-                                               exit(0);
+                                               return;
                                }
                                continue;
                        }
                                }
                                continue;
                        }
-                       for (T = tab;;) {
-                               if (T->logout <= 0) {
-                                       bcopy(bp->ut_line,T->tty,LMAX);
-                                       break;
+                       /*
+                        * if the line is '{' or '|', date got set; see
+                        * utmp(5) for more info.
+                        */
+                       if ((bp->ut_line[0] == '{' || bp->ut_line[0] == '|')
+                           && !bp->ut_line[1]) {
+                               if (want(bp, NO)) {
+                                       ct = ctime(&bp->ut_time);
+                                       printf("%-*.*s  %-*.*s %-*.*s %10.10s %5.5s \n", UT_NAMESIZE, UT_NAMESIZE, bp->ut_name, UT_LINESIZE, UT_LINESIZE, bp->ut_line, UT_HOSTSIZE, UT_HOSTSIZE, bp->ut_host, ct, ct + 11);
+                                       if (maxrec && !--maxrec)
+                                               return;
                                }
                                }
-                               if (lineq(T->tty,bp->ut_line))
+                               continue;
+                       }
+                       /* find associated tty */
+                       for (T = ttylist;; T = T->next) {
+                               if (!T) {
+                                       /* add new one */
+                                       T = addtty(bp->ut_line);
                                        break;
                                        break;
-                               if ((++T)->logout == -1) {
-                                       fputs("last: too many terminals.\n",stderr);
-                                       exit(1);
                                }
                                }
+                               if (!strncmp(T->tty, bp->ut_line, UT_LINESIZE))
+                                       break;
                        }
                        }
-                       if (bp->ut_name[0] && want(bp,YES)) {
+                       if (bp->ut_name[0] && want(bp, YES)) {
                                ct = ctime(&bp->ut_time);
                                ct = ctime(&bp->ut_time);
-                               printf("%-*.*s  %-*.*s %-*.*s %10.10s %5.5s ",NMAX,NMAX,bp->ut_name,LMAX,LMAX,bp->ut_line,HMAX,HMAX,bp->ut_host,ct,ct + 11);
+                               printf("%-*.*s  %-*.*s %-*.*s %10.10s %5.5s ", UT_NAMESIZE, UT_NAMESIZE, bp->ut_name, UT_LINESIZE, UT_LINESIZE, bp->ut_line, UT_HOSTSIZE, UT_HOSTSIZE, bp->ut_host, ct, ct + 11);
                                if (!T->logout)
                                        puts("  still logged in");
                                else {
                                        if (T->logout < 0) {
                                                T->logout = -T->logout;
                                if (!T->logout)
                                        puts("  still logged in");
                                else {
                                        if (T->logout < 0) {
                                                T->logout = -T->logout;
-                                               printf("- %s",crmsg);
+                                               printf("- %s", crmsg);
                                        }
                                        else
                                        }
                                        else
-                                               printf("- %5.5s",ctime(&T->logout)+11);
+                                               printf("- %5.5s", ctime(&T->logout)+11);
                                        delta = T->logout - bp->ut_time;
                                        if (delta < SECDAY)
                                        delta = T->logout - bp->ut_time;
                                        if (delta < SECDAY)
-                                               printf("  (%5.5s)\n",asctime(gmtime(&delta))+11);
+                                               printf("  (%5.5s)\n", asctime(gmtime(&delta))+11);
                                        else
                                        else
-                                               printf(" (%ld+%5.5s)\n",delta / SECDAY,asctime(gmtime(&delta))+11);
+                                               printf(" (%ld+%5.5s)\n", delta / SECDAY, asctime(gmtime(&delta))+11);
                                }
                                if (maxrec != -1 && !--maxrec)
                                }
                                if (maxrec != -1 && !--maxrec)
-                                       exit(0);
+                                       return;
                        }
                        T->logout = bp->ut_time;
                }
        }
        ct = ctime(&buf[0].ut_time);
                        }
                        T->logout = bp->ut_time;
                }
        }
        ct = ctime(&buf[0].ut_time);
-       printf("\nwtmp begins %10.10s %5.5s \n",ct,ct + 11);
-       exit(0);
+       printf("\nwtmp begins %10.10s %5.5s \n", ct, ct + 11);
 }
 
 }
 
-onintr(signo)
-int    signo;
-{
-       char    *ct,
-               *ctime();
-
-       ct = ctime(&buf[0].ut_time);
-       printf("\ninterrupted %10.10s %5.5s \n",ct,ct + 11);
-       fflush(stdout);                 /* fix required for rsh */
-       if (signo == SIGINT)
-               exit(1);
-}
-
-want(bp,check)
-register struct utmp   *bp;
-int    check;
+/*
+ * want --
+ *     see if want this entry
+ */
+static
+want(bp, check)
+       register struct utmp *bp;
+       int check;
 {
 {
-       register char   **indx;
+       register ARG *step;
 
 
-       if (check) {
+       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.
+                * 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",3))
+               if (!strncmp(bp->ut_line, "ftp", sizeof("ftp") - 1))
                        bp->ut_line[3] = '\0';
                        bp->ut_line[3] = '\0';
-               else if (!strncmp(bp->ut_line,"uucp",4))
+               else if (!strncmp(bp->ut_line, "uucp", sizeof("uucp") - 1))
                        bp->ut_line[4] = '\0';
                        bp->ut_line[4] = '\0';
-       }
-       if (!*sargs)
+       if (!arglist)
                return(YES);
                return(YES);
-       for (indx = sargs;*indx;++indx)
-               if (nameq(*indx,bp->ut_name) || lineq(*indx,bp->ut_line))
-                       return(YES);
+
+       for (step = arglist; step; step = step->next)
+               switch(step->type) {
+               case HOST_TYPE:
+                       if (!strncasecmp(step->name, bp->ut_host, UT_HOSTSIZE))
+                               return(YES);
+                       break;
+               case TTY_TYPE:
+                       if (!strncmp(step->name, bp->ut_line, UT_LINESIZE))
+                               return(YES);
+                       break;
+               case USER_TYPE:
+                       if (!strncmp(step->name, bp->ut_name, UT_NAMESIZE))
+                               return(YES);
+                       break;
+       }
        return(NO);
 }
 
        return(NO);
 }
 
-char *
-strspl(str)
-char   *str;
+/*
+ * addarg --
+ *     add an entry to a linked list of arguments
+ */
+static
+addarg(type, arg)
+       int type;
+       char *arg;
+{
+       register ARG *cur;
+       char *malloc();
+
+       if (!(cur = (ARG *)malloc((u_int)sizeof(ARG)))) {
+               fputs("last: malloc failure.\n", stderr);
+               exit(1);
+       }
+       cur->next = arglist;
+       cur->type = type;
+       cur->name = arg;
+       arglist = cur;
+}
+
+/*
+ * addtty --
+ *     add an entry to a linked list of ttys
+ */
+static TTY *
+addtty(ttyname)
+       char *ttyname;
 {
 {
-       register char   *res;
-       char    *malloc();
+       register TTY *cur;
+       char *malloc();
 
 
-       if (!(res = malloc((u_int)(4 + strlen(str))))) {
-               fputs("last: malloc failure.\n",stderr);
+       if (!(cur = (TTY *)malloc((u_int)sizeof(TTY)))) {
+               fputs("last: malloc failure.\n", stderr);
                exit(1);
        }
                exit(1);
        }
-       strcpy(res,"tty");
-       strcpy(res + 3,str);
-       return(res);
+       cur->next = ttylist;
+       cur->logout = currentout;
+       bcopy(ttyname, cur->tty, UT_LINESIZE);
+       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
+hostconv(arg)
+       char *arg;
+{
+       static int first = 1;
+       static char *hostdot, name[MAXHOSTNAMELEN];
+       char *argdot, *index();
+
+       if (!(argdot = index(arg, '.')))
+               return;
+       if (first) {
+               first = 0;
+               if (gethostname(name, sizeof(name))) {
+                       perror("last: gethostname");
+                       exit(1);
+               }
+               hostdot = index(name, '.');
+       }
+       if (hostdot && !strcasecmp(hostdot, argdot))
+               *argdot = '\0';
+}
+
+/*
+ * ttyconv --
+ *     convert tty to correct name.
+ */
+static char *
+ttyconv(arg)
+       char *arg;
+{
+       char *mval, *malloc(), *strcpy();
+
+       /*
+        * 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" */
+               if (!(mval = malloc((u_int)8))) {
+                       fputs("last: malloc failure.\n", stderr);
+                       exit(1);
+               }
+               if (!strcmp(arg, "co"))
+                       (void)strcpy(mval, "console");
+               else {
+                       (void)strcpy(mval, "tty");
+                       (void)strcpy(mval + 3, arg);
+               }
+               return(mval);
+       }
+       if (!strncmp(arg, _PATH_DEV, sizeof(_PATH_DEV) - 1))
+               return(arg + 5);
+       return(arg);
+}
+
+/*
+ * onintr --
+ *     on interrupt, we inform the user how far we've gotten
+ */
+static
+onintr(signo)
+       int signo;
+{
+       char *ct, *ctime();
+
+       ct = ctime(&buf[0].ut_time);
+       printf("\ninterrupted %10.10s %5.5s \n", ct, ct + 11);
+       if (signo == SIGINT)
+               exit(1);
+       (void)fflush(stdout);                   /* fix required for rsh */
 }
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.