src/who.c

   1 /* GNU's who.
   2    Copyright (C) 1992-2023 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by jla; revised by djm; revised again by mstone */
  18
  19 /* Output format:
  20    name [state] line time [activity] [pid] [comment] [exit]
  21    state: -T
  22    name, line, time: not -q
  23    idle: -u
  24 */
  25
  26 #include <config.h>
  27 #include <getopt.h>
  28 #include <stdckdint.h>
  29 #include <stdio.h>
  30
  31 #include <sys/types.h>
  32 #include "system.h"
  33
  34 #include "c-ctype.h"
  35 #include "canon-host.h"
  36 #include "readutmp.h"
  37 #include "hard-locale.h"
  38 #include "quote.h"
  39
  40 #ifdef TTY_GROUP_NAME
  41 # include <grp.h>
  42 #endif
  43
  44 /* The official name of this program (e.g., no 'g' prefix).  */
  45 #define PROGRAM_NAME "who"
  46
  47 #define AUTHORS \
  48   proper_name ("Joseph Arceneaux"), \
  49   proper_name ("David MacKenzie"), \
  50   proper_name ("Michael Stone")
  51
  52 #ifdef RUN_LVL
  53 # define UT_TYPE_RUN_LVL(U) ((U)->ut_type == RUN_LVL)
  54 #else
  55 # define UT_TYPE_RUN_LVL(U) false
  56 #endif
  57
  58 #ifdef INIT_PROCESS
  59 # define UT_TYPE_INIT_PROCESS(U) ((U)->ut_type == INIT_PROCESS)
  60 #else
  61 # define UT_TYPE_INIT_PROCESS(U) false
  62 #endif
  63
  64 #ifdef LOGIN_PROCESS
  65 # define UT_TYPE_LOGIN_PROCESS(U) ((U)->ut_type == LOGIN_PROCESS)
  66 #else
  67 # define UT_TYPE_LOGIN_PROCESS(U) false
  68 #endif
  69
  70 #ifdef DEAD_PROCESS
  71 # define UT_TYPE_DEAD_PROCESS(U) ((U)->ut_type == DEAD_PROCESS)
  72 #else
  73 # define UT_TYPE_DEAD_PROCESS(U) false
  74 #endif
  75
  76 #ifdef NEW_TIME
  77 # define UT_TYPE_NEW_TIME(U) ((U)->ut_type == NEW_TIME)
  78 #else
  79 # define UT_TYPE_NEW_TIME(U) false
  80 #endif
  81
  82 #define IDLESTR_LEN 6
  83
  84 #if HAVE_STRUCT_XTMP_UT_PID
  85 # define PIDSTR_DECL_AND_INIT(Var, Utmp_ent) \
  86   char Var[INT_STRLEN_BOUND (Utmp_ent->ut_pid) + 1]; \
  87   sprintf (Var, "%ld", (long int) (Utmp_ent->ut_pid))
  88 #else
  89 # define PIDSTR_DECL_AND_INIT(Var, Utmp_ent) \
  90   char const *Var = ""
  91 #endif
  92
  93 #if HAVE_STRUCT_XTMP_UT_ID
  94 # define UT_ID(U) ((U)->ut_id)
  95 #else
  96 # define UT_ID(U) "??"
  97 #endif
  98
  99 /* If true, attempt to canonicalize hostnames via a DNS lookup. */
 100 static bool do_lookup;
 101
 102 /* If true, display only a list of usernames and count of
 103    the users logged on.
 104    Ignored for 'who am i'.  */
 105 static bool short_list;
 106
 107 /* If true, display only name, line, and time fields.  */
 108 static bool short_output;
 109
 110 /* If true, display the hours:minutes since each user has touched
 111    the keyboard, or "." if within the last minute, or "old" if
 112    not within the last day.  */
 113 static bool include_idle;
 114
 115 /* If true, display a line at the top describing each field.  */
 116 static bool include_heading;
 117
 118 /* If true, display a '+' for each user if mesg y, a '-' if mesg n,
 119    or a '?' if their tty cannot be statted. */
 120 static bool include_mesg;
 121
 122 /* If true, display process termination & exit status.  */
 123 static bool include_exit;
 124
 125 /* If true, display the last boot time.  */
 126 static bool need_boottime;
 127
 128 /* If true, display dead processes.  */
 129 static bool need_deadprocs;
 130
 131 /* If true, display processes waiting for user login.  */
 132 static bool need_login;
 133
 134 /* If true, display processes started by init.  */
 135 static bool need_initspawn;
 136
 137 /* If true, display the last clock change.  */
 138 static bool need_clockchange;
 139
 140 /* If true, display the current runlevel.  */
 141 static bool need_runlevel;
 142
 143 /* If true, display user processes.  */
 144 static bool need_users;
 145
 146 /* If true, display info only for the controlling tty.  */
 147 static bool my_line_only;
 148
 149 /* The strftime format to use for login times, and its expected
 150    output width.  */
 151 static char const *time_format;
 152 static int time_format_width;
 153
 154 /* for long options with no corresponding short option, use enum */
 155 enum
 156 {
 157   LOOKUP_OPTION = CHAR_MAX + 1
 158 };
 159
 160 static struct option const longopts[] =
 161 {
 162   {"all", no_argument, nullptr, 'a'},
 163   {"boot", no_argument, nullptr, 'b'},
 164   {"count", no_argument, nullptr, 'q'},
 165   {"dead", no_argument, nullptr, 'd'},
 166   {"heading", no_argument, nullptr, 'H'},
 167   {"login", no_argument, nullptr, 'l'},
 168   {"lookup", no_argument, nullptr, LOOKUP_OPTION},
 169   {"message", no_argument, nullptr, 'T'},
 170   {"mesg", no_argument, nullptr, 'T'},
 171   {"process", no_argument, nullptr, 'p'},
 172   {"runlevel", no_argument, nullptr, 'r'},
 173   {"short", no_argument, nullptr, 's'},
 174   {"time", no_argument, nullptr, 't'},
 175   {"users", no_argument, nullptr, 'u'},
 176   {"writable", no_argument, nullptr, 'T'},
 177   {GETOPT_HELP_OPTION_DECL},
 178   {GETOPT_VERSION_OPTION_DECL},
 179   {nullptr, 0, nullptr, 0}
 180 };
 181
 182 /* Return a string representing the time between WHEN and now.
 183    BOOTTIME is the time of last reboot.
 184    FIXME: locale? */
 185 static char const *
 186 idle_string (time_t when, time_t boottime)
 187 {
 188   static time_t now = TYPE_MINIMUM (time_t);
 189
 190   if (now == TYPE_MINIMUM (time_t))
 191     time (&now);
 192
 193   int seconds_idle;
 194   if (boottime < when && when <= now
 195       && ! ckd_sub (&seconds_idle, now, when)
 196       && seconds_idle < 24 * 60 * 60)
 197     {
 198       if (seconds_idle < 60)
 199         return "  .  ";
 200       else
 201         {
 202           static char idle_hhmm[IDLESTR_LEN];
 203           sprintf (idle_hhmm, "%02d:%02d",
 204                    seconds_idle / (60 * 60),
 205                    (seconds_idle % (60 * 60)) / 60);
 206           return idle_hhmm;
 207         }
 208     }
 209
 210   return _(" old ");
 211 }
 212
 213 /* Return a time string.  */
 214 static char const *
 215 time_string (struct gl_utmp const *utmp_ent)
 216 {
 217   static char buf[INT_STRLEN_BOUND (intmax_t) + sizeof "-%m-%d %H:%M"];
 218   struct tm *tmp = localtime (&utmp_ent->ut_ts.tv_sec);
 219
 220   if (tmp)
 221     {
 222       strftime (buf, sizeof buf, time_format, tmp);
 223       return buf;
 224     }
 225   else
 226     return timetostr (utmp_ent->ut_ts.tv_sec, buf);
 227 }
 228
 229 /* Print formatted output line. Uses mostly arbitrary field sizes, probably
 230    will need tweaking if any of the localization stuff is done, or for 64 bit
 231    pids, etc. */
 232 static void
 233 print_line (char const *user, const char state,
 234             char const *line,
 235             char const *time_str, char const *idle, char const *pid,
 236             char const *comment, char const *exitstr)
 237 {
 238   static char mesg[3] = { ' ', 'x', '\0' };
 239   char *buf;
 240   char x_idle[1 + IDLESTR_LEN + 1];
 241   char x_pid[1 + INT_STRLEN_BOUND (pid_t) + 1];
 242   char *x_exitstr;
 243   int err;
 244
 245   mesg[1] = state;
 246
 247   if (include_idle && !short_output && strlen (idle) < sizeof x_idle - 1)
 248     sprintf (x_idle, " %-6s", idle);
 249   else
 250     *x_idle = '\0';
 251
 252   if (!short_output && strlen (pid) < sizeof x_pid - 1)
 253     sprintf (x_pid, " %10s", pid);
 254   else
 255     *x_pid = '\0';
 256
 257   x_exitstr = xmalloc (include_exit ? 1 + MAX (12, strlen (exitstr)) + 1 : 1);
 258   if (include_exit)
 259     sprintf (x_exitstr, " %-12s", exitstr);
 260   else
 261     *x_exitstr = '\0';
 262
 263   err = asprintf (&buf,
 264                   "%-8s"
 265                   "%s"
 266                   " %-12s"
 267                   " %-*s"
 268                   "%s"
 269                   "%s"
 270                   " %-8s"
 271                   "%s"
 272                   ,
 273                   user ? user : "   .",
 274                   include_mesg ? mesg : "",
 275                   line,
 276                   time_format_width,
 277                   time_str,
 278                   x_idle,
 279                   x_pid,
 280                   /* FIXME: it's not really clear whether the following
 281                      field should be in the short_output.  A strict reading
 282                      of SUSv2 would suggest not, but I haven't seen any
 283                      implementations that actually work that way... */
 284                   comment,
 285                   x_exitstr
 286                   );
 287   if (err == -1)
 288     xalloc_die ();
 289
 290   {
 291     /* Remove any trailing spaces.  */
 292     char *p = buf + strlen (buf);
 293     while (*--p == ' ')
 294       /* empty */;
 295     *(p + 1) = '\0';
 296   }
 297
 298   puts (buf);
 299   free (buf);
 300   free (x_exitstr);
 301 }
 302
 303 /* Return true if a terminal device given as PSTAT allows other users
 304    to send messages to; false otherwise */
 305 static bool
 306 is_tty_writable (struct stat const *pstat)
 307 {
 308 #ifdef TTY_GROUP_NAME
 309   /* Ensure the group of the TTY device matches TTY_GROUP_NAME, more info at
 310      https://bugzilla.redhat.com/454261 */
 311   struct group *ttygr = getgrnam (TTY_GROUP_NAME);
 312   if (!ttygr || (pstat->st_gid != ttygr->gr_gid))
 313     return false;
 314 #endif
 315
 316   return pstat->st_mode & S_IWGRP;
 317 }
 318
 319 /* Send properly parsed USER_PROCESS info to print_line.  The most
 320    recent boot time is BOOTTIME. */
 321 static void
 322 print_user (struct gl_utmp const *utmp_ent, time_t boottime)
 323 {
 324   struct stat stats;
 325   time_t last_change;
 326   char mesg;
 327   char idlestr[IDLESTR_LEN + 1];
 328   PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
 329   static char *hoststr;
 330 #if HAVE_STRUCT_XTMP_UT_HOST
 331   static idx_t hostlen;
 332 #endif
 333
 334   /* If ut_line contains a space, the device name starts after the space.  */
 335   char *line = utmp_ent->ut_line;
 336   char *space = strchr (line, ' ');
 337   line = space ? space + 1 : line;
 338
 339   int dirfd;
 340   if (IS_ABSOLUTE_FILE_NAME (line))
 341     dirfd = AT_FDCWD;
 342   else
 343     {
 344       static int dev_dirfd;
 345       if (!dev_dirfd)
 346         {
 347           dev_dirfd = open ("/dev", O_PATHSEARCH | O_DIRECTORY);
 348           if (dev_dirfd < 0)
 349             dev_dirfd = AT_FDCWD - 1;
 350         }
 351       dirfd = dev_dirfd;
 352     }
 353
 354   if (AT_FDCWD <= dirfd && fstatat (dirfd, line, &stats, 0) == 0)
 355     {
 356       mesg = is_tty_writable (&stats) ? '+' : '-';
 357       last_change = stats.st_atime;
 358     }
 359   else
 360     {
 361       mesg = '?';
 362       last_change = 0;
 363     }
 364
 365   if (last_change)
 366     sprintf (idlestr, "%.*s", IDLESTR_LEN, idle_string (last_change, boottime));
 367   else
 368     sprintf (idlestr, "  ?");
 369
 370 #if HAVE_STRUCT_XTMP_UT_HOST
 371   if (utmp_ent->ut_host[0])
 372     {
 373       char *host = nullptr;
 374       char *display = nullptr;
 375       char *ut_host = utmp_ent->ut_host;
 376
 377       /* Look for an X display.  */
 378       display = strchr (ut_host, ':');
 379       if (display)
 380         *display++ = '\0';
 381
 382       if (*ut_host && do_lookup)
 383         {
 384           /* See if we can canonicalize it.  */
 385           host = canon_host (ut_host);
 386         }
 387
 388       if (! host)
 389         host = ut_host;
 390
 391       if (display)
 392         {
 393           idx_t needed = strlen (host) + strlen (display) + 4;
 394           if (hostlen < needed)
 395             {
 396               free (hoststr);
 397               hoststr = xpalloc (nullptr, &hostlen, needed - hostlen, -1, 1);
 398             }
 399           char *p = hoststr;
 400           *p++ = '(';
 401           p = stpcpy (p, host);
 402           *p++ = ':';
 403           strcpy (stpcpy (p, display), ")");
 404         }
 405       else
 406         {
 407           idx_t needed = strlen (host) + 3;
 408           if (hostlen < needed)
 409             {
 410               free (hoststr);
 411               hoststr = xpalloc (nullptr, &hostlen, needed - hostlen, -1, 1);
 412             }
 413           char *p = hoststr;
 414           *p++ = '(';
 415           strcpy (stpcpy (p, host), ")");
 416         }
 417
 418       if (host != ut_host)
 419         free (host);
 420     }
 421   else
 422     {
 423       if (hostlen < 1)
 424         hoststr = xpalloc (hoststr, &hostlen, 1, -1, 1);
 425       *hoststr = '\0';
 426     }
 427 #endif
 428
 429   print_line (utmp_ent->ut_user, mesg,
 430               utmp_ent->ut_line,
 431               time_string (utmp_ent), idlestr, pidstr,
 432               hoststr ? hoststr : "", "");
 433 }
 434
 435 static void
 436 print_boottime (struct gl_utmp const *utmp_ent)
 437 {
 438   print_line ("", ' ', _("system boot"),
 439               time_string (utmp_ent), "", "", "", "");
 440 }
 441
 442 static char *
 443 make_id_equals_comment (struct gl_utmp const *utmp_ent)
 444 {
 445   char const *id = UT_ID (utmp_ent);
 446   idx_t idlen = strlen (id);
 447   char const *prefix = _("id=");
 448   idx_t prefixlen = strlen (prefix);
 449   char *comment = xmalloc (prefixlen + idlen + 1);
 450   char *p = mempcpy (comment, prefix, prefixlen);
 451   p = mempcpy (p, id, idlen);
 452   *p = '\0';
 453   return comment;
 454 }
 455
 456 static void
 457 print_deadprocs (struct gl_utmp const *utmp_ent)
 458 {
 459   static char *exitstr;
 460   char *comment = make_id_equals_comment (utmp_ent);
 461   PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
 462
 463   if (!exitstr)
 464     exitstr = xmalloc (strlen (_("term="))
 465                        + INT_STRLEN_BOUND (utmp_ent->ut_exit.e_termination) + 1
 466                        + strlen (_("exit="))
 467                        + INT_STRLEN_BOUND (utmp_ent->ut_exit.e_exit)
 468                        + 1);
 469   sprintf (exitstr, "%s%d %s%d", _("term="), utmp_ent->ut_exit.e_termination,
 470            _("exit="), utmp_ent->ut_exit.e_exit);
 471
 472   /* FIXME: add idle time? */
 473
 474   print_line ("", ' ', utmp_ent->ut_line,
 475               time_string (utmp_ent), "", pidstr, comment, exitstr);
 476   free (comment);
 477 }
 478
 479 static void
 480 print_login (struct gl_utmp const *utmp_ent)
 481 {
 482   char *comment = make_id_equals_comment (utmp_ent);
 483   PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
 484
 485   /* FIXME: add idle time? */
 486
 487   print_line (_("LOGIN"), ' ', utmp_ent->ut_line,
 488               time_string (utmp_ent), "", pidstr, comment, "");
 489   free (comment);
 490 }
 491
 492 static void
 493 print_initspawn (struct gl_utmp const *utmp_ent)
 494 {
 495   char *comment = make_id_equals_comment (utmp_ent);
 496   PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
 497
 498   print_line ("", ' ', utmp_ent->ut_line,
 499               time_string (utmp_ent), "", pidstr, comment, "");
 500   free (comment);
 501 }
 502
 503 static void
 504 print_clockchange (struct gl_utmp const *utmp_ent)
 505 {
 506   /* FIXME: handle NEW_TIME & OLD_TIME both */
 507   print_line ("", ' ', _("clock change"),
 508               time_string (utmp_ent), "", "", "", "");
 509 }
 510
 511 static void
 512 print_runlevel (struct gl_utmp const *utmp_ent)
 513 {
 514   static char *runlevline, *comment;
 515   unsigned char last = utmp_ent->ut_pid / 256;
 516   unsigned char curr = utmp_ent->ut_pid % 256;
 517
 518   if (!runlevline)
 519     runlevline = xmalloc (strlen (_("run-level")) + 3);
 520   sprintf (runlevline, "%s %c", _("run-level"), curr);
 521
 522   if (!comment)
 523     comment = xmalloc (strlen (_("last=")) + 2);
 524   sprintf (comment, "%s%c", _("last="), (last == 'N') ? 'S' : last);
 525
 526   print_line ("", ' ', runlevline, time_string (utmp_ent),
 527               "", "", c_isprint (last) ? comment : "", "");
 528
 529   return;
 530 }
 531
 532 /* Print the username of each valid entry and the number of valid entries
 533    in UTMP_BUF, which should have N elements. */
 534 static void
 535 list_entries_who (idx_t n, struct gl_utmp const *utmp_buf)
 536 {
 537   idx_t entries = 0;
 538   char const *separator = "";
 539
 540   while (n--)
 541     {
 542       if (IS_USER_PROCESS (utmp_buf))
 543         {
 544           char *trimmed_name;
 545
 546           trimmed_name = extract_trimmed_name (utmp_buf);
 547
 548           printf ("%s%s", separator, trimmed_name);
 549           free (trimmed_name);
 550           separator = " ";
 551           entries++;
 552         }
 553       utmp_buf++;
 554     }
 555   printf (_("\n# users=%td\n"), entries);
 556 }
 557
 558 static void
 559 print_heading (void)
 560 {
 561   print_line (_("NAME"), ' ', _("LINE"), _("TIME"), _("IDLE"),
 562               _("PID"), _("COMMENT"), _("EXIT"));
 563 }
 564
 565 /* Display UTMP_BUF, which should have N entries. */
 566 static void
 567 scan_entries (idx_t n, struct gl_utmp const *utmp_buf)
 568 {
 569   char *ttyname_b IF_LINT ( = nullptr);
 570   time_t boottime = TYPE_MINIMUM (time_t);
 571
 572   if (include_heading)
 573     print_heading ();
 574
 575   if (my_line_only)
 576     {
 577       ttyname_b = ttyname (STDIN_FILENO);
 578       if (!ttyname_b)
 579         return;
 580       if (STRNCMP_LIT (ttyname_b, "/dev/") == 0)
 581         ttyname_b += sizeof "/dev/" - 1;        /* Discard /dev/ prefix.  */
 582     }
 583
 584   while (n--)
 585     {
 586       if (!my_line_only
 587           || STREQ (ttyname_b, utmp_buf->ut_line))
 588         {
 589           if (need_users && IS_USER_PROCESS (utmp_buf))
 590             print_user (utmp_buf, boottime);
 591           else if (need_runlevel && UT_TYPE_RUN_LVL (utmp_buf))
 592             print_runlevel (utmp_buf);
 593           else if (need_boottime && UT_TYPE_BOOT_TIME (utmp_buf))
 594             print_boottime (utmp_buf);
 595           /* I've never seen one of these, so I don't know what it should
 596              look like :^)
 597              FIXME: handle OLD_TIME also, perhaps show the delta? */
 598           else if (need_clockchange && UT_TYPE_NEW_TIME (utmp_buf))
 599             print_clockchange (utmp_buf);
 600           else if (need_initspawn && UT_TYPE_INIT_PROCESS (utmp_buf))
 601             print_initspawn (utmp_buf);
 602           else if (need_login && UT_TYPE_LOGIN_PROCESS (utmp_buf))
 603             print_login (utmp_buf);
 604           else if (need_deadprocs && UT_TYPE_DEAD_PROCESS (utmp_buf))
 605             print_deadprocs (utmp_buf);
 606         }
 607
 608       if (UT_TYPE_BOOT_TIME (utmp_buf))
 609         boottime = utmp_buf->ut_ts.tv_sec;
 610
 611       utmp_buf++;
 612     }
 613 }
 614
 615 /* Display a list of who is on the system, according to utmp file FILENAME.
 616    Use read_utmp OPTIONS to read the file.  */
 617 static void
 618 who (char const *filename, int options)
 619 {
 620   idx_t n_users;
 621   struct gl_utmp *utmp_buf;
 622   if (short_list)
 623     options |= READ_UTMP_USER_PROCESS;
 624   if (read_utmp (filename, &n_users, &utmp_buf, options) != 0)
 625     error (EXIT_FAILURE, errno, "%s", quotef (filename));
 626
 627   if (short_list)
 628     list_entries_who (n_users, utmp_buf);
 629   else
 630     scan_entries (n_users, utmp_buf);
 631
 632   free (utmp_buf);
 633 }
 634
 635 void
 636 usage (int status)
 637 {
 638   if (status != EXIT_SUCCESS)
 639     emit_try_help ();
 640   else
 641     {
 642       printf (_("Usage: %s [OPTION]... [ FILE | ARG1 ARG2 ]\n"), program_name);
 643       fputs (_("\
 644 Print information about users who are currently logged in.\n\
 645 "), stdout);
 646       fputs (_("\
 647 \n\
 648   -a, --all         same as -b -d --login -p -r -t -T -u\n\
 649   -b, --boot        time of last system boot\n\
 650   -d, --dead        print dead processes\n\
 651   -H, --heading     print line of column headings\n\
 652 "), stdout);
 653       fputs (_("\
 654   -l, --login       print system login processes\n\
 655 "), stdout);
 656       fputs (_("\
 657       --lookup      attempt to canonicalize hostnames via DNS\n\
 658   -m                only hostname and user associated with stdin\n\
 659   -p, --process     print active processes spawned by init\n\
 660 "), stdout);
 661       fputs (_("\
 662   -q, --count       all login names and number of users logged on\n\
 663   -r, --runlevel    print current runlevel\n\
 664   -s, --short       print only name, line, and time (default)\n\
 665   -t, --time        print last system clock change\n\
 666 "), stdout);
 667       fputs (_("\
 668   -T, -w, --mesg    add user's message status as +, - or ?\n\
 669   -u, --users       list users logged in\n\
 670       --message     same as -T\n\
 671       --writable    same as -T\n\
 672 "), stdout);
 673       fputs (HELP_OPTION_DESCRIPTION, stdout);
 674       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 675       printf (_("\
 676 \n\
 677 If FILE is not specified, use %s.  %s as FILE is common.\n\
 678 If ARG1 ARG2 given, -m presumed: 'am i' or 'mom likes' are usual.\n\
 679 "), UTMP_FILE, WTMP_FILE);
 680       emit_ancillary_info (PROGRAM_NAME);
 681     }
 682   exit (status);
 683 }
 684
 685 int
 686 main (int argc, char **argv)
 687 {
 688   int optc;
 689   bool assumptions = true;
 690
 691   initialize_main (&argc, &argv);
 692   set_program_name (argv[0]);
 693   setlocale (LC_ALL, "");
 694   bindtextdomain (PACKAGE, LOCALEDIR);
 695   textdomain (PACKAGE);
 696
 697   atexit (close_stdout);
 698
 699   while ((optc = getopt_long (argc, argv, "abdlmpqrstuwHT", longopts, nullptr))
 700          != -1)
 701     {
 702       switch (optc)
 703         {
 704         case 'a':
 705           need_boottime = true;
 706           need_deadprocs = true;
 707           need_login = true;
 708           need_initspawn = true;
 709           need_runlevel = true;
 710           need_clockchange = true;
 711           need_users = true;
 712           include_mesg = true;
 713           include_idle = true;
 714           include_exit = true;
 715           assumptions = false;
 716           break;
 717
 718         case 'b':
 719           need_boottime = true;
 720           assumptions = false;
 721           break;
 722
 723         case 'd':
 724           need_deadprocs = true;
 725           include_idle = true;
 726           include_exit = true;
 727           assumptions = false;
 728           break;
 729
 730         case 'H':
 731           include_heading = true;
 732           break;
 733
 734         case 'l':
 735           need_login = true;
 736           include_idle = true;
 737           assumptions = false;
 738           break;
 739
 740         case 'm':
 741           my_line_only = true;
 742           break;
 743
 744         case 'p':
 745           need_initspawn = true;
 746           assumptions = false;
 747           break;
 748
 749         case 'q':
 750           short_list = true;
 751           break;
 752
 753         case 'r':
 754           need_runlevel = true;
 755           include_idle = true;
 756           assumptions = false;
 757           break;
 758
 759         case 's':
 760           short_output = true;
 761           break;
 762
 763         case 't':
 764           need_clockchange = true;
 765           assumptions = false;
 766           break;
 767
 768         case 'T':
 769         case 'w':
 770           include_mesg = true;
 771           break;
 772
 773         case 'u':
 774           need_users = true;
 775           include_idle = true;
 776           assumptions = false;
 777           break;
 778
 779         case LOOKUP_OPTION:
 780           do_lookup = true;
 781           break;
 782
 783         case_GETOPT_HELP_CHAR;
 784
 785         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 786
 787         default:
 788           usage (EXIT_FAILURE);
 789         }
 790     }
 791
 792   if (assumptions)
 793     {
 794       need_users = true;
 795       short_output = true;
 796     }
 797
 798   if (include_exit)
 799     {
 800       short_output = false;
 801     }
 802
 803   if (hard_locale (LC_TIME))
 804     {
 805       time_format = "%Y-%m-%d %H:%M";
 806       time_format_width = 4 + 1 + 2 + 1 + 2 + 1 + 2 + 1 + 2;
 807     }
 808   else
 809     {
 810       time_format = "%b %e %H:%M";
 811       time_format_width = 3 + 1 + 2 + 1 + 2 + 1 + 2;
 812     }
 813
 814   switch (argc - optind)
 815     {
 816     case 2:                     /* who <blurf> <glop> */
 817       my_line_only = true;
 818       FALLTHROUGH;
 819     case -1:
 820     case 0:                     /* who */
 821       who (UTMP_FILE, READ_UTMP_CHECK_PIDS);
 822       break;
 823
 824     case 1:                     /* who <utmp file> */
 825       who (argv[optind], 0);
 826       break;
 827
 828     default:                    /* lose */
 829       error (0, 0, _("extra operand %s"), quote (argv[optind + 2]));
 830       usage (EXIT_FAILURE);
 831     }
 832
 833   return EXIT_SUCCESS;
 834 }