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