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

[Fabian Groffen]

commit:     b811b9afd740e8f4cc73f096e8c162d5d332aed2
Author:     Fabian Groffen <grobian <AT> gentoo <DOT> org>
AuthorDate: Sun Nov 17 15:01:00 2019 +0000
Commit:     Fabian Groffen <grobian <AT> gentoo <DOT> org>
CommitDate: Sun Nov 17 15:01:00 2019 +0000
URL:        https://gitweb.gentoo.org/proj/portage-utils.git/commit/?id=b811b9af

libq/tree: add support for binpgks and Packages file

This allows to foreach binpkgs (without Packages file index) as well as
use the Packages file to loop over them.

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

 libq/tree.c | 254 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++----
 libq/tree.h |  13 +++-
 2 files changed, 251 insertions(+), 16 deletions(-)

diff --git a/libq/tree.c b/libq/tree.c
index b0d0b5b..427281f 100644
--- a/libq/tree.c
+++ b/libq/tree.c
@@ -21,6 +21,7 @@
 #include "scandirat.h"
 #include "set.h"
 #include "tree.h"
+#include "xpak.h"
 
 #include <ctype.h>
 #include <xalloc.h>
@@ -30,7 +31,7 @@ static int tree_pkg_compar(const void *l, const void *r);
 static tree_ctx *
 tree_open_int(const char *sroot, const char *tdir, bool quiet)
 {
-	tree_ctx *ctx = xmalloc(sizeof(*ctx));
+	tree_ctx *ctx = xzalloc(sizeof(*ctx));
 
 	ctx->portroot_fd = open(sroot, O_RDONLY | O_CLOEXEC | O_PATH);
 	if (ctx->portroot_fd == -1) {
@@ -56,12 +57,8 @@ tree_open_int(const char *sroot, const char *tdir, bool quiet)
 		goto cv_error;
 
 	ctx->do_sort = false;
-	ctx->cat_de = NULL;
 	ctx->catsortfunc = alphasort;
 	ctx->pkgsortfunc = tree_pkg_compar;
-	ctx->repo = NULL;
-	ctx->ebuilddir_ctx = NULL;
-	ctx->ebuilddir_pkg_ctx = NULL;
 	return ctx;
 
  cv_error:
@@ -130,6 +127,24 @@ tree_open_vdb(const char *sroot, const char *svdb)
 	return ret;
 }
 
+static const char binpkg_packages[]  = "Packages";
+tree_ctx *
+tree_open_binpkg(const char *sroot, const char *spkg)
+{
+	tree_ctx *ret = tree_open_int(sroot, spkg, true);
+	char buf[_Q_PATH_MAX];
+
+	if (ret != NULL) {
+		ret->cachetype = CACHE_BINPKGS;
+
+		snprintf(buf, sizeof(buf), "%s%s/%s", sroot, spkg, binpkg_packages);
+		if (eat_file(buf, &ret->pkgs, &ret->pkgslen))
+			ret->cachetype = CACHE_PACKAGES;
+	}
+
+	return ret;
+}
+
 void
 tree_close(tree_ctx *ctx)
 {
@@ -141,6 +156,8 @@ tree_close(tree_ctx *ctx)
 		scandir_free(ctx->cat_de, ctx->cat_cnt);
 	if (ctx->repo != NULL)
 		free(ctx->repo);
+	if (ctx->pkgs != NULL)
+		free(ctx->pkgs);
 	if (ctx->ebuilddir_ctx != NULL)
 		free(ctx->ebuilddir_ctx);
 	free(ctx);
@@ -443,6 +460,13 @@ tree_next_pkg(tree_cat_ctx *cat_ctx)
 				}
 			}
 		} while (ret == NULL);
+	} else if (ctx->cachetype == CACHE_BINPKGS) {
+		char *p = NULL;
+		do {
+			ret = tree_next_pkg_int(cat_ctx);
+		} while (ret != NULL && (p = strstr(ret->name, ".tbz2")) == NULL);
+		if (p != NULL)
+			*p = '\0';
 	} else {
 		ret = tree_next_pkg_int(cat_ctx);
 	}
@@ -805,22 +829,96 @@ err:
 	return NULL;
 }
 
+static void
+tree_read_file_binpkg_xpak_cb(
+	void *ctx,
+	char *pathname,
+	int pathname_len,
+	int data_offset,
+	int data_len,
+	char *data)
+{
+	tree_pkg_meta *m = (tree_pkg_meta *)ctx;
+	char **key;
+	size_t pos;
+	size_t len;
+
+#define match_path(K) \
+	else if (pathname_len == (sizeof(#K) - 1) && strcmp(pathname, #K) == 0) \
+		key = &m->K
+	if (1 == 0); /* dummy for syntax */
+	match_path(DEPEND);
+	match_path(RDEPEND);
+	match_path(SLOT);
+	match_path(SRC_URI);
+	match_path(RESTRICT);
+	match_path(HOMEPAGE);
+	match_path(DESCRIPTION);
+	match_path(KEYWORDS);
+	match_path(INHERITED);
+	match_path(IUSE);
+	match_path(CDEPEND);
+	match_path(PDEPEND);
+	match_path(PROVIDE);
+	match_path(EAPI);
+	match_path(PROPERTIES);
+	match_path(DEFINED_PHASES);
+	match_path(REQUIRED_USE);
+	match_path(BDEPEND);
+	match_path(CONTENTS);
+	match_path(USE);
+	match_path(repository);
+	else
+		return;
+#undef match_path
+
+	/* hijack unused members */
+	pos = (size_t)m->_eclasses_;
+	len = (size_t)m->_md5_;
+
+	/* trim whitespace (mostly trailing newline) */
+	while (isspace((int)data[data_offset + data_len - 1]))
+		data_len--;
+
+	if (len - pos < (size_t)data_len) {
+		len += (((data_len + 1) / BUFSIZ) + 1) * BUFSIZ;
+		m->_data = xrealloc(m->_data, len);
+		m->_md5_ = (char *)len;
+	}
+
+	*key = m->_data + pos;
+	snprintf(*key, len - pos, "%.*s", data_len, data + data_offset);
+	pos += data_len + 1;
+	m->_eclasses_ = (char *)pos;
+}
+
+static tree_pkg_meta *
+tree_read_file_binpkg(tree_pkg_ctx *pkg_ctx)
+{
+	tree_pkg_meta *m = xzalloc(sizeof(tree_pkg_meta));
+
+	xpak_process_fd(pkg_ctx->fd, true, m, tree_read_file_binpkg_xpak_cb);
+	pkg_ctx->fd = -1;  /* closed by xpak_process_fd */
+
+	return m;
+}
+
 tree_pkg_meta *
 tree_pkg_read(tree_pkg_ctx *pkg_ctx)
 {
 	tree_ctx *ctx = pkg_ctx->cat_ctx->ctx;
 
 	if (pkg_ctx->fd == -1) {
-		if (ctx->cachetype != CACHE_EBUILD) {
-			pkg_ctx->fd = openat(pkg_ctx->cat_ctx->fd, pkg_ctx->name,
-					O_RDONLY | O_CLOEXEC);
-		} else {
+		if (ctx->cachetype == CACHE_EBUILD || ctx->cachetype == CACHE_BINPKGS) {
 			char *p = (char *)pkg_ctx->name;
 			p += strlen(p);
 			*p = '.';
 			pkg_ctx->fd = openat(pkg_ctx->cat_ctx->fd, pkg_ctx->name,
 					O_RDONLY | O_CLOEXEC);
 			*p = '\0';
+		} else {
+			pkg_ctx->fd = openat(pkg_ctx->cat_ctx->fd, pkg_ctx->name,
+					O_RDONLY | O_CLOEXEC);
 		}
 		if (pkg_ctx->fd == -1)
 			return NULL;
@@ -832,6 +930,10 @@ tree_pkg_read(tree_pkg_ctx *pkg_ctx)
 		return tree_read_file_pms(pkg_ctx);
 	} else if (ctx->cachetype == CACHE_EBUILD) {
 		return tree_read_file_ebuild(pkg_ctx);
+	} else if (ctx->cachetype == CACHE_BINPKGS) {
+		return tree_read_file_binpkg(pkg_ctx);
+	} else if (ctx->cachetype == CACHE_PACKAGES) {
+		return (tree_pkg_meta *)pkg_ctx->cat_ctx->ctx->pkgs;
 	}
 
 	warn("Unknown metadata cache type!");
@@ -841,8 +943,10 @@ tree_pkg_read(tree_pkg_ctx *pkg_ctx)
 void
 tree_close_meta(tree_pkg_meta *cache)
 {
-	if (!cache)
+	if (cache == NULL)
 		errf("Cache is empty !");
+	if (cache->_data != NULL)
+		free(cache->_data);
 	free(cache);
 }
 
@@ -952,6 +1056,112 @@ tree_close_pkg(tree_pkg_ctx *pkg_ctx)
 	free(pkg_ctx);
 }
 
+static int
+tree_foreach_packages(tree_ctx *ctx, tree_pkg_cb callback, void *priv)
+{
+	char *p = ctx->pkgs;
+	char *q;
+	char *c;
+	size_t len = ctx->pkgslen;
+	int ret = 0;
+
+	/* reused for every entry */
+	tree_cat_ctx *cat = xzalloc(sizeof(tree_cat_ctx));
+	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;
+		for (q = p; len > 0 && *q != '\n'; q++, len--)
+			if (c == NULL && *q == ':')
+				c = q;
+
+		if (len == 0)
+			break;
+
+		/* empty line, end of a block */
+		if (p == q) {
+			/* make callback with populated atom */
+			if (atom != NULL) {
+				/* 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 ? "0" : meta->SLOT;
+				pkg->repo = ctx->repo;
+				pkg->atom = atom;
+
+				/* do call callback with pkg_atom (populate cat and pkg) */
+				ret |= callback(pkg, priv);
+
+				atom_implode(atom);
+			}
+
+			memset(meta, 0, sizeof(meta[0]));
+			atom = NULL;
+			if (len > 0) {  /* hop over \n */
+				p++;
+				len--;
+			}
+			continue;
+		}
+
+		/* skip invalid lines */
+		if (c == NULL || q - c < 3 || c[1] != ' ')
+			continue;
+
+		/* NULL-terminate p and c, file should end with \n */
+		*q = '\0';
+		*c = '\0';
+		c += 2;         /* hop over ": " */
+		if (len > 0) {  /* hop over \n */
+			q++;
+			len--;
+		}
+
+		if (strcmp(p, "REPO") == 0) { /* from global section in older files */
+			ctx->repo = c;
+		} else if (strcmp(p, "CPV") == 0) {
+			if (atom != NULL)
+				atom_implode(atom);
+			atom = atom_explode(c);
+#define match_key(X) match_key2(X,X)
+#define match_key2(X,Y) \
+		} else if (strcmp(p, #X) == 0) { \
+			meta->Y = c
+		match_key(DEFINED_PHASES);
+		match_key(DEPEND);
+		match_key2(DESC, DESCRIPTION);
+		match_key(EAPI);
+		match_key(IUSE);
+		match_key(KEYWORDS);
+		match_key(LICENSE);
+		match_key2(MD5, _md5_);
+		match_key2(SHA1, _eclasses_);
+		match_key(RDEPEND);
+		match_key(SLOT);
+		match_key(USE);
+		match_key(PDEPEND);
+#undef match_key
+#undef match_key2
+		}
+
+		p = q;
+	} while (len > 0);
+
+	/* ensure we don't free a garbage pointer */
+	ctx->repo = NULL;
+
+	return ret;
+}
+
 int
 tree_foreach_pkg(tree_ctx *ctx,
 		tree_pkg_cb callback, void *priv, tree_cat_filter filter,
@@ -964,6 +1174,10 @@ tree_foreach_pkg(tree_ctx *ctx,
 	if (ctx == NULL)
 		return EXIT_FAILURE;
 
+	/* handle Packages (binpkgs index) file separately */
+	if (ctx->cachetype == CACHE_PACKAGES)
+		return tree_foreach_packages(ctx, callback, priv);
+
 	ctx->do_sort = sort;
 	if (catsortfunc != NULL)
 		ctx->catsortfunc = catsortfunc;
@@ -1009,23 +1223,35 @@ tree_get_atom(tree_pkg_ctx *pkg_ctx, bool complete)
 							&pkg_ctx->repo, &pkg_ctx->repo_len);
 				pkg_ctx->atom->REPO = pkg_ctx->repo;
 			}
-		} else { /* metadata or ebuild */
+		} else { /* metadata, ebuild, binpkg or Packages */
+			tree_pkg_meta *meta = NULL;
 			if (pkg_ctx->atom->SLOT == NULL) {
 				if (pkg_ctx->slot == NULL) {
-					tree_pkg_meta *meta = tree_pkg_read(pkg_ctx);
+					meta = tree_pkg_read(pkg_ctx);
 					if (meta != NULL) {
 						if (meta->SLOT != NULL) {
 							pkg_ctx->slot = xstrdup(meta->SLOT);
 							pkg_ctx->slot_len = strlen(pkg_ctx->slot);
 						}
-						tree_close_meta(meta);
 					}
 				}
 				pkg_ctx->atom->SLOT = pkg_ctx->slot;
 			}
 			/* repo is set from the tree, when found */
-			if (pkg_ctx->atom->REPO == NULL)
+			if (pkg_ctx->atom->REPO == NULL) {
+				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);
+						pkg_ctx->repo_len = strlen(pkg_ctx->repo);
+					}
+				}
 				pkg_ctx->atom->REPO = pkg_ctx->repo;
+			}
+
+			if (meta != NULL)
+				tree_close_meta(meta);
 		}
 
 		/* this is a bit atom territory, but since we pulled in SLOT we

diff --git a/libq/tree.h b/libq/tree.h
index c2a30f1..d769b7b 100644
--- a/libq/tree.h
+++ b/libq/tree.h
@@ -18,7 +18,7 @@ typedef struct tree_pkg_ctx      tree_pkg_ctx;
 typedef struct tree_pkg_meta     tree_pkg_meta;
 typedef struct tree_metadata_xml tree_metadata_xml;
 
-/* VDB context */
+/* tree context */
 struct tree_ctx {
 	int portroot_fd;
 	int tree_fd;
@@ -35,11 +35,15 @@ struct tree_ctx {
 		CACHE_METADATA_PMS,
 		CACHE_EBUILD,
 		CACHE_VDB,
+		CACHE_PACKAGES,
+		CACHE_BINPKGS,
 	} cachetype:3;
 	tree_pkg_ctx *ebuilddir_pkg_ctx;
 	tree_cat_ctx *ebuilddir_cat_ctx;
 	tree_ctx *ebuilddir_ctx;
 	char *repo;
+	char *pkgs;
+	size_t pkgslen;
 };
 
 /* Category context */
@@ -90,6 +94,10 @@ struct tree_pkg_meta {
 	char *BDEPEND;
 	char *_eclasses_;
 	char *_md5_;
+	/* binpkgs/vdb */
+	char *CONTENTS;
+	char *USE;
+	char *repository;
 };
 
 /* Metadata.xml */
@@ -104,8 +112,9 @@ struct tree_metadata_xml {
 typedef int (tree_pkg_cb)(tree_pkg_ctx *, void *priv);
 typedef int (tree_cat_filter)(tree_cat_ctx *, void *priv);
 
-tree_ctx *tree_open_vdb(const char *sroot, const char *svdb);
 tree_ctx *tree_open(const char *sroot, const char *portdir);
+tree_ctx *tree_open_vdb(const char *sroot, const char *svdb);
+tree_ctx *tree_open_binpkg(const char *sroot, const char *spkg);
 void tree_close(tree_ctx *ctx);
 int tree_filter_cat(const struct dirent *de);
 tree_cat_ctx *tree_open_cat(tree_ctx *ctx, const char *name);