60 #include <utmpx.h>
61 #include <sys/utsname.h>
62 #include <sys/stat.h>
63 #include <sys/mkdev.h>
64 #include <dirent.h>
65 #include <procfs.h> /* /proc header file */
66 #include <sys/wait.h>
67 #include <locale.h>
68 #include <unistd.h>
69 #include <limits.h>
70 #include <priv_utils.h>
71
72 /*
73 * Use the full lengths from utmpx for user and line.
74 */
75 #define NMAX (sizeof (((struct utmpx *)0)->ut_user))
76 #define LMAX (sizeof (((struct utmpx *)0)->ut_line))
77
78 /* Print minimum field widths. */
79 #define LOGIN_WIDTH 8
80 #define LINE_WIDTH 12
81
82 #define DIV60(t) ((t+30)/60) /* x/60 rounded */
83
84 #ifdef ERR
85 #undef ERR
86 #endif
87 #define ERR (-1)
88
89 #define DEVNAMELEN 14
90 #define HSIZE 256 /* size of process hash table */
91 #define PROCDIR "/proc"
92 #define INITPROCESS (pid_t)1 /* init process pid */
93 #define NONE 'n' /* no state */
94 #define RUNNING 'r' /* runnable process */
95 #define ZOMBIE 'z' /* zombie process */
96 #define VISITED 'v' /* marked node as visited */
97
98 static int ndevs; /* number of configured devices */
99 static int maxdev; /* slots for configured devices */
100 #define DNINCR 100
116 *p_sibling, /* sibling pointer */
117 *p_pgrplink, /* pgrp link */
118 *p_link; /* hash table chain pointer */
119 };
120
121 /*
122 * define hash table for struct uproc
123 * Hash function uses process id
124 * and the size of the hash table(HSIZE)
125 * to determine process index into the table.
126 */
127 static struct uproc pr_htbl[HSIZE];
128
129 static struct uproc *findhash(pid_t);
130 static time_t findidle(char *);
131 static void clnarglist(char *);
132 static void showproc(struct uproc *);
133 static void showtotals(struct uproc *);
134 static void calctotals(struct uproc *);
135 static char *getty(dev_t);
136 static void prttime(time_t, char *);
137 static void prtat(time_t *);
138 static void checkampm(char *);
139
140 static char *prog;
141 static int header = 1; /* true if -h flag: don't print heading */
142 static int lflag = 0; /* true if -l flag: w command format */
143 static char *sel_user; /* login of particular user selected */
144 static time_t now; /* current time of day */
145 static time_t uptime; /* time of last reboot & elapsed time since */
146 static int nusers; /* number of users logged in now */
147 static time_t idle; /* number of minutes user is idle */
148 static time_t jobtime; /* total cpu time visible */
149 static char doing[520]; /* process attached to terminal */
150 static time_t proctime; /* cpu time of process in doing */
151 static int empty;
152 static pid_t curpid;
153
154 #if SIGQUIT > SIGINT
155 #define ACTSIZE SIGQUIT
156 #else
157 #define ACTSIZE SIGINT
158 #endif
266 } else if (ut->ut_type == BOOT_TIME) {
267 uptime = now - ut->ut_xtime;
268 uptime += 30;
269 days = uptime / (60*60*24);
270 uptime %= (60*60*24);
271 hrs = uptime / (60*60);
272 uptime %= (60*60);
273 mins = uptime / 60;
274
275 (void) printf(dcgettext(NULL,
276 " up %d day(s), %d hr(s), "
277 "%d min(s)", LC_TIME),
278 days, hrs, mins);
279 }
280 }
281
282 ut = utmpbegin; /* rewind utmp data */
283 (void) printf(dcgettext(NULL,
284 " %d user(s)\n", LC_TIME), nusers);
285 (void) printf(dcgettext(NULL, "User tty "
286 "login@ idle JCPU PCPU what\n", LC_TIME));
287 } else { /* standard whodo header */
288 char date_buf[100];
289
290 /*
291 * print current time and date
292 */
293 (void) strftime(date_buf, sizeof (date_buf),
294 dcgettext(NULL, "%C", LC_TIME), localtime(&now));
295 (void) printf("%s\n", date_buf);
296
297 /*
298 * print system name
299 */
300 (void) uname(&uts);
301 (void) printf("%s\n", uts.nodename);
302 }
303 }
304
305 /*
306 * loop through /proc, reading info about each process
307 * and build the parent/child tree
308 */
309 if (!(dirp = opendir(PROCDIR))) {
310 (void) fprintf(stderr, gettext("%s: could not open %s: %s\n"),
311 prog, PROCDIR, strerror(errno));
312 exit(1);
313 }
314
457 (void) closedir(dirp);
458 (void) time(&now); /* get current time */
459
460 /*
461 * loop through utmpx file, printing process info
462 * about each logged in user
463 */
464 for (ut = utmpbegin; ut < utmpend; ut++) {
465 time_t tim;
466
467 if (ut->ut_type != USER_PROCESS)
468 continue;
469 if (sel_user && strncmp(ut->ut_name, sel_user, NMAX) != 0)
470 continue; /* we're looking for somebody else */
471 if (lflag) { /* -l flag format (w command) */
472 /* print login name of the user */
473 (void) printf("%-*.*s ", LOGIN_WIDTH, (int)NMAX,
474 ut->ut_name);
475
476 /* print tty user is on */
477 (void) printf("%-*.*s", LINE_WIDTH, (int)LMAX,
478 ut->ut_line);
479
480 /* print when the user logged in */
481 tim = ut->ut_xtime;
482 (void) prtat(&tim);
483
484 /* print idle time */
485 idle = findidle(ut->ut_line);
486 if (idle >= 36 * 60)
487 (void) printf(dcgettext(NULL, "%2ddays ",
488 LC_TIME), (idle + 12 * 60) / (24 * 60));
489 else
490 prttime(idle, " ");
491 showtotals(findhash((pid_t)ut->ut_pid));
492 } else { /* standard whodo format */
493 tim = ut->ut_xtime;
494 tm = localtime(&tim);
495 (void) printf("\n%-*.*s %-*.*s %2.1d:%2.2d\n",
496 LINE_WIDTH, (int)LMAX, ut->ut_line,
497 LOGIN_WIDTH, (int)NMAX, ut->ut_name, tm->tm_hour,
498 tm->tm_min);
499 showproc(findhash((pid_t)ut->ut_pid));
500 }
501 }
502
503 return (0);
504 }
505
506 /*
507 * Used for standard whodo format.
508 * This is the recursive routine descending the process
509 * tree starting from the given process pointer(up).
510 * It used depth-first search strategy and also marked
545
546
547 /*
548 * Used for -l flag (w command) format.
549 * Prints the CPU time for all processes & children,
550 * and the cpu time for interesting process,
551 * and what the user is doing.
552 */
553 static void
554 showtotals(struct uproc *up)
555 {
556 jobtime = 0;
557 proctime = 0;
558 empty = 1;
559 curpid = -1;
560 (void) strcpy(doing, "-"); /* default act: normally never prints */
561 calctotals(up);
562
563 /* print CPU time for all processes & children */
564 /* and need to convert clock ticks to seconds first */
565 prttime((time_t)jobtime, " ");
566
567 /* print cpu time for interesting process */
568 /* and need to convert clock ticks to seconds first */
569 prttime((time_t)proctime, " ");
570
571 /* what user is doing, current process */
572 (void) printf(" %-.32s\n", doing);
573 }
574
575 /*
576 * Used for -l flag (w command) format.
577 * This recursive routine descends the process
578 * tree starting from the given process pointer(up).
579 * It used depth-first search strategy and also marked
580 * each node as visited as it traversed down the tree.
581 * It calculates the process time for all processes &
582 * children. It also finds the "interesting" process
583 * and determines its cpu time and command.
584 */
585 static void
586 calctotals(struct uproc *up)
587 {
588 struct uproc *zp;
589
590 if (up->p_state == VISITED)
591 return;
592 up->p_state = VISITED;
721 tp = malloc(sizeof (*tp)); /* add new node */
722 if (!tp) {
723 (void) fprintf(stderr, gettext("%s: out of memory!: %s\n"),
724 prog, strerror(errno));
725 exit(1);
726 }
727 (void) memset((char *)tp, 0, sizeof (*tp));
728 tp->p_upid = pid;
729 tp->p_state = NONE;
730 tp->p_child = tp->p_sibling = tp->p_pgrplink = (pid_t)0;
731 tp->p_link = up->p_link; /* insert after head */
732 up->p_link = tp;
733 return (tp);
734 }
735
736 #define HR (60 * 60)
737 #define DAY (24 * HR)
738 #define MON (30 * DAY)
739
740 /*
741 * prints a time in hours and minutes or minutes and seconds.
742 * The character string 'tail' is printed at the end, obvious
743 * strings to pass are "", " ", or "am".
744 */
745 static void
746 prttime(time_t tim, char *tail)
747 {
748 if (tim >= 60)
749 (void) printf(dcgettext(NULL, "%3d:%02d", LC_TIME),
750 (int)tim/60, (int)tim%60);
751 else if (tim > 0)
752 (void) printf(dcgettext(NULL, " %2d", LC_TIME), (int)tim);
753 else
754 (void) printf(" ");
755 (void) printf("%s", tail);
756 }
757
758
759 /*
760 * prints a 12 hour time given a pointer to a time of day
761 */
762 static void
763 prtat(time_t *time)
764 {
765 struct tm *p;
766
767 p = localtime(time);
768 if (now - *time <= 18 * HR) {
769 char timestr[50];
770 (void) strftime(timestr, sizeof (timestr),
771 dcgettext(NULL, " %l:%M""%p", LC_TIME), p);
772 checkampm(timestr);
773 (void) printf("%s", timestr);
774 } else if (now - *time <= 7 * DAY) {
775 char weekdaytime[20];
776
777 (void) strftime(weekdaytime, sizeof (weekdaytime),
778 dcgettext(NULL, "%a%l%p", LC_TIME), p);
779 checkampm(weekdaytime);
780 (void) printf(" %s", weekdaytime);
781 } else {
782 char monthtime[20];
783
784 (void) strftime(monthtime, sizeof (monthtime),
785 dcgettext(NULL, "%e%b%y", LC_TIME), p);
786 (void) printf(" %s", monthtime);
787 }
788 }
789
790 /*
791 * find & return number of minutes current tty has been idle
792 */
793 static time_t
794 findidle(char *devname)
795 {
796 struct stat stbuf;
797 time_t lastaction, diff;
798 char ttyname[64];
799
800 (void) strcpy(ttyname, "/dev/");
801 (void) strcat(ttyname, devname);
802 if (stat(ttyname, &stbuf) != -1) {
803 lastaction = stbuf.st_atime;
804 diff = now - lastaction;
805 diff = DIV60(diff);
806 if (diff < 0)
813 /*
814 * given a pointer to the argument string clean out unsavory characters.
815 */
816 static void
817 clnarglist(char *arglist)
818 {
819 char *c;
820 int err = 0;
821
822 /* get rid of unsavory characters */
823 for (c = arglist; *c == NULL; c++) {
824 if ((*c < ' ') || (*c > 0176)) {
825 if (err++ > 5) {
826 *arglist = NULL;
827 break;
828 }
829 *c = '?';
830 }
831 }
832 }
833
834 /* replaces all occurences of AM/PM with am/pm */
835 static void
836 checkampm(char *str)
837 {
838 char *ampm;
839 while ((ampm = strstr(str, "AM")) != NULL ||
840 (ampm = strstr(str, "PM")) != NULL) {
841 *ampm = tolower(*ampm);
842 *(ampm+1) = tolower(*(ampm+1));
843 }
844 }
|
60 #include <utmpx.h>
61 #include <sys/utsname.h>
62 #include <sys/stat.h>
63 #include <sys/mkdev.h>
64 #include <dirent.h>
65 #include <procfs.h> /* /proc header file */
66 #include <sys/wait.h>
67 #include <locale.h>
68 #include <unistd.h>
69 #include <limits.h>
70 #include <priv_utils.h>
71
72 /*
73 * Use the full lengths from utmpx for user and line.
74 */
75 #define NMAX (sizeof (((struct utmpx *)0)->ut_user))
76 #define LMAX (sizeof (((struct utmpx *)0)->ut_line))
77
78 /* Print minimum field widths. */
79 #define LOGIN_WIDTH 8
80 #define LINE_WIDTH 8
81
82 #define DIV60(t) ((t+30)/60) /* x/60 rounded */
83
84 #ifdef ERR
85 #undef ERR
86 #endif
87 #define ERR (-1)
88
89 #define DEVNAMELEN 14
90 #define HSIZE 256 /* size of process hash table */
91 #define PROCDIR "/proc"
92 #define INITPROCESS (pid_t)1 /* init process pid */
93 #define NONE 'n' /* no state */
94 #define RUNNING 'r' /* runnable process */
95 #define ZOMBIE 'z' /* zombie process */
96 #define VISITED 'v' /* marked node as visited */
97
98 static int ndevs; /* number of configured devices */
99 static int maxdev; /* slots for configured devices */
100 #define DNINCR 100
116 *p_sibling, /* sibling pointer */
117 *p_pgrplink, /* pgrp link */
118 *p_link; /* hash table chain pointer */
119 };
120
121 /*
122 * define hash table for struct uproc
123 * Hash function uses process id
124 * and the size of the hash table(HSIZE)
125 * to determine process index into the table.
126 */
127 static struct uproc pr_htbl[HSIZE];
128
129 static struct uproc *findhash(pid_t);
130 static time_t findidle(char *);
131 static void clnarglist(char *);
132 static void showproc(struct uproc *);
133 static void showtotals(struct uproc *);
134 static void calctotals(struct uproc *);
135 static char *getty(dev_t);
136 static void prttime(time_t, int);
137 static void prtat(time_t *);
138
139 static char *prog;
140 static int header = 1; /* true if -h flag: don't print heading */
141 static int lflag = 0; /* true if -l flag: w command format */
142 static char *sel_user; /* login of particular user selected */
143 static time_t now; /* current time of day */
144 static time_t uptime; /* time of last reboot & elapsed time since */
145 static int nusers; /* number of users logged in now */
146 static time_t idle; /* number of minutes user is idle */
147 static time_t jobtime; /* total cpu time visible */
148 static char doing[520]; /* process attached to terminal */
149 static time_t proctime; /* cpu time of process in doing */
150 static int empty;
151 static pid_t curpid;
152
153 #if SIGQUIT > SIGINT
154 #define ACTSIZE SIGQUIT
155 #else
156 #define ACTSIZE SIGINT
157 #endif
265 } else if (ut->ut_type == BOOT_TIME) {
266 uptime = now - ut->ut_xtime;
267 uptime += 30;
268 days = uptime / (60*60*24);
269 uptime %= (60*60*24);
270 hrs = uptime / (60*60);
271 uptime %= (60*60);
272 mins = uptime / 60;
273
274 (void) printf(dcgettext(NULL,
275 " up %d day(s), %d hr(s), "
276 "%d min(s)", LC_TIME),
277 days, hrs, mins);
278 }
279 }
280
281 ut = utmpbegin; /* rewind utmp data */
282 (void) printf(dcgettext(NULL,
283 " %d user(s)\n", LC_TIME), nusers);
284 (void) printf(dcgettext(NULL, "User tty "
285 "login@ idle JCPU PCPU what\n",
286 LC_TIME));
287 } else { /* standard whodo header */
288 char date_buf[100];
289
290 /*
291 * print current time and date
292 */
293 (void) strftime(date_buf, sizeof (date_buf),
294 "%c", localtime(&now));
295 (void) printf("%s\n", date_buf);
296
297 /*
298 * print system name
299 */
300 (void) uname(&uts);
301 (void) printf("%s\n", uts.nodename);
302 }
303 }
304
305 /*
306 * loop through /proc, reading info about each process
307 * and build the parent/child tree
308 */
309 if (!(dirp = opendir(PROCDIR))) {
310 (void) fprintf(stderr, gettext("%s: could not open %s: %s\n"),
311 prog, PROCDIR, strerror(errno));
312 exit(1);
313 }
314
457 (void) closedir(dirp);
458 (void) time(&now); /* get current time */
459
460 /*
461 * loop through utmpx file, printing process info
462 * about each logged in user
463 */
464 for (ut = utmpbegin; ut < utmpend; ut++) {
465 time_t tim;
466
467 if (ut->ut_type != USER_PROCESS)
468 continue;
469 if (sel_user && strncmp(ut->ut_name, sel_user, NMAX) != 0)
470 continue; /* we're looking for somebody else */
471 if (lflag) { /* -l flag format (w command) */
472 /* print login name of the user */
473 (void) printf("%-*.*s ", LOGIN_WIDTH, (int)NMAX,
474 ut->ut_name);
475
476 /* print tty user is on */
477 (void) printf("%-*.*s ", LINE_WIDTH, (int)LMAX,
478 ut->ut_line);
479
480 /* print when the user logged in */
481 tim = ut->ut_xtime;
482 (void) prtat(&tim);
483
484 /* print idle time */
485 idle = findidle(ut->ut_line);
486 prttime(idle, 8);
487 showtotals(findhash((pid_t)ut->ut_pid));
488 } else { /* standard whodo format */
489 tim = ut->ut_xtime;
490 tm = localtime(&tim);
491 (void) printf("\n%-*.*s %-*.*s %2.1d:%2.2d\n",
492 LINE_WIDTH, (int)LMAX, ut->ut_line,
493 LOGIN_WIDTH, (int)NMAX, ut->ut_name, tm->tm_hour,
494 tm->tm_min);
495 showproc(findhash((pid_t)ut->ut_pid));
496 }
497 }
498
499 return (0);
500 }
501
502 /*
503 * Used for standard whodo format.
504 * This is the recursive routine descending the process
505 * tree starting from the given process pointer(up).
506 * It used depth-first search strategy and also marked
541
542
543 /*
544 * Used for -l flag (w command) format.
545 * Prints the CPU time for all processes & children,
546 * and the cpu time for interesting process,
547 * and what the user is doing.
548 */
549 static void
550 showtotals(struct uproc *up)
551 {
552 jobtime = 0;
553 proctime = 0;
554 empty = 1;
555 curpid = -1;
556 (void) strcpy(doing, "-"); /* default act: normally never prints */
557 calctotals(up);
558
559 /* print CPU time for all processes & children */
560 /* and need to convert clock ticks to seconds first */
561 prttime((time_t)jobtime, 8);
562
563 /* print cpu time for interesting process */
564 /* and need to convert clock ticks to seconds first */
565 prttime((time_t)proctime, 8);
566
567 /* what user is doing, current process */
568 (void) printf("%-.32s\n", doing);
569 }
570
571 /*
572 * Used for -l flag (w command) format.
573 * This recursive routine descends the process
574 * tree starting from the given process pointer(up).
575 * It used depth-first search strategy and also marked
576 * each node as visited as it traversed down the tree.
577 * It calculates the process time for all processes &
578 * children. It also finds the "interesting" process
579 * and determines its cpu time and command.
580 */
581 static void
582 calctotals(struct uproc *up)
583 {
584 struct uproc *zp;
585
586 if (up->p_state == VISITED)
587 return;
588 up->p_state = VISITED;
717 tp = malloc(sizeof (*tp)); /* add new node */
718 if (!tp) {
719 (void) fprintf(stderr, gettext("%s: out of memory!: %s\n"),
720 prog, strerror(errno));
721 exit(1);
722 }
723 (void) memset((char *)tp, 0, sizeof (*tp));
724 tp->p_upid = pid;
725 tp->p_state = NONE;
726 tp->p_child = tp->p_sibling = tp->p_pgrplink = (pid_t)0;
727 tp->p_link = up->p_link; /* insert after head */
728 up->p_link = tp;
729 return (tp);
730 }
731
732 #define HR (60 * 60)
733 #define DAY (24 * HR)
734 #define MON (30 * DAY)
735
736 /*
737 * prttime prints a time in days, hours, minutes, or seconds.
738 * The second argument is the field width.
739 */
740 static void
741 prttime(time_t tim, int width)
742 {
743 char value[12];
744 char *unit;
745
746 if (tim >= 36 * HR) {
747 (void) snprintf(value, sizeof (value), "%d",
748 (tim + (DAY / 2)) / (DAY));
749 unit = dcgettext(NULL, "days", LC_TIME);
750 } else if (tim >= 36 * 60) {
751 (void) snprintf(value, sizeof (value), "%d",
752 (tim + (HR / 2)) / (HR));
753 unit = dcgettext(NULL, "hours", LC_TIME);
754 } else if (tim >= 60) {
755 (void) snprintf(value, sizeof (value), "%d",
756 (tim + 30) / 60);
757 unit = dcgettext(NULL, "mins", LC_TIME);
758 } else if (tim > 0) {
759 (void) snprintf(value, sizeof (value), "%d", (int)tim);
760 unit = dcgettext(NULL, "secs", LC_TIME);
761 } else {
762 (void) strcpy(value, "0");
763 unit = " ";
764 }
765 width -= 2 + strlen(value);
766 width = (width > 1) ? width : 1;
767 printf("%s %-*s ", value, width, unit);
768 }
769
770
771 /*
772 * prints a locale-specific time given a pointer to a time of day
773 */
774 static void
775 prtat(time_t *time)
776 {
777 struct tm *p;
778
779 p = localtime(time);
780 if (now - *time <= 18 * HR) {
781 char timestr[50];
782
783 (void) strftime(timestr, sizeof (timestr),
784 "%X", p);
785 printf("%-11s ", timestr);
786 } else if (now - *time <= 7 * DAY) {
787 char weekdaytime[20];
788
789 (void) strftime(weekdaytime, sizeof (weekdaytime),
790 "%d %b", p);
791 printf("%-11s ", weekdaytime);
792 } else {
793 char monthtime[20];
794
795 (void) strftime(monthtime, sizeof (monthtime),
796 "%b %Y", p);
797 printf("%-11s ", monthtime);
798 }
799 }
800
801 /*
802 * find & return number of minutes current tty has been idle
803 */
804 static time_t
805 findidle(char *devname)
806 {
807 struct stat stbuf;
808 time_t lastaction, diff;
809 char ttyname[64];
810
811 (void) strcpy(ttyname, "/dev/");
812 (void) strcat(ttyname, devname);
813 if (stat(ttyname, &stbuf) != -1) {
814 lastaction = stbuf.st_atime;
815 diff = now - lastaction;
816 diff = DIV60(diff);
817 if (diff < 0)
824 /*
825 * given a pointer to the argument string clean out unsavory characters.
826 */
827 static void
828 clnarglist(char *arglist)
829 {
830 char *c;
831 int err = 0;
832
833 /* get rid of unsavory characters */
834 for (c = arglist; *c == NULL; c++) {
835 if ((*c < ' ') || (*c > 0176)) {
836 if (err++ > 5) {
837 *arglist = NULL;
838 break;
839 }
840 *c = '?';
841 }
842 }
843 }
|