[gentoo-commits] proj/portage-utils:master commit in: libq/, /

["Fabian Groffen" <grobian@gentoo.org>]

commit:     c9e89dfa7cc3ae22bc3c731a3d617e4912bd831a
Author:     Fabian Groffen <grobian <AT> gentoo <DOT> org>
AuthorDate: Mon Dec 30 17:21:21 2019 +0000
Commit:     Fabian Groffen <grobian <AT> gentoo <DOT> org>
CommitDate: Mon Dec 30 17:21:21 2019 +0000
URL:        https://gitweb.gentoo.org/proj/portage-utils.git/commit/?id=c9e89dfa

libq/tree: introduce a wrapper for retrieving ebuild metadata

To further hide the difference between trees, add a wrapper around
tree_get_meta, which deals with the underlying storage format.  This is
most notably useful when dealing with vdb-based and binpkgs because they
have a specific or more expensive way of retrieval.  This can now
properly be hidden from the q applets.

Signed-off-by: Fabian Groffen <grobian <AT> gentoo.org>

 libq/tree.c | 166 ++++++++++++++++++++++++++++++++++++++++++++++++------------
 libq/tree.h |  55 +++++++++++---------
 qdepends.c  |  36 +++++--------
 qkeyword.c  |   6 +--
 qlist.c     |  71 +++-----------------------
 qsearch.c   |  16 ++----
 quse.c      |  71 +++++++++-----------------
 7 files changed, 213 insertions(+), 208 deletions(-)

diff --git a/libq/tree.c b/libq/tree.c
index d9eec76..bac9d00 100644
--- a/libq/tree.c
+++ b/libq/tree.c
@@ -326,6 +326,7 @@ tree_open_pkg(tree_cat_ctx *cat_ctx, const char *name)
 	pkg_ctx->fd = -1;
 	pkg_ctx->cat_ctx = cat_ctx;
 	pkg_ctx->atom = NULL;
+	pkg_ctx->meta = NULL;
 	return pkg_ctx;
 }
 
@@ -418,8 +419,7 @@ tree_next_pkg(tree_cat_ctx *cat_ctx)
 				tree_ctx *pkgdir = ctx->ebuilddir_ctx;
 
 				if (pkgdir == NULL)
-					pkgdir = ctx->ebuilddir_ctx = xmalloc(sizeof(tree_ctx));
-				memset(ctx->ebuilddir_ctx, '\0', sizeof(*ctx->ebuilddir_ctx));
+					pkgdir = ctx->ebuilddir_ctx = xzalloc(sizeof(tree_ctx));
 
 				ctx->ebuilddir_pkg_ctx = tree_next_pkg_int(cat_ctx);
 				if (ctx->ebuilddir_pkg_ctx == NULL)
@@ -554,13 +554,13 @@ tree_read_file_pms(tree_pkg_ctx *pkg_ctx)
 	if ((off_t)fread(ptr, 1, s.st_size, f) != s.st_size)
 		goto err;
 
-	ret->DEPEND = ptr;
+	ret->Q_DEPEND = ptr;
 #define next_line(curr, next) \
-	if ((ptr = strchr(ret->curr, '\n')) == NULL) { \
+	if ((ptr = strchr(ret->Q_##curr, '\n')) == NULL) { \
 		warn("Invalid cache file for '%s'", buf); \
 		goto err; \
 	} \
-	ret->next = ptr+1; \
+	ret->Q_##next = ptr+1; \
 	*ptr = '\0';
 	next_line(DEPEND, RDEPEND)
 	next_line(RDEPEND, SLOT)
@@ -630,7 +630,7 @@ tree_read_file_md5(tree_pkg_ctx *pkg_ctx)
 	 * */
 #define assign_var_cmp(keyname, cmpkey) \
 	if (strncmp(keyptr, cmpkey, strlen(cmpkey)) == 0) { \
-		ret->keyname = valptr; \
+		ret->Q_##keyname = valptr; \
 		continue; \
 	}
 #define assign_var(keyname) \
@@ -741,7 +741,7 @@ tree_read_file_ebuild(tree_pkg_ctx *pkg_ctx)
 		if (q < p && *p == '=') {
 			*p++ = '\0';
 			/* match variable against which ones we look for */
-#define match_key(X) else if (strcmp(q, #X) == 0) key = &ret->X
+#define match_key(X) else if (strcmp(q, #X) == 0) key = &ret->Q_##X
 			if (1 == 0); /* dummy for syntax */
 			match_key(DEPEND);
 			match_key(RDEPEND);
@@ -840,7 +840,7 @@ tree_read_file_binpkg_xpak_cb(
 
 #define match_path(K) \
 	else if (pathname_len == (sizeof(#K) - 1) && strcmp(pathname, #K) == 0) \
-		key = &m->K
+		key = &m->Q_##K
 	if (1 == 0); /* dummy for syntax */
 	match_path(DEPEND);
 	match_path(RDEPEND);
@@ -868,33 +868,33 @@ tree_read_file_binpkg_xpak_cb(
 #undef match_path
 
 	/* hijack unused members */
-	pos = (size_t)m->_eclasses_;
-	len = (size_t)m->_md5_;
+	pos = (size_t)m->Q__eclasses_;
+	len = (size_t)m->Q__md5_;
 
 	/* trim whitespace (mostly trailing newline) */
 	while (isspace((int)data[data_offset + data_len - 1]))
 		data_len--;
 
 	if (len - pos < (size_t)data_len) {
-		char *old_data = m->_data;
+		char *old_data = m->Q__data;
 		len += (((data_len + 1) / BUFSIZ) + 1) * BUFSIZ;
-		m->_data = xrealloc(m->_data, len);
-		m->_md5_ = (char *)len;
+		m->Q__data = xrealloc(m->Q__data, len);
+		m->Q__md5_ = (char *)len;
 
 		/* re-position existing keys */
-		if (old_data != NULL && m->_data != old_data) {
+		if (old_data != NULL && m->Q__data != old_data) {
 			char **newdata = (char **)m;
 			int elems = sizeof(tree_pkg_meta) / sizeof(char *);
 			while (elems-- > 0)
 				if (newdata[elems] != NULL)
-					newdata[elems] = m->_data + (newdata[elems] - old_data);
+					newdata[elems] = m->Q__data + (newdata[elems] - old_data);
 		}
 	}
 
-	*key = m->_data + pos;
+	*key = m->Q__data + pos;
 	snprintf(*key, len - pos, "%.*s", data_len, data + data_offset);
 	pos += data_len + 1;
-	m->_eclasses_ = (char *)pos;
+	m->Q__eclasses_ = (char *)pos;
 }
 
 static tree_pkg_meta *
@@ -941,7 +941,7 @@ tree_pkg_read(tree_pkg_ctx *pkg_ctx)
 		return (tree_pkg_meta *)pkg_ctx->cat_ctx->ctx->pkgs;
 	}
 
-	warn("Unknown metadata cache type!");
+	warn("Unknown/unsupported metadata cache type!");
 	return NULL;
 }
 
@@ -950,11 +950,101 @@ tree_close_meta(tree_pkg_meta *cache)
 {
 	if (cache == NULL)
 		errf("Cache is empty !");
-	if (cache->_data != NULL)
-		free(cache->_data);
+	if (cache->Q__data != NULL)
+		free(cache->Q__data);
 	free(cache);
 }
 
+char *
+tree_pkg_meta_get_int(tree_pkg_ctx *pkg_ctx, size_t offset, const char *keyn)
+{
+	tree_ctx *ctx = pkg_ctx->cat_ctx->ctx;
+	char **key;
+
+	/* offset is a byte offset in the tree_pkg_meta struct, pointing to
+	 * key, the tree_pkg_meta_get macro takes care of this */
+
+	if (ctx->cachetype == CACHE_VDB) {
+		if (pkg_ctx->meta == NULL)
+			pkg_ctx->meta = xzalloc(sizeof(tree_pkg_meta));
+
+		key = (char **)((char *)&pkg_ctx->meta->Q__data + offset);
+
+		/* just eat the file if we haven't yet */
+		if (*key == NULL) {
+			int fd = tree_pkg_vdb_openat(pkg_ctx, keyn, O_RDONLY, 0);
+			struct stat s;
+			size_t pos;
+			size_t len;
+			tree_pkg_meta *m = pkg_ctx->meta;
+
+			if (fd < 0)
+				return NULL;
+			if (fstat(fd, &s) != 0 || s.st_size == 0) {
+				close(fd);
+				return NULL;
+			}
+
+			/* hijack unused members */
+			pos = (size_t)m->Q__eclasses_;
+			len = (size_t)m->Q__md5_;
+
+			/* TODO: this is an exact copy from tree_read_file_binpkg_xpak_cb */
+			if (len - pos < (size_t)s.st_size) {
+				char *old_data = m->Q__data;
+				len += (((s.st_size + 1) / BUFSIZ) + 1) * BUFSIZ;
+				m->Q__data = xrealloc(m->Q__data, len);
+				m->Q__md5_ = (char *)len;
+
+				/* re-position existing keys */
+				if (old_data != NULL && m->Q__data != old_data) {
+					char **newdata = (char **)m;
+					int elems = sizeof(tree_pkg_meta) / sizeof(char *);
+					while (elems-- > 0)
+						if (newdata[elems] != NULL)
+							newdata[elems] =
+								m->Q__data + (newdata[elems] - old_data);
+				}
+			}
+
+			if (read(fd, &m->Q__data[pos], s.st_size) == (ssize_t)s.st_size) {
+				char *p = *key = m->Q__data + pos;
+				p[s.st_size] = '\0';
+				while (s.st_size > 0 && isspace((int)p[s.st_size - 1]))
+					p[s.st_size--] = '\0';
+				pos += s.st_size + 1;
+				m->Q__eclasses_ = (char *)pos;
+			}
+			close(fd);
+		}
+	} else {
+		if (pkg_ctx->meta == NULL)
+			pkg_ctx->meta = tree_pkg_read(pkg_ctx);
+		if (pkg_ctx->meta == NULL)
+			return NULL;
+
+		key = (char **)((char *)&pkg_ctx->meta->Q__data + offset);
+
+		/* Packages are nice, but also a bit daft, because they don't
+		 * contain everything available (for a semi-good reason though)
+		 * We cannot downgrade the tree execution to BINPKGS, because
+		 * we're running from tree_foreach_packages */
+		if (*key == NULL && ctx->cachetype == CACHE_PACKAGES) {
+			ctx->cachetype = CACHE_BINPKGS;
+			pkg_ctx->fd = -1;
+			pkg_ctx->meta = tree_pkg_read(pkg_ctx);
+			ctx->cachetype = CACHE_PACKAGES;
+			if (pkg_ctx->meta == NULL) {
+				/* hrmffff. */
+				pkg_ctx->fd = 0;
+				pkg_ctx->meta = tree_pkg_read(pkg_ctx);
+			}
+			key = (char **)((char *)&pkg_ctx->meta->Q__data + offset);
+		}
+	}
+	return *key;
+}
+
 tree_metadata_xml *
 tree_pkg_metadata(tree_pkg_ctx *pkg_ctx)
 {
@@ -1058,6 +1148,9 @@ tree_close_pkg(tree_pkg_ctx *pkg_ctx)
 	if (pkg_ctx->cat_ctx->ctx->do_sort)
 		free((char *)pkg_ctx->name);
 	free(pkg_ctx->slot);
+	if (pkg_ctx->meta != NULL &&
+			(void *)pkg_ctx->meta != (void *)pkg_ctx->cat_ctx->ctx->pkgs)
+		tree_close_meta(pkg_ctx->meta);
 	free(pkg_ctx);
 }
 
@@ -1067,18 +1160,16 @@ tree_foreach_packages(tree_ctx *ctx, tree_pkg_cb callback, void *priv)
 	char *p = ctx->pkgs;
 	char *q;
 	char *c;
+	char pkgname[_Q_PATH_MAX];
 	size_t len = ctx->pkgslen;
 	int ret = 0;
 
 	/* reused for every entry */
-	tree_cat_ctx *cat = xzalloc(sizeof(tree_cat_ctx));
+	tree_cat_ctx *cat = NULL;
 	tree_pkg_ctx *pkg = xzalloc(sizeof(tree_pkg_ctx));
 	tree_pkg_meta *meta = xzalloc(sizeof(tree_pkg_meta));
 	depend_atom *atom = NULL;
 
-	cat->ctx = ctx;
-	pkg->cat_ctx = cat;
-
 	do {
 		/* find next line */
 		c = NULL;
@@ -1093,15 +1184,26 @@ tree_foreach_packages(tree_ctx *ctx, tree_pkg_cb callback, void *priv)
 		if (p == q) {
 			/* make callback with populated atom */
 			if (atom != NULL) {
+				size_t pkgnamelen;
+
 				/* store meta ptr in repo->pkgs, such that get_pkg_meta
 				 * can grab it from there (for free) */
 				ctx->pkgs = (char *)meta;
 
-				cat->name = atom->CATEGORY;
-				pkg->name = atom->PN;
-				pkg->slot = meta->SLOT == NULL ? (char *)"0" : meta->SLOT;
+				if (cat == NULL || strcmp(cat->name, atom->CATEGORY) != 0)
+				{
+					if (cat != NULL)
+						tree_close_cat(cat);
+					pkg->cat_ctx = cat = tree_open_cat(ctx, atom->CATEGORY);
+				}
+				pkgnamelen = snprintf(pkgname, sizeof(pkgname), "%s-%s.tbz2",
+						atom->PN, atom->PR_int > 0 ? atom->PVR : atom->PV);
+				pkgname[pkgnamelen - (sizeof(".tbz2") - 1)] = '\0';
+				pkg->name = pkgname;
+				pkg->slot = meta->Q_SLOT == NULL ? (char *)"0" : meta->Q_SLOT;
 				pkg->repo = ctx->repo;
 				pkg->atom = atom;
+				pkg->fd = 0;  /* intentional, meta has already been read */
 
 				/* do call callback with pkg_atom (populate cat and pkg) */
 				ret |= callback(pkg, priv);
@@ -1140,7 +1242,7 @@ tree_foreach_packages(tree_ctx *ctx, tree_pkg_cb callback, void *priv)
 #define match_key(X) match_key2(X,X)
 #define match_key2(X,Y) \
 		} else if (strcmp(p, #X) == 0) { \
-			meta->Y = c
+			meta->Q_##Y = c
 		match_key(DEFINED_PHASES);
 		match_key(DEPEND);
 		match_key2(DESC, DESCRIPTION);
@@ -1234,8 +1336,8 @@ tree_get_atom(tree_pkg_ctx *pkg_ctx, bool complete)
 				if (pkg_ctx->slot == NULL) {
 					meta = tree_pkg_read(pkg_ctx);
 					if (meta != NULL) {
-						if (meta->SLOT != NULL) {
-							pkg_ctx->slot = xstrdup(meta->SLOT);
+						if (meta->Q_SLOT != NULL) {
+							pkg_ctx->slot = xstrdup(meta->Q_SLOT);
 							pkg_ctx->slot_len = strlen(pkg_ctx->slot);
 						}
 					}
@@ -1247,8 +1349,8 @@ tree_get_atom(tree_pkg_ctx *pkg_ctx, bool complete)
 				if (pkg_ctx->repo == NULL && ctx->cachetype == CACHE_BINPKGS) {
 					if (meta == NULL)
 						meta = tree_pkg_read(pkg_ctx);
-					if (meta != NULL && meta->repository != NULL) {
-						pkg_ctx->repo = xstrdup(meta->repository);
+					if (meta != NULL && meta->Q_repository != NULL) {
+						pkg_ctx->repo = xstrdup(meta->Q_repository);
 						pkg_ctx->repo_len = strlen(pkg_ctx->repo);
 					}
 				}

diff --git a/libq/tree.h b/libq/tree.h
index aacfb14..8a37cbb 100644
--- a/libq/tree.h
+++ b/libq/tree.h
@@ -8,6 +8,7 @@
 
 #include <dirent.h>
 #include <stdbool.h>
+#include <stddef.h>
 
 #include "atom.h"
 #include "set.h"
@@ -67,37 +68,38 @@ struct tree_pkg_ctx {
 	int fd;
 	tree_cat_ctx *cat_ctx;
 	depend_atom *atom;
+	tree_pkg_meta *meta;
 };
 
 /* Ebuild data */
 struct tree_pkg_meta {
-	char *_data;
-	char *DEPEND;        /* line 1 */
-	char *RDEPEND;
-	char *SLOT;
-	char *SRC_URI;
-	char *RESTRICT;      /* line 5 */
-	char *HOMEPAGE;
-	char *LICENSE;
-	char *DESCRIPTION;
-	char *KEYWORDS;
-	char *INHERITED;     /* line 10 */
-	char *IUSE;
-	char *CDEPEND;
-	char *PDEPEND;
-	char *PROVIDE;       /* line 14 */
-	char *EAPI;
-	char *PROPERTIES;
+	char *Q__data;
+	char *Q_DEPEND;        /* line 1 */
+	char *Q_RDEPEND;
+	char *Q_SLOT;
+	char *Q_SRC_URI;
+	char *Q_RESTRICT;      /* line 5 */
+	char *Q_HOMEPAGE;
+	char *Q_LICENSE;
+	char *Q_DESCRIPTION;
+	char *Q_KEYWORDS;
+	char *Q_INHERITED;     /* line 10 */
+	char *Q_IUSE;
+	char *Q_CDEPEND;
+	char *Q_PDEPEND;
+	char *Q_PROVIDE;       /* line 14 */
+	char *Q_EAPI;
+	char *Q_PROPERTIES;
 	/* These are MD5-Cache only */
-	char *DEFINED_PHASES;
-	char *REQUIRED_USE;
-	char *BDEPEND;
-	char *_eclasses_;
-	char *_md5_;
+	char *Q_DEFINED_PHASES;
+	char *Q_REQUIRED_USE;
+	char *Q_BDEPEND;
+	char *Q__eclasses_;
+	char *Q__md5_;
 	/* binpkgs/vdb */
-	char *CONTENTS;
-	char *USE;
-	char *repository;
+	char *Q_CONTENTS;
+	char *Q_USE;
+	char *Q_repository;
 };
 
 /* Metadata.xml */
@@ -132,6 +134,9 @@ FILE *tree_pkg_vdb_fopenat(tree_pkg_ctx *pkg_ctx, const char *file,
 bool tree_pkg_vdb_eat(tree_pkg_ctx *pkg_ctx, const char *file, char **bufptr, size_t *buflen);
 tree_pkg_meta *tree_pkg_read(tree_pkg_ctx *pkg_ctx);
 void tree_close_meta(tree_pkg_meta *cache);
+char *tree_pkg_meta_get_int(tree_pkg_ctx *pkg_ctx, size_t offset, const char *key);
+#define tree_pkg_meta_get(P,X) \
+	tree_pkg_meta_get_int(P, offsetof(tree_pkg_meta, Q_##X), #X)
 tree_metadata_xml *tree_pkg_metadata(tree_pkg_ctx *pkg_ctx);
 void tree_close_metadata(tree_metadata_xml *meta_ctx);
 void tree_close_pkg(tree_pkg_ctx *pkg_ctx);

diff --git a/qdepends.c b/qdepends.c
index 6f89835..9969d90 100644
--- a/qdepends.c
+++ b/qdepends.c
@@ -114,7 +114,6 @@ qdepends_results_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 	int ret = 0;
 	dep_node *dep_tree;
 	char **d;
-	tree_pkg_meta *meta = NULL;
 	char *depstr;
 
 	/* matrix consists of:
@@ -155,27 +154,17 @@ qdepends_results_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 	xarrayfree_int(state->deps);
 	clear_set(state->udeps);
 
-	if (state->qmode & QMODE_TREE)
-		if ((meta = tree_pkg_read(pkg_ctx)) == NULL)
-			return ret;
 	dfile = depend_files;
 	for (i = QMODE_DEPEND; i <= QMODE_BDEPEND; i <<= 1, dfile++) {
 		if (!(state->qmode & i))
 			continue;
 
-		if (state->qmode & QMODE_INSTALLED) {
-			if (!tree_pkg_vdb_eat(pkg_ctx, *dfile,
-						&state->depend, &state->depend_len))
-				continue;
-			depstr = state->depend;
-		} else {
-			depstr = i == 1<<0 ? meta->DEPEND :
-					 i == 1<<1 ? meta->RDEPEND :
-					 i == 1<<2 ? meta->PDEPEND :
-					 i == 1<<3 ? meta->BDEPEND : NULL;
-			if (depstr == NULL)
-				continue;
-		}
+		depstr = i == 1<<0 ? tree_pkg_meta_get(pkg_ctx, DEPEND) :
+				 i == 1<<1 ? tree_pkg_meta_get(pkg_ctx, RDEPEND) :
+				 i == 1<<2 ? tree_pkg_meta_get(pkg_ctx, PDEPEND) :
+				 i == 1<<3 ? tree_pkg_meta_get(pkg_ctx, BDEPEND) : NULL;
+		if (depstr == NULL)
+			continue;
 		dep_tree = dep_grow_tree(depstr);
 		if (dep_tree == NULL)
 			continue;
@@ -188,10 +177,13 @@ qdepends_results_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 				tree_pkg_ctx *vpkg =
 					tree_open_pkg(vcat, pkg_ctx->name);
 				if (vpkg != NULL) {
-					if (tree_pkg_vdb_eat(vpkg, *dfile,
-							&state->depend, &state->depend_len))
-					{
-						dep_node *dep_vdb = dep_grow_tree(state->depend);
+					depstr = i == 1<<0 ? tree_pkg_meta_get(vpkg, DEPEND) :
+							 i == 1<<1 ? tree_pkg_meta_get(vpkg, RDEPEND) :
+							 i == 1<<2 ? tree_pkg_meta_get(vpkg, PDEPEND) :
+							 i == 1<<3 ? tree_pkg_meta_get(vpkg, BDEPEND) :
+							 NULL;
+					if (depstr != NULL) {
+						dep_node *dep_vdb = dep_grow_tree(depstr);
 						if (dep_vdb != NULL)
 							dep_flatten_tree(dep_vdb, state->deps);
 					}
@@ -299,8 +291,6 @@ int qdepends_main(int argc, char **argv)
 		.deps = deps,
 		.udeps = create_set(),
 		.qmode = 0,
-		.depend = NULL,
-		.depend_len = 0,
 		.format = "%[CATEGORY]%[PF]",
 		.vdb = NULL,
 	};

diff --git a/qkeyword.c b/qkeyword.c
index 4e84ebd..70f75de 100644
--- a/qkeyword.c
+++ b/qkeyword.c
@@ -643,7 +643,6 @@ qkeyword_results_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 	qkeyword_data *data = (qkeyword_data *)priv;
 	char buf[_Q_PATH_MAX];
 	depend_atom *patom = NULL;
-	tree_pkg_meta *meta;
 	tree_metadata_xml *metadata;
 	struct elist *emailw;
 	int ret;
@@ -679,11 +678,8 @@ qkeyword_results_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 	}
 
 	keywords = data->keywordsbuf;
-	meta = tree_pkg_read(pkg_ctx);
-	if (meta == NULL)
-		return EXIT_FAILURE;
 
-	if (read_keywords(meta->KEYWORDS, keywords) < 0) {
+	if (read_keywords(tree_pkg_meta_get(pkg_ctx, KEYWORDS), keywords) < 0) {
 		if (verbose)
 			warn("Failed to read keywords for %s%s/%s%s%s",
 				BOLD, pkg_ctx->cat_ctx->name, BLUE, pkg_ctx->name, NORM);

diff --git a/qlist.c b/qlist.c
index 3f20ced..1d4862f 100644
--- a/qlist.c
+++ b/qlist.c
@@ -329,45 +329,14 @@ struct qlist_opt_state {
 	const char *fmt;
 };
 
-struct qlist_xpakcbctx {
-	const char *key;
-	char *retdata;
-	size_t retlen;
-};
-
-static void
-_qlist_xpakcb(
-	void *ctx,
-	char *pathname,
-	int pathname_len,
-	int data_offset,
-	int data_len,
-	char *data)
-{
-	struct qlist_xpakcbctx *xctx = ctx;
-	(void)pathname_len;
-
-	/* see if this path matches what we're looking for */
-	if (strcmp(pathname, xctx->key) != 0)
-		return;
-
-	xctx->retdata = xrealloc(xctx->retdata, data_len + 1);
-	memcpy(xctx->retdata, data + data_offset, data_len + 1);
-	xctx->retlen = data_len;
-}
-
 static int
 qlist_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 {
 	struct qlist_opt_state *state = priv;
 	int i;
-	FILE *fp;
+	char *contents;
+	char *line;
 	depend_atom *atom;
-	struct qlist_xpakcbctx cbctx = {
-		.key = "CONTENTS",
-		.retdata = NULL,
-		.retlen = 0,
-	};
 
 	/* see if this cat/pkg is requested */
 	if (!state->all) {
@@ -392,38 +361,15 @@ qlist_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 		printf("%s %sCONTENTS%s:\n",
 				atom_format(state->fmt, atom), DKBLUE, NORM);
 
-	if (state->do_binpkgs) {
-		char xpak[_Q_PATH_MAX];
-		int ret;
-		snprintf(xpak, sizeof(xpak), "%s/%s/%s/%s-%s.tbz2",
-				portroot, pkgdir, atom->CATEGORY, atom->PN,
-				atom->PR_int > 0 ? atom->PVR : atom->PV);
-		ret = xpak_extract(xpak, &cbctx, &_qlist_xpakcb);
-		if (ret != 0 || cbctx.retdata == NULL)
-			fp = NULL;
-		else
-#ifdef HAVE_FMEMOPEN
-			fp = fmemopen(cbctx.retdata, cbctx.retlen, "r");
-#else
-		{
-			/* resort to writing a file in tmpspace */
-			fp = tmpfile();
-			if (fp != NULL) {
-				fwrite(cbctx.retdata, 1, cbctx.retlen, fp);
-				fseek(fp, 0, SEEK_SET);
-			}
-		}
-#endif
-	} else {
-		fp = tree_pkg_vdb_fopenat_ro(pkg_ctx, "CONTENTS");
-	}
-	if (fp == NULL)
+	if ((contents = tree_pkg_meta_get(pkg_ctx, CONTENTS)) == NULL)
 		return 1;
 
-	while (getline(&state->buf, &state->buflen, fp) != -1) {
+	while ((line = strtok(contents, "\n")) != NULL) {
 		contents_entry *e;
 
-		e = contents_parse_line(state->buf);
+		contents = NULL;  /* for strtok */
+
+		e = contents_parse_line(line);
 		if (!e)
 			continue;
 
@@ -455,9 +401,6 @@ qlist_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 				break;
 		}
 	}
-	fclose(fp);
-	if (state->do_binpkgs && cbctx.retdata != NULL)
-		free(cbctx.retdata);
 
 	return 1;
 }

diff --git a/qsearch.c b/qsearch.c
index d6470f6..a26e2d6 100644
--- a/qsearch.c
+++ b/qsearch.c
@@ -66,7 +66,6 @@ qsearch_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 
 	struct qsearch_state *state = (struct qsearch_state *)priv;
 	depend_atom *atom;
-	tree_pkg_meta *meta;
 	char *desc;
 	bool match;
 
@@ -84,17 +83,13 @@ qsearch_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 		match = true;
 
 	desc = NULL;
-	meta = NULL;
 	if ((match && (state->show_homepage || state->show_desc)) ||
 			(!match && state->search_desc))
 	{
-		meta = tree_pkg_read(pkg_ctx);
-		if (meta != NULL) {
-			if (state->show_homepage)
-				desc = meta->HOMEPAGE;
-			else if (state->show_desc)
-				desc = meta->DESCRIPTION;
-		}
+		if (state->show_homepage)
+			desc = tree_pkg_meta_get(pkg_ctx, HOMEPAGE);
+		else if (state->show_desc)
+			desc = tree_pkg_meta_get(pkg_ctx, DESCRIPTION);
 	}
 
 	if (!match && state->search_desc && desc != NULL &&
@@ -109,9 +104,6 @@ qsearch_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 				(state->show_name ? "" : desc ? desc : ""));
 	}
 
-	if (meta != NULL)
-		tree_close_meta(meta);
-
 	if (last_atom != NULL)
 		atom_implode(last_atom);
 	last_atom = atom;

diff --git a/quse.c b/quse.c
index df8626e..be34e48 100644
--- a/quse.c
+++ b/quse.c
@@ -412,7 +412,6 @@ quse_results_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 	struct quse_state *state = (struct quse_state *)priv;
 	depend_atom *atom = NULL;  /* pacify compiler */
 	char buf[8192];
-	tree_pkg_meta *meta;
 	set *use = NULL;
 	bool match;
 	char *p;
@@ -439,52 +438,38 @@ quse_results_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 		}
 	}
 
-	if (state->overlay != NULL) {
-		meta = tree_pkg_read(pkg_ctx);
-		if (meta == NULL)
+	if (!state->do_licence) {
+		if (tree_pkg_meta_get(pkg_ctx, IUSE) == NULL)
 			return 0;
-		if (meta->IUSE == NULL)
-			return 0;
-	} else {
-		size_t dummy;
-
-		meta = xzalloc(sizeof(*meta));
 
-		dummy = 0;
-		if (!tree_pkg_vdb_eat(pkg_ctx, "IUSE", &meta->IUSE, &dummy)) {
-			free(meta);
-			return 0;
+		if (state->do_describe) {
+			portdirfd = openat(pkg_ctx->cat_ctx->ctx->portroot_fd,
+					state->overlay == NULL ? main_overlay : state->overlay,
+					O_RDONLY | O_CLOEXEC | O_PATH);
+			if (portdirfd == -1)
+				return 0;
 		}
 
-		dummy = 0;
-		tree_pkg_vdb_eat(pkg_ctx, "LICENSE", &meta->LICENSE, &dummy);
-
-		s = NULL;
-		dummy = 0;
-		tree_pkg_vdb_eat(pkg_ctx, "USE", &s, &dummy);
-		p = s;
-		while ((q = strchr(p, (int)' ')) != NULL) {
-			*q++ = '\0';
-			use = add_set(p, use);
-			p = q;
+		/* available when dealing with VDB or binpkgs */
+		if ((p = tree_pkg_meta_get(pkg_ctx, USE)) != NULL) {
+			while ((q = strchr(p, (int)' ')) != NULL) {
+				*q++ = '\0';
+				use = add_set(p, use);
+				p = q;
+			}
+			if (*p != '\0')
+				use = add_set(p, use);
 		}
-		if (*p != '\0')
-			use = add_set(p, use);
-		free(s);
-	}
-
-	if (state->do_describe) {
-		portdirfd = openat(pkg_ctx->cat_ctx->ctx->portroot_fd,
-				state->overlay == NULL ? main_overlay : state->overlay,
-				O_RDONLY | O_CLOEXEC | O_PATH);
-		if (portdirfd == -1)
+	} else {
+		if (tree_pkg_meta_get(pkg_ctx, LICENSE) == NULL)
 			return 0;
 	}
 
 	maxlen = 0;
 	cnt = 0;
 	match = false;
-	q = p = state->do_licence ? meta->LICENSE : meta->IUSE;
+	q = p = state->do_licence ?
+		tree_pkg_meta_get(pkg_ctx, LICENSE) : tree_pkg_meta_get(pkg_ctx, IUSE);
 	buf[0] = '\0';
 	v = buf;
 	w = buf + sizeof(buf);
@@ -567,7 +552,7 @@ quse_results_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 
 			printf("%s\n", atom_format(state->fmt, atom));
 
-			q = p = meta->IUSE;
+			q = p = tree_pkg_meta_get(pkg_ctx, IUSE);
 			buf[0] = '\0';
 			v = buf;
 			w = buf + sizeof(buf);
@@ -652,16 +637,8 @@ quse_results_cb(tree_pkg_ctx *pkg_ctx, void *priv)
 		}
 	}
 
-	if (state->overlay != NULL) {
-		tree_close_meta(meta);
-	} else {
-		free(meta->IUSE);
-		if (meta->LICENSE != NULL)
-			free(meta->LICENSE);
-		free(meta);
-		if (use != NULL)
-			free_set(use);
-	}
+	if (use != NULL)
+		free_set(use);
 	if (state->do_describe)
 		close(portdirfd);