2 Copyright (C) 1992-2012 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>
34 #include "canon-host.h"
37 #include "hard-locale.h"
44 /* The official name of this program (e.g., no 'g' prefix). */
45 #define PROGRAM_NAME "who"
48 proper_name ("Joseph Arceneaux"), \
49 proper_name ("David MacKenzie"), \
50 proper_name ("Michael Stone")
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 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 timetostr (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 /* Return true if a terminal device given as PSTAT allows other users
312 to send messages to; false otherwise */
314 is_tty_writable (struct stat const *pstat)
316 #ifdef TTY_GROUP_NAME
317 /* Ensure the group of the TTY device matches TTY_GROUP_NAME, more info at
318 https://bugzilla.redhat.com/454261 */
319 struct group *ttygr = getgrnam (TTY_GROUP_NAME);
320 if (!ttygr || (pstat->st_gid != ttygr->gr_gid))
324 return pstat->st_mode & S_IWGRP;
327 /* Send properly parsed USER_PROCESS info to print_line. The most
328 recent boot time is BOOTTIME. */
330 print_user (const STRUCT_UTMP *utmp_ent, time_t boottime)
335 char idlestr[IDLESTR_LEN + 1];
336 static char *hoststr;
338 static size_t hostlen;
341 #define DEV_DIR_WITH_TRAILING_SLASH "/dev/"
342 #define DEV_DIR_LEN (sizeof (DEV_DIR_WITH_TRAILING_SLASH) - 1)
344 char line[sizeof (utmp_ent->ut_line) + DEV_DIR_LEN + 1];
345 PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
347 /* Copy ut_line into LINE, prepending '/dev/' if ut_line is not
348 already an absolute file name. Some systems may put the full,
349 absolute file name in ut_line. */
350 if (utmp_ent->ut_line[0] == '/')
352 strncpy (line, utmp_ent->ut_line, sizeof (utmp_ent->ut_line));
353 line[sizeof (utmp_ent->ut_line)] = '\0';
357 strcpy (line, DEV_DIR_WITH_TRAILING_SLASH);
358 strncpy (line + DEV_DIR_LEN, utmp_ent->ut_line,
359 sizeof (utmp_ent->ut_line));
360 line[DEV_DIR_LEN + sizeof (utmp_ent->ut_line)] = '\0';
363 if (stat (line, &stats) == 0)
365 mesg = is_tty_writable (&stats) ? '+' : '-';
366 last_change = stats.st_atime;
375 sprintf (idlestr, "%.*s", IDLESTR_LEN, idle_string (last_change, boottime));
377 sprintf (idlestr, " ?");
380 if (utmp_ent->ut_host[0])
382 char ut_host[sizeof (utmp_ent->ut_host) + 1];
384 char *display = NULL;
386 /* Copy the host name into UT_HOST, and ensure it's nul terminated. */
387 strncpy (ut_host, utmp_ent->ut_host, sizeof (utmp_ent->ut_host));
388 ut_host[sizeof (utmp_ent->ut_host)] = '\0';
390 /* Look for an X display. */
391 display = strchr (ut_host, ':');
395 if (*ut_host && do_lookup)
397 /* See if we can canonicalize it. */
398 host = canon_host (ut_host);
406 if (hostlen < strlen (host) + strlen (display) + 4)
408 hostlen = strlen (host) + strlen (display) + 4;
410 hoststr = xmalloc (hostlen);
412 sprintf (hoststr, "(%s:%s)", host, display);
416 if (hostlen < strlen (host) + 3)
418 hostlen = strlen (host) + 3;
420 hoststr = xmalloc (hostlen);
422 sprintf (hoststr, "(%s)", host);
434 hoststr = xmalloc (hostlen);
440 print_line (sizeof UT_USER (utmp_ent), UT_USER (utmp_ent), mesg,
441 sizeof utmp_ent->ut_line, utmp_ent->ut_line,
442 time_string (utmp_ent), idlestr, pidstr,
443 hoststr ? hoststr : "", "");
447 print_boottime (const STRUCT_UTMP *utmp_ent)
449 print_line (-1, "", ' ', -1, _("system boot"),
450 time_string (utmp_ent), "", "", "", "");
454 make_id_equals_comment (STRUCT_UTMP const *utmp_ent)
456 char *comment = xmalloc (strlen (_("id=")) + sizeof UT_ID (utmp_ent) + 1);
458 strcpy (comment, _("id="));
459 strncat (comment, UT_ID (utmp_ent), sizeof UT_ID (utmp_ent));
464 print_deadprocs (const STRUCT_UTMP *utmp_ent)
466 static char *exitstr;
467 char *comment = make_id_equals_comment (utmp_ent);
468 PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
471 exitstr = xmalloc (strlen (_("term="))
472 + INT_STRLEN_BOUND (UT_EXIT_E_TERMINATION (utmp_ent)) + 1
473 + strlen (_("exit="))
474 + INT_STRLEN_BOUND (UT_EXIT_E_EXIT (utmp_ent))
476 sprintf (exitstr, "%s%d %s%d", _("term="), UT_EXIT_E_TERMINATION (utmp_ent),
477 _("exit="), UT_EXIT_E_EXIT (utmp_ent));
479 /* FIXME: add idle time? */
481 print_line (-1, "", ' ', sizeof utmp_ent->ut_line, utmp_ent->ut_line,
482 time_string (utmp_ent), "", pidstr, comment, exitstr);
487 print_login (const STRUCT_UTMP *utmp_ent)
489 char *comment = make_id_equals_comment (utmp_ent);
490 PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
492 /* FIXME: add idle time? */
494 print_line (-1, _("LOGIN"), ' ', sizeof utmp_ent->ut_line, utmp_ent->ut_line,
495 time_string (utmp_ent), "", pidstr, comment, "");
500 print_initspawn (const STRUCT_UTMP *utmp_ent)
502 char *comment = make_id_equals_comment (utmp_ent);
503 PIDSTR_DECL_AND_INIT (pidstr, utmp_ent);
505 print_line (-1, "", ' ', sizeof utmp_ent->ut_line, utmp_ent->ut_line,
506 time_string (utmp_ent), "", pidstr, comment, "");
511 print_clockchange (const STRUCT_UTMP *utmp_ent)
513 /* FIXME: handle NEW_TIME & OLD_TIME both */
514 print_line (-1, "", ' ', -1, _("clock change"),
515 time_string (utmp_ent), "", "", "", "");
519 print_runlevel (const STRUCT_UTMP *utmp_ent)
521 static char *runlevline, *comment;
522 unsigned char last = UT_PID (utmp_ent) / 256;
523 unsigned char curr = UT_PID (utmp_ent) % 256;
526 runlevline = xmalloc (strlen (_("run-level")) + 3);
527 sprintf (runlevline, "%s %c", _("run-level"), curr);
530 comment = xmalloc (strlen (_("last=")) + 2);
531 sprintf (comment, "%s%c", _("last="), (last == 'N') ? 'S' : last);
533 print_line (-1, "", ' ', -1, runlevline, time_string (utmp_ent),
534 "", "", c_isprint (last) ? comment : "", "");
539 /* Print the username of each valid entry and the number of valid entries
540 in UTMP_BUF, which should have N elements. */
542 list_entries_who (size_t n, const STRUCT_UTMP *utmp_buf)
544 unsigned long int entries = 0;
545 char const *separator = "";
549 if (IS_USER_PROCESS (utmp_buf))
553 trimmed_name = extract_trimmed_name (utmp_buf);
555 printf ("%s%s", separator, trimmed_name);
562 printf (_("\n# users=%lu\n"), entries);
568 print_line (-1, _("NAME"), ' ', -1, _("LINE"), _("TIME"), _("IDLE"),
569 _("PID"), _("COMMENT"), _("EXIT"));
572 /* Display UTMP_BUF, which should have N entries. */
574 scan_entries (size_t n, const STRUCT_UTMP *utmp_buf)
576 char *ttyname_b IF_LINT ( = NULL);
577 time_t boottime = TYPE_MINIMUM (time_t);
584 ttyname_b = ttyname (STDIN_FILENO);
587 if (STRNCMP_LIT (ttyname_b, DEV_DIR_WITH_TRAILING_SLASH) == 0)
588 ttyname_b += DEV_DIR_LEN; /* Discard /dev/ prefix. */
594 || strncmp (ttyname_b, utmp_buf->ut_line,
595 sizeof (utmp_buf->ut_line)) == 0)
597 if (need_users && IS_USER_PROCESS (utmp_buf))
598 print_user (utmp_buf, boottime);
599 else if (need_runlevel && UT_TYPE_RUN_LVL (utmp_buf))
600 print_runlevel (utmp_buf);
601 else if (need_boottime && UT_TYPE_BOOT_TIME (utmp_buf))
602 print_boottime (utmp_buf);
603 /* I've never seen one of these, so I don't know what it should
605 FIXME: handle OLD_TIME also, perhaps show the delta? */
606 else if (need_clockchange && UT_TYPE_NEW_TIME (utmp_buf))
607 print_clockchange (utmp_buf);
608 else if (need_initspawn && UT_TYPE_INIT_PROCESS (utmp_buf))
609 print_initspawn (utmp_buf);
610 else if (need_login && UT_TYPE_LOGIN_PROCESS (utmp_buf))
611 print_login (utmp_buf);
612 else if (need_deadprocs && UT_TYPE_DEAD_PROCESS (utmp_buf))
613 print_deadprocs (utmp_buf);
616 if (UT_TYPE_BOOT_TIME (utmp_buf))
617 boottime = UT_TIME_MEMBER (utmp_buf);
623 /* Display a list of who is on the system, according to utmp file FILENAME.
624 Use read_utmp OPTIONS to read the file. */
626 who (const char *filename, int options)
629 STRUCT_UTMP *utmp_buf;
631 if (read_utmp (filename, &n_users, &utmp_buf, options) != 0)
632 error (EXIT_FAILURE, errno, "%s", filename);
635 list_entries_who (n_users, utmp_buf);
637 scan_entries (n_users, utmp_buf);
645 if (status != EXIT_SUCCESS)
649 printf (_("Usage: %s [OPTION]... [ FILE | ARG1 ARG2 ]\n"), program_name);
651 Print information about users who are currently logged in.\n\
655 -a, --all same as -b -d --login -p -r -t -T -u\n\
656 -b, --boot time of last system boot\n\
657 -d, --dead print dead processes\n\
658 -H, --heading print line of column headings\n\
661 -l, --login print system login processes\n\
664 --lookup attempt to canonicalize hostnames via DNS\n\
665 -m only hostname and user associated with stdin\n\
666 -p, --process print active processes spawned by init\n\
669 -q, --count all login names and number of users logged on\n\
670 -r, --runlevel print current runlevel\n\
671 -s, --short print only name, line, and time (default)\n\
672 -t, --time print last system clock change\n\
675 -T, -w, --mesg add user's message status as +, - or ?\n\
676 -u, --users list users logged in\n\
677 --message same as -T\n\
678 --writable same as -T\n\
680 fputs (HELP_OPTION_DESCRIPTION, stdout);
681 fputs (VERSION_OPTION_DESCRIPTION, stdout);
684 If FILE is not specified, use %s. %s as FILE is common.\n\
685 If ARG1 ARG2 given, -m presumed: 'am i' or 'mom likes' are usual.\n\
686 "), UTMP_FILE, WTMP_FILE);
687 emit_ancillary_info ();
693 main (int argc, char **argv)
696 bool assumptions = true;
698 initialize_main (&argc, &argv);
699 set_program_name (argv[0]);
700 setlocale (LC_ALL, "");
701 bindtextdomain (PACKAGE, LOCALEDIR);
702 textdomain (PACKAGE);
704 atexit (close_stdout);
706 while ((optc = getopt_long (argc, argv, "abdlmpqrstuwHT", longopts, NULL))
712 need_boottime = true;
713 need_deadprocs = true;
715 need_initspawn = true;
716 need_runlevel = true;
717 need_clockchange = true;
726 need_boottime = true;
731 need_deadprocs = true;
738 include_heading = true;
752 need_initspawn = true;
761 need_runlevel = true;
771 need_clockchange = true;
790 case_GETOPT_HELP_CHAR;
792 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
795 usage (EXIT_FAILURE);
807 short_output = false;
810 if (hard_locale (LC_TIME))
812 time_format = "%Y-%m-%d %H:%M";
813 time_format_width = 4 + 1 + 2 + 1 + 2 + 1 + 2 + 1 + 2;
817 time_format = "%b %e %H:%M";
818 time_format_width = 3 + 1 + 2 + 1 + 2 + 1 + 2;
821 switch (argc - optind)
823 case 2: /* who <blurf> <glop> */
828 who (UTMP_FILE, READ_UTMP_CHECK_PIDS);
831 case 1: /* who <utmp file> */
832 who (argv[optind], 0);
836 error (0, 0, _("extra operand %s"), quote (argv[optind + 2]));
837 usage (EXIT_FAILURE);