usr.sbin/ac/ac.c

   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 }