xref: /freebsd/usr.sbin/ac/ac.c (revision c66ec88fed842fbaad62c30d510644ceb7bd2d71) 
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 1994 Christopher G. Demetriou
5  * Copyright (c) 1994 Simon J. Gerraty
6  * Copyright (c) 2012 Ed Schouten <ed@FreeBSD.org>
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  */
30 
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
33 
34 #include <sys/queue.h>
35 #include <sys/time.h>
36 
37 #include <err.h>
38 #include <errno.h>
39 #include <langinfo.h>
40 #include <locale.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <timeconv.h>
45 #include <unistd.h>
46 #include <utmpx.h>
47 
48 /*
49  * this is for our list of currently logged in sessions
50  */
51 struct utmpx_entry {
52 	SLIST_ENTRY(utmpx_entry) next;
53 	char		user[sizeof(((struct utmpx *)0)->ut_user)];
54 	char		id[sizeof(((struct utmpx *)0)->ut_id)];
55 #ifdef CONSOLE_TTY
56 	char		line[sizeof(((struct utmpx *)0)->ut_line)];
57 #endif
58 	struct timeval	time;
59 };
60 
61 /*
62  * this is for our list of users that are accumulating time.
63  */
64 struct user_entry {
65 	SLIST_ENTRY(user_entry) next;
66 	char		user[sizeof(((struct utmpx *)0)->ut_user)];
67 	struct timeval	time;
68 };
69 
70 /*
71  * this is for chosing whether to ignore a login
72  */
73 struct tty_entry {
74 	SLIST_ENTRY(tty_entry) next;
75 	char		line[sizeof(((struct utmpx *)0)->ut_line) + 2];
76 	size_t		len;
77 	int		ret;
78 };
79 
80 /*
81  * globals - yes yuk
82  */
83 #ifdef CONSOLE_TTY
84 static const char *Console = CONSOLE_TTY;
85 #endif
86 static struct timeval Total = { 0, 0 };
87 static struct timeval FirstTime = { 0, 0 };
88 static int	Flags = 0;
89 static SLIST_HEAD(, utmpx_entry) CurUtmpx = SLIST_HEAD_INITIALIZER(CurUtmpx);
90 static SLIST_HEAD(, user_entry) Users = SLIST_HEAD_INITIALIZER(Users);
91 static SLIST_HEAD(, tty_entry) Ttys = SLIST_HEAD_INITIALIZER(Ttys);
92 
93 #define	AC_W	1				/* not _PATH_WTMP */
94 #define	AC_D	2				/* daily totals (ignore -p) */
95 #define	AC_P	4				/* per-user totals */
96 #define	AC_U	8				/* specified users only */
97 #define	AC_T	16				/* specified ttys only */
98 
99 static void	ac(const char *);
100 static void	usage(void);
101 
102 static void
103 add_tty(const char *line)
104 {
105 	struct tty_entry *tp;
106 	char *rcp;
107 
108 	Flags |= AC_T;
109 
110 	if ((tp = malloc(sizeof(*tp))) == NULL)
111 		errx(1, "malloc failed");
112 	tp->len = 0;				/* full match */
113 	tp->ret = 1;				/* do if match */
114 	if (*line == '!') {			/* don't do if match */
115 		tp->ret = 0;
116 		line++;
117 	}
118 	strlcpy(tp->line, line, sizeof(tp->line));
119 	/* Wildcard. */
120 	if ((rcp = strchr(tp->line, '*')) != NULL) {
121 		*rcp = '\0';
122 		/* Match len bytes only. */
123 		tp->len = strlen(tp->line);
124 	}
125 	SLIST_INSERT_HEAD(&Ttys, tp, next);
126 }
127 
128 /*
129  * should we process the named tty?
130  */
131 static int
132 do_tty(const char *line)
133 {
134 	struct tty_entry *tp;
135 	int def_ret = 0;
136 
137 	SLIST_FOREACH(tp, &Ttys, next) {
138 		if (tp->ret == 0)		/* specific don't */
139 			def_ret = 1;		/* default do */
140 		if (tp->len != 0) {
141 			if (strncmp(line, tp->line, tp->len) == 0)
142 				return tp->ret;
143 		} else {
144 			if (strncmp(line, tp->line, sizeof(tp->line)) == 0)
145 				return tp->ret;
146 		}
147 	}
148 	return (def_ret);
149 }
150 
151 #ifdef CONSOLE_TTY
152 /*
153  * is someone logged in on Console?
154  */
155 static int
156 on_console(void)
157 {
158 	struct utmpx_entry *up;
159 
160 	SLIST_FOREACH(up, &CurUtmpx, next)
161 		if (strcmp(up->line, Console) == 0)
162 			return (1);
163 	return (0);
164 }
165 #endif
166 
167 /*
168  * Update user's login time.
169  * If no entry for this user is found, a new entry is inserted into the
170  * list alphabetically.
171  */
172 static void
173 update_user(const char *user, struct timeval secs)
174 {
175 	struct user_entry *up, *aup;
176 	int c;
177 
178 	aup = NULL;
179 	SLIST_FOREACH(up, &Users, next) {
180 		c = strcmp(up->user, user);
181 		if (c == 0) {
182 			timeradd(&up->time, &secs, &up->time);
183 			timeradd(&Total, &secs, &Total);
184 			return;
185 		} else if (c > 0)
186 			break;
187 		aup = up;
188 	}
189 	/*
190 	 * not found so add new user unless specified users only
191 	 */
192 	if (Flags & AC_U)
193 		return;
194 
195 	if ((up = malloc(sizeof(*up))) == NULL)
196 		errx(1, "malloc failed");
197 	if (aup == NULL)
198 		SLIST_INSERT_HEAD(&Users, up, next);
199 	else
200 		SLIST_INSERT_AFTER(aup, up, next);
201 	strlcpy(up->user, user, sizeof(up->user));
202 	up->time = secs;
203 	timeradd(&Total, &secs, &Total);
204 }
205 
206 int
207 main(int argc, char *argv[])
208 {
209 	const char *wtmpf = NULL;
210 	int c;
211 
212 	(void) setlocale(LC_TIME, "");
213 
214 	while ((c = getopt(argc, argv, "c:dpt:w:")) != -1) {
215 		switch (c) {
216 		case 'c':
217 #ifdef CONSOLE_TTY
218 			Console = optarg;
219 #else
220 			usage();		/* XXX */
221 #endif
222 			break;
223 		case 'd':
224 			Flags |= AC_D;
225 			break;
226 		case 'p':
227 			Flags |= AC_P;
228 			break;
229 		case 't':			/* only do specified ttys */
230 			add_tty(optarg);
231 			break;
232 		case 'w':
233 			Flags |= AC_W;
234 			wtmpf = optarg;
235 			break;
236 		case '?':
237 		default:
238 			usage();
239 			break;
240 		}
241 	}
242 	if (optind < argc) {
243 		/*
244 		 * initialize user list
245 		 */
246 		for (; optind < argc; optind++) {
247 			update_user(argv[optind], (struct timeval){ 0, 0 });
248 		}
249 		Flags |= AC_U;			/* freeze user list */
250 	}
251 	if (Flags & AC_D)
252 		Flags &= ~AC_P;
253 	ac(wtmpf);
254 
255 	return (0);
256 }
257 
258 /*
259  * print login time in decimal hours
260  */
261 static void
262 show(const char *user, struct timeval secs)
263 {
264 	(void)printf("\t%-*s %8.2f\n",
265 	    (int)sizeof(((struct user_entry *)0)->user), user,
266 	    (double)secs.tv_sec / 3600);
267 }
268 
269 static void
270 show_users(void)
271 {
272 	struct user_entry *lp;
273 
274 	SLIST_FOREACH(lp, &Users, next)
275 		show(lp->user, lp->time);
276 }
277 
278 /*
279  * print total login time for 24hr period in decimal hours
280  */
281 static void
282 show_today(struct timeval today)
283 {
284 	struct user_entry *up;
285 	struct utmpx_entry *lp;
286 	char date[64];
287 	struct timeval diff, total = { 0, 0 }, usec = { 0, 1 }, yesterday;
288 	static int d_first = -1;
289 
290 	if (d_first < 0)
291 		d_first = (*nl_langinfo(D_MD_ORDER) == 'd');
292 	timersub(&today, &usec, &yesterday);
293 	(void)strftime(date, sizeof(date),
294 		       d_first ? "%e %b  total" : "%b %e  total",
295 		       localtime(&yesterday.tv_sec));
296 
297 	SLIST_FOREACH(lp, &CurUtmpx, next) {
298 		timersub(&today, &lp->time, &diff);
299 		update_user(lp->user, diff);
300 		/* As if they just logged in. */
301 		lp->time = today;
302 	}
303 	SLIST_FOREACH(up, &Users, next) {
304 		timeradd(&total, &up->time, &total);
305 		/* For next day. */
306 		timerclear(&up->time);
307 	}
308 	if (timerisset(&total))
309 		(void)printf("%s %11.2f\n", date, (double)total.tv_sec / 3600);
310 }
311 
312 /*
313  * Log a user out and update their times.
314  * If ut_type is BOOT_TIME or SHUTDOWN_TIME, we log all users out as the
315  * system has been shut down.
316  */
317 static void
318 log_out(const struct utmpx *up)
319 {
320 	struct utmpx_entry *lp, *lp2, *tlp;
321 	struct timeval secs;
322 
323 	for (lp = SLIST_FIRST(&CurUtmpx), lp2 = NULL; lp != NULL;)
324 		if (up->ut_type == BOOT_TIME || up->ut_type == SHUTDOWN_TIME ||
325 		    (up->ut_type == DEAD_PROCESS &&
326 		    memcmp(lp->id, up->ut_id, sizeof(up->ut_id)) == 0)) {
327 			timersub(&up->ut_tv, &lp->time, &secs);
328 			update_user(lp->user, secs);
329 			/*
330 			 * now lose it
331 			 */
332 			tlp = lp;
333 			lp = SLIST_NEXT(lp, next);
334 			if (lp2 == NULL)
335 				SLIST_REMOVE_HEAD(&CurUtmpx, next);
336 			else
337 				SLIST_REMOVE_AFTER(lp2, next);
338 			free(tlp);
339 		} else {
340 			lp2 = lp;
341 			lp = SLIST_NEXT(lp, next);
342 		}
343 }
344 
345 /*
346  * if do_tty says ok, login a user
347  */
348 static void
349 log_in(struct utmpx *up)
350 {
351 	struct utmpx_entry *lp;
352 
353 	/*
354 	 * this could be a login. if we're not dealing with
355 	 * the console name, say it is.
356 	 *
357 	 * If we are, and if ut_host==":0.0" we know that it
358 	 * isn't a real login. _But_ if we have not yet recorded
359 	 * someone being logged in on Console - due to the wtmp
360 	 * file starting after they logged in, we'll pretend they
361 	 * logged in, at the start of the wtmp file.
362 	 */
363 
364 #ifdef CONSOLE_TTY
365 	if (up->ut_host[0] == ':') {
366 		/*
367 		 * SunOS 4.0.2 does not treat ":0.0" as special but we
368 		 * do.
369 		 */
370 		if (on_console())
371 			return;
372 		/*
373 		 * ok, no recorded login, so they were here when wtmp
374 		 * started!  Adjust ut_time!
375 		 */
376 		up->ut_tv = FirstTime;
377 		/*
378 		 * this allows us to pick the right logout
379 		 */
380 		strlcpy(up->ut_line, Console, sizeof(up->ut_line));
381 	}
382 #endif
383 	/*
384 	 * If we are doing specified ttys only, we ignore
385 	 * anything else.
386 	 */
387 	if (Flags & AC_T && !do_tty(up->ut_line))
388 		return;
389 
390 	/*
391 	 * go ahead and log them in
392 	 */
393 	if ((lp = malloc(sizeof(*lp))) == NULL)
394 		errx(1, "malloc failed");
395 	SLIST_INSERT_HEAD(&CurUtmpx, lp, next);
396 	strlcpy(lp->user, up->ut_user, sizeof(lp->user));
397 	memcpy(lp->id, up->ut_id, sizeof(lp->id));
398 #ifdef CONSOLE_TTY
399 	memcpy(lp->line, up->ut_line, sizeof(lp->line));
400 #endif
401 	lp->time = up->ut_tv;
402 }
403 
404 static void
405 ac(const char *file)
406 {
407 	struct utmpx_entry *lp;
408 	struct utmpx *usr, usht;
409 	struct tm *ltm;
410 	struct timeval prev_secs, ut_timecopy, secs, clock_shift, now;
411 	int day, rfound;
412 
413 	day = -1;
414 	timerclear(&prev_secs);	/* Minimum acceptable date == 1970. */
415 	timerclear(&secs);
416 	timerclear(&clock_shift);
417 	rfound = 0;
418 	if (setutxdb(UTXDB_LOG, file) != 0)
419 		err(1, "%s", file);
420 	while ((usr = getutxent()) != NULL) {
421 		rfound++;
422 		ut_timecopy = usr->ut_tv;
423 		/* Don't let the time run backwards. */
424 		if (timercmp(&ut_timecopy, &prev_secs, <))
425 			ut_timecopy = prev_secs;
426 		prev_secs = ut_timecopy;
427 
428 		if (!timerisset(&FirstTime))
429 			FirstTime = ut_timecopy;
430 		if (Flags & AC_D) {
431 			ltm = localtime(&ut_timecopy.tv_sec);
432 			if (day >= 0 && day != ltm->tm_yday) {
433 				day = ltm->tm_yday;
434 				/*
435 				 * print yesterday's total
436 				 */
437 				secs = ut_timecopy;
438 				secs.tv_sec -= ltm->tm_sec;
439 				secs.tv_sec -= 60 * ltm->tm_min;
440 				secs.tv_sec -= 3600 * ltm->tm_hour;
441 				secs.tv_usec = 0;
442 				show_today(secs);
443 			} else
444 				day = ltm->tm_yday;
445 		}
446 		switch(usr->ut_type) {
447 		case OLD_TIME:
448 			clock_shift = ut_timecopy;
449 			break;
450 		case NEW_TIME:
451 			timersub(&clock_shift, &ut_timecopy, &clock_shift);
452 			/*
453 			 * adjust time for those logged in
454 			 */
455 			SLIST_FOREACH(lp, &CurUtmpx, next)
456 				timersub(&lp->time, &clock_shift, &lp->time);
457 			break;
458 		case BOOT_TIME:
459 		case SHUTDOWN_TIME:
460 			log_out(usr);
461 			FirstTime = ut_timecopy; /* shouldn't be needed */
462 			break;
463 		case USER_PROCESS:
464 			/*
465 			 * If they came in on pts/..., then it is only
466 			 * a login session if the ut_host field is non-empty.
467 			 */
468 			if (strncmp(usr->ut_line, "pts/", 4) != 0 ||
469 			    *usr->ut_host != '\0')
470 				log_in(usr);
471 			break;
472 		case DEAD_PROCESS:
473 			log_out(usr);
474 			break;
475 		}
476 	}
477 	endutxent();
478 	(void)gettimeofday(&now, NULL);
479 	if (Flags & AC_W)
480 		usht.ut_tv = ut_timecopy;
481 	else
482 		usht.ut_tv = now;
483 	usht.ut_type = SHUTDOWN_TIME;
484 
485 	if (Flags & AC_D) {
486 		ltm = localtime(&ut_timecopy.tv_sec);
487 		if (day >= 0 && day != ltm->tm_yday) {
488 			/*
489 			 * print yesterday's total
490 			 */
491 			secs = ut_timecopy;
492 			secs.tv_sec -= ltm->tm_sec;
493 			secs.tv_sec -= 60 * ltm->tm_min;
494 			secs.tv_sec -= 3600 * ltm->tm_hour;
495 			secs.tv_usec = 0;
496 			show_today(secs);
497 		}
498 	}
499 	/*
500 	 * anyone still logged in gets time up to now
501 	 */
502 	log_out(&usht);
503 
504 	if (Flags & AC_D)
505 		show_today(now);
506 	else {
507 		if (Flags & AC_P)
508 			show_users();
509 		show("total", Total);
510 	}
511 }
512 
513 static void
514 usage(void)
515 {
516 	(void)fprintf(stderr,
517 #ifdef CONSOLE_TTY
518 	    "ac [-dp] [-c console] [-t tty] [-w wtmp] [users ...]\n");
519 #else
520 	    "ac [-dp] [-t tty] [-w wtmp] [users ...]\n");
521 #endif
522 	exit(1);
523 }
524