2 Copyright (C) 1992-2008 Free Software Foundation, Inc.
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.
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.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 /* Written by jla; revised by djm; revised again by mstone */
20 name [state] line time [activity] [pid] [comment] [exit]
22 name, line, time: not -q
30 #include <sys/types.h>
33 #include "canon-host.h"
36 #include "hard-locale.h"
40 /* The official name of this program (e.g., no `g' prefix). */
41 #define PROGRAM_NAME "who"
44 proper_name ("Joseph Arceneaux"), \
45 proper_name ("David MacKenzie"), \
46 proper_name ("Michael Stone")
48 #ifndef MAXHOSTNAMELEN
49 # define MAXHOSTNAMELEN 64
53 # define UT_TYPE_RUN_LVL(U) UT_TYPE_EQ (U, RUN_LVL)
55 # define UT_TYPE_RUN_LVL(U) false
59 # define UT_TYPE_INIT_PROCESS(U) UT_TYPE_EQ (U, INIT_PROCESS)
61 # define UT_TYPE_INIT_PROCESS(U) false
65 # define UT_TYPE_LOGIN_PROCESS(U) UT_TYPE_EQ (U, LOGIN_PROCESS)
67 # define UT_TYPE_LOGIN_PROCESS(U) false
71 # define UT_TYPE_DEAD_PROCESS(U) UT_TYPE_EQ (U, DEAD_PROCESS)
73 # define UT_TYPE_DEAD_PROCESS(U) false
77 # define UT_TYPE_NEW_TIME(U) UT_TYPE_EQ (U, NEW_TIME)
79 # define UT_TYPE_NEW_TIME(U) false
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))
89 # define PIDSTR_DECL_AND_INIT(Var, Utmp_ent) \
93 #if HAVE_STRUCT_XTMP_UT_ID
94 # define UT_ID(U) ((U)->ut_id)
96 # define UT_ID(U) "??"
101 /* If true, attempt to canonicalize hostnames via a DNS lookup. */
102 static bool do_lookup;
104 /* If true, display only a list of usernames and count of
106 Ignored for `who am i'. */
107 static bool short_list;
109 /* If true, display only name, line, and time fields. */
110 static bool short_output;
112 /* If true, 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 bool include_idle;
117 /* If true, display a line at the top describing each field. */
118 static bool include_heading;
120 /* If true, display a `+' for each user if mesg y, a `-' if mesg n,
121 or a `?' if their tty cannot be statted. */
122 static bool include_mesg;
124 /* If true, display process termination & exit status. */
125 static bool include_exit;
127 /* If true, display the last boot time. */
128 static bool need_boottime;
130 /* If true, display dead processes. */
131 static bool need_deadprocs;
133 /* If true, display processes waiting for user login. */
134 static bool need_login;
136 /* If true, display processes started by init. */
137 static bool need_initspawn;
139 /* If true, display the last clock change. */
140 static bool need_clockchange;
142 /* If true, display the current runlevel. */
143 static bool need_runlevel;
145 /* If true, display user processes. */
146 static bool need_users;
148 /* If true, display info only for the controlling tty. */
149 static bool my_line_only;
151 /* The strftime format to use for login times, and its expected
153 static char const *time_format;
154 static int time_format_width;
156 /* for long options with no corresponding short option, use enum */
159 LOOKUP_OPTION = CHAR_MAX + 1
162 static const struct option const longopts[] =
164 {"all", no_argument, NULL, 'a'},
165 {"boot", no_argument, NULL, 'b'},
166 {"count", no_argument, NULL, 'q'},
167 {"dead", no_argument, NULL, 'd'},
168 {"heading", no_argument, NULL, 'H'},
169 {"login", no_argument, NULL, 'l'},
170 {"lookup", no_argument, NULL, LOOKUP_OPTION},
171 {"message", no_argument, NULL, 'T'},
172 {"mesg", no_argument, NULL, 'T'},
173 {"process", no_argument, NULL, 'p'},
174 {"runlevel", no_argument, NULL, 'r'},
175 {"short", no_argument, NULL, 's'},
176 {"time", no_argument, NULL, 't'},
177 {"users", no_argument, NULL, 'u'},
178 {"writable", no_argument, NULL, 'T'},
179 {GETOPT_HELP_OPTION_DECL},
180 {GETOPT_VERSION_OPTION_DECL},
184 /* Return a string representing the time between WHEN and now.
185 BOOTTIME is the time of last reboot.
188 idle_string (time_t when, time_t boottime)
190 static time_t now = TYPE_MINIMUM (time_t);
192 if (now == TYPE_MINIMUM (time_t))
195 if (boottime < when && now - 24 * 60 * 60 < when && when <= now)
197 int seconds_idle = now - when;
198 if (seconds_idle < 60)
202 static char idle_hhmm[IDLESTR_LEN];
203 sprintf (idle_hhmm, "%02d:%02d",
204 seconds_idle / (60 * 60),
205 (seconds_idle % (60 * 60)) / 60);
213 /* Return a time string. */
215 time_string (const STRUCT_UTMP *utmp_ent)
217 static char buf[INT_STRLEN_BOUND (intmax_t) + sizeof "-%m-%d %H:%M"];
219 /* Don't take the address of UT_TIME_MEMBER directly.
220 Ulrich Drepper wrote:
221 ``... GNU libc (and perhaps other libcs as well) have extended
222 utmp file formats which do not use a simple time_t ut_time field.
223 In glibc, ut_time is a macro which selects for backward compatibility
224 the tv_sec member of a struct timeval value.'' */
225 time_t t = UT_TIME_MEMBER (utmp_ent);
226 struct tm *tmp = localtime (&t);
230 strftime (buf, sizeof buf, time_format, tmp);
234 return TYPE_SIGNED (time_t) ? imaxtostr (t, buf) : umaxtostr (t, buf);
237 /* Print formatted output line. Uses mostly arbitrary field sizes, probably
238 will need tweaking if any of the localization stuff is done, or for 64 bit
241 print_line (int userlen, const char *user, const char state,
242 int linelen, const char *line,
243 const char *time_str, const char *idle, const char *pid,
244 const char *comment, const char *exitstr)
246 static char mesg[3] = { ' ', 'x', '\0' };
248 char x_idle[1 + IDLESTR_LEN + 1];
249 char x_pid[1 + INT_STRLEN_BOUND (pid_t) + 1];
255 if (include_idle && !short_output && strlen (idle) < sizeof x_idle - 1)
256 sprintf (x_idle, " %-6s", idle);
260 if (!short_output && strlen (pid) < sizeof x_pid - 1)
261 sprintf (x_pid, " %10s", pid);
265 x_exitstr = xmalloc (include_exit ? 1 + MAX (12, strlen (exitstr)) + 1 : 1);
267 sprintf (x_exitstr, " %-12s", exitstr);
271 err = asprintf (&buf,
281 userlen, user ? user : " .",
282 include_mesg ? mesg : "",
288 /* FIXME: it's not really clear whether the following
289 field should be in the short_output. A strict reading
290 of SUSv2 would suggest not, but I haven't seen any
291 implementations that actually work that way... */
299 /* Remove any trailing spaces. */
300 char *p = buf + strlen (buf);
311 /* Send properly parsed USER_PROCESS info to print_line. The most
312 recent boot time is BOOTTIME. */
314 print_user (const STRUCT_UTMP *utmp_ent, time_t boottime)
319 char idlestr[IDLESTR_LEN + 1];
320 static char *hoststr;
322 static size_t hostlen;
325 #define DEV_DIR_WITH_TRAILING_SLASH "/dev/"
326 #define DEV_DIR_LEN (sizeof (DEV_DIR_WITH_TRAILING_SLASH) - 1)
328 char line[sizeof (utmp_ent->ut_line) + DEV_DIR_LEN + 1];
329 PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
331 /* Copy ut_line into LINE, prepending `/dev/' if ut_line is not
332 already an absolute file name. Some systems may put the full,
333 absolute file name in ut_line. */
334 if (utmp_ent->ut_line[0] == '/')
336 strncpy (line, utmp_ent->ut_line, sizeof (utmp_ent->ut_line));
337 line[sizeof (utmp_ent->ut_line)] = '\0';
341 strcpy (line, DEV_DIR_WITH_TRAILING_SLASH);
342 strncpy (line + DEV_DIR_LEN, utmp_ent->ut_line,
343 sizeof (utmp_ent->ut_line));
344 line[DEV_DIR_LEN + sizeof (utmp_ent->ut_line)] = '\0';
347 if (stat (line, &stats) == 0)
349 mesg = (stats.st_mode & S_IWGRP) ? '+' : '-';
350 last_change = stats.st_atime;
359 sprintf (idlestr, "%.*s", IDLESTR_LEN, idle_string (last_change, boottime));
361 sprintf (idlestr, " ?");
364 if (utmp_ent->ut_host[0])
366 char ut_host[sizeof (utmp_ent->ut_host) + 1];
368 char *display = NULL;
370 /* Copy the host name into UT_HOST, and ensure it's nul terminated. */
371 strncpy (ut_host, utmp_ent->ut_host, sizeof (utmp_ent->ut_host));
372 ut_host[sizeof (utmp_ent->ut_host)] = '\0';
374 /* Look for an X display. */
375 display = strchr (ut_host, ':');
379 if (*ut_host && do_lookup)
381 /* See if we can canonicalize it. */
382 host = canon_host (ut_host);
390 if (hostlen < strlen (host) + strlen (display) + 4)
392 hostlen = strlen (host) + strlen (display) + 4;
393 hoststr = xrealloc (hoststr, hostlen);
395 sprintf (hoststr, "(%s:%s)", host, display);
399 if (hostlen < strlen (host) + 3)
401 hostlen = strlen (host) + 3;
402 hoststr = xrealloc (hoststr, hostlen);
404 sprintf (hoststr, "(%s)", host);
415 hoststr = xrealloc (hoststr, hostlen);
421 print_line (sizeof UT_USER (utmp_ent), UT_USER (utmp_ent), mesg,
422 sizeof utmp_ent->ut_line, utmp_ent->ut_line,
423 time_string (utmp_ent), idlestr, pidstr,
424 hoststr ? hoststr : "", "");
428 print_boottime (const STRUCT_UTMP *utmp_ent)
430 print_line (-1, "", ' ', -1, "system boot",
431 time_string (utmp_ent), "", "", "", "");
435 make_id_equals_comment (STRUCT_UTMP const *utmp_ent)
437 char *comment = xmalloc (strlen (_("id=")) + sizeof UT_ID (utmp_ent) + 1);
439 strcpy (comment, _("id="));
440 strncat (comment, UT_ID (utmp_ent), sizeof UT_ID (utmp_ent));
445 print_deadprocs (const STRUCT_UTMP *utmp_ent)
447 static char *exitstr;
448 char *comment = make_id_equals_comment (utmp_ent);
449 PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
452 exitstr = xmalloc (strlen (_("term="))
453 + INT_STRLEN_BOUND (UT_EXIT_E_TERMINATION (utmp_ent)) + 1
454 + strlen (_("exit="))
455 + INT_STRLEN_BOUND (UT_EXIT_E_EXIT (utmp_ent))
457 sprintf (exitstr, "%s%d %s%d", _("term="), UT_EXIT_E_TERMINATION (utmp_ent),
458 _("exit="), UT_EXIT_E_EXIT (utmp_ent));
460 /* FIXME: add idle time? */
462 print_line (-1, "", ' ', sizeof utmp_ent->ut_line, utmp_ent->ut_line,
463 time_string (utmp_ent), "", pidstr, comment, exitstr);
468 print_login (const STRUCT_UTMP *utmp_ent)
470 char *comment = make_id_equals_comment (utmp_ent);
471 PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
473 /* FIXME: add idle time? */
475 print_line (-1, "LOGIN", ' ', sizeof utmp_ent->ut_line, utmp_ent->ut_line,
476 time_string (utmp_ent), "", pidstr, comment, "");
481 print_initspawn (const STRUCT_UTMP *utmp_ent)
483 char *comment = make_id_equals_comment (utmp_ent);
484 PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
486 print_line (-1, "", ' ', sizeof utmp_ent->ut_line, utmp_ent->ut_line,
487 time_string (utmp_ent), "", pidstr, comment, "");
492 print_clockchange (const STRUCT_UTMP *utmp_ent)
494 /* FIXME: handle NEW_TIME & OLD_TIME both */
495 print_line (-1, "", ' ', -1, _("clock change"),
496 time_string (utmp_ent), "", "", "", "");
500 print_runlevel (const STRUCT_UTMP *utmp_ent)
502 static char *runlevline, *comment;
503 unsigned char last = UT_PID (utmp_ent) / 256;
504 unsigned char curr = UT_PID (utmp_ent) % 256;
507 runlevline = xmalloc (strlen (_("run-level")) + 3);
508 sprintf (runlevline, "%s %c", _("run-level"), curr);
511 comment = xmalloc (strlen (_("last=")) + 2);
512 sprintf (comment, "%s%c", _("last="), (last == 'N') ? 'S' : last);
514 print_line (-1, "", ' ', -1, runlevline, time_string (utmp_ent),
515 "", "", comment, "");
520 /* Print the username of each valid entry and the number of valid entries
521 in UTMP_BUF, which should have N elements. */
523 list_entries_who (size_t n, const STRUCT_UTMP *utmp_buf)
525 unsigned long int entries = 0;
526 char const *separator = "";
530 if (IS_USER_PROCESS (utmp_buf))
534 trimmed_name = extract_trimmed_name (utmp_buf);
536 printf ("%s%s", separator, trimmed_name);
543 printf (_("\n# users=%lu\n"), entries);
549 print_line (-1, _("NAME"), ' ', -1, _("LINE"), _("TIME"), _("IDLE"),
550 _("PID"), _("COMMENT"), _("EXIT"));
553 /* Display UTMP_BUF, which should have N entries. */
555 scan_entries (size_t n, const STRUCT_UTMP *utmp_buf)
557 char *ttyname_b IF_LINT ( = NULL);
558 time_t boottime = TYPE_MINIMUM (time_t);
565 ttyname_b = ttyname (STDIN_FILENO);
568 if (strncmp (ttyname_b, DEV_DIR_WITH_TRAILING_SLASH, DEV_DIR_LEN) == 0)
569 ttyname_b += DEV_DIR_LEN; /* Discard /dev/ prefix. */
575 strncmp (ttyname_b, utmp_buf->ut_line,
576 sizeof (utmp_buf->ut_line)) == 0)
578 if (need_users && IS_USER_PROCESS (utmp_buf))
579 print_user (utmp_buf, boottime);
580 else if (need_runlevel && UT_TYPE_RUN_LVL (utmp_buf))
581 print_runlevel (utmp_buf);
582 else if (need_boottime && UT_TYPE_BOOT_TIME (utmp_buf))
583 print_boottime (utmp_buf);
584 /* I've never seen one of these, so I don't know what it should
586 FIXME: handle OLD_TIME also, perhaps show the delta? */
587 else if (need_clockchange && UT_TYPE_NEW_TIME (utmp_buf))
588 print_clockchange (utmp_buf);
589 else if (need_initspawn && UT_TYPE_INIT_PROCESS (utmp_buf))
590 print_initspawn (utmp_buf);
591 else if (need_login && UT_TYPE_LOGIN_PROCESS (utmp_buf))
592 print_login (utmp_buf);
593 else if (need_deadprocs && UT_TYPE_DEAD_PROCESS (utmp_buf))
594 print_deadprocs (utmp_buf);
597 if (UT_TYPE_BOOT_TIME (utmp_buf))
598 boottime = UT_TIME_MEMBER (utmp_buf);
604 /* Display a list of who is on the system, according to utmp file FILENAME.
605 Use read_utmp OPTIONS to read the file. */
607 who (const char *filename, int options)
610 STRUCT_UTMP *utmp_buf;
612 if (read_utmp (filename, &n_users, &utmp_buf, options) != 0)
613 error (EXIT_FAILURE, errno, "%s", filename);
616 list_entries_who (n_users, utmp_buf);
618 scan_entries (n_users, utmp_buf);
626 if (status != EXIT_SUCCESS)
627 fprintf (stderr, _("Try `%s --help' for more information.\n"),
631 printf (_("Usage: %s [OPTION]... [ FILE | ARG1 ARG2 ]\n"), program_name);
634 -a, --all same as -b -d --login -p -r -t -T -u\n\
635 -b, --boot time of last system boot\n\
636 -d, --dead print dead processes\n\
637 -H, --heading print line of column headings\n\
640 -l, --login print system login processes\n\
643 --lookup attempt to canonicalize hostnames via DNS\n\
644 -m only hostname and user associated with stdin\n\
645 -p, --process print active processes spawned by init\n\
648 -q, --count all login names and number of users logged on\n\
649 -r, --runlevel print current runlevel\n\
650 -s, --short print only name, line, and time (default)\n\
651 -t, --time print last system clock change\n\
654 -T, -w, --mesg add user's message status as +, - or ?\n\
655 -u, --users list users logged in\n\
656 --message same as -T\n\
657 --writable same as -T\n\
659 fputs (HELP_OPTION_DESCRIPTION, stdout);
660 fputs (VERSION_OPTION_DESCRIPTION, stdout);
663 If FILE is not specified, use %s. %s as FILE is common.\n\
664 If ARG1 ARG2 given, -m presumed: `am i' or `mom likes' are usual.\n\
665 "), UTMP_FILE, WTMP_FILE);
666 emit_bug_reporting_address ();
672 main (int argc, char **argv)
675 bool assumptions = true;
677 initialize_main (&argc, &argv);
678 set_program_name (argv[0]);
679 setlocale (LC_ALL, "");
680 bindtextdomain (PACKAGE, LOCALEDIR);
681 textdomain (PACKAGE);
683 atexit (close_stdout);
685 while ((optc = getopt_long (argc, argv, "abdlmpqrstuwHT", longopts, NULL))
691 need_boottime = true;
692 need_deadprocs = true;
694 need_initspawn = true;
695 need_runlevel = true;
696 need_clockchange = true;
705 need_boottime = true;
710 need_deadprocs = true;
717 include_heading = true;
731 need_initspawn = true;
740 need_runlevel = true;
750 need_clockchange = true;
769 case_GETOPT_HELP_CHAR;
771 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
774 usage (EXIT_FAILURE);
786 short_output = false;
789 if (hard_locale (LC_TIME))
791 time_format = "%Y-%m-%d %H:%M";
792 time_format_width = 4 + 1 + 2 + 1 + 2 + 1 + 2 + 1 + 2;
796 time_format = "%b %e %H:%M";
797 time_format_width = 3 + 1 + 2 + 1 + 2 + 1 + 2;
800 switch (argc - optind)
802 case 2: /* who <blurf> <glop> */
807 who (UTMP_FILE, READ_UTMP_CHECK_PIDS);
810 case 1: /* who <utmp file> */
811 who (argv[optind], 0);
815 error (0, 0, _("extra operand %s"), quote (argv[optind + 2]));
816 usage (EXIT_FAILURE);