port/gen/getut.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1988, 2011, Oracle and/or its affiliates. All rights reserved.
 */

/*  Copyright (c) 1988 AT&T */
/*    All Rights Reserved   */

/*
 * Compatibility routines to read and write alternate
 * utmp-like files.  These routines are only used in
 * the case where utmpname() is used to change to a file
 * other than /var/adm/utmp or /var/adm/wtmp.  In this case,
 * we assume that someone really wants to read old utmp-format
 * files.  Otherwise, the getutent, setutent, getutid, setutline,
 * and pututline functions are actually wrappers around the
 * equivalent function operating on utmpx-like files.
 */

#include "lint.h"
#include <stdio.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <utmpx.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <utime.h>
#include <sys/wait.h>

#define MAXVAL  255 /* max value for an id 'character' */

#ifdef ut_time
#undef ut_time
#endif

static void utmp_frec2api(const struct futmp *, struct utmp *);
static void utmp_api2frec(const struct utmp *, struct futmp *);
struct utmp     *_compat_getutent(void);
struct utmp *_compat_getutid(const struct utmp *);
struct utmp *_compat_getutline(const struct utmp *);
struct utmp *_compat_pututline(const struct utmp *);
void        _compat_setutent(void);
void        _compat_endutent(void);
void        _compat_updwtmp(const char *, struct utmp *);
struct utmp *_compat_makeut(struct utmp *);
struct utmp *_compat_modut(struct utmp *);

static void unlockut(void);
static int  idcmp(const char *, const char *);
static int  allocid(char *, unsigned char *);
static int  lockut(void);


static int fd = -1; /* File descriptor for the utmp file. */
/*
 * name of the current utmp-like file - set by utmpname (getutx.c)
 * only if running in backward compatibility mode
 * We don't modify this, but we can't declare it const or lint will freak.
 */
extern char _compat_utmpfile[];

#ifdef ERRDEBUG
static long loc_utmp;   /* Where in "utmp" the current "ubuf" was found. */
#endif

static struct futmp fubuf;  /* Copy of last entry read in. */
static struct utmp ubuf;    /* Last entry returned to client */

/*
 * In the 64-bit world, the utmp data structure grows because of
 * the ut_time field (a time_t) at the end of it.
 */
static void
utmp_frec2api(const struct futmp *src, struct utmp *dst)
{
    if (src == NULL)
        return;

    (void) strncpy(dst->ut_user, src->ut_user, sizeof (dst->ut_user));
    (void) strncpy(dst->ut_line, src->ut_line, sizeof (dst->ut_line));
    (void) memcpy(dst->ut_id, src->ut_id, sizeof (dst->ut_id));
    dst->ut_pid = src->ut_pid;
    dst->ut_type = src->ut_type;
    dst->ut_exit.e_termination = src->ut_exit.e_termination;
    dst->ut_exit.e_exit = src->ut_exit.e_exit;
    dst->ut_time = (time_t)src->ut_time;
}

static void
utmp_api2frec(const struct utmp *src, struct futmp *dst)
{
    if (src == NULL)
        return;

    (void) strncpy(dst->ut_user, src->ut_user, sizeof (dst->ut_user));
    (void) strncpy(dst->ut_line, src->ut_line, sizeof (dst->ut_line));
    (void) memcpy(dst->ut_id, src->ut_id, sizeof (dst->ut_id));
    dst->ut_pid = src->ut_pid;
    dst->ut_type = src->ut_type;
    dst->ut_exit.e_termination = src->ut_exit.e_termination;
    dst->ut_exit.e_exit = src->ut_exit.e_exit;
    dst->ut_time = (time32_t)src->ut_time;
}

/*
 * "getutent_frec" gets the raw version of the next entry in the utmp file.
 */
static struct futmp *
getutent_frec(void)
{
    /*
     * If the "utmp" file is not open, attempt to open it for
     * reading.  If there is no file, attempt to create one.  If
     * both attempts fail, return NULL.  If the file exists, but
     * isn't readable and writeable, do not attempt to create.
     */
    if (fd < 0) {
        if ((fd = open(_compat_utmpfile, O_RDWR|O_CREAT, 0644)) < 0) {

            /*
             * If the open failed for permissions, try opening
             * it only for reading.  All "pututline()" later
             * will fail the writes.
             */
            if ((fd = open(_compat_utmpfile, O_RDONLY)) < 0)
                return (NULL);
        }
    }

    /* Try to read in the next entry from the utmp file.  */

    if (read(fd, &fubuf, sizeof (fubuf)) != sizeof (fubuf)) {
        bzero(&fubuf, sizeof (fubuf));
        return (NULL);
    }

    /* Save the location in the file where this entry was found. */

    (void) lseek(fd, 0L, 1);
    return (&fubuf);
}

/*
 * "_compat_getutent" gets the next entry in the utmp file.
 */
struct utmp *
_compat_getutent(void)
{
    struct futmp *futp;

    futp = getutent_frec();
    utmp_frec2api(&fubuf, &ubuf);
    if (futp == NULL)
        return (NULL);
    return (&ubuf);
}

/*
 * "_compat_getutid" finds the specified entry in the utmp file.  If
 * it can't find it, it returns NULL.
 */
struct utmp *
_compat_getutid(const struct utmp *entry)
{
    short type;

    utmp_api2frec(&ubuf, &fubuf);

    /*
     * Start looking for entry.  Look in our current buffer before
     * reading in new entries.
     */
    do {
        /*
         * If there is no entry in "ubuf", skip to the read.
         */
        if (fubuf.ut_type != EMPTY) {
            switch (entry->ut_type) {

            /*
             * Do not look for an entry if the user sent
             * us an EMPTY entry.
             */
            case EMPTY:
                return (NULL);

            /*
             * For RUN_LVL, BOOT_TIME, DOWN_TIME,
             * OLD_TIME, and NEW_TIME entries, only the
             * types have to match.  If they do, return
             * the address of internal buffer.
             */
            case RUN_LVL:
            case BOOT_TIME:
            case DOWN_TIME:
            case OLD_TIME:
            case NEW_TIME:
                if (entry->ut_type == fubuf.ut_type) {
                    utmp_frec2api(&fubuf, &ubuf);
                    return (&ubuf);
                }
                break;

            /*
             * For INIT_PROCESS, LOGIN_PROCESS, USER_PROCESS,
             * and DEAD_PROCESS the type of the entry in "fubuf",
             * must be one of the above and id's must match.
             */
            case INIT_PROCESS:
            case LOGIN_PROCESS:
            case USER_PROCESS:
            case DEAD_PROCESS:
                if (((type = fubuf.ut_type) == INIT_PROCESS ||
                    type == LOGIN_PROCESS ||
                    type == USER_PROCESS ||
                    type == DEAD_PROCESS) &&
                    fubuf.ut_id[0] == entry->ut_id[0] &&
                    fubuf.ut_id[1] == entry->ut_id[1] &&
                    fubuf.ut_id[2] == entry->ut_id[2] &&
                    fubuf.ut_id[3] == entry->ut_id[3]) {
                    utmp_frec2api(&fubuf, &ubuf);
                    return (&ubuf);
                }
                break;

            /* Do not search for illegal types of entry. */
            default:
                return (NULL);
            }
        }
    } while (getutent_frec() != NULL);

    /* the proper entry wasn't found. */

    utmp_frec2api(&fubuf, &ubuf);
    return (NULL);
}

/*
 * "_compat_getutline" searches the "utmp" file for a LOGIN_PROCESS or
 * USER_PROCESS with the same "line" as the specified "entry".
 */
struct utmp *
_compat_getutline(const struct utmp *entry)
{
    utmp_api2frec(&ubuf, &fubuf);

    do {
        /*
         * If the current entry is the one we are interested in,
         * return a pointer to it.
         */
        if (fubuf.ut_type != EMPTY &&
            (fubuf.ut_type == LOGIN_PROCESS ||
            fubuf.ut_type == USER_PROCESS) &&
            strncmp(&entry->ut_line[0], &fubuf.ut_line[0],
            sizeof (fubuf.ut_line)) == 0) {
            utmp_frec2api(&fubuf, &ubuf);
            return (&ubuf);
        }
    } while (getutent_frec() != NULL);

    utmp_frec2api(&fubuf, &ubuf);
    return (NULL);
}

/*
 * "_compat_pututline" writes the structure sent into the utmp file
 * If there is already an entry with the same id, then it is
 * overwritten, otherwise a new entry is made at the end of the
 * utmp file.
 */
struct utmp *
_compat_pututline(const struct utmp *entry)
{
    int fc;
    struct utmp *answer;
    struct utmp tmpbuf;
    struct futmp ftmpbuf;

    /*
     * Copy the user supplied entry into our temporary buffer to
     * avoid the possibility that the user is actually passing us
     * the address of "ubuf".
     */
    tmpbuf = *entry;
    utmp_api2frec(entry, &ftmpbuf);

    (void) getutent_frec();
    if (fd < 0) {
#ifdef  ERRDEBUG
        gdebug("pututline: Unable to create utmp file.\n");
#endif
        return (NULL);
    }

    /* Make sure file is writable */

    if ((fc = fcntl(fd, F_GETFL, NULL)) == -1 || (fc & O_RDWR) != O_RDWR)
        return (NULL);

    /*
     * Find the proper entry in the utmp file.  Start at the current
     * location.  If it isn't found from here to the end of the
     * file, then reset to the beginning of the file and try again.
     * If it still isn't found, then write a new entry at the end of
     * the file.  (Making sure the location is an integral number of
     * utmp structures into the file incase the file is scribbled.)
     */

    if (_compat_getutid(&tmpbuf) == NULL) {
#ifdef  ERRDEBUG
        gdebug("1st getutid() failed. fd: %d", fd);
#endif
        _compat_setutent();
        if (_compat_getutid(&tmpbuf) == NULL) {
#ifdef  ERRDEBUG
            loc_utmp = lseek(fd, 0L, 1);
            gdebug("2nd getutid() failed. fd: %d loc_utmp: %ld\n",
                fd, loc_utmp);
#endif
            (void) fcntl(fd, F_SETFL, fc | O_APPEND);
        } else
            (void) lseek(fd, -(long)sizeof (struct futmp), 1);
    } else
        (void) lseek(fd, -(long)sizeof (struct futmp), 1);

    /*
     * Write out the user supplied structure.  If the write fails,
     * then the user probably doesn't have permission to write the
     * utmp file.
     */
    if (write(fd, &ftmpbuf, sizeof (ftmpbuf)) != sizeof (ftmpbuf)) {
#ifdef  ERRDEBUG
        gdebug("pututline failed: write-%d\n", errno);
#endif
        answer = NULL;
    } else {
        /*
         * Copy the new user structure into ubuf so that it will
         * be up to date in the future.
         */
        fubuf = ftmpbuf;
        utmp_frec2api(&fubuf, &ubuf);
        answer = &ubuf;

#ifdef  ERRDEBUG
        gdebug("id: %c%c loc: %ld\n", fubuf.ut_id[0],
            fubuf.ut_id[1], fubuf.ut_id[2], fubuf.ut_id[3],
            loc_utmp);
#endif
    }

    (void) fcntl(fd, F_SETFL, fc);

    return (answer);
}

/*
 * "_compat_setutent" just resets the utmp file back to the beginning.
 */
void
_compat_setutent(void)
{
    if (fd != -1)
        (void) lseek(fd, 0L, 0);

    /*
     * Zero the stored copy of the last entry read, since we are
     * resetting to the beginning of the file.
     */
    bzero(&ubuf, sizeof (ubuf));
    bzero(&fubuf, sizeof (fubuf));
}

/*
 * "_compat_endutent" closes the utmp file.
 */
void
_compat_endutent(void)
{
    if (fd != -1)
        (void) close(fd);
    fd = -1;
    bzero(&ubuf, sizeof (ubuf));
    bzero(&fubuf, sizeof (fubuf));
}


/*
 * If one of wtmp and wtmpx files exist, create the other, and the record.
 * If they both exist add the record.
 */
void
_compat_updwtmp(const char *file, struct utmp *ut)
{
    struct futmp fut;
    int fd;


    fd = open(file, O_WRONLY | O_APPEND);

    if (fd < 0) {
        if ((fd = open(file, O_WRONLY|O_CREAT, 0644)) < 0)
            return;
    }

    (void) lseek(fd, 0, 2);

    utmp_api2frec(ut, &fut);
    (void) write(fd, &fut, sizeof (fut));

    (void) close(fd);
}


/*
 * makeut - create a utmp entry, recycling an id if a wild card is
 *  specified.
 *
 *  args:   utmp - point to utmp structure to be created
 */
struct utmp *
_compat_makeut(struct utmp *utmp)
{
    int i;
    struct utmp *utp;   /* "current" utmp entry being examined */
    int wild;       /* flag, true iff wild card char seen */

    /* the last id we matched that was NOT a dead proc */
    unsigned char saveid[_UTMP_ID_LEN];

    wild = 0;
    for (i = 0; i < _UTMP_ID_LEN; i++)
        if (utmp->ut_id[i] == _UTMP_ID_WILDCARD) {
            wild = 1;
            break;
        }

    if (wild) {

        /*
         * try to lock the utmp file, only needed if we're
         * doing wildcard matching
         */

        if (lockut())
            return (0);
        _compat_setutent();

        /* find the first alphanumeric character */
        for (i = 0; i < MAXVAL; ++i)
            if (isalnum(i))
                break;

        (void) memset(saveid, i, _UTMP_ID_LEN);

        while ((utp = _compat_getutent()) != 0) {
            if (idcmp(utmp->ut_id, utp->ut_id))
                continue;
            if (utp->ut_type == DEAD_PROCESS)
                break;
            (void) memcpy(saveid, utp->ut_id, _UTMP_ID_LEN);
        }

        if (utp) {
            /*
             * found an unused entry, reuse it
             */
            (void) memcpy(utmp->ut_id, utp->ut_id, _UTMP_ID_LEN);
            utp = _compat_pututline(utmp);
            if (utp)
                _compat_updwtmp(WTMP_FILE, utp);
            _compat_endutent();
            unlockut();
            return (utp);

        } else {
            /*
             * nothing available, try to allocate an id
             */
            if (allocid(utmp->ut_id, saveid)) {
                _compat_endutent();
                unlockut();
                return (NULL);
            } else {
                utp = _compat_pututline(utmp);
                if (utp)
                    _compat_updwtmp(WTMP_FILE, utp);
                _compat_endutent();
                unlockut();
                return (utp);
            }
        }
    } else {
        utp = _compat_pututline(utmp);
        if (utp)
            _compat_updwtmp(WTMP_FILE, utp);
        _compat_endutent();
        return (utp);
    }
}


/*
 * _compat_modut - modify a utmp entry.
 *
 *  args:   utmp - point to utmp structure to be created
 */
struct utmp *
_compat_modut(struct utmp *utp)
{
    int i;                  /* scratch variable */
    struct utmp utmp;           /* holding area */
    struct utmp *ucp = &utmp;       /* and a pointer to it */
    struct utmp *up;    /* "current" utmp entry being examined */
    struct futmp *fup;

    for (i = 0; i < _UTMP_ID_LEN; ++i)
        if (utp->ut_id[i] == _UTMP_ID_WILDCARD)
            return (0);

    /* copy the supplied utmp structure someplace safe */
    utmp = *utp;
    _compat_setutent();
    while (fup = getutent_frec()) {
        if (idcmp(ucp->ut_id, fup->ut_id))
            continue;
        break;
    }
    up = _compat_pututline(ucp);
    if (up)
        _compat_updwtmp(WTMP_FILE, up);
    _compat_endutent();
    return (up);
}


/*
 * idcmp - compare two id strings, return 0 if same, non-zero if not *
 *  args:   s1 - first id string
 *      s2 - second id string
 */
static int
idcmp(const char *s1, const char *s2)
{
    int i;

    for (i = 0; i < _UTMP_ID_LEN; ++i)
        if (*s1 != _UTMP_ID_WILDCARD && (*s1++ != *s2++))
            return (-1);
    return (0);
}


/*
 * allocid - allocate an unused id for utmp, either by recycling a
 *  DEAD_PROCESS entry or creating a new one.  This routine only
 *  gets called if a wild card character was specified.
 *
 *  args:   srcid - pattern for new id
 *      saveid - last id matching pattern for a non-dead process
 */
static int
allocid(char *srcid, unsigned char *saveid)
{
    int i;      /* scratch variable */
    int changed;    /* flag to indicate that a new id has been generated */
    char copyid[_UTMP_ID_LEN];  /* work area */

    (void) memcpy(copyid, srcid, _UTMP_ID_LEN);
    changed = 0;
    for (i = 0; i < _UTMP_ID_LEN; ++i) {
        /*
         * if this character isn't wild, it'll
         * be part of the generated id
         */
        if (copyid[i] != _UTMP_ID_WILDCARD)
            continue;
        /*
         * it's a wild character, retrieve the
         * character from the saved id
         */
        copyid[i] = saveid[i];
        /*
         * if we haven't changed anything yet,
         * try to find a new char to use
         */
        if (!changed && (saveid[i] < MAXVAL)) {

/*
 * Note: this algorithm is taking the "last matched" id and trying to make
 * a 1 character change to it to create a new one.  Rather than special-case
 * the first time (when no perturbation is really necessary), just don't
 * allocate the first valid id.
 */

            while (++saveid[i] < MAXVAL) {
                /* make sure new char is alphanumeric */
                if (isalnum(saveid[i])) {
                    copyid[i] = saveid[i];
                    changed = 1;
                    break;
                }
            }

            if (!changed) {
                /*
                 * Then 'reset' the current count at
                 * this position to it's lowest valid
                 * value, and propagate the carry to
                 * the next wild-card slot
                 *
                 * See 1113208.
                 */
                saveid[i] = 0;
                while (!isalnum(saveid[i]))
                    saveid[i]++;
                copyid[i] = ++saveid[i];
            }
        }
    }
    /* changed is true if we were successful in allocating an id */
    if (changed) {
        (void) memcpy(srcid, copyid, _UTMP_ID_LEN);
        return (0);
    } else
        return (-1);
}


/*
 * lockut - lock utmp file
 */
static int
lockut(void)
{
    if ((fd = open(_compat_utmpfile, O_RDWR|O_CREAT, 0644)) < 0)
        return (-1);

    if (lockf(fd, F_LOCK, 0) < 0) {
        (void) close(fd);
        fd = -1;
        return (-1);
    }
    return (0);
}


/*
 * unlockut - unlock utmp file
 */
static void
unlockut(void)
{
    (void) lockf(fd, F_ULOCK, 0);
    (void) close(fd);
    fd = -1;
}


#ifdef  ERRDEBUG

#include <stdarg.h>
#include <stdio.h>

static void
gdebug(const char *fmt, ...)
{
    FILE *fp;
    int errnum;
    va_list ap;

    if ((fp = fopen("/etc/dbg.getut", "a+F")) == NULL)
        return;
    va_start(ap, fmt);
    (void) vfprintf(fp, fmt, ap);
    va_end(ap);
    (void) fclose(fp);
}
#endif