/*-
 * 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);
}