--- utmpx.c.orig	2009-04-01 04:01:12.000000000 -0700
+++ utmpx.c	2009-04-01 04:09:50.000000000 -0700
@@ -49,48 +49,57 @@ __RCSID("$NetBSD: utmpx.c,v 1.21 2003/09
 #include <sys/time.h>
 #include <sys/wait.h>
 
-#include <assert.h>
-#include <db.h>
-#include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#ifdef LEGACY_UTMP_APIS
 #include <utmp.h>
-/* don't define earlier, has side effects in fcntl.h */
-#define __LIBC12_SOURCE__
+#endif /* LEGACY_UTMP_APIS */
 #include <utmpx.h>
+#include <utmpx-darwin.h>
+#include <errno.h>
 #include <vis.h>
-
-__warn_references(getlastlogx,
-    "warning: reference to compatibility getlastlogx(); include <utmpx.h> for correct reference")
-__warn_references(lastlogxname,
-    "warning: reference to deprecated lastlogxname()")
+#include <notify.h>
 
 static FILE *fp;
 static int readonly = 0;
 static struct utmpx ut;
 static char utfile[MAXPATHLEN] = _PATH_UTMPX;
-static char llfile[MAXPATHLEN] = _PATH_LASTLOGX;
+__private_extern__ int utfile_system = 1; /* are we using _PATH_UTMPX? */
+__private_extern__ pthread_mutex_t utmpx_mutex = PTHREAD_MUTEX_INITIALIZER;
 
-static struct utmpx *utmp_update(const struct utmpx *);
+static struct utmpx *_getutxid(const struct utmpx *);
 
-static const char vers[] = "utmpx-1.00";
+__private_extern__ const char _utmpx_vers[] = "utmpx-1.00";
 
-void
-setutxent()
+__private_extern__ void
+_setutxent()
 {
 
 	(void)memset(&ut, 0, sizeof(ut));
 	if (fp == NULL)
 		return;
+#ifdef __LP64__
+	(void)fseeko(fp, (off_t)sizeof(struct utmpx32), SEEK_SET);
+#else /* __LP64__ */
 	(void)fseeko(fp, (off_t)sizeof(ut), SEEK_SET);
+#endif /* __LP64__ */
 }
 
 
 void
-endutxent()
+setutxent()
+{
+	UTMPX_LOCK;
+	_setutxent();
+	UTMPX_UNLOCK;
+}
+
+
+__private_extern__ void
+_endutxent()
 {
 
 	(void)memset(&ut, 0, sizeof(ut));
@@ -102,9 +111,21 @@ endutxent()
 }
 
 
-struct utmpx *
-getutxent()
+void
+endutxent()
 {
+	UTMPX_LOCK;
+	_endutxent();
+	UTMPX_UNLOCK;
+}
+
+
+static struct utmpx *
+_getutxent()
+{
+#ifdef __LP64__
+	struct utmpx32 ut32;
+#endif /* __LP64__ */
 
 	if (fp == NULL) {
 		struct stat st;
@@ -116,7 +137,8 @@ getutxent()
 				else
 					readonly = 1;
 			}
-					
+
+		fcntl(fileno(fp), F_SETFD, 1); /* set close-on-exec flag */
 
 		/* get file size in order to check if new file */
 		if (fstat(fileno(fp), &st) == -1)
@@ -124,27 +146,51 @@ getutxent()
 
 		if (st.st_size == 0) {
 			/* new file, add signature record */
+#ifdef __LP64__
+			(void)memset(&ut32, 0, sizeof(ut32));
+			ut32.ut_type = SIGNATURE;
+			(void)memcpy(ut32.ut_user, _utmpx_vers, sizeof(_utmpx_vers));
+			if (fwrite(&ut32, sizeof(ut32), 1, fp) != 1)
+#else /* __LP64__ */
 			(void)memset(&ut, 0, sizeof(ut));
 			ut.ut_type = SIGNATURE;
-			(void)memcpy(ut.ut_user, vers, sizeof(vers));
+			(void)memcpy(ut.ut_user, _utmpx_vers, sizeof(_utmpx_vers));
 			if (fwrite(&ut, sizeof(ut), 1, fp) != 1)
+#endif /* __LP64__ */
 				goto failclose;
 		} else {
 			/* old file, read signature record */
+#ifdef __LP64__
+			if (fread(&ut32, sizeof(ut32), 1, fp) != 1)
+#else /* __LP64__ */
 			if (fread(&ut, sizeof(ut), 1, fp) != 1)
+#endif /* __LP64__ */
 				goto failclose;
-			if (memcmp(ut.ut_user, vers, sizeof(vers)) != 0 ||
+#ifdef __LP64__
+			if (memcmp(ut32.ut_user, _utmpx_vers, sizeof(_utmpx_vers)) != 0 ||
+			    ut32.ut_type != SIGNATURE)
+#else /* __LP64__ */
+			if (memcmp(ut.ut_user, _utmpx_vers, sizeof(_utmpx_vers)) != 0 ||
 			    ut.ut_type != SIGNATURE)
+#endif /* __LP64__ */
 				goto failclose;
 		}
 	}
 
+#ifdef __LP64__
+	if (fread(&ut32, sizeof(ut32), 1, fp) != 1)
+#else /* __LP64__ */
 	if (fread(&ut, sizeof(ut), 1, fp) != 1)
+#endif /* __LP64__ */
 		goto fail;
 
+#ifdef __LP64__
+	_utmpx32_64(&ut32, &ut);
+#endif /* __LP64__ */
 	return &ut;
 failclose:
 	(void)fclose(fp);
+	fp = NULL;
 fail:
 	(void)memset(&ut, 0, sizeof(ut));
 	return NULL;
@@ -152,14 +198,45 @@ fail:
 
 
 struct utmpx *
+getutxent()
+{
+	struct utmpx *ret;
+	UTMPX_LOCK;
+	ret = _getutxent();
+	UTMPX_UNLOCK;
+	return ret;
+}
+
+struct utmpx *
 getutxid(const struct utmpx *utx)
 {
+	struct utmpx temp;
+	const struct utmpx *ux;
+	struct utmpx *ret;
 
 	_DIAGASSERT(utx != NULL);
 
 	if (utx->ut_type == EMPTY)
 		return NULL;
 
+	UTMPX_LOCK;
+	/* make a copy as needed, and auto-fill if requested */
+	ux = _utmpx_working_copy(utx, &temp, 1);
+	if (!ux) {
+		UTMPX_UNLOCK;
+		return NULL;
+	}
+
+	ret = _getutxid(ux);
+	UTMPX_UNLOCK;
+	return ret;
+}
+
+
+static struct utmpx *
+_getutxid(const struct utmpx *utx)
+{
+
 	do {
 		if (ut.ut_type == EMPTY)
 			continue;
@@ -193,7 +270,7 @@ getutxid(const struct utmpx *utx)
 		default:
 			return NULL;
 		}
-	} while (getutxent() != NULL);
+	} while (_getutxent() != NULL);
 	return NULL;
 }
 
@@ -204,6 +281,7 @@ getutxline(const struct utmpx *utx)
 
 	_DIAGASSERT(utx != NULL);
 
+	UTMPX_LOCK;
 	do {
 		switch (ut.ut_type) {
 		case EMPTY:
@@ -211,13 +289,16 @@ getutxline(const struct utmpx *utx)
 		case LOGIN_PROCESS:
 		case USER_PROCESS:
 			if (strncmp(ut.ut_line, utx->ut_line,
-			    sizeof(ut.ut_line)) == 0)
+			    sizeof(ut.ut_line)) == 0) {
+				UTMPX_UNLOCK;
 				return &ut;
+			}
 			break;
 		default:
 			break;
 		}
-	} while (getutxent() != NULL);
+	} while (_getutxent() != NULL);
+	UTMPX_UNLOCK;
 	return NULL;
 }
 
@@ -225,156 +306,180 @@ getutxline(const struct utmpx *utx)
 struct utmpx *
 pututxline(const struct utmpx *utx)
 {
-	struct utmpx temp, *u = NULL;
-	int gotlock = 0;
+	struct utmpx *ux;
 
 	_DIAGASSERT(utx != NULL);
 
-	if (utx == NULL)
+	if (utx == NULL) {
+		errno = EINVAL;
 		return NULL;
+	}
 
-	if (strcmp(_PATH_UTMPX, utfile) == 0)
-		if ((fp != NULL && readonly) || (fp == NULL && geteuid() != 0))
-			return utmp_update(utx);
-
+	UTMPX_LOCK;
+	if ((ux = _pututxline(utx)) != NULL && utfile_system) {
+		_utmpx_asl(ux);	/* the equivalent of wtmpx and lastlogx */
+#ifdef UTMP_COMPAT
+		_write_utmp_compat(ux);
+#endif /* UTMP_COMPAT */
+	}
+	UTMPX_UNLOCK;
+	return ux;
+}
 
-	(void)memcpy(&temp, utx, sizeof(temp));
+__private_extern__ struct utmpx *
+_pututxline(const struct utmpx *utx)
+{
+	struct utmpx temp, *u = NULL, *x;
+	const struct utmpx *ux;
+#ifdef __LP64__
+	struct utmpx32 ut32;
+#endif /* __LP64__ */
+	struct flock fl;
+#define gotlock		(fl.l_start >= 0)
+
+	fl.l_start = -1; /* also means we haven't locked */
+	if (utfile_system)
+		if ((fp != NULL && readonly) || (fp == NULL && geteuid() != 0)) {
+			errno = EPERM;
+			return NULL;
+		}
 
 	if (fp == NULL) {
-		(void)getutxent();
-		if (fp == NULL || readonly)
+		(void)_getutxent();
+		if (fp == NULL || readonly) {
+			errno = EPERM;
 			return NULL;
+		}
 	}
 
-	if (getutxid(&temp) == NULL) {
-		setutxent();
-		if (getutxid(&temp) == NULL) {
-			if (lockf(fileno(fp), F_LOCK, (off_t)0) == -1)
+	/* make a copy as needed, and auto-fill if requested */
+	ux = _utmpx_working_copy(utx, &temp, 0);
+	if (!ux)
+		return NULL;
+
+	if ((x = _getutxid(ux)) == NULL) {
+		_setutxent();
+		if ((x = _getutxid(ux)) == NULL) {
+			/*
+			 * utx->ut_type has any original mask bits, while
+			 * ux->ut_type has those mask bits removed.  If we
+			 * are trying to record a dead process, and
+			 * UTMPX_DEAD_IF_CORRESPONDING_MASK is set, then since
+			 * there is no matching entry, we return NULL.
+			 */
+			if (ux->ut_type == DEAD_PROCESS &&
+			    (utx->ut_type & UTMPX_DEAD_IF_CORRESPONDING_MASK)) {
+				errno = EINVAL;
+				return NULL;
+			}
+			/*
+			 * Replace lockf() with fcntl() and a fixed start
+			 * value.  We should already be at EOF.
+			 */
+			if ((fl.l_start = lseek(fileno(fp), 0, SEEK_CUR)) < 0)
+				return NULL;
+			fl.l_len = 0;
+			fl.l_whence = SEEK_SET;
+			fl.l_type = F_WRLCK;
+			if (fcntl(fileno(fp), F_SETLKW, &fl) == -1)
 				return NULL;
-			gotlock++;
 			if (fseeko(fp, (off_t)0, SEEK_END) == -1)
 				goto fail;
 		}
 	}
 
 	if (!gotlock) {
+		/*
+		 * utx->ut_type has any original mask bits, while
+		 * ux->ut_type has those mask bits removed.  If we
+		 * are trying to record a dead process, if
+		 * UTMPX_DEAD_IF_CORRESPONDING_MASK is set, but the found
+		 * entry is not a (matching) USER_PROCESS, then return NULL.
+		 */
+		if (ux->ut_type == DEAD_PROCESS &&
+		    (utx->ut_type & UTMPX_DEAD_IF_CORRESPONDING_MASK) &&
+		    x->ut_type != USER_PROCESS) {
+			errno = EINVAL;
+			return NULL;
+		}
 		/* we are not appending */
+#ifdef __LP64__
+		if (fseeko(fp, -(off_t)sizeof(ut32), SEEK_CUR) == -1)
+#else /* __LP64__ */
 		if (fseeko(fp, -(off_t)sizeof(ut), SEEK_CUR) == -1)
+#endif /* __LP64__ */
 			return NULL;
 	}
 
-	if (fwrite(&temp, sizeof (temp), 1, fp) != 1)
+#ifdef __LP64__
+	_utmpx64_32(ux, &ut32);
+	if (fwrite(&ut32, sizeof (ut32), 1, fp) != 1)
+#else /* __LP64__ */
+	if (fwrite(ux, sizeof (*ux), 1, fp) != 1)
+#endif /* __LP64__ */
 		goto fail;
 
 	if (fflush(fp) == -1)
 		goto fail;
 
-	u = memcpy(&ut, &temp, sizeof(ut));
+	u = memcpy(&ut, ux, sizeof(ut));
+	notify_post(UTMPX_CHANGE_NOTIFICATION);
 fail:
 	if (gotlock) {
-		if (lockf(fileno(fp), F_ULOCK, (off_t)0) == -1)
+		int save = errno;
+		fl.l_type = F_UNLCK;
+		if (fcntl(fileno(fp), F_SETLK, &fl) == -1)
 			return NULL;
+		errno = save;
 	}
 	return u;
 }
 
 
-static struct utmpx *
-utmp_update(const struct utmpx *utx)
-{
-	char buf[sizeof(*utx) * 4 + 1];
-	pid_t pid;
-	int status;
-
-	_DIAGASSERT(utx != NULL);
-
-	(void)strvisx(buf, (const char *)(const void *)utx, sizeof(*utx),
-	    VIS_WHITE);
-	switch (pid = fork()) {
-	case 0:
-		(void)execl(_PATH_UTMP_UPDATE,
-		    strrchr(_PATH_UTMP_UPDATE, '/') + 1, buf, NULL);
-		exit(1);
-		/*NOTREACHED*/
-	case -1:
-		return NULL;
-	default:
-		if (waitpid(pid, &status, 0) == -1)
-			return NULL;
-		if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
-			return memcpy(&ut, utx, sizeof(ut));
-		return NULL;
-	}
-
-}
-
 /*
  * The following are extensions and not part of the X/Open spec.
  */
 int
-updwtmpx(const char *file, const struct utmpx *utx)
-{
-	int fd;
-	int saved_errno;
-
-	_DIAGASSERT(file != NULL);
-	_DIAGASSERT(utx != NULL);
-
-	fd = open(file, O_WRONLY|O_APPEND|O_SHLOCK);
-
-	if (fd == -1) {
-		if ((fd = open(file, O_CREAT|O_WRONLY|O_EXLOCK, 0644)) == -1)
-			return -1;
-		(void)memset(&ut, 0, sizeof(ut));
-		ut.ut_type = SIGNATURE;
-		(void)memcpy(ut.ut_user, vers, sizeof(vers));
-		if (write(fd, &ut, sizeof(ut)) == -1)
-			goto failed;
-	}
-	if (write(fd, utx, sizeof(*utx)) == -1)
-		goto failed;
-	if (close(fd) == -1)
-		return -1;
-	return 0;
-
-  failed:
-	saved_errno = errno;
-	(void) close(fd);
-	errno = saved_errno;
-	return -1;
-}
-
-
-int
 utmpxname(const char *fname)
 {
 	size_t len;
 
-	_DIAGASSERT(fname != NULL);
+	UTMPX_LOCK;
+	if (fname == NULL) {
+		strcpy(utfile, _PATH_UTMPX);
+		utfile_system = 1;
+		_endutxent();
+		UTMPX_UNLOCK;
+		return 1;
+	}
 
 	len = strlen(fname);
 
-	if (len >= sizeof(utfile))
+	if (len >= sizeof(utfile)) {
+		UTMPX_UNLOCK;
 		return 0;
+	}
 
 	/* must end in x! */
-	if (fname[len - 1] != 'x')
+	if (fname[len - 1] != 'x') {
+		UTMPX_UNLOCK;
 		return 0;
+	}
 
 	(void)strlcpy(utfile, fname, sizeof(utfile));
-	endutxent();
+	_endutxent();
+	utfile_system = 0;
+	UTMPX_UNLOCK;
 	return 1;
 }
 
-
+#ifdef LEGACY_UTMP_APIS
 void
 getutmp(const struct utmpx *ux, struct utmp *u)
 {
 
-	_DIAGASSERT(ux != NULL);
-	_DIAGASSERT(u != NULL);
-
-	(void)memcpy(u->ut_name, ux->ut_name, sizeof(u->ut_name));
+	bzero(u, sizeof(*u));
+	(void)memcpy(u->ut_name, ux->ut_user, sizeof(u->ut_name));
 	(void)memcpy(u->ut_line, ux->ut_line, sizeof(u->ut_line));
 	(void)memcpy(u->ut_host, ux->ut_host, sizeof(u->ut_host));
 	u->ut_time = ux->ut_tv.tv_sec;
@@ -384,109 +489,16 @@ void
 getutmpx(const struct utmp *u, struct utmpx *ux)
 {
 
-	_DIAGASSERT(ux != NULL);
-	_DIAGASSERT(u != NULL);
-
-	(void)memcpy(ux->ut_name, u->ut_name, sizeof(u->ut_name));
+	bzero(ux, sizeof(*ux));
+	(void)memcpy(ux->ut_user, u->ut_name, sizeof(u->ut_name));
+	ux->ut_user[sizeof(u->ut_name)] = 0;
 	(void)memcpy(ux->ut_line, u->ut_line, sizeof(u->ut_line));
+	ux->ut_line[sizeof(u->ut_line)] = 0;
 	(void)memcpy(ux->ut_host, u->ut_host, sizeof(u->ut_host));
+	ux->ut_host[sizeof(u->ut_host)] = 0;
 	ux->ut_tv.tv_sec = u->ut_time;
 	ux->ut_tv.tv_usec = 0;
-	(void)memset(&ux->ut_ss, 0, sizeof(ux->ut_ss));
-	ux->ut_pid = 0;
+	ux->ut_pid = getpid();
 	ux->ut_type = USER_PROCESS;
-	ux->ut_session = 0;
-	ux->ut_exit.e_termination = 0;
-	ux->ut_exit.e_exit = 0;
-}
-
-int
-lastlogxname(const char *fname)
-{
-	size_t len;
-
-	_DIAGASSERT(fname != NULL);
-
-	len = strlen(fname);
-
-	if (len >= sizeof(llfile))
-		return 0;
-
-	/* must end in x! */
-	if (fname[len - 1] != 'x')
-		return 0;
-
-	(void)strlcpy(llfile, fname, sizeof(llfile));
-	return 1;
-}
-
-struct lastlogx *
-getlastlogx(uid_t uid, struct lastlogx *ll)
-{
-
-	return __getlastlogx13(_PATH_LASTLOGX, uid, ll);
-}
-
-struct lastlogx *
-__getlastlogx13(const char *fname, uid_t uid, struct lastlogx *ll)
-{
-	DBT key, data;
-	DB *db;
-
-	_DIAGASSERT(fname != NULL);
-	_DIAGASSERT(ll != NULL);
-
-	db = dbopen(fname, O_RDONLY|O_SHLOCK, 0, DB_HASH, NULL);
-
-	if (db == NULL)
-		return NULL;
-
-	key.data = &uid;
-	key.size = sizeof(uid);
-
-	if ((db->get)(db, &key, &data, 0) != 0)
-		goto error;
-
-	if (data.size != sizeof(*ll)) {
-		errno = EFTYPE;
-		goto error;
-	}
-
-	if (ll == NULL)
-		if ((ll = malloc(sizeof(*ll))) == NULL)
-			goto done;
-
-	(void)memcpy(ll, data.data, sizeof(*ll));
-	goto done;
-error:
-	ll = NULL;
-done:
-	(db->close)(db);
-	return ll;
-}
-
-int
-updlastlogx(const char *fname, uid_t uid, struct lastlogx *ll)
-{
-	DBT key, data;
-	int error = 0;
-	DB *db;
-
-	_DIAGASSERT(fname != NULL);
-	_DIAGASSERT(ll != NULL);
-
-	db = dbopen(fname, O_RDWR|O_CREAT|O_EXLOCK, 0, DB_HASH, NULL);
-
-	if (db == NULL)
-		return -1;
-
-	key.data = &uid;
-	key.size = sizeof(uid);
-	data.data = ll;
-	data.size = sizeof(*ll);
-	if ((db->put)(db, &key, &data, 0) != 0)
-		error = -1;
-
-	(db->close)(db);
-	return error;
 }
+#endif /* LEGACY_UTMP_APIS */