src/who-users.c

   1 /* GNU's uptime/users/who.
   2    Copyright (C) 92, 93, 94, 95, 1996 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 2, or (at your option)
   7    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, write to the Free Software Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* Written by jla; revised by djm */
  19
  20 /* Output format:
  21    name [state] line time [idle] host
  22    state: -T
  23    name, line, time: not -q
  24    idle: -u
  25
  26    Options:
  27    -m           Same as 'who am i', for POSIX.
  28    -q           Only user names and # logged on; overrides all other options.
  29    -s           Name, line, time (default).
  30    -i, -u       Idle hours and minutes; '.' means active in last minute;
  31                 'old' means idle for >24 hours.
  32    -H           Print column headings at top.
  33    -w, -T       -s plus mesg (+ or -, or ? if bad line). */
  34
  35 #include <config.h>
  36 #include <stdio.h>
  37 #include <sys/types.h>
  38
  39 #ifdef HAVE_UTMPX_H
  40 # include <utmpx.h>
  41 # define STRUCT_UTMP struct utmpx
  42 # define UT_TIME_MEMBER(UT_PTR) ((UT_PTR)->ut_tv.tv_sec)
  43 #else
  44 # include <utmp.h>
  45 # define STRUCT_UTMP struct utmp
  46 # define UT_TIME_MEMBER(UT_PTR) ((UT_PTR)->ut_time)
  47 #endif
  48
  49 #include <time.h>
  50 #include <getopt.h>
  51 #ifdef HAVE_SYS_PARAM_H
  52 #include <sys/param.h>
  53 #endif
  54
  55 #include "system.h"
  56 #include "error.h"
  57
  58 #if !defined (UTMP_FILE) && defined (_PATH_UTMP)        /* 4.4BSD.  */
  59 #define UTMP_FILE _PATH_UTMP
  60 #endif
  61
  62 #if defined (UTMPX_FILE)        /* Solaris, SysVr4 */
  63 #undef  UTMP_FILE
  64 #define UTMP_FILE UTMPX_FILE
  65 #endif
  66
  67 #ifndef UTMP_FILE
  68 #define UTMP_FILE "/etc/utmp"
  69 #endif
  70
  71 #ifndef MAXHOSTNAMELEN
  72 #define MAXHOSTNAMELEN 64
  73 #endif
  74
  75 #ifndef S_IWGRP
  76 #define S_IWGRP 020
  77 #endif
  78
  79 #ifdef WHO
  80 #define COMMAND_NAME "who"
  81 #else
  82 #ifdef USERS
  83 #define COMMAND_NAME "users"
  84 #else
  85 #ifdef UPTIME
  86 #define COMMAND_NAME "uptime"
  87 #else
  88  error You must define one of WHO, UPTIME or USERS.
  89 #endif /* UPTIME */
  90 #endif /* USERS */
  91 #endif /* WHO */
  92
  93 int gethostname ();
  94 char *ttyname ();
  95 char *xmalloc ();
  96
  97 /* The name this program was run with. */
  98 char *program_name;
  99
 100 /* If nonzero, display usage information and exit.  */
 101 static int show_help;
 102
 103 /* If nonzero, print the version on standard output and exit.  */
 104 static int show_version;
 105
 106 #ifdef WHO
 107 /* If nonzero, display only a list of usernames and count of
 108    the users logged on.
 109    Ignored for `who am i'. */
 110 static int short_list;
 111
 112 /* If nonzero, display the hours:minutes since each user has touched
 113    the keyboard, or "." if within the last minute, or "old" if
 114    not within the last day. */
 115 static int include_idle;
 116
 117 /* If nonzero, display a line at the top describing each field. */
 118 static int include_heading;
 119
 120 /* If nonzero, display a `+' for each user if mesg y, a `-' if mesg n,
 121    or a `?' if their tty cannot be statted. */
 122 static int include_mesg;
 123 #endif /* WHO */
 124
 125 static struct option const longopts[] =
 126 {
 127 #ifdef WHO
 128   {"count", no_argument, NULL, 'q'},
 129   {"idle", no_argument, NULL, 'u'},
 130   {"heading", no_argument, NULL, 'H'},
 131   {"message", no_argument, NULL, 'T'},
 132   {"mesg", no_argument, NULL, 'T'},
 133   {"writable", no_argument, NULL, 'T'},
 134 #endif /* WHO */
 135   {"help", no_argument, &show_help, 1},
 136   {"version", no_argument, &show_version, 1},
 137   {NULL, 0, NULL, 0}
 138 };
 139
 140 static STRUCT_UTMP *utmp_contents;
 141
 142 #ifdef UPTIME
 143 static void
 144 print_uptime (int n)
 145 {
 146   register STRUCT_UTMP *this = utmp_contents;
 147   register int entries = 0;
 148   time_t boot_time = 0;
 149   time_t time_now;
 150   time_t uptime;
 151   int updays;
 152   int uphours;
 153   int upmins;
 154   struct tm *tmn;
 155   double avg[3];
 156   int loads;
 157
 158   /* Loop through all the utmp entries we just read and count up the valid
 159      ones, also in the process possibly gleaning boottime. */
 160   while (n--)
 161     {
 162       if (this->ut_name[0]
 163 #ifdef USER_PROCESS
 164           && this->ut_type == USER_PROCESS
 165 #endif
 166           )
 167         {
 168           ++entries;
 169         }
 170       /* If BOOT_MSG is defined, we can get boottime from utmp.  This avoids
 171          possibly needing special privs to read /dev/kmem. */
 172 #ifdef BOOT_MSG
 173       if (!strcmp (this->ut_line, BOOT_MSG))
 174         boot_time = UT_TIME_MEMBER (this);
 175 #endif /* BOOT_MSG */
 176       ++this;
 177   }
 178   if (boot_time == 0)
 179     error (1, errno, _("couldn't get boot time"));
 180   time_now = time (0);
 181   uptime = time_now - boot_time;
 182   updays = uptime / 86400;
 183   uphours = (uptime - (updays * 86400)) / 3600;
 184   upmins = (uptime - (updays * 86400) - (uphours * 3600)) / 60;
 185   tmn = localtime (&time_now);
 186   printf (_(" %2d:%02d%s  up "), ((tmn->tm_hour % 12) == 0
 187                                ? 12 : tmn->tm_hour % 12),
 188           tmn->tm_min, (tmn->tm_hour < 12 ? _("am") : _("pm")));
 189   if (updays > 0)
 190     printf ("%d %s,", updays, (updays == 1 ? _("days") : _("day")));
 191   printf (" %2d:%02d,  %d %s", uphours, upmins, entries,
 192           (entries == 1) ? _("user") : _("users"));
 193
 194 #ifdef HAVE_GETLOADAVG
 195   loads = getloadavg (avg, 3);
 196 #else
 197   loads = -1;
 198 #endif
 199
 200   if (loads == -1)
 201     putchar ('\n');
 202   else
 203     {
 204       if (loads > 0)
 205         printf (_(",  load average: %.2f"), avg[0]);
 206       if (loads > 1)
 207         printf (", %.2f", avg[1]);
 208       if (loads > 2)
 209         printf (", %.2f", avg[2]);
 210       if (loads > 0)
 211         putchar ('\n');
 212     }
 213 }
 214 #endif /* UPTIME */
 215
 216
 217
 218 #if defined (WHO) || defined (USERS)
 219
 220 /* Copy UT->ut_name into storage obtained from malloc.  Then remove any
 221    trailing spaces from the copy, NUL terminate it, and return the copy.  */
 222
 223 static char *
 224 extract_trimmed_name (const STRUCT_UTMP *ut)
 225 {
 226   char *p, *trimmed_name;
 227
 228   trimmed_name = xmalloc (sizeof (ut->ut_name) + 1);
 229   strncpy (trimmed_name, ut->ut_name, sizeof (ut->ut_name));
 230   /* Append a trailing space character.  Some systems pad names shorter than
 231      the maximum with spaces, others pad with NULs.  Remove any spaces.  */
 232   trimmed_name[sizeof (ut->ut_name)] = ' ';
 233   p = strchr (trimmed_name, ' ');
 234   if (p != NULL)
 235     *p = '\0';
 236   return trimmed_name;
 237 }
 238
 239 #endif /* WHO || USERS */
 240
 241 #if WHO
 242
 243 /* Return a string representing the time between WHEN and the time
 244    that this function is first run. */
 245
 246 static const char *
 247 idle_string (time_t when)
 248 {
 249   static time_t now = 0;
 250   static char idle[10];
 251   time_t seconds_idle;
 252
 253   if (now == 0)
 254     time (&now);
 255
 256   seconds_idle = now - when;
 257   if (seconds_idle < 60)        /* One minute. */
 258     return "  .  ";
 259   if (seconds_idle < (24 * 60 * 60)) /* One day. */
 260     {
 261       sprintf (idle, "%02d:%02d",
 262                (int) (seconds_idle / (60 * 60)),
 263                (int) ((seconds_idle % (60 * 60)) / 60));
 264       return (const char *) idle;
 265     }
 266   return _(" old ");
 267 }
 268
 269 /* Display a line of information about entry THIS. */
 270
 271 static void
 272 print_entry (STRUCT_UTMP *this)
 273 {
 274   struct stat stats;
 275   time_t last_change;
 276   char mesg;
 277
 278 #define DEV_DIR_WITH_TRAILING_SLASH "/dev/"
 279 #define DEV_DIR_LEN (sizeof (DEV_DIR_WITH_TRAILING_SLASH) - 1)
 280
 281   char line[sizeof (this->ut_line) + DEV_DIR_LEN + 1];
 282
 283   /* Copy ut_line into LINE, prepending `/dev/' if ut_line is not
 284      already an absolute pathname.  Some system may put the full,
 285      absolute pathname in ut_line.  */
 286   if (this->ut_line[0] == '/')
 287     {
 288       strncpy (line, this->ut_line, sizeof (this->ut_line));
 289       line[sizeof (this->ut_line)] = '\0';
 290     }
 291   else
 292     {
 293       strcpy (line, DEV_DIR_WITH_TRAILING_SLASH);
 294       strncpy (line + DEV_DIR_LEN, this->ut_line, sizeof (this->ut_line));
 295       line[DEV_DIR_LEN + sizeof (this->ut_line)] = '\0';
 296     }
 297
 298   if (stat (line, &stats) == 0)
 299     {
 300       mesg = (stats.st_mode & S_IWGRP) ? '+' : '-';
 301       last_change = stats.st_atime;
 302     }
 303   else
 304     {
 305       mesg = '?';
 306       last_change = 0;
 307     }
 308
 309   printf ("%-8.*s", (int) sizeof (this->ut_name), this->ut_name);
 310   if (include_mesg)
 311     printf ("  %c  ", mesg);
 312   printf (" %-8.*s", (int) sizeof (this->ut_line), this->ut_line);
 313   printf (" %-12.12s", ctime (&UT_TIME_MEMBER (this)) + 4);
 314
 315   if (include_idle)
 316     {
 317       if (last_change)
 318         printf (" %s", idle_string (last_change));
 319       else
 320         printf ("   .  ");
 321     }
 322 #ifdef HAVE_UT_HOST
 323   if (this->ut_host[0])
 324     {
 325       extern char *canon_host ();
 326       char ut_host[sizeof (this->ut_host) + 1];
 327       char *host = 0, *display = 0;
 328
 329       /* Copy the host name into UT_HOST, and ensure it's nul terminated. */
 330       strncpy (ut_host, this->ut_host, (int) sizeof (this->ut_host));
 331       ut_host[sizeof (this->ut_host)] = '\0';
 332
 333       /* Look for an X display.  */
 334       display = strrchr (ut_host, ':');
 335       if (display)
 336         *display++ = '\0';
 337
 338       if (*ut_host)
 339         /* See if we can canonicalize it.  */
 340         host = canon_host (ut_host);
 341       if (! host)
 342         host = ut_host;
 343
 344       if (display)
 345         printf (" (%s:%s)", host, display);
 346       else
 347         printf (" (%s)", host);
 348     }
 349 #endif
 350
 351   putchar ('\n');
 352 }
 353
 354 /* Print the username of each valid entry and the number of valid entries
 355    in `utmp_contents', which should have N elements. */
 356
 357 static void
 358 list_entries_who (int n)
 359 {
 360   register STRUCT_UTMP *this = utmp_contents;
 361   int entries;
 362
 363   entries = 0;
 364   while (n--)
 365     {
 366       if (this->ut_name[0]
 367 #ifdef USER_PROCESS
 368           && this->ut_type == USER_PROCESS
 369 #endif
 370          )
 371         {
 372           char *trimmed_name;
 373
 374           trimmed_name = extract_trimmed_name (this);
 375
 376           printf ("%s ", trimmed_name);
 377           free (trimmed_name);
 378           entries++;
 379         }
 380       this++;
 381     }
 382   printf (_("\n# users=%u\n"), entries);
 383 }
 384
 385 #endif /* WHO */
 386
 387 #ifdef USERS
 388
 389 static int
 390 userid_compare (const void *v_a, const void *v_b)
 391 {
 392   char **a = (char **) v_a;
 393   char **b = (char **) v_b;
 394   return strcmp (*a, *b);
 395 }
 396
 397 static void
 398 list_entries_users (int n)
 399 {
 400   register STRUCT_UTMP *this = utmp_contents;
 401   char **u;
 402   int i;
 403   int n_entries;
 404
 405   n_entries = 0;
 406   u = (char **) xmalloc (n * sizeof (u[0]));
 407   for (i = 0; i < n; i++)
 408     {
 409       if (this->ut_name[0]
 410 #ifdef USER_PROCESS
 411           && this->ut_type == USER_PROCESS
 412 #endif
 413          )
 414         {
 415           char *trimmed_name;
 416
 417           trimmed_name = extract_trimmed_name (this);
 418
 419           u[n_entries] = trimmed_name;
 420           ++n_entries;
 421         }
 422       this++;
 423     }
 424
 425   qsort (u, n_entries, sizeof (u[0]), userid_compare);
 426
 427   for (i = 0; i < n_entries; i++)
 428     {
 429       int c;
 430       fputs (u[i], stdout);
 431       c = (i < n_entries-1 ? ' ' : '\n');
 432       putchar (c);
 433     }
 434
 435   for (i = 0; i < n_entries; i++)
 436     free (u[i]);
 437   free (u);
 438 }
 439
 440 #endif /* USERS */
 441
 442 #ifdef WHO
 443
 444 static void
 445 print_heading (void)
 446 {
 447   printf ("%-8s ", _("USER"));
 448   if (include_mesg)
 449     printf (_("MESG "));
 450   printf ("%-8s ", _("LINE"));
 451   printf (_("LOGIN-TIME   "));
 452   if (include_idle)
 453     printf (_("IDLE  "));
 454   printf (_("FROM\n"));
 455 }
 456
 457 /* Display `utmp_contents', which should have N entries. */
 458
 459 static void
 460 scan_entries (int n)
 461 {
 462   register STRUCT_UTMP *this = utmp_contents;
 463
 464   if (include_heading)
 465     print_heading ();
 466
 467   while (n--)
 468     {
 469       if (this->ut_name[0]
 470 #ifdef USER_PROCESS
 471           && this->ut_type == USER_PROCESS
 472 #endif
 473          )
 474         print_entry (this);
 475       this++;
 476     }
 477 }
 478
 479 #endif /* WHO */
 480
 481 /* Read the utmp file FILENAME into UTMP_CONTENTS and return the
 482    number of entries it contains. */
 483
 484 static int
 485 read_utmp (char *filename)
 486 {
 487   FILE *utmp;
 488   struct stat file_stats;
 489   size_t n_read;
 490   size_t size;
 491
 492   utmp = fopen (filename, "r");
 493   if (utmp == NULL)
 494     error (1, errno, "%s", filename);
 495
 496   fstat (fileno (utmp), &file_stats);
 497   size = file_stats.st_size;
 498   if (size > 0)
 499     utmp_contents = (STRUCT_UTMP *) xmalloc (size);
 500   else
 501     {
 502       fclose (utmp);
 503       return 0;
 504     }
 505
 506   /* Use < instead of != in case the utmp just grew.  */
 507   n_read = fread (utmp_contents, 1, size, utmp);
 508   if (ferror (utmp) || fclose (utmp) == EOF
 509       || n_read < size)
 510     error (1, errno, "%s", filename);
 511
 512   return size / sizeof (STRUCT_UTMP);
 513 }
 514
 515 /* Display a list of who is on the system, according to utmp file FILENAME. */
 516
 517 static void
 518 who (char *filename)
 519 {
 520   int users;
 521
 522   users = read_utmp (filename);
 523 #ifdef WHO
 524   if (short_list)
 525     list_entries_who (users);
 526   else
 527     scan_entries (users);
 528 #else
 529 #ifdef USERS
 530   list_entries_users (users);
 531 #else
 532 #ifdef UPTIME
 533   print_uptime (users);
 534 #endif /* UPTIME */
 535 #endif /* USERS */
 536 #endif /* WHO */
 537 }
 538
 539 #ifdef WHO
 540
 541 /* Search `utmp_contents', which should have N entries, for
 542    an entry with a `ut_line' field identical to LINE.
 543    Return the first matching entry found, or NULL if there
 544    is no matching entry. */
 545
 546 static STRUCT_UTMP *
 547 search_entries (int n, char *line)
 548 {
 549   register STRUCT_UTMP *this = utmp_contents;
 550
 551   while (n--)
 552     {
 553       if (this->ut_name[0]
 554 #ifdef USER_PROCESS
 555           && this->ut_type == USER_PROCESS
 556 #endif
 557           && !strncmp (line, this->ut_line, sizeof (this->ut_line)))
 558         return this;
 559       this++;
 560     }
 561   return NULL;
 562 }
 563
 564 /* Display the entry in utmp file FILENAME for this tty on standard input,
 565    or nothing if there is no entry for it. */
 566
 567 static void
 568 who_am_i (char *filename)
 569 {
 570   register STRUCT_UTMP *utmp_entry;
 571   char hostname[MAXHOSTNAMELEN + 1];
 572   char *tty;
 573
 574   if (gethostname (hostname, MAXHOSTNAMELEN + 1))
 575     *hostname = 0;
 576
 577   if (include_heading)
 578     {
 579       printf ("%*s ", (int) strlen (hostname), " ");
 580       print_heading ();
 581     }
 582
 583   tty = ttyname (0);
 584   if (tty == NULL)
 585     return;
 586   tty += 5;                     /* Remove "/dev/".  */
 587
 588   utmp_entry = search_entries (read_utmp (filename), tty);
 589   if (utmp_entry == NULL)
 590     return;
 591
 592   printf ("%s!", hostname);
 593   print_entry (utmp_entry);
 594 }
 595
 596 static void
 597 usage (int status)
 598 {
 599   if (status != 0)
 600     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 601              program_name);
 602   else
 603     {
 604       printf (_("Usage: %s [OPTION]... [ FILE | ARG1 ARG2 ]\n"), program_name);
 605       printf (_("\
 606 \n\
 607   -H, --heading     print line of column headings\n\
 608   -T, -w, --mesg    add user's message status as +, - or ?\n\
 609   -i, -u, --idle    add user idle time as HOURS:MINUTES, . or old\n\
 610   -m                only hostname and user associated with stdin\n\
 611   -q, --count       all login names and number of users logged on\n\
 612   -s                (ignored)\n\
 613       --help        display this help and exit\n\
 614       --message     same as -T\n\
 615       --version     output version information and exit\n\
 616       --writeable   same as -T\n\
 617 \n\
 618 If FILE not given, uses /etc/utmp.  /etc/wtmp as FILE is common.\n\
 619 If ARG1 ARG2 given, -m presumed: `am i' or `mom likes' are usual.\n\
 620 "));
 621     }
 622   exit (status);
 623 }
 624 #endif /* WHO */
 625
 626 #if defined(USERS) || defined(UPTIME)
 627 static void
 628 usage (int status)
 629 {
 630   if (status != 0)
 631     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 632              program_name);
 633   else
 634     {
 635       printf (_("Usage: %s [OPTION]... [ FILE ]\n"), program_name);
 636       printf (_("\
 637 Output who is currently logged in according to FILE.\n\
 638 If FILE not given, uses /etc/utmp.  /etc/wtmp as FILE is common.\n\
 639 \n\
 640       --help        display this help and exit\n\
 641       --version     output version information and exit\n"));
 642     }
 643   exit (status);
 644 }
 645 #endif /* USERS || UPTIME */
 646
 647 int
 648 main (int argc, char **argv)
 649 {
 650   int optc, longind;
 651 #ifdef WHO
 652   int my_line_only = 0;
 653 #endif /* WHO */
 654
 655   program_name = argv[0];
 656   setlocale (LC_ALL, "");
 657   bindtextdomain (PACKAGE, LOCALEDIR);
 658   textdomain (PACKAGE);
 659
 660 #ifdef WHO
 661   while ((optc = getopt_long (argc, argv, "imqsuwHT", longopts, &longind))
 662 #else
 663   while ((optc = getopt_long (argc, argv, "", longopts, &longind))
 664 #endif /* WHO */
 665          != EOF)
 666     {
 667       switch (optc)
 668         {
 669         case 0:
 670           break;
 671
 672 #ifdef WHO
 673         case 'm':
 674           my_line_only = 1;
 675           break;
 676
 677         case 'q':
 678           short_list = 1;
 679           break;
 680
 681         case 's':
 682           break;
 683
 684         case 'i':
 685         case 'u':
 686           include_idle = 1;
 687           break;
 688
 689         case 'H':
 690           include_heading = 1;
 691           break;
 692
 693         case 'w':
 694         case 'T':
 695           include_mesg = 1;
 696           break;
 697 #endif /* WHO */
 698
 699         default:
 700           usage (1);
 701         }
 702     }
 703
 704   if (show_version)
 705     {
 706       printf ("%s - %s\n", COMMAND_NAME, PACKAGE_VERSION);
 707       exit (0);
 708     }
 709
 710   if (show_help)
 711     usage (0);
 712
 713   switch (argc - optind)
 714     {
 715     case 0:                     /* who */
 716 #ifdef WHO
 717       if (my_line_only)
 718         who_am_i (UTMP_FILE);
 719       else
 720 #endif /* WHO */
 721         who (UTMP_FILE);
 722       break;
 723
 724     case 1:                     /* who <utmp file> */
 725 #ifdef WHO
 726       if (my_line_only)
 727         who_am_i (argv[optind]);
 728       else
 729 #endif /* WHO */
 730         who (argv[optind]);
 731       break;
 732
 733 #ifdef WHO
 734     case 2:                     /* who <blurf> <glop> */
 735       who_am_i (UTMP_FILE);
 736       break;
 737 #endif /* WHO */
 738
 739     default:                    /* lose */
 740       error (0, 0, _("too many arguments"));
 741       usage (1);
 742     }
 743
 744   exit (0);
 745 }