usr/src/cmd/who/who.c

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