freebsd-skq/usr.sbin/ac/ac.c
Ed Schouten 8f67c5bc87 Relicense ac(8).
Though the license of the original ac(8) source code provides many
liberties, we are already somewhat violating it. The license requires us
to clearly comment any modifications to the source code, as the original
authors of course do not want to get bug reports for modified versions
of ac(8). This is something we have not done consistently.

The need for such a license clause has become less over time. It is very
unlikely that end users will contact the original authors, as the
copyright is from 1994. I contacted both the copyright holders. They
responded in a timely fashion and were more than willing to relicense it
to a 2-clause BSD license. To address any concerns about bug reports
going to the original authors instead of me, add my own name and email
address to the copyright statements as well.

MFC after:		1 month
Special thanks to:	Christopher Demetriou and Simon Gerraty
2012-08-31 18:26:39 +00:00

522 lines
12 KiB
C

/*-
* Copyright (c) 1994 Christopher G. Demetriou
* Copyright (c) 1994 Simon J. Gerraty
* Copyright (c) 2012 Ed Schouten <ed@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/queue.h>
#include <sys/time.h>
#include <err.h>
#include <errno.h>
#include <langinfo.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <timeconv.h>
#include <unistd.h>
#include <utmpx.h>
/*
* this is for our list of currently logged in sessions
*/
struct utmpx_entry {
SLIST_ENTRY(utmpx_entry) next;
char user[sizeof(((struct utmpx *)0)->ut_user)];
char id[sizeof(((struct utmpx *)0)->ut_id)];
#ifdef CONSOLE_TTY
char line[sizeof(((struct utmpx *)0)->ut_line)];
#endif
struct timeval time;
};
/*
* this is for our list of users that are accumulating time.
*/
struct user_entry {
SLIST_ENTRY(user_entry) next;
char user[sizeof(((struct utmpx *)0)->ut_user)];
struct timeval time;
};
/*
* this is for chosing whether to ignore a login
*/
struct tty_entry {
SLIST_ENTRY(tty_entry) next;
char line[sizeof(((struct utmpx *)0)->ut_line) + 2];
size_t len;
int ret;
};
/*
* globals - yes yuk
*/
#ifdef CONSOLE_TTY
static const char *Console = CONSOLE_TTY;
#endif
static struct timeval Total = { 0, 0 };
static struct timeval FirstTime = { 0, 0 };
static int Flags = 0;
static SLIST_HEAD(, utmpx_entry) CurUtmpx = SLIST_HEAD_INITIALIZER(CurUtmpx);
static SLIST_HEAD(, user_entry) Users = SLIST_HEAD_INITIALIZER(Users);
static SLIST_HEAD(, tty_entry) Ttys = SLIST_HEAD_INITIALIZER(Ttys);
#define AC_W 1 /* not _PATH_WTMP */
#define AC_D 2 /* daily totals (ignore -p) */
#define AC_P 4 /* per-user totals */
#define AC_U 8 /* specified users only */
#define AC_T 16 /* specified ttys only */
static void ac(const char *);
static void usage(void);
static void
add_tty(const char *line)
{
struct tty_entry *tp;
char *rcp;
Flags |= AC_T;
if ((tp = malloc(sizeof(*tp))) == NULL)
errx(1, "malloc failed");
tp->len = 0; /* full match */
tp->ret = 1; /* do if match */
if (*line == '!') { /* don't do if match */
tp->ret = 0;
line++;
}
strlcpy(tp->line, line, sizeof(tp->line));
/* Wildcard. */
if ((rcp = strchr(tp->line, '*')) != NULL) {
*rcp = '\0';
/* Match len bytes only. */
tp->len = strlen(tp->line);
}
SLIST_INSERT_HEAD(&Ttys, tp, next);
}
/*
* should we process the named tty?
*/
static int
do_tty(const char *line)
{
struct tty_entry *tp;
int def_ret = 0;
SLIST_FOREACH(tp, &Ttys, next) {
if (tp->ret == 0) /* specific don't */
def_ret = 1; /* default do */
if (tp->len != 0) {
if (strncmp(line, tp->line, tp->len) == 0)
return tp->ret;
} else {
if (strncmp(line, tp->line, sizeof(tp->line)) == 0)
return tp->ret;
}
}
return (def_ret);
}
#ifdef CONSOLE_TTY
/*
* is someone logged in on Console?
*/
static int
on_console(void)
{
struct utmpx_entry *up;
SLIST_FOREACH(up, &CurUtmpx, next)
if (strcmp(up->line, Console) == 0)
return (1);
return (0);
}
#endif
/*
* Update user's login time.
* If no entry for this user is found, a new entry is inserted into the
* list alphabetically.
*/
static void
update_user(const char *user, struct timeval secs)
{
struct user_entry *up, *aup;
int c;
aup = NULL;
SLIST_FOREACH(up, &Users, next) {
c = strcmp(up->user, user);
if (c == 0) {
timeradd(&up->time, &secs, &up->time);
timeradd(&Total, &secs, &Total);
return;
} else if (c > 0)
break;
aup = up;
}
/*
* not found so add new user unless specified users only
*/
if (Flags & AC_U)
return;
if ((up = malloc(sizeof(*up))) == NULL)
errx(1, "malloc failed");
if (aup == NULL)
SLIST_INSERT_HEAD(&Users, up, next);
else
SLIST_INSERT_AFTER(aup, up, next);
strlcpy(up->user, user, sizeof(up->user));
up->time = secs;
timeradd(&Total, &secs, &Total);
}
int
main(int argc, char *argv[])
{
const char *wtmpf = NULL;
int c;
(void) setlocale(LC_TIME, "");
while ((c = getopt(argc, argv, "c:dpt:w:")) != -1) {
switch (c) {
case 'c':
#ifdef CONSOLE_TTY
Console = optarg;
#else
usage(); /* XXX */
#endif
break;
case 'd':
Flags |= AC_D;
break;
case 'p':
Flags |= AC_P;
break;
case 't': /* only do specified ttys */
add_tty(optarg);
break;
case 'w':
Flags |= AC_W;
wtmpf = optarg;
break;
case '?':
default:
usage();
break;
}
}
if (optind < argc) {
/*
* initialize user list
*/
for (; optind < argc; optind++) {
update_user(argv[optind], (struct timeval){ 0, 0 });
}
Flags |= AC_U; /* freeze user list */
}
if (Flags & AC_D)
Flags &= ~AC_P;
ac(wtmpf);
return (0);
}
/*
* print login time in decimal hours
*/
static void
show(const char *user, struct timeval secs)
{
(void)printf("\t%-*s %8.2f\n",
(int)sizeof(((struct user_entry *)0)->user), user,
(double)secs.tv_sec / 3600);
}
static void
show_users(void)
{
struct user_entry *lp;
SLIST_FOREACH(lp, &Users, next)
show(lp->user, lp->time);
}
/*
* print total login time for 24hr period in decimal hours
*/
static void
show_today(struct timeval today)
{
struct user_entry *up;
struct utmpx_entry *lp;
char date[64];
struct timeval diff, total = { 0, 0 }, usec = { 0, 1 }, yesterday;
static int d_first = -1;
if (d_first < 0)
d_first = (*nl_langinfo(D_MD_ORDER) == 'd');
timersub(&today, &usec, &yesterday);
(void)strftime(date, sizeof(date),
d_first ? "%e %b total" : "%b %e total",
localtime(&yesterday.tv_sec));
SLIST_FOREACH(lp, &CurUtmpx, next) {
timersub(&today, &lp->time, &diff);
update_user(lp->user, diff);
/* As if they just logged in. */
lp->time = today;
}
SLIST_FOREACH(up, &Users, next) {
timeradd(&total, &up->time, &total);
/* For next day. */
timerclear(&up->time);
}
if (timerisset(&total))
(void)printf("%s %11.2f\n", date, (double)total.tv_sec / 3600);
}
/*
* Log a user out and update their times.
* If ut_type is BOOT_TIME or SHUTDOWN_TIME, we log all users out as the
* system has been shut down.
*/
static void
log_out(const struct utmpx *up)
{
struct utmpx_entry *lp, *lp2, *tlp;
struct timeval secs;
for (lp = SLIST_FIRST(&CurUtmpx), lp2 = NULL; lp != NULL;)
if (up->ut_type == BOOT_TIME || up->ut_type == SHUTDOWN_TIME ||
(up->ut_type == DEAD_PROCESS &&
memcmp(lp->id, up->ut_id, sizeof(up->ut_id)) == 0)) {
timersub(&up->ut_tv, &lp->time, &secs);
update_user(lp->user, secs);
/*
* now lose it
*/
tlp = lp;
lp = SLIST_NEXT(lp, next);
if (lp2 == NULL)
SLIST_REMOVE_HEAD(&CurUtmpx, next);
else
SLIST_REMOVE_AFTER(lp2, next);
free(tlp);
} else {
lp2 = lp;
lp = SLIST_NEXT(lp, next);
}
}
/*
* if do_tty says ok, login a user
*/
static void
log_in(struct utmpx *up)
{
struct utmpx_entry *lp;
/*
* this could be a login. if we're not dealing with
* the console name, say it is.
*
* If we are, and if ut_host==":0.0" we know that it
* isn't a real login. _But_ if we have not yet recorded
* someone being logged in on Console - due to the wtmp
* file starting after they logged in, we'll pretend they
* logged in, at the start of the wtmp file.
*/
#ifdef CONSOLE_TTY
if (up->ut_host[0] == ':') {
/*
* SunOS 4.0.2 does not treat ":0.0" as special but we
* do.
*/
if (on_console())
return;
/*
* ok, no recorded login, so they were here when wtmp
* started! Adjust ut_time!
*/
up->ut_tv = FirstTime;
/*
* this allows us to pick the right logout
*/
strlcpy(up->ut_line, Console, sizeof(up->ut_line));
}
#endif
/*
* If we are doing specified ttys only, we ignore
* anything else.
*/
if (Flags & AC_T && !do_tty(up->ut_line))
return;
/*
* go ahead and log them in
*/
if ((lp = malloc(sizeof(*lp))) == NULL)
errx(1, "malloc failed");
SLIST_INSERT_HEAD(&CurUtmpx, lp, next);
strlcpy(lp->user, up->ut_user, sizeof(lp->user));
memcpy(lp->id, up->ut_id, sizeof(lp->id));
#ifdef CONSOLE_TTY
memcpy(lp->line, up->ut_line, sizeof(lp->line));
#endif
lp->time = up->ut_tv;
}
static void
ac(const char *file)
{
struct utmpx_entry *lp;
struct utmpx *usr, usht;
struct tm *ltm;
struct timeval prev_secs, ut_timecopy, secs, clock_shift, now;
int day, rfound;
day = -1;
timerclear(&prev_secs); /* Minimum acceptable date == 1970. */
timerclear(&secs);
timerclear(&clock_shift);
rfound = 0;
if (setutxdb(UTXDB_LOG, file) != 0)
err(1, "%s", file);
while ((usr = getutxent()) != NULL) {
rfound++;
ut_timecopy = usr->ut_tv;
/* Don't let the time run backwards. */
if (timercmp(&ut_timecopy, &prev_secs, <))
ut_timecopy = prev_secs;
prev_secs = ut_timecopy;
if (!timerisset(&FirstTime))
FirstTime = ut_timecopy;
if (Flags & AC_D) {
ltm = localtime(&ut_timecopy.tv_sec);
if (day >= 0 && day != ltm->tm_yday) {
day = ltm->tm_yday;
/*
* print yesterday's total
*/
secs = ut_timecopy;
secs.tv_sec -= ltm->tm_sec;
secs.tv_sec -= 60 * ltm->tm_min;
secs.tv_sec -= 3600 * ltm->tm_hour;
secs.tv_usec = 0;
show_today(secs);
} else
day = ltm->tm_yday;
}
switch(usr->ut_type) {
case OLD_TIME:
clock_shift = ut_timecopy;
break;
case NEW_TIME:
timersub(&clock_shift, &ut_timecopy, &clock_shift);
/*
* adjust time for those logged in
*/
SLIST_FOREACH(lp, &CurUtmpx, next)
timersub(&lp->time, &clock_shift, &lp->time);
break;
case BOOT_TIME:
case SHUTDOWN_TIME:
log_out(usr);
FirstTime = ut_timecopy; /* shouldn't be needed */
break;
case USER_PROCESS:
/*
* If they came in on pts/..., then it is only
* a login session if the ut_host field is non-empty.
*/
if (strncmp(usr->ut_line, "pts/", 4) != 0 ||
*usr->ut_host != '\0')
log_in(usr);
break;
case DEAD_PROCESS:
log_out(usr);
break;
}
}
endutxent();
(void)gettimeofday(&now, NULL);
if (Flags & AC_W)
usht.ut_tv = ut_timecopy;
else
usht.ut_tv = now;
usht.ut_type = SHUTDOWN_TIME;
if (Flags & AC_D) {
ltm = localtime(&ut_timecopy.tv_sec);
if (day >= 0 && day != ltm->tm_yday) {
/*
* print yesterday's total
*/
secs = ut_timecopy;
secs.tv_sec -= ltm->tm_sec;
secs.tv_sec -= 60 * ltm->tm_min;
secs.tv_sec -= 3600 * ltm->tm_hour;
secs.tv_usec = 0;
show_today(secs);
}
}
/*
* anyone still logged in gets time up to now
*/
log_out(&usht);
if (Flags & AC_D)
show_today(now);
else {
if (Flags & AC_P)
show_users();
show("total", Total);
}
}
static void
usage(void)
{
(void)fprintf(stderr,
#ifdef CONSOLE_TTY
"ac [-dp] [-c console] [-t tty] [-w wtmp] [users ...]\n");
#else
"ac [-dp] [-t tty] [-w wtmp] [users ...]\n");
#endif
exit(1);
}