/*

 * 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 2008 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*	Copyright (c) 1988 AT&T	*/

/*	  All Rights Reserved  	*/

/*

 * University Copyright- Copyright (c) 1982, 1986, 1988

 * The Regents of the University of California

 * All Rights Reserved

 *

 * University Acknowledgment- Portions of this document are derived from

 * software developed by the University of California, Berkeley, and its

 * contributors.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*

 * Routines to read and write the /etc/utmpx file. Also contains

 * binary compatibility routines to support the old utmp interfaces

 * on systems with MAXPID <= SHRT_MAX.

 */

#include <sys/types.h>

#include <stdio.h>

#include <sys/param.h>

#include <sys/stat.h>

#include <utmpx.h>

#include <errno.h>

#include <fcntl.h>

#include <string.h>

#include <strings.h>

#include <unistd.h>

#include <ctype.h>

#include <stdlib.h>

#include <sys/wait.h>

#include <pthread.h>

#include <limits.h>

#include <signal.h>

#include <spawn.h>

#define	IDLEN		4	/* length of id field in utmp */

#define	SC_WILDC	0xff	/* wild char for utmp ids */

#define	MAXFILE		79	/* Maximum pathname length for "utmpx" file */

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

#define	IPIPE		"/var/run/initpipe"	/* FIFO to send pids to init */

#define	UPIPE		"/var/run/utmppipe"	/* FIFO to send pids to utmpd */

#define	VAR_UTMPX_FILE	"/var/adm/utmpx" /* for sanity check only */

/*

 * format of message sent to init

 */

typedef struct	pidrec {

	int	pd_type;	/* command type */

	pid_t	pd_pid;		/* pid */

} pidrec_t;

/*

 * pd_type's

 */

#define	ADDPID 1	/* add a pid to "godchild" list */

#define	REMPID 2	/* remove a pid to "godchild" list */

static void	utmpx_frec2api(const struct futmpx *, struct utmpx *);

static void	utmpx_api2frec(const struct utmpx *, struct futmpx *);

static void	unlockutx(void);

static void	sendpid(int, pid_t);

static void	sendupid(int, pid_t);

static int	idcmp(const char *, const char *);

static int	allocid(char *, unsigned char *);

static int	lockutx(void);

static struct utmpx *invoke_utmp_update(const struct utmpx *);

static struct futmpx *getoneutx(off_t *);

static void	putoneutx(const struct utmpx *, off_t);

static int	big_pids_in_use(void);

/*

 * prototypes for utmp compatibility routines (in getut.c)

 */

extern struct utmp *_compat_getutent(void);

extern struct utmp *_compat_getutid(const struct utmp *);

extern struct utmp *_compat_getutline(const struct utmp *);

extern struct utmp *_compat_pututline(const struct utmp *);

extern void _compat_setutent(void);

extern void _compat_endutent(void);

extern void _compat_updwtmp(const char *, struct utmp *);

extern struct utmp *_compat_makeut(struct utmp *);

static int fd = -1;	/* File descriptor for the utmpx file. */

static int ut_got_maxpid = 0;	/* Flag set when sysconf(_SC_MAXPID) called */

static pid_t ut_maxpid = 0;	/* Value of MAXPID from sysconf */

static int tempfd = -1;  /* To store fd between lockutx() and unlockutx() */

static	FILE	*fp = NULL;	/* Buffered file descriptior for utmpx file */

static int changed_name = 0;	/* Flag set when not using utmpx file */

static char utmpxfile[MAXFILE+1] = UTMPX_FILE;	/* Name of the current */

char _compat_utmpfile[MAXFILE+1];

static int compat_utmpflag = 0;	/* old compat mode flag */

static struct futmpx fubuf;	/* Copy of last entry read in. */

static struct utmpx ubuf;	/* Last entry returned to client */

static struct utmp utmpcompat;	/* Buffer for returning utmp-format data */

/*

 * In the 64-bit world, the utmpx data structure grows because of

 * the ut_time field (a struct timeval) grows in the middle of it.

 */

static void

utmpx_frec2api(const struct futmpx *src, struct utmpx *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_tv.tv_sec = (time_t)src->ut_tv.tv_sec;

	dst->ut_tv.tv_usec = (suseconds_t)src->ut_tv.tv_usec;

	dst->ut_session = src->ut_session;

	bzero(dst->pad, sizeof (dst->pad));

	dst->ut_syslen = src->ut_syslen;

	(void) memcpy(dst->ut_host, src->ut_host, sizeof (dst->ut_host));

}

static void

utmpx_api2frec(const struct utmpx *src, struct futmpx *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_tv.tv_sec = (time32_t)src->ut_tv.tv_sec;

	dst->ut_tv.tv_usec = (int32_t)src->ut_tv.tv_usec;

	dst->ut_session = src->ut_session;

	bzero(dst->pad, sizeof (dst->pad));

	dst->ut_syslen = src->ut_syslen;

	(void) memcpy(dst->ut_host, src->ut_host, sizeof (dst->ut_host));

}

/*

 * "getutxent_frec" gets the raw version of the next entry in the utmpx file.

 */

static struct futmpx *

getutxent_frec(void)

{

	/*

	 * If the "utmpx" 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(utmpxfile, O_RDWR|O_CREAT, 0644)) < 0) {

			/*

			 * If the open failed for permissions, try opening

			 * it only for reading.  All "pututxline()" later

			 * will fail the writes.

			 */

			if ((fd = open(utmpxfile, O_RDONLY)) < 0)

				return (NULL);

			if ((fp = fopen(utmpxfile, "rF")) == NULL) {

				(void) close(fd);

				fd = -1;

				return (NULL);

			}

		} else {

			/*

			 * Get the stream pointer

			 */

			if ((fp = fopen(utmpxfile, "r+F")) == NULL) {

				(void) close(fd);

				fd = -1;

				return (NULL);

			}

		}

	}

	/*

	 * Try to read in the next entry from the utmpx file.

	 */

	if (fread(&fubuf, sizeof (fubuf), 1, fp) != 1) {

		/*

		 * Make sure fubuf is zeroed.

		 */

		bzero(&fubuf, sizeof (fubuf));

		return (NULL);

	}

	return (&fubuf);

}

/*

 * "big_pids_in_use" determines whether large pid numbers are in use

 * or not.  If MAXPID won't fit in a signed short, the utmp.ut_pid

 * field will overflow.

 *

 * Returns 0 if small pids are in use, 1 otherwise

 */

static int

big_pids_in_use(void)

{

	if (!ut_got_maxpid) {

		ut_got_maxpid++;

		ut_maxpid = sysconf(_SC_MAXPID);

	}

	return (ut_maxpid > SHRT_MAX ? 1 : 0);

}

/*

 * "getutxent" gets the next entry in the utmpx file.

 */

struct utmpx *

getutxent(void)

{

	struct futmpx *futxp;

	futxp = getutxent_frec();

	utmpx_frec2api(&fubuf, &ubuf);

	if (futxp == NULL)

		return (NULL);

	return (&ubuf);

}

/*

 * "getutent" gets the next entry in the utmp file.

 */

struct utmp *

getutent(void)

{

	struct utmpx *utmpx;

	if (compat_utmpflag)

		return (_compat_getutent());

	/* fail if we can't represent maxpid properly */

	if (big_pids_in_use()) {

		errno = EOVERFLOW;

		return (NULL);

	}

	if ((utmpx = getutxent()) == NULL)

		return (NULL);

	getutmp(utmpx, &utmpcompat);

	return (&utmpcompat);

}

/*

 * "getutxid" finds the specified entry in the utmpx file.  If

 * it can't find it, it returns NULL.

 */

struct utmpx *

getutxid(const struct utmpx *entry)

{

	short type;

	/*

	 * From XPG5: "The getutxid() or getutxline() may cache data.

	 * For this reason, to use getutxline() to search for multiple

	 * occurrences, it is necessary to zero out the static data after

	 * each success, or getutxline() could just return a pointer to

	 * the same utmpx structure over and over again."

	 */

	utmpx_api2frec(&ubuf, &fubuf);

	/*

	 * Start looking for entry. Look in our current buffer before

	 * reading in new entries.

	 */

	do {

		/*

		 * If there is no entry in "fubuf", 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, 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) {

					utmpx_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])) {

					utmpx_frec2api(&fubuf, &ubuf);

					return (&ubuf);

				}

				break;

			/*

			 * Do not search for illegal types of entry.

			 */

			default:

				return (NULL);

			}

		}

	} while (getutxent_frec() != NULL);

	/*

	 * Return NULL since the proper entry wasn't found.

	 */

	utmpx_frec2api(&fubuf, &ubuf);

	return (NULL);

}

/*

 * "getutid" finds the specified entry in the utmp file.  If

 * it can't find it, it returns NULL.

 */

struct utmp *

getutid(const struct utmp *entry)

{

	struct utmpx utmpx;

	struct utmpx *utmpx2;

	if (compat_utmpflag)

		return (_compat_getutid(entry));

	/* fail if we can't represent maxpid properly */

	if (big_pids_in_use()) {

		errno = EOVERFLOW;

		return (NULL);

	}

	getutmpx(entry, &utmpx);

	if ((utmpx2 = getutxid(&utmpx)) == NULL)

		return (NULL);

	getutmp(utmpx2, &utmpcompat);

	return (&utmpcompat);

}

/*

 * "getutxline" searches the "utmpx" file for a LOGIN_PROCESS or

 * USER_PROCESS with the same "line" as the specified "entry".

 */

struct utmpx *

getutxline(const struct utmpx *entry)

{

	/*

	 * From XPG5: "The getutxid() or getutxline() may cache data.

	 * For this reason, to use getutxline() to search for multiple

	 * occurrences, it is necessary to zero out the static data after

	 * each success, or getutxline() could just return a pointer to

	 * the same utmpx structure over and over again."

	 */

	utmpx_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) {

			utmpx_frec2api(&fubuf, &ubuf);

			return (&ubuf);

		}

	} while (getutxent_frec() != NULL);

	/*

	 * Since entry wasn't found, return NULL.

	 */

	utmpx_frec2api(&fubuf, &ubuf);

	return (NULL);

}

/*

 * "getutline" searches the "utmp" file for a LOGIN_PROCESS or

 * USER_PROCESS with the same "line" as the specified "entry".

 */

struct utmp *

getutline(const struct utmp *entry)

{

	struct utmpx utmpx;

	struct utmpx *utmpx2;

	if (compat_utmpflag)

		return (_compat_getutline(entry));

	/* fail if we can't represent maxpid properly */

	if (big_pids_in_use()) {

		errno = EOVERFLOW;

		return (NULL);

	}

	/* call getutxline */

	getutmpx(entry, &utmpx);

	if ((utmpx2 = getutxline(&utmpx)) == NULL)

		return (NULL);

	getutmp(utmpx2, &utmpcompat);

	return (&utmpcompat);

}

/*

 * invoke_utmp_update

 *

 * Invokes the utmp_update program which has the privilege to write

 * to the /etc/utmp file.

 */

#define	UTMP_UPDATE 	"/usr/lib/utmp_update"

#define	STRSZ	64	/* Size of char buffer for argument strings */

static struct utmpx *

invoke_utmp_update(const struct utmpx *entryx)

{

	extern char **environ;

	posix_spawnattr_t attr;

	int status;

	int cancel_state;

	pid_t child;

	pid_t w;

	int i;

	char user[STRSZ], id[STRSZ], line[STRSZ], pid[STRSZ], type[STRSZ],

	    term[STRSZ], exit[STRSZ], time[STRSZ], time_usec[STRSZ],

	    session_id[STRSZ], syslen[32];

	char pad[sizeof (entryx->pad) * 2 + 1];

	char host[sizeof (entryx->ut_host) + 1];

	struct utmpx *curx = NULL;

	char bin2hex[] = "0123456789ABCDEF";

	unsigned char *cp;

	char *argvec[15];

	int error;

	/*

	 * Convert the utmp struct to strings for command line arguments.

	 */

	(void) strncpy(user, entryx->ut_user, sizeof (entryx->ut_user));

	user[sizeof (entryx->ut_user)] = '\0';

	(void) strncpy(id, entryx->ut_id, sizeof (entryx->ut_id));

	id[sizeof (entryx->ut_id)] = '\0';

	(void) strncpy(line, entryx->ut_line, sizeof (entryx->ut_line));

	line[sizeof (entryx->ut_line)] = '\0';

	(void) sprintf(pid, "%d", entryx->ut_pid);

	(void) sprintf(type, "%d", entryx->ut_type);

	(void) sprintf(term, "%d", entryx->ut_exit.e_termination);

	(void) sprintf(exit, "%d", entryx->ut_exit.e_exit);

	(void) sprintf(time, "%ld", entryx->ut_tv.tv_sec);

	(void) sprintf(time_usec, "%ld", entryx->ut_tv.tv_usec);

	(void) sprintf(session_id, "%d", entryx->ut_session);

	cp = (unsigned char *)entryx->pad;

	for (i = 0; i < sizeof (entryx->pad); ++i) {

		pad[i << 1] = bin2hex[(cp[i] >> 4) & 0xF];

		pad[(i << 1) + 1] = bin2hex[cp[i] & 0xF];

	}

	pad[sizeof (pad) - 1] = '\0';