1 files changed, 140 insertions, 213 deletions

diff --git a/src/pwcache.c b/src/pwcache.c
index 91435bd..af8c237 100644
--- a/src/pwcache.c
+++ b/src/pwcache.c
@@ -1,293 +1,220 @@
-/****************************************************************************
- * bfs                                                                      *
- * Copyright (C) 2020 Tavian Barnes <tavianator@tavianator.com>             *
- *                                                                          *
- * Permission to use, copy, modify, and/or distribute this software for any *
- * purpose with or without fee is hereby granted.                           *
- *                                                                          *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES *
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF         *
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR  *
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   *
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN    *
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF  *
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.           *
- ****************************************************************************/
+// Copyright © Tavian Barnes <tavianator@tavianator.com>
+// SPDX-License-Identifier: 0BSD
 
+#include "prelude.h"
 #include "pwcache.h"
-#include "darray.h"
+#include "alloc.h"
 #include "trie.h"
 #include <errno.h>
 #include <grp.h>
 #include <pwd.h>
-#include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
+
+/** Represents cache hits for negative results. */
+static void *MISSING = &MISSING;
+
+/** Callback type for bfs_getent(). */
+typedef void *bfs_getent_fn(const void *key, void *ptr, size_t bufsize);
+
+/** Shared scaffolding for get{pw,gr}{nam,?id}_r(). */
+static void *bfs_getent(bfs_getent_fn *fn, const void *key, struct trie_leaf *leaf, struct varena *varena) {
+	if (leaf->value) {
+		errno = 0;
+		return leaf->value == MISSING ? NULL : leaf->value;
+	}
+
+	// _SC_GET{PW,GR}_R_SIZE_MAX tend to be fairly large (~1K).  That's okay
+	// for temporary allocations, but for these long-lived ones, let's start
+	// with a smaller buffer.
+	size_t bufsize = 128;
+	void *ptr = varena_alloc(varena, bufsize);
+	if (!ptr) {
+		return NULL;
+	}
+
+	while (true) {
+		void *ret = fn(key, ptr, bufsize);
+		if (ret) {
+			leaf->value = ret;
+			return ret;
+		} else if (errno == 0) {
+			leaf->value = MISSING;
+			break;
+		} else if (errno == ERANGE) {
+			void *next = varena_grow(varena, ptr, &bufsize);
+			if (!next) {
+				break;
+			}
+			ptr = next;
+		} else {
+			break;
+		}
+	}
+
+	varena_free(varena, ptr, bufsize);
+	return NULL;
+}
+
+/**
+ * An arena-allocated struct passwd.
+ */
+struct bfs_passwd {
+	struct passwd pwd;
+	char buf[];
+};
 
 struct bfs_users {
-	/** The array of passwd entries. */
-	struct passwd *entries;
+	/** bfs_passwd arena. */
+	struct varena varena;
 	/** A map from usernames to entries. */
 	struct trie by_name;
 	/** A map from UIDs to entries. */
 	struct trie by_uid;
 };
 
-struct bfs_users *bfs_users_parse(void) {
-	int error;
-
-	struct bfs_users *users = malloc(sizeof(*users));
+struct bfs_users *bfs_users_new(void) {
+	struct bfs_users *users = ALLOC(struct bfs_users);
 	if (!users) {
 		return NULL;
 	}
 
-	users->entries = NULL;
+	VARENA_INIT(&users->varena, struct bfs_passwd, buf);
 	trie_init(&users->by_name);
 	trie_init(&users->by_uid);
+	return users;
+}
 
-	setpwent();
-
-	while (true) {
-		errno = 0;
-		struct passwd *ent = getpwent();
-		if (!ent) {
-			if (errno) {
-				error = errno;
-				goto fail_end;
-			} else {
-				break;
-			}
-		}
+/** bfs_getent() callback for getpwnam_r(). */
+static void *bfs_getpwnam_impl(const void *key, void *ptr, size_t bufsize) {
+	struct bfs_passwd *storage = ptr;
 
-		if (DARRAY_PUSH(&users->entries, ent) != 0) {
-			error = errno;
-			goto fail_end;
-		}
+	struct passwd *ret = NULL;
+	errno = getpwnam_r(key, &storage->pwd, storage->buf, bufsize, &ret);
+	return ret;
+}
 
-		ent = users->entries + darray_length(users->entries) - 1;
-		ent->pw_name = strdup(ent->pw_name);
-		ent->pw_dir = strdup(ent->pw_dir);
-		ent->pw_shell = strdup(ent->pw_shell);
-		if (!ent->pw_name || !ent->pw_dir || !ent->pw_shell) {
-			error = ENOMEM;
-			goto fail_end;
-		}
+const struct passwd *bfs_getpwnam(struct bfs_users *users, const char *name) {
+	struct trie_leaf *leaf = trie_insert_str(&users->by_name, name);
+	if (!leaf) {
+		return NULL;
 	}
 
-	endpwent();
-
-	for (size_t i = 0; i < darray_length(users->entries); ++i) {
-		struct passwd *entry = &users->entries[i];
-		struct trie_leaf *leaf = trie_insert_str(&users->by_name, entry->pw_name);
-		if (leaf) {
-			if (!leaf->value) {
-				leaf->value = entry;
-			}
-		} else {
-			error = errno;
-			goto fail_free;
-		}
-
-		leaf = trie_insert_mem(&users->by_uid, &entry->pw_uid, sizeof(entry->pw_uid));
-		if (leaf) {
-			if (!leaf->value) {
-				leaf->value = entry;
-			}
-		} else {
-			error = errno;
-			goto fail_free;
-		}
-	}
+	return bfs_getent(bfs_getpwnam_impl, name, leaf, &users->varena);
+}
 
-	return users;
+/** bfs_getent() callback for getpwuid_r(). */
+static void *bfs_getpwuid_impl(const void *key, void *ptr, size_t bufsize) {
+	const uid_t *uid = key;
+	struct bfs_passwd *storage = ptr;
 
-fail_end:
-	endpwent();
-fail_free:
-	bfs_users_free(users);
-	errno = error;
-	return NULL;
+	struct passwd *ret = NULL;
+	errno = getpwuid_r(*uid, &storage->pwd, storage->buf, bufsize, &ret);
+	return ret;
 }
 
-const struct passwd *bfs_getpwnam(const struct bfs_users *users, const char *name) {
-	const struct trie_leaf *leaf = trie_find_str(&users->by_name, name);
-	if (leaf) {
-		return leaf->value;
-	} else {
+const struct passwd *bfs_getpwuid(struct bfs_users *users, uid_t uid) {
+	struct trie_leaf *leaf = trie_insert_mem(&users->by_uid, &uid, sizeof(uid));
+	if (!leaf) {
 		return NULL;
 	}
+
+	return bfs_getent(bfs_getpwuid_impl, &uid, leaf, &users->varena);
 }
 
-const struct passwd *bfs_getpwuid(const struct bfs_users *users, uid_t uid) {
-	const struct trie_leaf *leaf = trie_find_mem(&users->by_uid, &uid, sizeof(uid));
-	if (leaf) {
-		return leaf->value;
-	} else {
-		return NULL;
-	}
+void bfs_users_flush(struct bfs_users *users) {
+	trie_clear(&users->by_uid);
+	trie_clear(&users->by_name);
+	varena_clear(&users->varena);
 }
 
 void bfs_users_free(struct bfs_users *users) {
 	if (users) {
 		trie_destroy(&users->by_uid);
 		trie_destroy(&users->by_name);
-
-		for (size_t i = 0; i < darray_length(users->entries); ++i) {
-			struct passwd *entry = &users->entries[i];
-			free(entry->pw_shell);
-			free(entry->pw_dir);
-			free(entry->pw_name);
-		}
-		darray_free(users->entries);
-
+		varena_destroy(&users->varena);
 		free(users);
 	}
 }
 
+/**
+ * An arena-allocated struct group.
+ */
+struct bfs_group {
+	struct group grp;
+	char buf[];
+};
+
 struct bfs_groups {
-	/** The array of group entries. */
-	struct group *entries;
+	/** bfs_group arena. */
+	struct varena varena;
 	/** A map from group names to entries. */
 	struct trie by_name;
 	/** A map from GIDs to entries. */
 	struct trie by_gid;
 };
 
-/**
- * struct group::gr_mem isn't properly aligned on macOS, so do this to avoid
- * ASAN warnings.
- */
-static char *next_gr_mem(void **gr_mem) {
-	char *mem;
-	memcpy(&mem, *gr_mem, sizeof(mem));
-	*gr_mem = (char *)*gr_mem + sizeof(mem);
-	return mem;
-}
-
-struct bfs_groups *bfs_groups_parse(void) {
-	int error;
-
-	struct bfs_groups *groups = malloc(sizeof(*groups));
+struct bfs_groups *bfs_groups_new(void) {
+	struct bfs_groups *groups = ALLOC(struct bfs_groups);
 	if (!groups) {
 		return NULL;
 	}
 
-	groups->entries = NULL;
+	VARENA_INIT(&groups->varena, struct bfs_group, buf);
 	trie_init(&groups->by_name);
 	trie_init(&groups->by_gid);
+	return groups;
+}
 
-	setgrent();
-
-	while (true) {
-		errno = 0;
-		struct group *ent = getgrent();
-		if (!ent) {
-			if (errno) {
-				error = errno;
-				goto fail_end;
-			} else {
-				break;
-			}
-		}
-
-		if (DARRAY_PUSH(&groups->entries, ent) != 0) {
-			error = errno;
-			goto fail_end;
-		}
-		ent = groups->entries + darray_length(groups->entries) - 1;
-
-		void *members = ent->gr_mem;
-		ent->gr_mem = NULL;
-
-		ent->gr_name = strdup(ent->gr_name);
-		if (!ent->gr_name) {
-			error = errno;
-			goto fail_end;
-		}
+/** bfs_getent() callback for getgrnam_r(). */
+static void *bfs_getgrnam_impl(const void *key, void *ptr, size_t bufsize) {
+	struct bfs_group *storage = ptr;
 
-		for (char *mem = next_gr_mem(&members); mem; mem = next_gr_mem(&members)) {
-			char *dup = strdup(mem);
-			if (!dup) {
-				error = errno;
-				goto fail_end;
-			}
+	struct group *ret = NULL;
+	errno = getgrnam_r(key, &storage->grp, storage->buf, bufsize, &ret);
+	return ret;
+}
 
-			if (DARRAY_PUSH(&ent->gr_mem, &dup) != 0) {
-				error = errno;
-				free(dup);
-				goto fail_end;
-			}
-		}
+const struct group *bfs_getgrnam(struct bfs_groups *groups, const char *name) {
+	struct trie_leaf *leaf = trie_insert_str(&groups->by_name, name);
+	if (!leaf) {
+		return NULL;
 	}
 
-	endgrent();
-
-	for (size_t i = 0; i < darray_length(groups->entries); ++i) {
-		struct group *entry = &groups->entries[i];
-		struct trie_leaf *leaf = trie_insert_str(&groups->by_name, entry->gr_name);
-		if (leaf) {
-			if (!leaf->value) {
-				leaf->value = entry;
-			}
-		} else {
-			error = errno;
-			goto fail_free;
-		}
-
-		leaf = trie_insert_mem(&groups->by_gid, &entry->gr_gid, sizeof(entry->gr_gid));
-		if (leaf) {
-			if (!leaf->value) {
-				leaf->value = entry;
-			}
-		} else {
-			error = errno;
-			goto fail_free;
-		}
-	}
+	return bfs_getent(bfs_getgrnam_impl, name, leaf, &groups->varena);
+}
 
-	return groups;
+/** bfs_getent() callback for getgrgid_r(). */
+static void *bfs_getgrgid_impl(const void *key, void *ptr, size_t bufsize) {
+	const gid_t *gid = key;
+	struct bfs_group *storage = ptr;
 
-fail_end:
-	endgrent();
-fail_free:
-	bfs_groups_free(groups);
-	errno = error;
-	return NULL;
+	struct group *ret = NULL;
+	errno = getgrgid_r(*gid, &storage->grp, storage->buf, bufsize, &ret);
+	return ret;
 }
 
-const struct group *bfs_getgrnam(const struct bfs_groups *groups, const char *name) {
-	const struct trie_leaf *leaf = trie_find_str(&groups->by_name, name);
-	if (leaf) {
-		return leaf->value;
-	} else {
+const struct group *bfs_getgrgid(struct bfs_groups *groups, gid_t gid) {
+	struct trie_leaf *leaf = trie_insert_mem(&groups->by_gid, &gid, sizeof(gid));
+	if (!leaf) {
 		return NULL;
 	}
+
+	return bfs_getent(bfs_getgrgid_impl, &gid, leaf, &groups->varena);
 }
 
-const struct group *bfs_getgrgid(const struct bfs_groups *groups, gid_t gid) {
-	const struct trie_leaf *leaf = trie_find_mem(&groups->by_gid, &gid, sizeof(gid));
-	if (leaf) {
-		return leaf->value;
-	} else {
-		return NULL;
-	}
+void bfs_groups_flush(struct bfs_groups *groups) {
+	trie_clear(&groups->by_gid);
+	trie_clear(&groups->by_name);
+	varena_clear(&groups->varena);
 }
 
 void bfs_groups_free(struct bfs_groups *groups) {
 	if (groups) {
 		trie_destroy(&groups->by_gid);
 		trie_destroy(&groups->by_name);
-
-		for (size_t i = 0; i < darray_length(groups->entries); ++i) {
-			struct group *entry = &groups->entries[i];
-			for (size_t j = 0; j < darray_length(entry->gr_mem); ++j) {
-				free(entry->gr_mem[j]);
-			}
-			darray_free(entry->gr_mem);
-			free(entry->gr_name);
-		}
-		darray_free(groups->entries);
-
+		varena_destroy(&groups->varena);
 		free(groups);
 	}
 }