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 /* 22 * Copyright (c) 2013 Gary Mills 23 * 24 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 29 /* All Rights Reserved */ 30 31 /* 32 * University Copyright- Copyright (c) 1982, 1986, 1988 33 * The Regents of the University of California 34 * All Rights Reserved 35 * 36 * University Acknowledgment- Portions of this document are derived from 37 * software developed by the University of California, Berkeley, and its 38 * contributors. 39 */ 40 41 /* 42 * This is the new whodo command which takes advantage of 43 * the /proc interface to gain access to the information 44 * of all the processes currently on the system. 45 * 46 * Maintenance note: 47 * 48 * Much of this code is replicated in w.c. If you're 49 * fixing bugs here, then you should probably fix 'em there too. 50 */ 51 52 #include <stdio.h> 53 #include <string.h> 54 #include <stdlib.h> 55 #include <ctype.h> 56 #include <fcntl.h> 57 #include <time.h> 58 #include <errno.h> 59 #include <sys/types.h> 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 101 static struct devl { /* device list */ 102 char dname[DEVNAMELEN]; /* device name */ 103 dev_t ddev; /* device number */ 104 } *devl; 105 106 struct uproc { 107 pid_t p_upid; /* user process id */ 108 char p_state; /* numeric value of process state */ 109 dev_t p_ttyd; /* controlling tty of process */ 110 time_t p_time; /* ticks of user & system time */ 111 time_t p_ctime; /* ticks of child user & system time */ 112 int p_igintr; /* 1=ignores SIGQUIT and SIGINT */ 113 char p_comm[PRARGSZ+1]; /* command */ 114 char p_args[PRARGSZ+1]; /* command line arguments */ 115 struct uproc *p_child, /* first child pointer */ 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 159 160 int 161 main(int argc, char *argv[]) 162 { 163 struct utmpx *ut; 164 struct utmpx *utmpbegin; 165 struct utmpx *utmpend; 166 struct utmpx *utp; 167 struct tm *tm; 168 struct uproc *up, *parent, *pgrp; 169 struct psinfo info; 170 struct sigaction actinfo[ACTSIZE]; 171 struct pstatus statinfo; 172 size_t size; 173 struct stat sbuf; 174 struct utsname uts; 175 DIR *dirp; 176 struct dirent *dp; 177 char pname[64]; 178 char *fname; 179 int procfd; 180 int i; 181 int days, hrs, mins; 182 int entries; 183 184 /* 185 * This program needs the proc_owner privilege 186 */ 187 (void) __init_suid_priv(PU_CLEARLIMITSET, PRIV_PROC_OWNER, 188 (char *)NULL); 189 190 (void) setlocale(LC_ALL, ""); 191 #if !defined(TEXT_DOMAIN) 192 #define TEXT_DOMAIN "SYS_TEST" 193 #endif 194 (void) textdomain(TEXT_DOMAIN); 195 196 prog = argv[0]; 197 198 while (argc > 1) { 199 if (argv[1][0] == '-') { 200 for (i = 1; argv[1][i]; i++) { 201 switch (argv[1][i]) { 202 203 case 'h': 204 header = 0; 205 break; 206 207 case 'l': 208 lflag++; 209 break; 210 211 default: 212 (void) printf(gettext( 213 "usage: %s [ -hl ] [ user ]\n"), 214 prog); 215 exit(1); 216 } 217 } 218 } else { 219 if (!isalnum(argv[1][0]) || argc > 2) { 220 (void) printf(gettext( 221 "usage: %s [ -hl ] [ user ]\n"), prog); 222 exit(1); 223 } else 224 sel_user = argv[1]; 225 } 226 argc--; argv++; 227 } 228 229 /* 230 * read the UTMPX_FILE (contains information about 231 * each logged in user) 232 */ 233 if (stat(UTMPX_FILE, &sbuf) == ERR) { 234 (void) fprintf(stderr, gettext("%s: stat error of %s: %s\n"), 235 prog, UTMPX_FILE, strerror(errno)); 236 exit(1); 237 } 238 entries = sbuf.st_size / sizeof (struct futmpx); 239 size = sizeof (struct utmpx) * entries; 240 241 if ((ut = malloc(size)) == NULL) { 242 (void) fprintf(stderr, gettext("%s: malloc error of %s: %s\n"), 243 prog, UTMPX_FILE, strerror(errno)); 244 exit(1); 245 } 246 247 (void) utmpxname(UTMPX_FILE); 248 249 utmpbegin = ut; 250 /* LINTED pointer cast may result in improper alignment */ 251 utmpend = (struct utmpx *)((char *)utmpbegin + size); 252 253 setutxent(); 254 while ((ut < utmpend) && ((utp = getutxent()) != NULL)) 255 (void) memcpy(ut++, utp, sizeof (*ut)); 256 endutxent(); 257 258 (void) time(&now); /* get current time */ 259 260 if (header) { /* print a header */ 261 if (lflag) { /* w command format header */ 262 prtat(&now); 263 for (ut = utmpbegin; ut < utmpend; ut++) { 264 if (ut->ut_type == USER_PROCESS) { 265 nusers++; 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 315 while ((dp = readdir(dirp)) != NULL) { 316 if (dp->d_name[0] == '.') 317 continue; 318 retry: 319 (void) snprintf(pname, sizeof (pname), 320 "%s/%s/", PROCDIR, dp->d_name); 321 fname = pname + strlen(pname); 322 (void) strcpy(fname, "psinfo"); 323 if ((procfd = open(pname, O_RDONLY)) < 0) 324 continue; 325 if (read(procfd, &info, sizeof (info)) != sizeof (info)) { 326 int err = errno; 327 (void) close(procfd); 328 if (err == EAGAIN) 329 goto retry; 330 if (err != ENOENT) 331 (void) fprintf(stderr, gettext( 332 "%s: read() failed on %s: %s\n"), 333 prog, pname, strerror(err)); 334 continue; 335 } 336 (void) close(procfd); 337 338 up = findhash(info.pr_pid); 339 up->p_ttyd = info.pr_ttydev; 340 up->p_state = (info.pr_nlwp == 0? ZOMBIE : RUNNING); 341 up->p_time = 0; 342 up->p_ctime = 0; 343 up->p_igintr = 0; 344 (void) strncpy(up->p_comm, info.pr_fname, 345 sizeof (info.pr_fname)); 346 up->p_args[0] = 0; 347 348 if (up->p_state != NONE && up->p_state != ZOMBIE) { 349 (void) strcpy(fname, "status"); 350 351 /* now we need the proc_owner privilege */ 352 (void) __priv_bracket(PRIV_ON); 353 354 procfd = open(pname, O_RDONLY); 355 356 /* drop proc_owner privilege after open */ 357 (void) __priv_bracket(PRIV_OFF); 358 359 if (procfd < 0) 360 continue; 361 362 if (read(procfd, &statinfo, sizeof (statinfo)) 363 != sizeof (statinfo)) { 364 int err = errno; 365 (void) close(procfd); 366 if (err == EAGAIN) 367 goto retry; 368 if (err != ENOENT) 369 (void) fprintf(stderr, gettext( 370 "%s: read() failed on %s: %s \n"), 371 prog, pname, strerror(err)); 372 continue; 373 } 374 (void) close(procfd); 375 376 up->p_time = statinfo.pr_utime.tv_sec + 377 statinfo.pr_stime.tv_sec; 378 up->p_ctime = statinfo.pr_cutime.tv_sec + 379 statinfo.pr_cstime.tv_sec; 380 381 (void) strcpy(fname, "sigact"); 382 383 /* now we need the proc_owner privilege */ 384 (void) __priv_bracket(PRIV_ON); 385 386 procfd = open(pname, O_RDONLY); 387 388 /* drop proc_owner privilege after open */ 389 (void) __priv_bracket(PRIV_OFF); 390 391 if (procfd < 0) 392 continue; 393 if (read(procfd, actinfo, sizeof (actinfo)) 394 != sizeof (actinfo)) { 395 int err = errno; 396 (void) close(procfd); 397 if (err == EAGAIN) 398 goto retry; 399 if (err != ENOENT) 400 (void) fprintf(stderr, gettext( 401 "%s: read() failed on %s: %s \n"), 402 prog, pname, strerror(err)); 403 continue; 404 } 405 (void) close(procfd); 406 407 up->p_igintr = 408 actinfo[SIGINT-1].sa_handler == SIG_IGN && 409 actinfo[SIGQUIT-1].sa_handler == SIG_IGN; 410 411 up->p_args[0] = 0; 412 413 /* 414 * Process args if there's a chance we'll print it. 415 */ 416 if (lflag) { /* w command needs args */ 417 clnarglist(info.pr_psargs); 418 (void) strcpy(up->p_args, info.pr_psargs); 419 if (up->p_args[0] == 0 || 420 up->p_args[0] == '-' && 421 up->p_args[1] <= ' ' || 422 up->p_args[0] == '?') { 423 (void) strcat(up->p_args, " ("); 424 (void) strcat(up->p_args, up->p_comm); 425 (void) strcat(up->p_args, ")"); 426 } 427 } 428 429 } 430 431 /* 432 * link pgrp together in case parents go away 433 * Pgrp chain is a single linked list originating 434 * from the pgrp leader to its group member. 435 */ 436 if (info.pr_pgid != info.pr_pid) { /* not pgrp leader */ 437 pgrp = findhash(info.pr_pgid); 438 up->p_pgrplink = pgrp->p_pgrplink; 439 pgrp->p_pgrplink = up; 440 } 441 parent = findhash(info.pr_ppid); 442 443 /* if this is the new member, link it in */ 444 if (parent->p_upid != INITPROCESS) { 445 if (parent->p_child) { 446 up->p_sibling = parent->p_child; 447 up->p_child = 0; 448 } 449 parent->p_child = up; 450 } 451 452 } 453 454 /* revert to non-privileged user */ 455 (void) __priv_relinquish(); 456 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 511 * each node as printed as it traversed down the tree. 512 */ 513 static void 514 showproc(struct uproc *up) 515 { 516 struct uproc *zp; 517 518 if (up->p_state == VISITED) /* we already been here */ 519 return; 520 /* print the data for this process */ 521 if (up->p_state == ZOMBIE) 522 (void) printf(" %-*.*s %5d %4.1ld:%2.2ld %s\n", 523 LINE_WIDTH, (int)LMAX, " ?", (int)up->p_upid, 0L, 0L, 524 "<defunct>"); 525 else if (up->p_state != NONE) { 526 (void) printf(" %-*.*s %5d %4.1ld:%2.2ld %s\n", 527 LINE_WIDTH, (int)LMAX, getty(up->p_ttyd), (int)up->p_upid, 528 up->p_time / 60L, up->p_time % 60L, 529 up->p_comm); 530 } 531 up->p_state = VISITED; 532 533 /* descend for its children */ 534 if (up->p_child) { 535 showproc(up->p_child); 536 for (zp = up->p_child->p_sibling; zp; zp = zp->p_sibling) { 537 showproc(zp); 538 } 539 } 540 541 /* print the pgrp relation */ 542 if (up->p_pgrplink) 543 showproc(up->p_pgrplink); 544 } 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; 593 if (up->p_state == NONE || up->p_state == ZOMBIE) 594 return; 595 jobtime += up->p_time + up->p_ctime; 596 proctime += up->p_time; 597 598 if (empty && !up->p_igintr) { 599 empty = 0; 600 curpid = -1; 601 } 602 603 if (up->p_upid > curpid && (!up->p_igintr || empty)) { 604 curpid = up->p_upid; 605 (void) strcpy(doing, up->p_args); 606 } 607 608 /* descend for its children */ 609 if (up->p_child) { 610 calctotals(up->p_child); 611 for (zp = up->p_child->p_sibling; zp; zp = zp->p_sibling) 612 calctotals(zp); 613 } 614 } 615 616 static char * 617 devadd(char *name, dev_t ddev) 618 { 619 struct devl *dp; 620 int leng, start, i; 621 622 if (ndevs == maxdev) { 623 maxdev += DNINCR; 624 dp = realloc(devl, maxdev * sizeof (struct devl)); 625 if (!dp) { 626 (void) fprintf(stderr, 627 gettext("%s: out of memory!: %s\n"), 628 prog, strerror(errno)); 629 exit(1); 630 } 631 devl = dp; 632 } 633 dp = &devl[ndevs++]; 634 635 dp->ddev = ddev; 636 if (name == NULL) { 637 (void) strcpy(dp->dname, " ? "); 638 return (dp->dname); 639 } 640 641 leng = strlen(name); 642 if (leng < DEVNAMELEN + 4) { 643 /* strip off "/dev/" */ 644 (void) strcpy(dp->dname, &name[5]); 645 } else { 646 /* strip enough off the front to fit */ 647 start = leng - DEVNAMELEN - 1; 648 649 for (i = start; i < leng && name[i] != '/'; i++) 650 ; 651 if (i == leng) 652 (void) strncpy(dp->dname, &name[start], DEVNAMELEN); 653 else 654 (void) strncpy(dp->dname, &name[i+1], DEVNAMELEN); 655 } 656 return (dp->dname); 657 } 658 659 static char * 660 devlookup(dev_t ddev) 661 { 662 struct devl *dp; 663 int i; 664 665 for (dp = devl, i = 0; i < ndevs; dp++, i++) { 666 if (dp->ddev == ddev) 667 return (dp->dname); 668 } 669 return (NULL); 670 } 671 672 /* 673 * This routine gives back a corresponding device name 674 * from the device number given. 675 */ 676 static char * 677 getty(dev_t dev) 678 { 679 extern char *_ttyname_dev(dev_t, char *, size_t); 680 char devname[TTYNAME_MAX]; 681 char *retval; 682 683 if (dev == PRNODEV) 684 return (" ? "); 685 686 if ((retval = devlookup(dev)) != NULL) 687 return (retval); 688 689 retval = _ttyname_dev(dev, devname, sizeof (devname)); 690 return (devadd(retval, dev)); 691 } 692 693 /* 694 * Findhash finds the appropriate entry in the process 695 * hash table (pr_htbl) for the given pid in case that 696 * pid exists on the hash chain. It returns back a pointer 697 * to that uproc structure. If this is a new pid, it allocates 698 * a new node, initializes it, links it into the chain (after 699 * head) and returns a structure pointer. 700 */ 701 static struct uproc * 702 findhash(pid_t pid) 703 { 704 struct uproc *up, *tp; 705 706 tp = up = &pr_htbl[(int)pid % HSIZE]; 707 if (up->p_upid == 0) { /* empty slot */ 708 up->p_upid = pid; 709 up->p_state = NONE; 710 up->p_child = up->p_sibling = up->p_pgrplink = up->p_link = 0; 711 return (up); 712 } 713 if (up->p_upid == pid) { /* found in hash table */ 714 return (up); 715 } 716 for (tp = up->p_link; tp; tp = tp->p_link) { /* follow chain */ 717 if (tp->p_upid == pid) { 718 return (tp); 719 } 720 } 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) 807 diff = 0; 808 } else 809 diff = 0; 810 return (diff); 811 } 812 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 }