BSD 2 development

[unix-history] / src / last.c

/* Copyright (c) 1979 Regents of the University of California */
#
/*
 * NAME: last
 *
 * SYNOPSIS: last [list]
 *
 * DESCRIPTION: Displays login history of named users or tty's.
 *    		Last with no argument prints history for all users.
 *
 * EXTERNAL ROUTINES USED: bread.c blseek.c
 *
 * AUTHOR - Howard P. Katseff
 */

# include <sys/types.h>
# include <stdio.h>
# include <sys/stat.h>
# include <utmp.h>

char	yes =	1,
	no  =	0,

	*wtmp = "/usr/adm/wtmp",
	b [512],

	Arg	  [25] [9],
	tty_names [48] [9],

	*ctime  (),
	*move   (),
	*rmchar ();


long	logouts	[48];

struct utmp buf;

main (argc, argv)
char **argv;
{
	char	f,
		narg,

		*bend,
		*p,
		*q;

	short	i,
		nbyte;

	int	lx,
		ntime,
		otime,

		intrp ();

	struct	stat sbuf;
 
	for (i = 1; i < argc; i++)
	{
		if
		(
			length (argv [i]) > 2 /* long tty or user name */
			||
			equal (argv [i], "~") /* tilde */
			||
			getpwnam (argv [i]) /* user name */
		)
		{
			move (argv [i], Arg [narg++]);
		}
		else /* short tty name */
		{
			move (argv [i], move ("tty", Arg [narg++]));
		}
	}
	f = open (wtmp, 0);
	if (f < 0)
	{
		perror (wtmp);
		fflush (stdout);
		exit ();
	}
	if (fstat (f, &sbuf) < 0)
	{
		perror ("/usr/adm/wtmp");
		fflush (stdout);
		exit ();
	}
	lx = sbuf.st_size;
	blseek (f, lx, 0);
	lx -= sizeof buf;
	signal (2, intrp);
	for (;;)	/* the large loop */
	{
		if (lx < sizeof buf)
		{
			q = ctime (&buf.ut_time);
			printf
			(
				"\nwtmp begins %10.10s  %5.5s \n",
				q, q + 11
			);
			fflush (stdout);
			exit ();
		}
	/*
	 * read the next login-logout record
	 */
		if (bread (f, &buf+1, -sizeof buf) < sizeof buf)
		{
			perror ("impossible error\n");
			exit ();
		}
		if (should_print ())
		{
			q = ctime (&buf.ut_time);
			printf
			(
				"%-8.8s  %-8.8s  %10.10s %5.5s ",
				buf.ut_name, buf.ut_line, q, 11+q
			);
			otime = buf.ut_time;
		/*
		 * look up the logout time for the tty
		 */
			for (i = 0;; i++)
			{
				if (!*tty_names [i])
				{ /* not in the table, therefore add it */
					move (buf.ut_line, tty_names [i]);
					ntime = 0;
					break;
				}
				if (equal (tty_names [i], buf.ut_line))
				{
					ntime = logouts [i];
					break;
				}
			}
			if (ntime == 0)
			{
				printf ("  still logged in\n");
			}
			else
			{
				if (ntime < 0)
				{
					ntime = -ntime;
					printf ("- crash");
				}
				else 
				{
					printf ("- %5.5s", ctime (&ntime) + 11);
				}
			/*
			 * calculate how long logged in
			 */
				otime = ntime - otime;
				otime += 231220830 + 10800;
				if (otime < 231220830 + 86400 + 10800)
				{
					printf
					(
						"  (%5.5s)\n",
						 ctime (&otime) + 11
					);
				}
				else
				{
					printf
					(
						" (%ld+%5.5s)\n",
						(otime -
						(231330830-86400-10800))/86400,
						ctime (&otime) + 11
					);
				}
			}
			fflush (stdout);
		}
		lx -= sizeof buf;
		if (equal (buf.ut_line, "~"))
		{
			for (i = 0; *tty_names [i]; i++)
			{
				logouts [i] = -buf.ut_time;
			}
		}
		else
		{
			for (i = 0;; i++)
			{
				if (!*tty_names [i])
				{
					move (buf.ut_line, tty_names [i]);
					break;
				}
				if (equal (tty_names [i], buf.ut_line))
				{
					logouts [i] = buf.ut_time;
					break;
				}
			}
		}
	}
}

equal (a, b)
char *a, *b;
{
	char i;

	for (i = 0; i < 8; i++)
	{
		if (!*a) return (!*b);
		if (*a++ != *b++) return (0);
	}
	return (1);
}


intrp ()
{
	char *q;

	signal (2, 1); /* ignore further interrupts */
	q = ctime (&buf.ut_time);
	printf
	(
		"\ninterrupted %10.10s %5.5s \n",
		q, q + 11
	);
	exit ();
}

/*
 * NAMES:
 *	bread (), brseek (), blseek ()
 *
 * DESCRIPTION:
 *	This is a buffered read package which simulates
 *	read (), lseek () and lseek ().
 *
 *      Bread may be called with a negative nbytes which causes it to
 *      read backwards.  In this case, buffer should point to the first
 *      byte following the buffer.  If only a partial read is possible
 *      (due to beginning of file), only the last bytes of the buffer
 *      will be filled.
 */

char	*next;

int	nl, nr, i, j, k;

bread (file, buff, nbytes)
char *buff;
{
	register nb;

	if (nbytes > 0)
	{
		for (nb = nbytes; nb > 0; nb--)
		{
			if (!nr)
			{
				nr = read (file, next=b, 512);
				nl = 0;
				if (nr < 0) return (-1);
				if (nr == 0) return (nbytes - nb);
			}
			*buff++ = *next++;
			nl++;
			nr--;
		}
	}
	else
	{
		nbytes = -nbytes;
		for (nb = nbytes; nb > 0; nb--)
		{
			if (!nl)
			{
				lseek (file, (long) - (512 + nr), 1);
				nl = read (file, b, 512);
				if (nl < 0)
				{
					for (k = 511; k > 0; k--)
					{
						lseek (file, (long) 1, 1);
						nl = read (file, b, k);
						if (nl >= 0) break;
					}
					if (nl < 0) return (nbytes-nb);
				}
				if (nl == 0) return (nbytes-nb);
				next = b + nl;
				nr = 0;
			}
			*--buff = *--next;
			nr++;
			nl--;
		}
	}
	return (nbytes);
}

brseek (file, offset, flag)
{
	nl = nr = 0;
	return (lseek (file, (long) offset, flag));
}

blseek (file, offset, flag) 
long offset;
{
	nl = nr = 0;
	return (lseek (file, offset, flag));
}

char *
rmchar (c, s)
char c, *s;
{
	for (; *s; s++)
	{
		if (*s == c)
		{
			*s = 0;
			return (s);
		}
	}
	return (0);
}

length (a)
char *a;
{
	char *b;

	for (b = a; *b; b++);
	return (b - a);
}

char *
move (a, b)
char *a, *b;
{
	while (*b++ = *a++);
	return (b - 1);
}

should_print ()
{
	char i;

	if (buf.ut_name [0] == no) return no; /* a logout entry */
	if (!**Arg) return yes;
	for (i = 0; i < *Arg [i]; i++)
	{
		if 
		(
			equal (Arg [i], buf.ut_name)
			||
			equal (Arg [i], buf.ut_line)
		)
		return yes;
	}
	return no;
}