mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-24 11:29:10 +00:00
8f67c5bc87
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
522 lines
12 KiB
C
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);
|
|
}
|