From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id E133D138334 for ; Mon, 30 Dec 2019 17:24:54 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 00D7BE0C95; Mon, 30 Dec 2019 17:24:54 +0000 (UTC) Received: from smtp.gentoo.org (mail.gentoo.org [IPv6:2001:470:ea4a:1:5054:ff:fec7:86e4]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id CF1ACE0C95 for ; Mon, 30 Dec 2019 17:24:53 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 3539B34DD92 for ; Mon, 30 Dec 2019 17:24:52 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id B6F3B7A for ; Mon, 30 Dec 2019 17:24:49 +0000 (UTC) From: "Fabian Groffen" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Fabian Groffen" Message-ID: <1577726481.c9e89dfa7cc3ae22bc3c731a3d617e4912bd831a.grobian@gentoo> Subject: [gentoo-commits] proj/portage-utils:master commit in: libq/, / X-VCS-Repository: proj/portage-utils X-VCS-Files: libq/tree.c libq/tree.h qdepends.c qkeyword.c qlist.c qsearch.c quse.c X-VCS-Directories: libq/ / X-VCS-Committer: grobian X-VCS-Committer-Name: Fabian Groffen X-VCS-Revision: c9e89dfa7cc3ae22bc3c731a3d617e4912bd831a X-VCS-Branch: master Date: Mon, 30 Dec 2019 17:24:49 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 10d4e5a0-db36-42b1-ad61-f334850b73d3 X-Archives-Hash: 670e33c232e356df1e94a41618bc203c commit: c9e89dfa7cc3ae22bc3c731a3d617e4912bd831a Author: Fabian Groffen gentoo org> AuthorDate: Mon Dec 30 17:21:21 2019 +0000 Commit: Fabian Groffen gentoo 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 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 #include +#include #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);