/*
* 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