1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
22 /* All Rights Reserved */
23
24
25 /*
26 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
27 * Use is subject to license terms.
28 */
29
30 #pragma ident "%Z%%M% %I% %E% SMI"
31
32 /*
33 * This program analyzes information found in /var/adm/utmpx
34 *
35 * Additionally information is gathered from /etc/inittab
36 * if requested.
37 *
38 *
39 * Syntax:
40 *
41 * who am i Displays info on yourself
42 *
43 * who -a Displays information about All
44 * entries in /var/adm/utmpx
45 *
46 * who -b Displays info on last boot
47 *
48 * who -d Displays info on DEAD PROCESSES
49 *
50 * who -H Displays HEADERS for output
51 *
52 * who -l Displays info on LOGIN entries
53 *
54 * who -m Same as who am i
55 *
56 * who -p Displays info on PROCESSES spawned by init
57 *
58 * who -q Displays short information on
59 * current users who LOGGED ON
60 *
61 * who -r Displays info of current run-level
62 *
63 * who -s Displays requested info in SHORT form
64 *
65 * who -t Displays info on TIME changes
66 *
67 * who -T Displays writeability of each user
68 * (+ writeable, - non-writeable, ? hung)
69 *
70 * who -u Displays LONG info on users
71 * who have LOGGED ON
72 */
73
74 #define DATE_FMT "%b %e %H:%M"
75
76 /*
77 * %b Abbreviated month name
78 * %e Day of month
79 * %H hour (24-hour clock)
80 * %M minute
81 */
82 #include <errno.h>
83 #include <fcntl.h>
84 #include <stdio.h>
85 #include <string.h>
86 #include <sys/types.h>
87 #include <unistd.h>
88 #include <stdlib.h>
89 #include <sys/stat.h>
90 #include <time.h>
91 #include <utmpx.h>
92 #include <locale.h>
93 #include <pwd.h>
94 #include <limits.h>
95
96 static void process(void);
97 static void ck_file(char *);
98 static void dump(void);
99
100 static struct utmpx *utmpp; /* pointer for getutxent() */
101
102 /*
103 * utmpx defines wider fields for user and line. For compatibility of output,
104 * we are limiting these to the old maximums in utmp. Define UTMPX_NAMELEN
105 * to use the full lengths.
106 */
107 #ifndef UTMPX_NAMELEN
108 /* XXX - utmp - fix name length */
109 #define NMAX (_POSIX_LOGIN_NAME_MAX - 1)
110 #define LMAX 12
111 #else /* UTMPX_NAMELEN */
112 #define NMAX (sizeof (utmpp->ut_user))
113 #define LMAX (sizeof (utmpp->ut_line))
114 #endif
115
116 static char comment[BUFSIZ]; /* holds inittab comment */
117 static char errmsg[BUFSIZ]; /* used in snprintf for errors */
118 static int fildes; /* file descriptor for inittab */
119 static int Hopt = 0; /* 1 = who -H */
120 static char *inittab; /* ptr to inittab contents */
121 static char *iinit; /* index into inittab */
122 static int justme = 0; /* 1 = who am i */
123 static struct tm *lptr; /* holds user login time */
124 static char *myname; /* pointer to invoker's name */
125 static char *mytty; /* holds device user is on */
126 static char nameval[sizeof (utmpp->ut_user) + 1]; /* invoker's name */
127 static int number = 8; /* number of users per -q line */
128 static int optcnt = 0; /* keeps count of options */
129 static char outbuf[BUFSIZ]; /* buffer for output */
130 static char *program; /* holds name of this program */
131 #ifdef XPG4
132 static int aopt = 0; /* 1 = who -a */
133 static int dopt = 0; /* 1 = who -d */
134 #endif /* XPG4 */
135 static int qopt = 0; /* 1 = who -q */
136 static int sopt = 0; /* 1 = who -s */
137 static struct stat stbuf; /* area for stat buffer */
138 static struct stat *stbufp; /* ptr to structure */
139 static int terse = 1; /* 1 = print terse msgs */
140 static int Topt = 0; /* 1 = who -T */
141 static time_t timnow; /* holds current time */
142 static int totlusrs = 0; /* cntr for users on system */
143 static int uopt = 0; /* 1 = who -u */
144 static char user[sizeof (utmpp->ut_user) + 1]; /* holds user name */
145 static int validtype[UTMAXTYPE+1]; /* holds valid types */
146 static int wrap; /* flag to indicate wrap */
147 static char time_buf[128]; /* holds date and time string */
148 static char *end; /* used in strtol for end pointer */
149
150 int
151 main(int argc, char **argv)
152 {
153 int goerr = 0; /* non-zero indicates cmd error */
154 int i;
155 int optsw; /* switch for while of getopt() */
156
157 (void) setlocale(LC_ALL, "");
158
159 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
160 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
161 #endif
162 (void) textdomain(TEXT_DOMAIN);
163
164 validtype[USER_PROCESS] = 1;
165 validtype[EMPTY] = 0;
166 stbufp = &stbuf;
167
168 /*
169 * Strip off path name of this command
170 */
171 for (i = strlen(argv[0]); i >= 0 && argv[0][i] != '/'; --i);
172 if (i >= 0)
173 argv[0] += i+1;
174 program = argv[0];
175
176 /*
177 * Buffer stdout for speed
178 */
179 setbuf(stdout, outbuf);
180
181 /*
182 * Retrieve options specified on command line
183 * XCU4 - add -m option
184 */
185 while ((optsw = getopt(argc, argv, "abdHlmn:pqrstTu")) != EOF) {
186 optcnt++;
187 switch (optsw) {
188
189 case 'a':
190 optcnt += 7;
191 validtype[BOOT_TIME] = 1;
192 validtype[DEAD_PROCESS] = 1;
193 validtype[LOGIN_PROCESS] = 1;
194 validtype[INIT_PROCESS] = 1;
195 validtype[RUN_LVL] = 1;
196 validtype[OLD_TIME] = 1;
197 validtype[NEW_TIME] = 1;
198 validtype[USER_PROCESS] = 1;
199 #ifdef XPG4
200 aopt = 1;
201 #endif /* XPG4 */
202 uopt = 1;
203 Topt = 1;
204 if (!sopt) terse = 0;
205 break;
206
207 case 'b':
208 validtype[BOOT_TIME] = 1;
209 if (!uopt) validtype[USER_PROCESS] = 0;
210 break;
211
212 case 'd':
213 validtype[DEAD_PROCESS] = 1;
214 if (!uopt) validtype[USER_PROCESS] = 0;
215 #ifdef XPG4
216 dopt = 1;
217 #endif /* XPG4 */
218 break;
219
220 case 'H':
221 optcnt--; /* Don't count Header */
222 Hopt = 1;
223 break;
224
225 case 'l':
226 validtype[LOGIN_PROCESS] = 1;
227 if (!uopt) validtype[USER_PROCESS] = 0;
228 terse = 0;
229 break;
230 case 'm': /* New XCU4 option */
231 justme = 1;
232 break;
233
234 case 'n':
235 errno = 0;
236 number = strtol(optarg, &end, 10);
237 if (errno != 0 || *end != '\0') {
238 (void) fprintf(stderr, gettext(
239 "%s: Invalid numeric argument\n"),
240 program);
241 exit(1);
242 }
243 if (number < 1) {
244 (void) fprintf(stderr, gettext(
245 "%s: Number of users per line must "
246 "be at least 1\n"), program);
247 exit(1);
248 }
249 break;
250
251 case 'p':
252 validtype[INIT_PROCESS] = 1;
253 if (!uopt) validtype[USER_PROCESS] = 0;
254 break;
255
256 case 'q':
257 qopt = 1;
258 break;
259
260 case 'r':
261 validtype[RUN_LVL] = 1;
262 terse = 0;
263 if (!uopt) validtype[USER_PROCESS] = 0;
264 break;
265
266 case 's':
267 sopt = 1;
268 terse = 1;
269 break;
270
271 case 't':
272 validtype[OLD_TIME] = 1;
273 validtype[NEW_TIME] = 1;
274 if (!uopt) validtype[USER_PROCESS] = 0;
275 break;
276
277 case 'T':
278 Topt = 1;
279 #ifdef XPG4
280 terse = 1; /* XPG4 requires -T */
281 #else /* XPG4 */
282 terse = 0;
283 #endif /* XPG4 */
284 break;
285
286 case 'u':
287 uopt = 1;
288 validtype[USER_PROCESS] = 1;
289 if (!sopt) terse = 0;
290 break;
291
292 case '?':
293 goerr++;
294 break;
295 default:
296 break;
297 }
298 }
299 #ifdef XPG4
300 /*
301 * XCU4 changes - check for illegal sopt, Topt & aopt combination
302 */
303 if (sopt == 1) {
304 terse = 1;
305 if (Topt == 1 || aopt == 1)
306 goerr++;
307 }
308 #endif /* XPG4 */
309
310 if (goerr > 0) {
311 #ifdef XPG4
312 /*
313 * XCU4 - slightly different usage with -s -a & -T
314 */
315 (void) fprintf(stderr, gettext("\nUsage:\t%s"), program);
316 (void) fprintf(stderr,
317 gettext(" -s [-bdHlmpqrtu] [utmpx_like_file]\n"));
318
319 (void) fprintf(stderr, gettext(
320 "\t%s [-abdHlmpqrtTu] [utmpx_like_file]\n"), program);
321 #else /* XPG4 */
322 (void) fprintf(stderr, gettext(
323 "\nUsage:\t%s [-abdHlmpqrstTu] [utmpx_like_file]\n"),
324 program);
325 #endif /* XPG4 */
326 (void) fprintf(stderr,
327 gettext("\t%s -q [-n x] [utmpx_like_file]\n"), program);
328 (void) fprintf(stderr, gettext("\t%s [am i]\n"), program);
329 /*
330 * XCU4 changes - be explicit with "am i" options
331 */
332 (void) fprintf(stderr, gettext("\t%s [am I]\n"), program);
333 (void) fprintf(stderr, gettext(
334 "a\tall (bdlprtu options)\n"));
335 (void) fprintf(stderr, gettext("b\tboot time\n"));
336 (void) fprintf(stderr, gettext("d\tdead processes\n"));
337 (void) fprintf(stderr, gettext("H\tprint header\n"));
338 (void) fprintf(stderr, gettext("l\tlogin processes\n"));
339 (void) fprintf(stderr, gettext(
340 "n #\tspecify number of users per line for -q\n"));
341 (void) fprintf(stderr,
342 gettext("p\tprocesses other than getty or users\n"));
343 (void) fprintf(stderr, gettext("q\tquick %s\n"), program);
344 (void) fprintf(stderr, gettext("r\trun level\n"));
345 (void) fprintf(stderr, gettext(
346 "s\tshort form of %s (no time since last output or pid)\n"),
347 program);
348 (void) fprintf(stderr, gettext("t\ttime changes\n"));
349 (void) fprintf(stderr, gettext(
350 "T\tstatus of tty (+ writable, - not writable, "
351 "? hung)\n"));
352 (void) fprintf(stderr, gettext("u\tuseful information\n"));
353 (void) fprintf(stderr,
354 gettext("m\tinformation only about current terminal\n"));
355 (void) fprintf(stderr, gettext(
356 "am i\tinformation about current terminal "
357 "(same as -m)\n"));
358 (void) fprintf(stderr, gettext(
359 "am I\tinformation about current terminal "
360 "(same as -m)\n"));
361 exit(1);
362 }
363
364 /*
365 * XCU4: If -q option ignore all other options
366 */
367 if (qopt == 1) {
368 Hopt = 0;
369 sopt = 0;
370 Topt = 0;
371 uopt = 0;
372 justme = 0;
373 validtype[ACCOUNTING] = 0;
374 validtype[BOOT_TIME] = 0;
375 validtype[DEAD_PROCESS] = 0;
376 validtype[LOGIN_PROCESS] = 0;
377 validtype[INIT_PROCESS] = 0;
378 validtype[RUN_LVL] = 0;
379 validtype[OLD_TIME] = 0;
380 validtype[NEW_TIME] = 0;
381 validtype[USER_PROCESS] = 1;
382 }
383
384 if (argc == optind + 1) {
385 optcnt++;
386 ck_file(argv[optind]);
387 (void) utmpxname(argv[optind]);
388 }
389
390 /*
391 * Test for 'who am i' or 'who am I'
392 * XCU4 - check if justme was already set by -m option
393 */
394 if (justme == 1 || (argc == 3 && strcmp(argv[1], "am") == 0 &&
395 ((argv[2][0] == 'i' || argv[2][0] == 'I') &&
396 argv[2][1] == '\0'))) {
397 justme = 1;
398 myname = nameval;
399 (void) cuserid(myname);
400 if ((mytty = ttyname(fileno(stdin))) == NULL &&
401 (mytty = ttyname(fileno(stdout))) == NULL &&
402 (mytty = ttyname(fileno(stderr))) == NULL) {
403 (void) fprintf(stderr, gettext(
404 "Must be attached to terminal for 'am I' option\n"));
405 (void) fflush(stderr);
406 exit(1);
407 } else
408 mytty += 5; /* bump past "/dev/" */
409 }
410
411 if (!terse) {
412 if (Hopt)
413 (void) printf(gettext(
414 "NAME LINE TIME IDLE PID COMMENTS\n"));
415
416 timnow = time(0);
417
418 if ((fildes = open("/etc/inittab",
419 O_NONBLOCK|O_RDONLY)) == -1) {
420 (void) snprintf(errmsg, sizeof (errmsg),
421 gettext("%s: Cannot open /etc/inittab"), program);
422 perror(errmsg);
423 exit(errno);
424 }
425
426 if (fstat(fildes, stbufp) == -1) {
427 (void) snprintf(errmsg, sizeof (errmsg),
428 gettext("%s: Cannot stat /etc/inittab"), program);
429 perror(errmsg);
430 exit(errno);
431 }
432
433 if ((inittab = malloc(stbufp->st_size + 1)) == NULL) {
434 (void) snprintf(errmsg, sizeof (errmsg),
435 gettext("%s: Cannot allocate %ld bytes"),
436 program, stbufp->st_size);
437 perror(errmsg);
438 exit(errno);
439 }
440
441 if (read(fildes, inittab, stbufp->st_size)
442 != stbufp->st_size) {
443 (void) snprintf(errmsg, sizeof (errmsg),
444 gettext("%s: Error reading /etc/inittab"),
445 program);
446 perror(errmsg);
447 exit(errno);
448 }
449
450 inittab[stbufp->st_size] = '\0';
451 iinit = inittab;
452 } else {
453 if (Hopt) {
454 #ifdef XPG4
455 if (dopt) {
456 (void) printf(gettext(
457 "NAME LINE TIME COMMENTS\n"));
458 } else {
459 (void) printf(
460 gettext("NAME LINE TIME\n"));
461 }
462 #else /* XPG4 */
463 (void) printf(
464 gettext("NAME LINE TIME\n"));
465 #endif /* XPG4 */
466 }
467 }
468 process();
469
470 /*
471 * 'who -q' requires EOL upon exit,
472 * followed by total line
473 */
474 if (qopt)
475 (void) printf(gettext("\n# users=%d\n"), totlusrs);
476 return (0);
477 }
478
479 static void
480 dump()
481 {
482 char device[sizeof (utmpp->ut_line) + 1];
483 time_t hr;
484 time_t idle;
485 time_t min;
486 char path[sizeof (utmpp->ut_line) + 6];
487 int pexit;
488 int pterm;
489 int rc;
490 char w; /* writeability indicator */
491
492 /*
493 * Get and check user name
494 */
495 if (utmpp->ut_user[0] == '\0')
496 (void) strcpy(user, " .");
497 else {
498 (void) strncpy(user, utmpp->ut_user, sizeof (user));
499 user[sizeof (user) - 1] = '\0';
500 }
501 totlusrs++;
502
503 /*
504 * Do print in 'who -q' format
505 */
506 if (qopt) {
507 /*
508 * XCU4 - Use non user macro for correct user count
509 */
510 if (((totlusrs - 1) % number) == 0 && totlusrs > 1)
511 (void) printf("\n");
512 (void) printf("%-*s ", NMAX, user);
513 return;
514 }
515
516
517 pexit = (int)' ';
518 pterm = (int)' ';
519
520 /*
521 * Get exit info if applicable
522 */
523 if (utmpp->ut_type == RUN_LVL || utmpp->ut_type == DEAD_PROCESS) {
524 pterm = utmpp->ut_exit.e_termination;
525 pexit = utmpp->ut_exit.e_exit;
526 }
527
528 /*
529 * Massage ut_xtime field
530 */
531 lptr = localtime(&utmpp->ut_xtime);
532 (void) strftime(time_buf, sizeof (time_buf),
533 dcgettext(NULL, DATE_FMT, LC_TIME), lptr);
534
535 /*
536 * Get and massage device
537 */
538 if (utmpp->ut_line[0] == '\0')
539 (void) strcpy(device, " .");
540 else {
541 (void) strncpy(device, utmpp->ut_line,
542 sizeof (utmpp->ut_line));
543 device[sizeof (utmpp->ut_line)] = '\0';
544 }
545
546 /*
547 * Get writeability if requested
548 * XCU4 - only print + or - for user processes
549 */
550 if (Topt && (utmpp->ut_type == USER_PROCESS)) {
551 w = '-';
552 (void) strcpy(path, "/dev/");
553 (void) strncpy(path + 5, utmpp->ut_line,
554 sizeof (utmpp->ut_line));
555 path[5 + sizeof (utmpp->ut_line)] = '\0';
556
557 if ((rc = stat(path, stbufp)) == -1) w = '?';
558 else if ((stbufp->st_mode & S_IWOTH) ||
559 (stbufp->st_mode & S_IWGRP)) /* Check group & other */
560 w = '+';
561
562 } else
563 w = ' ';
564
565 /*
566 * Print the TERSE portion of the output
567 */
568 (void) printf("%-*s %c %-12s %s", NMAX, user, w, device, time_buf);
569
570 if (!terse) {
571 /*
572 * Stat device for idle time
573 * (Don't complain if you can't)
574 */
575 rc = -1;
576 if (utmpp->ut_type == USER_PROCESS) {
577 (void) strcpy(path, "/dev/");
578 (void) strncpy(path + 5, utmpp->ut_line,
579 sizeof (utmpp->ut_line));
580 path[5 + sizeof (utmpp->ut_line)] = '\0';
581 rc = stat(path, stbufp);
582 }
583 if (rc != -1) {
584 idle = timnow - stbufp->st_mtime;
585 hr = idle/3600;
586 min = (unsigned)(idle/60)%60;
587 if (hr == 0 && min == 0)
588 (void) printf(gettext(" . "));
589 else {
590 if (hr < 24)
591 (void) printf(" %2d:%2.2d", (int)hr,
592 (int)min);
593 else
594 (void) printf(gettext(" old "));
595 }
596 }
597
598 /*
599 * Add PID for verbose output
600 */
601 if (utmpp->ut_type != BOOT_TIME &&
602 utmpp->ut_type != RUN_LVL &&
603 utmpp->ut_type != ACCOUNTING)
604 (void) printf(" %5ld", utmpp->ut_pid);
605
606 /*
607 * Handle /etc/inittab comment
608 */
609 if (utmpp->ut_type == DEAD_PROCESS) {
610 (void) printf(gettext(" id=%4.4s "),
611 utmpp->ut_id);
612 (void) printf(gettext("term=%-3d "), pterm);
613 (void) printf(gettext("exit=%d "), pexit);
614 } else if (utmpp->ut_type != INIT_PROCESS) {
615 /*
616 * Search for each entry in inittab
617 * string. Keep our place from
618 * search to search to try and
619 * minimize the work. Wrap once if needed
620 * for each entry.
621 */
622 wrap = 0;
623 /*
624 * Look for a line beginning with
625 * utmpp->ut_id
626 */
627 while ((rc = strncmp(utmpp->ut_id, iinit,
628 strcspn(iinit, ":"))) != 0) {
629 for (; *iinit != '\n'; iinit++);
630 iinit++;
631
632 /*
633 * Wrap once if necessary to
634 * find entry in inittab
635 */
636 if (*iinit == '\0') {
637 if (!wrap) {
638 iinit = inittab;
639 wrap = 1;
640 }
641 }
642 }
643
644 if (*iinit != '\0') {
645 /*
646 * We found our entry
647 */
648 for (iinit++; *iinit != '#' &&
649 *iinit != '\n'; iinit++);
650 if (*iinit == '#') {
651 for (iinit++; *iinit == ' ' ||
652 *iinit == '\t'; iinit++);
653 for (rc = 0; *iinit != '\n'; iinit++)
654 comment[rc++] = *iinit;
655 comment[rc] = '\0';
656 } else
657 (void) strcpy(comment, " ");
658
659 (void) printf(" %s", comment);
660 } else
661 iinit = inittab; /* Reset pointer */
662 }
663 if (utmpp->ut_type == INIT_PROCESS)
664 (void) printf(gettext(" id=%4.4s"), utmpp->ut_id);
665 }
666 #ifdef XPG4
667 else
668 if (dopt && utmpp->ut_type == DEAD_PROCESS) {
669 (void) printf(gettext("\tterm=%-3d "), pterm);
670 (void) printf(gettext("exit=%d "), pexit);
671 }
672 #endif /* XPG4 */
673
674
675 /*
676 * Handle RUN_LVL process - If no alt. file - Only one!
677 */
678 if (utmpp->ut_type == RUN_LVL) {
679 (void) printf(" %c %5ld %c", pterm, utmpp->ut_pid,
680 pexit);
681 if (optcnt == 1 && !validtype[USER_PROCESS]) {
682 (void) printf("\n");
683 exit(0);
684 }
685 }
686
687 /*
688 * Handle BOOT_TIME process - If no alt. file - Only one!
689 */
690 if (utmpp->ut_type == BOOT_TIME) {
691 if (optcnt == 1 && !validtype[USER_PROCESS]) {
692 (void) printf("\n");
693 exit(0);
694 }
695 }
696
697 /*
698 * Get remote host from utmpx structure
699 */
700 if (utmpp && utmpp->ut_host[0])
701 (void) printf("\t(%.*s)", sizeof (utmpp->ut_host),
702 utmpp->ut_host);
703
704 /*
705 * Now, put on the trailing EOL
706 */
707 (void) printf("\n");
708 }
709
710 static void
711 process()
712 {
713 struct passwd *pwp;
714 int i = 0;
715 char *ttname;
716
717 /*
718 * Loop over each entry in /var/adm/utmpx
719 */
720
721 setutxent();
722 while ((utmpp = getutxent()) != NULL) {
723 #ifdef DEBUG
724 (void) printf(
725 "ut_user '%s'\nut_id '%s'\nut_line '%s'\nut_type '%d'\n\n",
726 utmpp->ut_user, utmpp->ut_id, utmpp->ut_line, utmpp->ut_type);
727 #endif
728 if (utmpp->ut_type <= UTMAXTYPE) {
729 /*
730 * Handle "am i"
731 */
732 if (justme) {
733 if (strncmp(myname, utmpp->ut_user,
734 sizeof (utmpp->ut_user)) == 0 &&
735 strncmp(mytty, utmpp->ut_line,
736 sizeof (utmpp->ut_line)) == 0 &&
737 utmpp->ut_type == USER_PROCESS) {
738 /*
739 * we have have found ourselves
740 * in the utmp file and the entry
741 * is a user process, this is not
742 * meaningful otherwise
743 *
744 */
745
746 dump();
747 exit(0);
748 }
749 continue;
750 }
751
752 /*
753 * Print the line if we want it
754 */
755 if (validtype[utmpp->ut_type]) {
756 #ifdef XPG4
757 if (utmpp->ut_type == LOGIN_PROCESS) {
758 if ((utmpp->ut_line[0] == '\0') ||
759 (strcmp(utmpp->ut_user, "LOGIN") != 0))
760 continue;
761 }
762 #endif /* XPG4 */
763 dump();
764 }
765 } else {
766 (void) fprintf(stderr,
767 gettext("%s: Error --- entry has ut_type "
768 "of %d\n"), program, utmpp->ut_type);
769 (void) fprintf(stderr,
770 gettext(" when maximum is %d\n"), UTMAXTYPE);
771 }
772 }
773
774 /*
775 * If justme is set at this point than the utmp entry
776 * was not found.
777 */
778 if (justme) {
779 static struct utmpx utmpt;
780
781 pwp = getpwuid(geteuid());
782 if (pwp != NULL)
783 while (i < (int)sizeof (utmpt.ut_user) &&
784 *pwp->pw_name != 0)
785 utmpt.ut_user[i++] = *pwp->pw_name++;
786
787 ttname = ttyname(1);
788
789 i = 0;
790 if (ttname != NULL)
791 while (i < (int)sizeof (utmpt.ut_line) &&
792 *ttname != 0)
793 utmpt.ut_line[i++] = *ttname++;
794
795 utmpt.ut_id[0] = 0;
796 utmpt.ut_pid = getpid();
797 utmpt.ut_type = USER_PROCESS;
798 (void) time(&utmpt.ut_xtime);
799 utmpp = &utmpt;
800 dump();
801 exit(0);
802 }
803 }
804
805 /*
806 * This routine checks the following:
807 *
808 * 1. File exists
809 *
810 * 2. We have read permissions
811 *
812 * 3. It is a multiple of utmp entries in size
813 *
814 * Failing any of these conditions causes who(1) to
815 * abort processing.
816 *
817 * 4. If file is empty we exit right away as there
818 * is no info to report on.
819 *
820 * This routine does not check utmpx files.
821 */
822 static void
823 ck_file(char *name)
824 {
825 struct stat sbuf;
826 int rc;
827
828 /*
829 * Does file exist? Do stat to check, and save structure
830 * so that we can check on the file's size later on.
831 */
832 if ((rc = stat(name, &sbuf)) == -1) {
833 (void) snprintf(errmsg, sizeof (errmsg),
834 gettext("%s: Cannot stat file '%s'"), program, name);
835 perror(errmsg);
836 exit(1);
837 }
838
839 /*
840 * The only real way we can be sure we can access the
841 * file is to try. If we succeed then we close it.
842 */
843 if (access(name, R_OK) < 0) {
844 (void) snprintf(errmsg, sizeof (errmsg),
845 gettext("%s: Cannot open file '%s'"), program, name);
846 perror(errmsg);
847 exit(1);
848 }
849
850 /*
851 * If the file is empty, we are all done.
852 */
853 if (!sbuf.st_size)
854 exit(0);
855
856 /*
857 * Make sure the file is a utmp file.
858 * We can only check for size being a multiple of
859 * utmp structures in length.
860 */
861 rc = sbuf.st_size % (int)sizeof (struct utmpx);
862 if (rc) {
863 (void) fprintf(stderr, gettext("%s: File '%s' is not "
864 "a utmpx file\n"), program, name);
865 exit(1);
866 }
867 }