emo/xbps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

xbps-checkvers: use proplib data structures and add cache file

Browse Source
This commit is contained in:
Duncaen
2019-06-14 21:12:51 +02:00
committed by Duncan Overbruck
parent 26cc209225
commit 3805fd5297
2 changed files with 157 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

429
bin/xbps-checkvers/main.c
View File

@ -60,217 +60,25 @@ do { \
#define _dprintf(...) #define _dprintf(...)
#endif #endif
#define SBUFSZ 128
#define ALIGN(n, a) (((n) + (a) - 1) & ~((a) - 1))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define NEXTSZ(o, r) ALIGN(MAX((o) * 2, (o) + (r)), SBUFSZ)
struct sbuf {
char *mem;
size_t len;
size_t size;
};
typedef struct str_ptr_t {
char *s;
size_t len;
int vmalloc;
} string;
typedef struct _map_item_t {
string k, v;
size_t i;
} map_item_t;
typedef struct _map_t {
size_t size, len;
map_item_t *items;
} map_t;
typedef struct _rcv_t { typedef struct _rcv_t {
const char *prog, *fname; const char *prog, *fname;
char *input, *ptr, *xbps_conf, *rootdir, *distdir, *pkgdir; char *input, *ptr, *xbps_conf, *rootdir, *distdir, *pkgdir;
uint8_t have_vars; uint8_t have_vars;
size_t len; size_t len;
map_t *env; xbps_dictionary_t env;
struct xbps_handle xhp;
xbps_dictionary_t pkgd; xbps_dictionary_t pkgd;
xbps_dictionary_t cache;
struct xbps_handle xhp;
bool show_all; bool show_all;
bool manual; bool manual;
bool installed; bool installed;
const char *format; const char *format;
char *cachefile;
} rcv_t; } rcv_t;
typedef int (*rcv_check_func)(rcv_t *); typedef int (*rcv_check_func)(rcv_t *);
typedef int (*rcv_proc_func)(rcv_t *, const char *, rcv_check_func); typedef int (*rcv_proc_func)(rcv_t *, const char *, rcv_check_func);
static void
sbuf_extend(struct sbuf *sb, int newsz)
{
sb->size = newsz;
sb->mem = realloc(sb->mem, newsz);
if (sb->mem == NULL) {
fprintf(stderr, "realloc: %s\n", strerror(errno));
exit(1);
}
}
static struct sbuf *
sbuf_make(void)
{
struct sbuf *sb = calloc(1, sizeof(*sb));
if (sb == NULL) {
fprintf(stderr, "calloc: %s\n", strerror(errno));
exit(1);
}
return sb;
}
static char *
sbuf_buf(struct sbuf *sb)
{
if (!sb->mem)
sbuf_extend(sb, 1);
sb->mem[sb->len] = '\0';
return sb->mem;
}
static size_t
sbuf_done(struct sbuf *sb, char **dest)
{
size_t len = sb->len;
*dest = sbuf_buf(sb);
free(sb);
return len;
}
static void
sbuf_chr(struct sbuf *sb, int c)
{
if (sb->len + 2 >= sb->size)
sbuf_extend(sb, NEXTSZ(sb->size, 1));
sb->mem[sb->len++] = c;
}
static void
sbuf_mem(struct sbuf *sb, const char *src, size_t len)
{
if (sb->len + len + 1 >= sb->size)
sbuf_extend(sb, NEXTSZ(sb->size, len + 1));
memcpy(sb->mem + sb->len, src, len);
sb->len += len;
}
static void
sbuf_str(struct sbuf *sb, const char *src)
{
sbuf_mem(sb, src, strlen(src));
}
#if 0
static void
sbuf_strn(struct sbuf *sb, const char *src, size_t n)
{
sbuf_mem(sb, src, n);
}
#endif
static map_item_t
map_new_item(void)
{
return (map_item_t){ .k = { NULL, 0, 0 }, .v = { NULL, 0, 0 }, .i = 0 };
}
static map_t *
map_create(void)
{
size_t i = 0;
map_t *map = malloc(sizeof(map_t));
if (map == NULL)
return NULL;
map->size = 16;
map->len = 0;
map->items = calloc(map->size, sizeof(map_item_t));
assert(map->items);
for (; i < map->size; i++) {
map->items[i] = map_new_item();
}
return map;
}
static map_item_t
map_find_n(map_t *map, const char *k, size_t n)
{
size_t i = 0;
map_item_t item;
for (i = 0; i < map->len; i++) {
item = map->items[i];
if (item.k.len != 0)
if ((strncmp(k, item.k.s, n) == 0))
break;
}
if (map->len == i)
return map_new_item();
return item;
}
static map_item_t
map_add_n(map_t *map, const char *k, size_t kn, const char *v, size_t vn)
{
size_t i;
map_item_t item;
assert(k);
assert(v);
if (++map->len > map->size) {
map->size += 16;
map->items = realloc(map->items,
sizeof(map_item_t)*(map->size));
assert(map->items);
for (i = map->size - 10; i < map->size; i++) {
map->items[i] = map_new_item();
}
}
item = map_find_n(map, k, kn);
if (item.k.len == 0) {
item = map_new_item();
item.k = (string){ (char *)__UNCONST(k), kn, 0 };
item.i = map->len - 1;
}
if (item.v.vmalloc == 1)
free(item.v.s);
item.v = (string){ (char *)__UNCONST(v), vn, 0 };
map->items[item.i] = item;
return map->items[item.i];
}
static map_item_t
map_find(map_t *map, const char *k)
{
return map_find_n(map, k, strlen(k));
}
static void
map_destroy(map_t *map)
{
size_t i = 0;
while (i < map->len) {
if (map->items[i].v.vmalloc == 1) {
if (map->items[i].v.s != NULL) {
free(map->items[i].v.s);
}
}
i++;
}
free(map->items);
free(map);
}
static int static int
show_usage(const char *prog) show_usage(const char *prog)
{ {
@ -302,6 +110,12 @@ rcv_init(rcv_t *rcv, const char *prog)
rcv->prog = prog; rcv->prog = prog;
rcv->have_vars = 0; rcv->have_vars = 0;
rcv->ptr = rcv->input = NULL; rcv->ptr = rcv->input = NULL;
rcv->cache = xbps_dictionary_internalize_from_file(rcv->cachefile);
if (!rcv->cache)
rcv->cache = xbps_dictionary_create();
assert(rcv->cache);
if (rcv->xbps_conf != NULL) { if (rcv->xbps_conf != NULL) {
xbps_strlcpy(rcv->xhp.confdir, rcv->xbps_conf, sizeof(rcv->xhp.confdir)); xbps_strlcpy(rcv->xhp.confdir, rcv->xbps_conf, sizeof(rcv->xhp.confdir));
} }
@ -315,12 +129,14 @@ rcv_init(rcv_t *rcv, const char *prog)
static void static void
rcv_end(rcv_t *rcv) rcv_end(rcv_t *rcv)
{ {
xbps_dictionary_externalize_to_file(rcv->cache, rcv->cachefile);
if (rcv->input != NULL) { if (rcv->input != NULL) {
free(rcv->input); free(rcv->input);
rcv->input = NULL; rcv->input = NULL;
} }
if (rcv->env != NULL) { if (rcv->env != NULL) {
map_destroy(rcv->env); xbps_object_release(rcv->env);
rcv->env = NULL; rcv->env = NULL;
} }
@ -332,6 +148,7 @@ rcv_end(rcv_t *rcv)
free(rcv->distdir); free(rcv->distdir);
if (rcv->pkgdir != NULL) if (rcv->pkgdir != NULL)
free(rcv->pkgdir); free(rcv->pkgdir);
free(rcv->cachefile);
} }
static bool static bool
@ -377,20 +194,22 @@ rcv_load_file(rcv_t *rcv, const char *fname)
return true; return true;
} }
static size_t static char *
rcv_sh_substitute(rcv_t *rcv, const char *str, size_t len, char **outp) rcv_sh_substitute(rcv_t *rcv, const char *str, size_t len)
{ {
const char *p; const char *p;
char *cmd; char *cmd, *ret;
struct sbuf *out = sbuf_make(); xbps_string_t out = xbps_string_create();
char b[2] = {0};
for (p = str; *p && p < str+len; p++) { for (p = str; *p && p < str+len; p++) {
switch (*p) { switch (*p) {
case '$': case '$':
if (p+1 < str+len) { if (p+1 < str+len) {
char buf[1024] = {0};
const char *ref; const char *ref;
const char *val;
size_t reflen; size_t reflen;
map_item_t item;
p++; p++;
if (*p == '(') { if (*p == '(') {
FILE *fp; FILE *fp;
@ -402,8 +221,10 @@ rcv_sh_substitute(rcv_t *rcv, const char *str, size_t len, char **outp)
cmd = strndup(ref, p-ref); cmd = strndup(ref, p-ref);
if ((fp = popen(cmd, "r")) == NULL) if ((fp = popen(cmd, "r")) == NULL)
goto err2; goto err2;
while ((c = fgetc(fp)) != EOF && c != '\n') while ((c = fgetc(fp)) != EOF && c != '\n') {
sbuf_chr(out, c); *b = c;
xbps_string_append_cstring(out, b);
}
if (pclose(fp) != 0) if (pclose(fp) != 0)
goto err2; goto err2;
free(cmd); free(cmd);
@ -434,20 +255,29 @@ rcv_sh_substitute(rcv_t *rcv, const char *str, size_t len, char **outp)
reflen = p-ref; reflen = p-ref;
p--; p--;
} }
item = map_find_n(rcv->env, ref, reflen); if (reflen) {
if ((strncmp(ref, item.k.s, reflen) == 0)) { if (reflen >= sizeof buf) {
sbuf_mem(out, item.v.s, item.v.len); fprintf(stderr, "out of memory\n");
} else { exit(1);
sbuf_str(out, "NULL"); }
strncpy(buf, ref, reflen);
if (xbps_dictionary_get_cstring_nocopy(rcv->env, buf, &val))
xbps_string_append_cstring(out, val);
else
xbps_string_append_cstring(out, "NULL");
break;
} }
break;
} }
/* fallthrough */ /* fallthrough */
default: default:
sbuf_chr(out, *p); *b = *p;
xbps_string_append_cstring(out, b);
} }
} }
return sbuf_done(out, outp);
ret = xbps_string_cstring(out);
xbps_object_release(out);
return ret;
err1: err1:
fprintf(stderr, "syntax error: in file '%s'\n", rcv->fname); fprintf(stderr, "syntax error: in file '%s'\n", rcv->fname);
@ -470,9 +300,7 @@ static void
rcv_get_pkgver(rcv_t *rcv) rcv_get_pkgver(rcv_t *rcv)
{ {
size_t klen, vlen; size_t klen, vlen;
map_item_t _item; char c, *ptr = rcv->ptr, *e, *p, *k, *v, *comment, *d, *key, *val;
map_item_t *item = NULL;
char c, *ptr = rcv->ptr, *e, *p, *k, *v, *comment, *d;
uint8_t vars = 0; uint8_t vars = 0;
while ((c = *ptr) != '\0') { while ((c = *ptr) != '\0') {
@ -525,22 +353,25 @@ rcv_get_pkgver(rcv_t *rcv)
if (vlen == 0) { if (vlen == 0) {
goto nextline; goto nextline;
} }
_item = map_add_n(rcv->env, k, klen, v, vlen); key = strndup(k, klen);
item = &rcv->env->items[_item.i];
item->v.vmalloc = 0;
assert(item);
assert(item->v.s);
assert(item->v.len);
if ((d = strchr(v, '$')) && d < v+vlen) { if ((d = strchr(v, '$')) && d < v+vlen)
item->v.len = rcv_sh_substitute(rcv, item->v.s, item->v.len, &item->v.s); val = rcv_sh_substitute(rcv, v, vlen);
item->v.vmalloc = 1; else
} val = strndup(v, vlen);
if (rcv->xhp.flags & XBPS_FLAG_DEBUG) {
printf("%s: %.*s %.*s\n", rcv->fname, if (!xbps_dictionary_set(rcv->env, key,
(int)item->k.len-1, item->k.s, xbps_string_create_cstring(val))) {
(int)item->v.len, item->v.s); fprintf(stderr, "error: xbps_dictionary_set");
exit(1);
} }
if (rcv->xhp.flags & XBPS_FLAG_DEBUG)
fprintf(stderr, "%s: %s %s\n", rcv->fname, key, val);
free(key);
free(val);
if (strncmp("pkgname", k, klen) == 0) { if (strncmp("pkgname", k, klen) == 0) {
rcv->have_vars |= GOT_PKGNAME_VAR; rcv->have_vars |= GOT_PKGNAME_VAR;
vars++; vars++;
@ -562,22 +393,73 @@ nextline:
static int static int
rcv_process_file(rcv_t *rcv, const char *fname, rcv_check_func check) rcv_process_file(rcv_t *rcv, const char *fname, rcv_check_func check)
{ {
rcv->env = map_create(); int rv = 0;
if (rcv->env == NULL) { xbps_object_t keysym;
rcv->env = NULL; xbps_object_iterator_t iter;
return EXIT_FAILURE; xbps_dictionary_t d;
} xbps_data_t mtime;
if (!rcv_load_file(rcv, fname)) { const char *pkgname, *version, *revision, *reverts;
map_destroy(rcv->env); struct stat st;
rcv->env = NULL; bool allocenv = false;
return EXIT_FAILURE;
}
rcv_get_pkgver(rcv);
check(rcv);
map_destroy(rcv->env);
rcv->env = NULL;
return 0; if (stat(fname, &st) == -1) {
rv = EXIT_FAILURE;
goto ret;
}
if ((d = xbps_dictionary_get(rcv->cache, fname))) {
mtime = xbps_dictionary_get(d, "mtime");
if (!xbps_data_equals_data(mtime, &st.st_mtim, sizeof st.st_mtim))
goto update;
rcv->env = d;
rcv->have_vars = GOT_PKGNAME_VAR | GOT_VERSION_VAR | GOT_REVISION_VAR;
} else {
update:
if (!rcv_load_file(rcv, fname)) {
rv = EXIT_FAILURE;
goto ret;
}
assert((rcv->env = xbps_dictionary_create()));
allocenv = true;
rcv_get_pkgver(rcv);
if (!xbps_dictionary_get_cstring_nocopy(rcv->env, "pkgname", &pkgname) ||
!xbps_dictionary_get_cstring_nocopy(rcv->env, "version", &version) ||
!xbps_dictionary_get_cstring_nocopy(rcv->env, "revision", &revision)) {
fprintf(stderr, "ERROR: '%s':"
" missing required variable (pkgname, version or revision)!",
fname);
exit(1);
}
if (!d) {
d = xbps_dictionary_create();
xbps_dictionary_set(rcv->cache, fname, d);
}
assert(xbps_dictionary_set_cstring(d, "pkgname", pkgname));
assert(xbps_dictionary_set_cstring(d, "version", version));
assert(xbps_dictionary_set_cstring(d, "revision", revision));
reverts = NULL;
xbps_dictionary_get_cstring_nocopy(rcv->env, "reverts", &reverts);
if (reverts)
assert(xbps_dictionary_set_cstring(d, "reverts", reverts));
mtime = xbps_data_create_data(&st.st_mtim, sizeof st.st_mtim);
assert(xbps_dictionary_set(d, "mtime", mtime));
}
check(rcv);
ret:
if (allocenv) {
iter = xbps_dictionary_iterator(rcv->env);
while ((keysym = xbps_object_iterator_next(iter)))
xbps_object_release(xbps_dictionary_get_keysym(rcv->env, keysym));
xbps_object_iterator_release(iter);
xbps_object_release(rcv->env);
}
rcv->env = NULL;
return rv;
} }
static void static void
@ -594,18 +476,17 @@ rcv_set_distdir(rcv_t *rcv, const char *distdir)
} }
static bool static bool
check_reverts(const char *repover, const map_item_t reverts) check_reverts(const char *repover, const char *reverts)
{ {
bool rv = false; bool rv = false;
char *sreverts, *p; char *sreverts, *p;
size_t len;
if (reverts.v.len == 0 || strlen(repover) < 1) assert(reverts);
return rv; if (!(len = strlen(reverts)))
return false;
sreverts = calloc(reverts.v.len+1, sizeof(char)); assert((sreverts = strdup(reverts)));
assert(sreverts);
strncpy(sreverts, reverts.v.s, reverts.v.len);
sreverts[reverts.v.len] = '\0';
for (p = sreverts; (p = strstr(p, repover));) { for (p = sreverts; (p = strstr(p, repover));) {
/* /*
@ -671,10 +552,9 @@ rcv_printf(rcv_t *rcv, FILE *fp, const char *pkgname, const char *repover,
static int static int
rcv_check_version(rcv_t *rcv) rcv_check_version(rcv_t *rcv)
{ {
map_item_t pkgname, version, revision, reverts;
const char *repover = NULL; const char *repover = NULL;
char srcver[BUFSIZ] = { '\0' }; char srcver[BUFSIZ] = { '\0' };
char pkgn[128]; const char *pkgname, *version, *revision, *reverts;
int sz; int sz;
assert(rcv); assert(rcv);
@ -692,47 +572,41 @@ rcv_check_version(rcv_t *rcv)
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
pkgname = map_find(rcv->env, "pkgname"); if (!xbps_dictionary_get_cstring_nocopy(rcv->env, "pkgname", &pkgname) ||
version = map_find(rcv->env, "version"); !xbps_dictionary_get_cstring_nocopy(rcv->env, "version", &version) ||
revision = map_find(rcv->env, "revision"); !xbps_dictionary_get_cstring_nocopy(rcv->env, "revision", &revision)) {
reverts = map_find(rcv->env, "reverts"); fprintf(stderr, "error:\n");
exit(1);
}
assert(pkgname.v.s); reverts = NULL;
assert(version.v.s); xbps_dictionary_get_cstring_nocopy(rcv->env, "reverts", &reverts);
assert(revision.v.s);
sz = snprintf(pkgn, sizeof pkgn, "%.*s", sz = snprintf(srcver, sizeof srcver, "%s_%s", version, revision);
(int)pkgname.v.len, pkgname.v.s);
if (sz < 0 || (size_t)sz >= sizeof pkgn)
exit(EXIT_FAILURE);
sz = snprintf(srcver, sizeof srcver, "%.*s-%.*s_%.*s",
(int)pkgname.v.len, pkgname.v.s,
(int)version.v.len, version.v.s,
(int)revision.v.len, revision.v.s);
if (sz < 0 || (size_t)sz >= sizeof srcver) if (sz < 0 || (size_t)sz >= sizeof srcver)
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
if (rcv->installed) if (rcv->installed)
rcv->pkgd = xbps_pkgdb_get_pkg(&rcv->xhp, pkgn); rcv->pkgd = xbps_pkgdb_get_pkg(&rcv->xhp, pkgname);
else else
rcv->pkgd = xbps_rpool_get_pkg(&rcv->xhp, pkgn); rcv->pkgd = xbps_rpool_get_pkg(&rcv->xhp, pkgname);
xbps_dictionary_get_cstring_nocopy(rcv->pkgd, "pkgver", &repover); xbps_dictionary_get_cstring_nocopy(rcv->pkgd, "pkgver", &repover);
if (repover)
repover += strlen(pkgname)+1;
if (!repover && rcv->manual) if (!repover && rcv->manual)
; ;
else if (rcv->show_all) else if (rcv->show_all)
; ;
else if (repover && (xbps_cmpver(repover+pkgname.v.len+1, else if (repover && (xbps_cmpver(repover, srcver) < 0 ||
srcver+pkgname.v.len+1) < 0 || (reverts && check_reverts(repover, reverts))))
check_reverts(repover+pkgname.v.len+1, reverts)))
; ;
else else
return 0; return 0;
repover = repover ? repover+pkgname.v.len+1 : "?"; repover = repover ? repover : "?";
rcv_printf(rcv, stdout, pkgn, repover, srcver+pkgname.v.len+1); rcv_printf(rcv, stdout, pkgname, repover, srcver);
return 0; return 0;
} }
@ -864,6 +738,7 @@ main(int argc, char **argv)
rcv_set_distdir(&rcv, distdir); rcv_set_distdir(&rcv, distdir);
free(distdir); free(distdir);
} }
rcv.cachefile = xbps_xasprintf("%s/.xbps-checkvers.plist", rcv.distdir);
argc -= optind; argc -= optind;
argv += optind; argv += optind;
@ -878,7 +753,7 @@ main(int argc, char **argv)
} }
rcv.manual = true; rcv.manual = true;
for (i = 0; i < argc; i++) { for (i = 0; i < argc; i++) {
char tmp[PATH_MAX], *tmpl, *p; char tmp[PATH_MAX] = {0}, *tmpl, *p;
if (strncmp(argv[i], "srcpkgs/", sizeof ("srcpkgs/")-1) == 0) { if (strncmp(argv[i], "srcpkgs/", sizeof ("srcpkgs/")-1) == 0) {
argv[i] += sizeof ("srcpkgs/")-1; argv[i] += sizeof ("srcpkgs/")-1;
} }

10
tests/xbps/xbps-checkvers/checkvers.sh
View File

@ -165,7 +165,7 @@ EOF
cd .. cd ..
xbps-checkvers -R $PWD/some_repo -D $PWD/void-packages 2>out xbps-checkvers -R $PWD/some_repo -D $PWD/void-packages 2>out
atf_check_equal $? 1 atf_check_equal $? 1
atf_check_equal "$(cat out)" "ERROR: 'A/template': missing pkgname variable!" atf_check_equal "$(cat out)" "ERROR: 'A/template': missing required variable (pkgname, version or revision)!"
} }
atf_test_case srcpkg_missing_version atf_test_case srcpkg_missing_version
@ -191,7 +191,7 @@ EOF
cd .. cd ..
xbps-checkvers -R $PWD/some_repo -D $PWD/void-packages 2>out xbps-checkvers -R $PWD/some_repo -D $PWD/void-packages 2>out
atf_check_equal $? 1 atf_check_equal $? 1
atf_check_equal "$(cat out)" "ERROR: 'A/template': missing version variable!" atf_check_equal "$(cat out)" "ERROR: 'A/template': missing required variable (pkgname, version or revision)!"
} }
atf_test_case srcpkg_missing_revision atf_test_case srcpkg_missing_revision
@ -217,7 +217,7 @@ EOF
cd .. cd ..
xbps-checkvers -R $PWD/some_repo -D $PWD/void-packages 2>out xbps-checkvers -R $PWD/some_repo -D $PWD/void-packages 2>out
atf_check_equal $? 1 atf_check_equal $? 1
atf_check_equal "$(cat out)" "ERROR: 'A/template': missing revision variable!" atf_check_equal "$(cat out)" "ERROR: 'A/template': missing required variable (pkgname, version or revision)!"
} }
atf_test_case srcpkg_missing_pkgver atf_test_case srcpkg_missing_pkgver
@ -243,7 +243,7 @@ EOF
cd .. cd ..
xbps-checkvers -R $PWD/some_repo -D $PWD/void-packages 2>out xbps-checkvers -R $PWD/some_repo -D $PWD/void-packages 2>out
atf_check_equal $? 1 atf_check_equal $? 1
atf_check_equal "$(cat out)" "ERROR: 'A/template': missing pkgname variable!" atf_check_equal "$(cat out)" "ERROR: 'A/template': missing required variable (pkgname, version or revision)!"
} }
atf_test_case srcpkg_missing_pkgverrev atf_test_case srcpkg_missing_pkgverrev
@ -269,7 +269,7 @@ EOF
cd .. cd ..
xbps-checkvers -R $PWD/some_repo -D $PWD/void-packages 2>out xbps-checkvers -R $PWD/some_repo -D $PWD/void-packages 2>out
atf_check_equal $? 1 atf_check_equal $? 1
atf_check_equal "$(cat out)" "ERROR: 'A/template': missing pkgname variable!" atf_check_equal "$(cat out)" "ERROR: 'A/template': missing required variable (pkgname, version or revision)!"
} }
atf_test_case srcpkg_with_a_ref atf_test_case srcpkg_with_a_ref