usr/src/lib/libc/port/gen/getut.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
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1988 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 /*
  31  * Compatibility routines to read and write alternate
  32  * utmp-like files.  These routines are only used in
  33  * the case where utmpname() is used to change to a file
  34  * other than /var/adm/utmp or /var/adm/wtmp.  In this case,
  35  * we assume that someone really wants to read old utmp-format
  36  * files.  Otherwise, the getutent, setutent, getutid, setutline,
  37  * and pututline functions are actually wrappers around the
  38  * equivalent function operating on utmpx-like files.
  39  */
  40
  41 #include "lint.h"
  42 #include <stdio.h>
  43 #include <sys/param.h>
  44 #include <sys/types.h>
  45 #include <sys/stat.h>
  46 #include <utmpx.h>
  47 #include <errno.h>
  48 #include <fcntl.h>
  49 #include <string.h>
  50 #include <strings.h>
  51 #include <stdlib.h>
  52 #include <unistd.h>
  53 #include <ctype.h>
  54 #include <utime.h>
  55 #include <sys/wait.h>
  56
  57 #define IDLEN   4       /* length of id field in utmp */
  58 #define SC_WILDC        0xff    /* wild char for utmp ids */
  59 #define MAXVAL  255     /* max value for an id 'character' */
  60
  61 #ifdef ut_time
  62 #undef ut_time
  63 #endif
  64
  65 static void     utmp_frec2api(const struct futmp *, struct utmp *);
  66 static void     utmp_api2frec(const struct utmp *, struct futmp *);
  67 struct utmp     *_compat_getutent(void);
  68 struct utmp     *_compat_getutid(const struct utmp *);
  69 struct utmp     *_compat_getutline(const struct utmp *);
  70 struct utmp     *_compat_pututline(const struct utmp *);
  71 void            _compat_setutent(void);
  72 void            _compat_endutent(void);
  73 void            _compat_updwtmp(const char *, struct utmp *);
  74 struct utmp     *_compat_makeut(struct utmp *);
  75 struct utmp     *_compat_modut(struct utmp *);
  76
  77 static void     unlockut(void);
  78 static int      idcmp(const char *, const char *);
  79 static int      allocid(char *, unsigned char *);
  80 static int      lockut(void);
  81
  82
  83 static int fd = -1;     /* File descriptor for the utmp file. */
  84 /*
  85  * name of the current utmp-like file - set by utmpname (getutx.c)
  86  * only if running in backward compatibility mode
  87  * We don't modify this, but we can't declare it const or lint will freak.
  88  */
  89 extern char _compat_utmpfile[];
  90
  91 #ifdef ERRDEBUG
  92 static long loc_utmp;   /* Where in "utmp" the current "ubuf" was found. */
  93 #endif
  94
  95 static struct futmp fubuf;      /* Copy of last entry read in. */
  96 static struct utmp ubuf;        /* Last entry returned to client */
  97
  98 /*
  99  * In the 64-bit world, the utmp data structure grows because of
 100  * the ut_time field (a time_t) at the end of it.
 101  */
 102 static void
 103 utmp_frec2api(const struct futmp *src, struct utmp *dst)
 104 {
 105         if (src == NULL)
 106                 return;
 107
 108         (void) strncpy(dst->ut_user, src->ut_user, sizeof (dst->ut_user));
 109         (void) strncpy(dst->ut_line, src->ut_line, sizeof (dst->ut_line));
 110         (void) memcpy(dst->ut_id, src->ut_id, sizeof (dst->ut_id));
 111         dst->ut_pid = src->ut_pid;
 112         dst->ut_type = src->ut_type;
 113         dst->ut_exit.e_termination = src->ut_exit.e_termination;
 114         dst->ut_exit.e_exit = src->ut_exit.e_exit;
 115         dst->ut_time = (time_t)src->ut_time;
 116 }
 117
 118 static void
 119 utmp_api2frec(const struct utmp *src, struct futmp *dst)
 120 {
 121         if (src == NULL)
 122                 return;
 123
 124         (void) strncpy(dst->ut_user, src->ut_user, sizeof (dst->ut_user));
 125         (void) strncpy(dst->ut_line, src->ut_line, sizeof (dst->ut_line));
 126         (void) memcpy(dst->ut_id, src->ut_id, sizeof (dst->ut_id));
 127         dst->ut_pid = src->ut_pid;
 128         dst->ut_type = src->ut_type;
 129         dst->ut_exit.e_termination = src->ut_exit.e_termination;
 130         dst->ut_exit.e_exit = src->ut_exit.e_exit;
 131         dst->ut_time = (time32_t)src->ut_time;
 132 }
 133
 134 /*
 135  * "getutent_frec" gets the raw version of the next entry in the utmp file.
 136  */
 137 static struct futmp *
 138 getutent_frec(void)
 139 {
 140         /*
 141          * If the "utmp" file is not open, attempt to open it for
 142          * reading.  If there is no file, attempt to create one.  If
 143          * both attempts fail, return NULL.  If the file exists, but
 144          * isn't readable and writeable, do not attempt to create.
 145          */
 146         if (fd < 0) {
 147                 if ((fd = open(_compat_utmpfile, O_RDWR|O_CREAT, 0644)) < 0) {
 148
 149                         /*
 150                          * If the open failed for permissions, try opening
 151                          * it only for reading.  All "pututline()" later
 152                          * will fail the writes.
 153                          */
 154                         if ((fd = open(_compat_utmpfile, O_RDONLY)) < 0)
 155                                 return (NULL);
 156                 }
 157         }
 158
 159         /* Try to read in the next entry from the utmp file.  */
 160
 161         if (read(fd, &fubuf, sizeof (fubuf)) != sizeof (fubuf)) {
 162                 bzero(&fubuf, sizeof (fubuf));
 163                 return (NULL);
 164         }
 165
 166         /* Save the location in the file where this entry was found. */
 167
 168         (void) lseek(fd, 0L, 1);
 169         return (&fubuf);
 170 }
 171
 172 /*
 173  * "_compat_getutent" gets the next entry in the utmp file.
 174  */
 175 struct utmp *
 176 _compat_getutent(void)
 177 {
 178         struct futmp *futp;
 179
 180         futp = getutent_frec();
 181         utmp_frec2api(&fubuf, &ubuf);
 182         if (futp == NULL)
 183                 return (NULL);
 184         return (&ubuf);
 185 }
 186
 187 /*
 188  * "_compat_getutid" finds the specified entry in the utmp file.  If
 189  * it can't find it, it returns NULL.
 190  */
 191 struct utmp *
 192 _compat_getutid(const struct utmp *entry)
 193 {
 194         short type;
 195
 196         utmp_api2frec(&ubuf, &fubuf);
 197
 198         /*
 199          * Start looking for entry.  Look in our current buffer before
 200          * reading in new entries.
 201          */
 202         do {
 203                 /*
 204                  * If there is no entry in "ubuf", skip to the read.
 205                  */
 206                 if (fubuf.ut_type != EMPTY) {
 207                         switch (entry->ut_type) {
 208
 209                         /*
 210                          * Do not look for an entry if the user sent
 211                          * us an EMPTY entry.
 212                          */
 213                         case EMPTY:
 214                                 return (NULL);
 215
 216                         /*
 217                          * For RUN_LVL, BOOT_TIME, DOWN_TIME,
 218                          * OLD_TIME, and NEW_TIME entries, only the
 219                          * types have to match.  If they do, return
 220                          * the address of internal buffer.
 221                          */
 222                         case RUN_LVL:
 223                         case BOOT_TIME:
 224                         case DOWN_TIME:
 225                         case OLD_TIME:
 226                         case NEW_TIME:
 227                                 if (entry->ut_type == fubuf.ut_type) {
 228                                         utmp_frec2api(&fubuf, &ubuf);
 229                                         return (&ubuf);
 230                                 }
 231                                 break;
 232
 233                         /*
 234                          * For INIT_PROCESS, LOGIN_PROCESS, USER_PROCESS,
 235                          * and DEAD_PROCESS the type of the entry in "fubuf",
 236                          * must be one of the above and id's must match.
 237                          */
 238                         case INIT_PROCESS:
 239                         case LOGIN_PROCESS:
 240                         case USER_PROCESS:
 241                         case DEAD_PROCESS:
 242                                 if (((type = fubuf.ut_type) == INIT_PROCESS ||
 243                                     type == LOGIN_PROCESS ||
 244                                     type == USER_PROCESS ||
 245                                     type == DEAD_PROCESS) &&
 246                                     fubuf.ut_id[0] == entry->ut_id[0] &&
 247                                     fubuf.ut_id[1] == entry->ut_id[1] &&
 248                                     fubuf.ut_id[2] == entry->ut_id[2] &&
 249                                     fubuf.ut_id[3] == entry->ut_id[3]) {
 250                                         utmp_frec2api(&fubuf, &ubuf);
 251                                         return (&ubuf);
 252                                 }
 253                                 break;
 254
 255                         /* Do not search for illegal types of entry. */
 256                         default:
 257                                 return (NULL);
 258                         }
 259                 }
 260         } while (getutent_frec() != NULL);
 261
 262         /* the proper entry wasn't found. */
 263
 264         utmp_frec2api(&fubuf, &ubuf);
 265         return (NULL);
 266 }
 267
 268 /*
 269  * "_compat_getutline" searches the "utmp" file for a LOGIN_PROCESS or
 270  * USER_PROCESS with the same "line" as the specified "entry".
 271  */
 272 struct utmp *
 273 _compat_getutline(const struct utmp *entry)
 274 {
 275         utmp_api2frec(&ubuf, &fubuf);
 276
 277         do {
 278                 /*
 279                  * If the current entry is the one we are interested in,
 280                  * return a pointer to it.
 281                  */
 282                 if (fubuf.ut_type != EMPTY &&
 283                     (fubuf.ut_type == LOGIN_PROCESS ||
 284                     fubuf.ut_type == USER_PROCESS) &&
 285                     strncmp(&entry->ut_line[0], &fubuf.ut_line[0],
 286                     sizeof (fubuf.ut_line)) == 0) {
 287                         utmp_frec2api(&fubuf, &ubuf);
 288                         return (&ubuf);
 289                 }
 290         } while (getutent_frec() != NULL);
 291
 292         utmp_frec2api(&fubuf, &ubuf);
 293         return (NULL);
 294 }
 295
 296 /*
 297  * "_compat_pututline" writes the structure sent into the utmp file
 298  * If there is already an entry with the same id, then it is
 299  * overwritten, otherwise a new entry is made at the end of the
 300  * utmp file.
 301  */
 302 struct utmp *
 303 _compat_pututline(const struct utmp *entry)
 304 {
 305         int fc;
 306         struct utmp *answer;
 307         struct utmp tmpbuf;
 308         struct futmp ftmpbuf;
 309
 310         /*
 311          * Copy the user supplied entry into our temporary buffer to
 312          * avoid the possibility that the user is actually passing us
 313          * the address of "ubuf".
 314          */
 315         tmpbuf = *entry;
 316         utmp_api2frec(entry, &ftmpbuf);
 317
 318         (void) getutent_frec();
 319         if (fd < 0) {
 320 #ifdef  ERRDEBUG
 321                 gdebug("pututline: Unable to create utmp file.\n");
 322 #endif
 323                 return (NULL);
 324         }
 325
 326         /* Make sure file is writable */
 327
 328         if ((fc = fcntl(fd, F_GETFL, NULL)) == -1 || (fc & O_RDWR) != O_RDWR)
 329                 return (NULL);
 330
 331         /*
 332          * Find the proper entry in the utmp file.  Start at the current
 333          * location.  If it isn't found from here to the end of the
 334          * file, then reset to the beginning of the file and try again.
 335          * If it still isn't found, then write a new entry at the end of
 336          * the file.  (Making sure the location is an integral number of
 337          * utmp structures into the file incase the file is scribbled.)
 338          */
 339
 340         if (_compat_getutid(&tmpbuf) == NULL) {
 341 #ifdef  ERRDEBUG
 342                 gdebug("1st getutid() failed. fd: %d", fd);
 343 #endif
 344                 _compat_setutent();
 345                 if (_compat_getutid(&tmpbuf) == NULL) {
 346 #ifdef  ERRDEBUG
 347                         loc_utmp = lseek(fd, 0L, 1);
 348                         gdebug("2nd getutid() failed. fd: %d loc_utmp: %ld\n",
 349                             fd, loc_utmp);
 350 #endif
 351                         (void) fcntl(fd, F_SETFL, fc | O_APPEND);
 352                 } else
 353                         (void) lseek(fd, -(long)sizeof (struct futmp), 1);
 354         } else
 355                 (void) lseek(fd, -(long)sizeof (struct futmp), 1);
 356
 357         /*
 358          * Write out the user supplied structure.  If the write fails,
 359          * then the user probably doesn't have permission to write the
 360          * utmp file.
 361          */
 362         if (write(fd, &ftmpbuf, sizeof (ftmpbuf)) != sizeof (ftmpbuf)) {
 363 #ifdef  ERRDEBUG
 364                 gdebug("pututline failed: write-%d\n", errno);
 365 #endif
 366                 answer = NULL;
 367         } else {
 368                 /*
 369                  * Copy the new user structure into ubuf so that it will
 370                  * be up to date in the future.
 371                  */
 372                 fubuf = ftmpbuf;
 373                 utmp_frec2api(&fubuf, &ubuf);
 374                 answer = &ubuf;
 375
 376 #ifdef  ERRDEBUG
 377                 gdebug("id: %c%c loc: %ld\n", fubuf.ut_id[0],
 378                     fubuf.ut_id[1], fubuf.ut_id[2], fubuf.ut_id[3],
 379                     loc_utmp);
 380 #endif
 381         }
 382
 383         (void) fcntl(fd, F_SETFL, fc);
 384
 385         return (answer);
 386 }
 387
 388 /*
 389  * "_compat_setutent" just resets the utmp file back to the beginning.
 390  */
 391 void
 392 _compat_setutent(void)
 393 {
 394         if (fd != -1)
 395                 (void) lseek(fd, 0L, 0);
 396
 397         /*
 398          * Zero the stored copy of the last entry read, since we are
 399          * resetting to the beginning of the file.
 400          */
 401         bzero(&ubuf, sizeof (ubuf));
 402         bzero(&fubuf, sizeof (fubuf));
 403 }
 404
 405 /*
 406  * "_compat_endutent" closes the utmp file.
 407  */
 408 void
 409 _compat_endutent(void)
 410 {
 411         if (fd != -1)
 412                 (void) close(fd);
 413         fd = -1;
 414         bzero(&ubuf, sizeof (ubuf));
 415         bzero(&fubuf, sizeof (fubuf));
 416 }
 417
 418
 419 /*
 420  * If one of wtmp and wtmpx files exist, create the other, and the record.
 421  * If they both exist add the record.
 422  */
 423 void
 424 _compat_updwtmp(const char *file, struct utmp *ut)
 425 {
 426         struct futmp fut;
 427         int fd;
 428
 429
 430         fd = open(file, O_WRONLY | O_APPEND);
 431
 432         if (fd < 0) {
 433                 if ((fd = open(file, O_WRONLY|O_CREAT, 0644)) < 0)
 434                         return;
 435         }
 436
 437         (void) lseek(fd, 0, 2);
 438
 439         utmp_api2frec(ut, &fut);
 440         (void) write(fd, &fut, sizeof (fut));
 441
 442         (void) close(fd);
 443 }
 444
 445
 446
 447 /*
 448  * makeut - create a utmp entry, recycling an id if a wild card is
 449  *      specified.
 450  *
 451  *      args:   utmp - point to utmp structure to be created
 452  */
 453 struct utmp *
 454 _compat_makeut(struct utmp *utmp)
 455 {
 456         int i;
 457         struct utmp *utp;       /* "current" utmp entry being examined */
 458         int wild;               /* flag, true iff wild card char seen */
 459
 460         /* the last id we matched that was NOT a dead proc */
 461         unsigned char saveid[IDLEN];
 462
 463         wild = 0;
 464         for (i = 0; i < IDLEN; i++)
 465                 if ((unsigned char)utmp->ut_id[i] == SC_WILDC) {
 466                         wild = 1;
 467                         break;
 468                 }
 469
 470         if (wild) {
 471
 472                 /*
 473                  * try to lock the utmp file, only needed if we're
 474                  * doing wildcard matching
 475                  */
 476
 477                 if (lockut())
 478                         return (0);
 479                 _compat_setutent();
 480
 481                 /* find the first alphanumeric character */
 482                 for (i = 0; i < MAXVAL; ++i)
 483                         if (isalnum(i))
 484                                 break;
 485
 486                 (void) memset(saveid, i, IDLEN);
 487
 488                 while ((utp = _compat_getutent()) != 0) {
 489                         if (idcmp(utmp->ut_id, utp->ut_id))
 490                                 continue;
 491                         if (utp->ut_type == DEAD_PROCESS)
 492                                 break;
 493                         (void) memcpy(saveid, utp->ut_id, IDLEN);
 494                 }
 495
 496                 if (utp) {
 497                         /*
 498                          * found an unused entry, reuse it
 499                          */
 500                         (void) memcpy(utmp->ut_id, utp->ut_id, IDLEN);
 501                         utp = _compat_pututline(utmp);
 502                         if (utp)
 503                                 _compat_updwtmp(WTMP_FILE, utp);
 504                         _compat_endutent();
 505                         unlockut();
 506                         return (utp);
 507
 508                 } else {
 509                         /*
 510                          * nothing available, try to allocate an id
 511                          */
 512                         if (allocid(utmp->ut_id, saveid)) {
 513                                 _compat_endutent();
 514                                 unlockut();
 515                                 return (NULL);
 516                         } else {
 517                                 utp = _compat_pututline(utmp);
 518                                 if (utp)
 519                                         _compat_updwtmp(WTMP_FILE, utp);
 520                                 _compat_endutent();
 521                                 unlockut();
 522                                 return (utp);
 523                         }
 524                 }
 525         } else {
 526                 utp = _compat_pututline(utmp);
 527                 if (utp)
 528                         _compat_updwtmp(WTMP_FILE, utp);
 529                 _compat_endutent();
 530                 return (utp);
 531         }
 532 }
 533
 534
 535 /*
 536  * _compat_modut - modify a utmp entry.
 537  *
 538  *      args:   utmp - point to utmp structure to be created
 539  */
 540 struct utmp *
 541 _compat_modut(struct utmp *utp)
 542 {
 543         int i;                                  /* scratch variable */
 544         struct utmp utmp;                       /* holding area */
 545         struct utmp *ucp = &utmp;               /* and a pointer to it */
 546         struct utmp *up;        /* "current" utmp entry being examined */
 547         struct futmp *fup;
 548
 549         for (i = 0; i < IDLEN; ++i)
 550                 if ((unsigned char)utp->ut_id[i] == SC_WILDC)
 551                         return (0);
 552
 553         /* copy the supplied utmp structure someplace safe */
 554         utmp = *utp;
 555         _compat_setutent();
 556         while (fup = getutent_frec()) {
 557                 if (idcmp(ucp->ut_id, fup->ut_id))
 558                         continue;
 559                 break;
 560         }
 561         up = _compat_pututline(ucp);
 562         if (up)
 563                 _compat_updwtmp(WTMP_FILE, up);
 564         _compat_endutent();
 565         return (up);
 566 }
 567
 568
 569
 570 /*
 571  * idcmp - compare two id strings, return 0 if same, non-zero if not *
 572  *      args:   s1 - first id string
 573  *              s2 - second id string
 574  */
 575 static int
 576 idcmp(const char *s1, const char *s2)
 577 {
 578         int i;
 579
 580         for (i = 0; i < IDLEN; ++i)
 581                 if ((unsigned char)*s1 != SC_WILDC && (*s1++ != *s2++))
 582                         return (-1);
 583         return (0);
 584 }
 585
 586
 587 /*
 588  * allocid - allocate an unused id for utmp, either by recycling a
 589  *      DEAD_PROCESS entry or creating a new one.  This routine only
 590  *      gets called if a wild card character was specified.
 591  *
 592  *      args:   srcid - pattern for new id
 593  *              saveid - last id matching pattern for a non-dead process
 594  */
 595 static int
 596 allocid(char *srcid, unsigned char *saveid)
 597 {
 598         int i;          /* scratch variable */
 599         int changed;    /* flag to indicate that a new id has been generated */
 600         char copyid[IDLEN];     /* work area */
 601
 602         (void) memcpy(copyid, srcid, IDLEN);
 603         changed = 0;
 604         for (i = 0; i < IDLEN; ++i) {
 605                 /*
 606                  * if this character isn't wild, it'll
 607                  * be part of the generated id
 608                  */
 609                 if ((unsigned char) copyid[i] != SC_WILDC)
 610                         continue;
 611                 /*
 612                  * it's a wild character, retrieve the
 613                  * character from the saved id
 614                  */
 615                 copyid[i] = saveid[i];
 616                 /*
 617                  * if we haven't changed anything yet,
 618                  * try to find a new char to use
 619                  */
 620                 if (!changed && (saveid[i] < MAXVAL)) {
 621
 622 /*
 623  * Note: this algorithm is taking the "last matched" id and trying to make
 624  * a 1 character change to it to create a new one.  Rather than special-case
 625  * the first time (when no perturbation is really necessary), just don't
 626  * allocate the first valid id.
 627  */
 628
 629                         while (++saveid[i] < MAXVAL) {
 630                                 /* make sure new char is alphanumeric */
 631                                 if (isalnum(saveid[i])) {
 632                                         copyid[i] = saveid[i];
 633                                         changed = 1;
 634                                         break;
 635                                 }
 636                         }
 637
 638                         if (!changed) {
 639                                 /*
 640                                  * Then 'reset' the current count at
 641                                  * this position to it's lowest valid
 642                                  * value, and propagate the carry to
 643                                  * the next wild-card slot
 644                                  *
 645                                  * See 1113208.
 646                                  */
 647                                 saveid[i] = 0;
 648                                 while (!isalnum(saveid[i]))
 649                                         saveid[i]++;
 650                                 copyid[i] = ++saveid[i];
 651                         }
 652                 }
 653         }
 654         /* changed is true if we were successful in allocating an id */
 655         if (changed) {
 656                 (void) memcpy(srcid, copyid, IDLEN);
 657                 return (0);
 658         } else
 659                 return (-1);
 660 }
 661
 662
 663 /*
 664  * lockut - lock utmp file
 665  */
 666 static int
 667 lockut(void)
 668 {
 669         if ((fd = open(_compat_utmpfile, O_RDWR|O_CREAT, 0644)) < 0)
 670                 return (-1);
 671
 672         if (lockf(fd, F_LOCK, 0) < 0) {
 673                 (void) close(fd);
 674                 fd = -1;
 675                 return (-1);
 676         }
 677         return (0);
 678 }
 679
 680
 681 /*
 682  * unlockut - unlock utmp file
 683  */
 684 static void
 685 unlockut(void)
 686 {
 687         (void) lockf(fd, F_ULOCK, 0);
 688         (void) close(fd);
 689         fd = -1;
 690 }
 691
 692
 693
 694 #ifdef  ERRDEBUG
 695
 696 #include <stdarg.h>
 697 #include <stdio.h>
 698
 699 static void
 700 gdebug(const char *fmt, ...)
 701 {
 702         FILE *fp;
 703         int errnum;
 704         va_list ap;
 705
 706         if ((fp = fopen("/etc/dbg.getut", "a+F")) == NULL)
 707                 return;
 708         va_start(ap, fmt);
 709         (void) vfprintf(fp, fmt, ap);
 710         va_end(ap);
 711         (void) fclose(fp);
 712 }
 713 #endif