lib: rewrite shlib check to avoid excessive allocations

Author: Duncaen

lib/transaction_check_shlibs.c

@@ -28,6 +28,11 @@
 #include <stdbool.h>
 #include <errno.h>
 
+#include "uthash.h"
+
+#include "xbps.h"
+#include "xbps/xbps_array.h"
+#include "xbps/xbps_dictionary.h"
 #include "xbps_api_impl.h"
 
 /*
@@ -43,142 +48,250 @@
  * Abort transaction if such case is found.
  */
 
-static void
-shlib_register(xbps_dictionary_t d, const char *shlib, const char *pkgver)
+struct shlib_entry {
+	const char *name;
+	UT_hash_handle hh;
+};
+
+struct shlib_ctx {
+	struct xbps_handle *xhp;
+	struct shlib_entry *entries;
+	xbps_dictionary_t seen;
+	xbps_array_t missing;
+};
+
+static struct shlib_entry *
+shlib_entry_find(struct shlib_entry *head, const char *name)
 {
-	xbps_array_t array;
-	bool alloc = false;
+	struct shlib_entry *res = NULL;
+	HASH_FIND_STR(head, name, res);
+	return res;
+}
 
-	if ((array = xbps_dictionary_get(d, shlib)) == NULL) {
-		alloc = true;
-		array = xbps_array_create();
-		xbps_dictionary_set(d, shlib, array);
+static struct shlib_entry *
+shlib_entry_get(struct shlib_ctx *ctx, const char *name)
+{
+	struct shlib_entry *res = shlib_entry_find(ctx->entries, name);
+	if (res)
+		return res;
+	res = calloc(1, sizeof(*res));
+	if (!res) {
+		xbps_error_printf("out of memory\n");
+		errno = ENOMEM;
+		return NULL;
 	}
-	if (!xbps_match_string_in_array(array, pkgver))
-		xbps_array_add_cstring_nocopy(array, pkgver);
-	if (alloc)
-		xbps_object_release(array);
+	res->name = name;
+	HASH_ADD_STR(ctx->entries, name, res);
+	return res;
 }
 
-static xbps_dictionary_t
-collect_shlibs(struct xbps_handle *xhp, xbps_array_t pkgs, bool req)
+static int
+collect_shlib_array(struct shlib_ctx *ctx, xbps_array_t array)
+{
+	for (unsigned int i = 0; i < xbps_array_count(array); i++) {
+		struct shlib_entry *entry;
+		const char *shlib = NULL;
+		if (!xbps_array_get_cstring_nocopy(array, i, &shlib))
+			return -EINVAL;
+		entry = shlib_entry_get(ctx, shlib);
+		if (!entry)
+			return -errno;
+	}
+	return 0;
+}
+
+static int
+collect_shlibs(struct shlib_ctx *ctx, xbps_array_t pkgs)
 {
 	xbps_object_t obj;
 	xbps_object_iterator_t iter;
-	xbps_dictionary_t d, pd;
-	const char *pkgname, *pkgver;
-
-	d = xbps_dictionary_create();
-	assert(d);
-
-	/* copy pkgdb to out temporary dictionary */
-	pd = xbps_dictionary_copy(xhp->pkgdb);
-	assert(pd);
-
-	/*
-	 * copy pkgs from transaction to our dictionary, overriding them
-	 * if they were there from pkgdb.
-	 */
-	iter = xbps_array_iterator(pkgs);
-	assert(iter);
-	while ((obj = xbps_object_iterator_next(iter))) {
-		if (!xbps_dictionary_get_cstring_nocopy(obj, "pkgname", &pkgname))
-			continue;
+	xbps_bool_t placeholder;
+
+	// can't set null values to xbps_dictionary so just use one boolean
+	placeholder = xbps_bool_create(true);
+	if (!placeholder) {
+		xbps_error_printf("out of memory\n");
+		return -ENOMEM;
+	}
+
+	ctx->seen = xbps_dictionary_create();
+	if (!ctx->seen) {
+		xbps_error_printf("out of memory\n");
+		return -ENOMEM;
+	}
 
-		/* ignore shlibs if pkg is on hold mode */
-		if (xbps_transaction_pkg_type(obj) == XBPS_TRANS_HOLD) {
+	for (unsigned int i = 0; i < xbps_array_count(pkgs); i++) {
+		const char *pkgname;
+		xbps_dictionary_t pkgd = xbps_array_get(pkgs, i);
+		xbps_array_t array;
+
+		if (xbps_transaction_pkg_type(pkgd) == XBPS_TRANS_HOLD)
 			continue;
+		if (!xbps_dictionary_get_cstring_nocopy(pkgd, "pkgname", &pkgname)) {
+			xbps_error_printf("invalid package: missing `pkgname` property\n");
+			return -EINVAL;
+		}
+		if (!xbps_dictionary_set(ctx->seen, pkgname, placeholder)) {
+			xbps_error_printf("out of memory\n");
+			return -ENOMEM;
 		}
 
-		xbps_dictionary_set(pd, pkgname, obj);
+		if (xbps_transaction_pkg_type(pkgd) == XBPS_TRANS_REMOVE)
+			continue;
+
+		array = xbps_dictionary_get(pkgd, "shlib-provides");
+		if (array) {
+			int r = collect_shlib_array(ctx, array);
+			if (r < 0)
+				return r;
+		}
 	}
-	xbps_object_iterator_release(iter);
 
-	/*
-	 * iterate over our dictionary to collect shlib-{requires,provides}.
-	 */
-	iter = xbps_dictionary_iterator(pd);
-	assert(iter);
+	iter = xbps_dictionary_iterator(ctx->xhp->pkgdb);
+	if (!iter) {
+		xbps_error_printf("out of memory\n");
+		return -ENOMEM;
+	}
 
 	while ((obj = xbps_object_iterator_next(iter))) {
-		xbps_array_t shobjs;
+		xbps_array_t array;
 		xbps_dictionary_t pkgd;
+		const char *pkgname = NULL;
 
-		pkgd = xbps_dictionary_get_keysym(pd, obj);
-		if (xbps_transaction_pkg_type(pkgd) == XBPS_TRANS_REMOVE) {
-			continue;
-		}
-		/*
-		 * If pkg does not have the required obj, pass to next one.
-		 */
-		xbps_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver);
-		shobjs = xbps_dictionary_get(pkgd,
-				req ? "shlib-requires" : "shlib-provides");
-		if (shobjs == NULL)
+		pkgname = xbps_dictionary_keysym_cstring_nocopy(obj);
+		/* ignore internal objs */
+		if (strncmp(pkgname, "_XBPS_", 6) == 0)
 			continue;
 
-		for (unsigned int i = 0; i < xbps_array_count(shobjs); i++) {
-			const char *shlib = NULL;
+		pkgd = xbps_dictionary_get_keysym(ctx->xhp->pkgdb, obj);
+
+		if (xbps_dictionary_get(ctx->seen, pkgname))
+			continue;
 
-			xbps_array_get_cstring_nocopy(shobjs, i, &shlib);
-			xbps_dbg_printf("%s: registering %s for %s\n",
-			    pkgver, shlib, req ? "shlib-requires" : "shlib-provides");
-			if (req)
-				shlib_register(d, shlib, pkgver);
-			else
-				xbps_dictionary_set_cstring_nocopy(d, shlib, pkgver);
+		array = xbps_dictionary_get(pkgd, "shlib-provides");
+		if (array) {
+			int r = collect_shlib_array(ctx, array);
+			if (r < 0)
+				return r;
 		}
 	}
+
 	xbps_object_iterator_release(iter);
-	xbps_object_release(pd);
-	return d;
+	return 0;
 }
 
-bool HIDDEN
-xbps_transaction_check_shlibs(struct xbps_handle *xhp, xbps_array_t pkgs)
+static int
+check_shlibs(struct shlib_ctx *ctx, xbps_array_t pkgs)
 {
-	xbps_array_t array, mshlibs;
-	xbps_object_t obj, obj2;
 	xbps_object_iterator_t iter;
-	xbps_dictionary_t shrequires, shprovides;
-	const char *pkgver = NULL, *shlib = NULL;
-	char *buf;
-	bool broken = false;
+	xbps_object_t obj;
 
-	shrequires = collect_shlibs(xhp, pkgs, true);
-	shprovides = collect_shlibs(xhp, pkgs, false);
+	for (unsigned int i = 0; i < xbps_array_count(pkgs); i++) {
+		xbps_array_t array;
+		xbps_dictionary_t pkgd = xbps_array_get(pkgs, i);
+		xbps_trans_type_t ttype = xbps_transaction_pkg_type(pkgd);
 
-	mshlibs = xbps_dictionary_get(xhp->transd, "missing_shlibs");
-	/* iterate over shlib-requires to find unmatched shlibs */
-	iter = xbps_dictionary_iterator(shrequires);
-	assert(iter);
+		if (ttype == XBPS_TRANS_HOLD || ttype == XBPS_TRANS_REMOVE)
+			continue;
 
-	while ((obj = xbps_object_iterator_next(iter))) {
-		shlib = xbps_dictionary_keysym_cstring_nocopy(obj);
-		xbps_dbg_printf("%s: checking for `%s': ", __func__, shlib);
-		if ((obj2 = xbps_dictionary_get(shprovides, shlib))) {
-			xbps_dbg_printf_append("provided by `%s'\n",
-			    xbps_string_cstring_nocopy(obj2));
+		array = xbps_dictionary_get(pkgd, "shlib-requires");
+		if (!array)
 			continue;
+		for (unsigned int j = 0; j < xbps_array_count(array); j++) {
+			const char *pkgver = NULL;
+			const char *shlib = NULL;
+			char *missing;
+			if (!xbps_array_get_cstring_nocopy(array, j, &shlib))
+				return -EINVAL;
+			if (shlib_entry_find(ctx->entries, shlib))
+				continue;
+			if (!xbps_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver))
+				return -EINVAL;
+			missing = xbps_xasprintf(
+			    "%s: broken, unresolvable shlib `%s'",
+			    pkgver, shlib);
+			if (!xbps_array_add_cstring_nocopy(ctx->missing, missing)) {
+				xbps_error_printf("out of memory\n");
+				return -ENOMEM;
+			}
 		}
-		xbps_dbg_printf_append("not found\n");
+	}
+
+	iter = xbps_dictionary_iterator(ctx->xhp->pkgdb);
+	if (!iter) {
+		xbps_error_printf("out of memory\n");
+		return -ENOMEM;
+	}
+
+	while ((obj = xbps_object_iterator_next(iter))) {
+		xbps_array_t array;
+		xbps_dictionary_t pkgd;
+		const char *pkgname = NULL;
+
+		pkgname = xbps_dictionary_keysym_cstring_nocopy(obj);
+		/* ignore internal objs */
+		if (strncmp(pkgname, "_XBPS_", 6) == 0)
+			continue;
+
+		pkgd  = xbps_dictionary_get_keysym(ctx->xhp->pkgdb, obj);
+
+		if (xbps_dictionary_get(ctx->seen, pkgname))
+			continue;
 
-		broken = true;
-		array = xbps_dictionary_get_keysym(shrequires, obj);
+		array = xbps_dictionary_get(pkgd, "shlib-requires");
+		if (!array)
+			continue;
 		for (unsigned int i = 0; i < xbps_array_count(array); i++) {
-			xbps_array_get_cstring_nocopy(array, i, &pkgver);
-			buf = xbps_xasprintf("%s: broken, unresolvable "
-			    "shlib `%s'", pkgver, shlib);
-			xbps_array_add_cstring(mshlibs, buf);
-			free(buf);
+			const char *pkgver = NULL;
+			const char *shlib = NULL;
+			char *missing;
+			if (!xbps_array_get_cstring_nocopy(array, i, &shlib))
+				return -EINVAL;
+			if (shlib_entry_find(ctx->entries, shlib))
+				continue;
+			if (!xbps_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver))
+				return -EINVAL;
+			missing = xbps_xasprintf(
+			    "%s: broken, unresolvable shlib `%s'", pkgver,
+			    shlib);
+			if (!xbps_array_add_cstring_nocopy(ctx->missing, missing)) {
+				xbps_error_printf("out of memory\n");
+				return -ENOMEM;
+			}
 		}
 	}
+
 	xbps_object_iterator_release(iter);
-	if (!broken) {
+	return 0;
+}
+
+bool HIDDEN
+xbps_transaction_check_shlibs(struct xbps_handle *xhp, xbps_array_t pkgs)
+{
+	struct shlib_entry *entry, *tmp;
+	struct shlib_ctx ctx = { .xhp = xhp };
+	int r;
+
+	ctx.missing = xbps_dictionary_get(xhp->transd, "missing_shlibs");
+
+	r = collect_shlibs(&ctx, pkgs);
+	if (r < 0)
+		goto err;
+
+	r = check_shlibs(&ctx, pkgs);
+	if (r < 0)
+		goto err;
+
+	if (xbps_array_count(ctx.missing) == 0)
 		xbps_dictionary_remove(xhp->transd, "missing_shlibs");
-	}
-	xbps_object_release(shprovides);
-	xbps_object_release(shrequires);
 
-	return true;
+	r = 0;
+err:
+	HASH_ITER(hh, ctx.entries, entry, tmp) {
+		HASH_DEL(ctx.entries, entry);
+		free(entry);
+	}
+	if (ctx.seen)
+		xbps_object_release(ctx.seen);
+	return r == 0;
 }