Radish alpha
H
HardenedBSD-pkg
rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9
HardenedBSD Package Manager
Radicle
Git
Commits › 2f040df
libpkg: add a _Generic pkg_get()
Baptiste Daroussin committed 3 years ago
commit 2f040df43d9d4eb25872deb10cdf1572655eb00f
parent d9c65f6
13 files changed +185 -104
modified libpkg/pkg.h.in
@@ -43,6 +43,7 @@ extern "C" {
#include <stdarg.h>

#include <stdbool.h>

#include <stdio.h>
+ 
#include <stdlib.h>



/* The expected name of the pkg(8) binary executable. */

#ifndef PKG_EXEC_NAME
@@ -556,40 +557,6 @@ typedef enum {
	PKG_BOOLEAN,

} pkg_el_t;
- 
#define pkg_get_string(p, t, v) do { \
- 
	struct pkg_el *e = pkg_get_element(p, t); \
- 
	if (e->type != PKG_STR) abort(); \
- 
	v = e->string; \
- 
	free(e); \
- 
} while (0);
-
- 
#define pkg_get_bool(p, t, v) do { \
- 
	struct pkg_el *e = pkg_get_element(p, t); \
- 
	if (e->type != PKG_BOOLEAN) abort(); \
- 
	v = e->boolean; \
- 
	free(e); \
- 
} while (0);
-
- 
#define pkg_get_int(p, t, v) do { \
- 
	struct pkg_el *e = pkg_get_element(p, t); \
- 
	if (e->type != PKG_INTEGER) abort(); \
- 
	v = e->integer; \
- 
	free(e); \
- 
} while (0);
-
- 
#define pkg_get_kv(p, t, v) do { \
- 
	struct pkg_el *e = pkg_get_element(p, t); \
- 
	if (e->type != PKG_KVLIST) abort(); \
- 
	v = e->kvlist; \
- 
	free(e); \
- 
} while (0);
-
- 
#define pkg_get_stringlist(p, t, v) do { \
- 
	struct pkg_el *e = pkg_get_element(p, t); \
- 
	if (e->type != PKG_STRINGLIST) abort(); \
- 
	v = e->stringlist; \
- 
} while (0);
- 


struct pkg_el {

	union {

		struct pkg_kvlist *kvlist;
@@ -1710,6 +1677,120 @@ struct pkg_stringlist_iterator *pkg_stringlist_iterator(struct pkg_stringlist *l
const char *pkg_stringlist_next(struct pkg_stringlist_iterator *it);

struct pkg_el *pkg_get_element(struct pkg *p, pkg_attr a);
+ 
static inline void
+ 
pkg_get_s(struct pkg *p, pkg_attr a, const char **val)
+ 
{
+ 
	struct pkg_el *e = pkg_get_element(p, a);
+ 
	*val = NULL;
+
+ 
	switch (e->type) {
+ 
	case PKG_STR:
+ 
		*val = e->string;
+ 
		break;
+ 
	case PKG_BOOLEAN:
+ 
		*val = e->boolean ? "true" : "false";
+ 
		break;
+ 
	case PKG_INTEGER:
+ 
		break;
+ 
	case PKG_KVLIST:
+ 
		free(e->stringlist);
+ 
	case PKG_STRINGLIST:
+ 
		free(e->kvlist);
+ 
		break;
+ 
	}
+ 
	free(e);
+ 
};
+
+ 
static inline void
+ 
pkg_get_i(struct pkg *p, pkg_attr a, int64_t *val)
+ 
{
+ 
	struct pkg_el *e = pkg_get_element(p, a);
+ 
	int64_t ret = -1;
+
+ 
	switch (e->type) {
+ 
	case PKG_STR:
+ 
		ret = e->string != NULL;
+ 
		break;
+ 
	case PKG_BOOLEAN:
+ 
		ret = e->boolean;
+ 
		break;
+ 
	case PKG_INTEGER:
+ 
		ret = e->integer;
+ 
		break;
+ 
	case PKG_KVLIST:
+ 
		free(e->stringlist);
+ 
	case PKG_STRINGLIST:
+ 
		free(e->kvlist);
+ 
		break;
+ 
	}
+ 
	free(e);
+ 
	*val = ret;
+ 
};
+
+ 
static inline void
+ 
pkg_get_b(struct pkg *p, pkg_attr a, bool *val)
+ 
{
+ 
	struct pkg_el *e = pkg_get_element(p, a);
+ 
	bool ret = false;
+
+ 
	switch (e->type) {
+ 
	case PKG_STR:
+ 
		ret = e->string != NULL;
+ 
		break;
+ 
	case PKG_BOOLEAN:
+ 
		ret = e->boolean;
+ 
		break;
+ 
	case PKG_INTEGER:
+ 
		ret = e->integer > 0;
+ 
		break;
+ 
	case PKG_KVLIST:
+ 
		free(e->stringlist);
+ 
	case PKG_STRINGLIST:
+ 
		free(e->kvlist);
+ 
		break;
+ 
	}
+ 
	free(e);
+ 
	*val = ret;
+ 
};
+
+ 
static inline void
+ 
pkg_get_kv(struct pkg *p, pkg_attr a, struct pkg_kvlist **val)
+ 
{
+ 
	struct pkg_el *e = pkg_get_element(p, a);
+ 
	struct pkg_kvlist *kv = NULL;
+
+ 
	if (e->type == PKG_KVLIST)
+ 
		kv = e->kvlist;
+ 
	free(e);
+ 
	*val = kv;
+ 
}
+
+ 
static inline void
+ 
pkg_get_sl(struct pkg *p, pkg_attr a, struct pkg_stringlist **val)
+ 
{
+ 
	struct pkg_el *e = pkg_get_element(p, a);
+ 
	struct pkg_stringlist *sl = NULL;
+
+ 
	if (e->type == PKG_STRINGLIST)
+ 
		sl = e->stringlist;
+ 
	free(e);
+ 
	*val = sl;
+ 
}
+ 
static inline void
+ 
pkg_get_invalid(struct pkg *p __unused, pkg_attr a __unused, void *v __unused)
+ 
{
+ 
	fprintf(stderr, "invalid attribute type for pkg_get\n");
+ 
	abort();
+ 
}
+
+ 
#define pkg_get(p, t, a) _Generic((a), \
+ 
	const char **: pkg_get_s, \
+ 
	int64_t *: pkg_get_i, \
+ 
	bool *: pkg_get_b, \
+ 
	struct pkg_kvlist **: pkg_get_kv, \
+ 
	struct pkg_stringlist **: pkg_get_sl, \
+ 
	default: pkg_get_invalid)(p, t, a)
+ 


#ifdef __cplusplus

}

#endif
modified mk/common.mk
@@ -18,11 +18,11 @@ DEPFILES_NONEMPTY= $(DEPFILES) /nonexistent
.SUFFIXES: .pico .in .bin .binin



.c.o:
- 
	$(CC) -Wall -Wextra -std=gnu99 -D_GNU_SOURCE=1 -MT $@ -MD -MP -MF $*.Tpo -o $@ -c $(CFLAGS) $(LOCAL_CFLAGS) $<
+ 
	$(CC) -Wall -Wextra -std=gnu11 -D_GNU_SOURCE=1 -MT $@ -MD -MP -MF $*.Tpo -o $@ -c $(CFLAGS) $(LOCAL_CFLAGS) $<

	mv $*.Tpo $*.Po



.c.pico:
- 
	$(CC) -Wall -Wextra -std=gnu99 -D_GNU_SOURCE=1 -MT $@ -MD -MP -MF $*.Tpico -o $@ -c $(CFLAGS) $(LOCAL_CFLAGS) $(SHOBJ_CFLAGS) $<
+ 
	$(CC) -Wall -Wextra -std=gnu11 -D_GNU_SOURCE=1 -MT $@ -MD -MP -MF $*.Tpico -o $@ -c $(CFLAGS) $(LOCAL_CFLAGS) $(SHOBJ_CFLAGS) $<

	mv $*.Tpico $*.Ppico



.in:
modified src/annotate.c
@@ -142,11 +142,11 @@ static int
do_show(struct pkg *pkg, const char *tag)

{

	struct pkg_kvlist_iterator *kit;
- 
	struct pkg_kvlist *kl;
+ 
	struct pkg_kvlist *kl = NULL;

	struct pkg_kv *note;

	int ret = EPKG_OK;
- 
	pkg_get_kv(pkg, PKG_ATTR_ANNOTATIONS, kl);
+ 
	pkg_get(pkg, PKG_ATTR_ANNOTATIONS, &kl);

	kit = pkg_kvlist_iterator(kl);

	while ((note = pkg_kvlist_next(kit))) {

		if (strcmp(tag, note->key) == 0) {
modified src/audit.c
@@ -79,7 +79,7 @@ add_to_check(pkghash *check, struct pkg *pkg)
{

	const char *uid;
- 
	pkg_get_string(pkg, PKG_ATTR_UNIQUEID, uid);
+ 
	pkg_get(pkg, PKG_ATTR_UNIQUEID, &uid);

	pkghash_safe_add(check, uid, pkg, NULL);

}
@@ -117,12 +117,12 @@ print_recursive_rdeps(pkghash *head, struct pkg *p, pkghash *seen, bool top, ucl
static void

print_issue(struct pkg *p, struct pkg_audit_issue *issue)

{
- 
	const char *version;
+ 
	const char *version = NULL;

	struct pkg_audit_versions_range *vers;

	const struct pkg_audit_entry *e;

	struct pkg_audit_cve *cve;
- 
	pkg_get_string(p, PKG_ATTR_VERSION, version);
+ 
	pkg_get(p, PKG_ATTR_VERSION, &version);



	e = issue->audit;

	if (version == NULL) {
@@ -388,14 +388,14 @@ exec_audit(int argc, char **argv)
			issues = NULL;

			pkg = (struct pkg *) hit.value;

			if (pkg_audit_is_vulnerable(audit, pkg, &issues, quiet)) {
- 
				const char *version;
+ 
				const char *version = NULL;

				const char *name = NULL;

				ucl_object_t *array = NULL;

				vuln ++;



				if (top == NULL) {

					affected += issues->count;
- 
					pkg_get_string(pkg, PKG_ATTR_VERSION, version);
+ 
					pkg_get(pkg, PKG_ATTR_VERSION, &version);

					if (quiet) {

						if (version != NULL)

							pkg_printf("%n-%v\n", pkg, pkg);
@@ -414,8 +414,8 @@ exec_audit(int argc, char **argv)
					if (vuln_objs == NULL)

						vuln_objs = ucl_object_typed_new(UCL_OBJECT);

					obj = ucl_object_typed_new(UCL_OBJECT);
- 
					pkg_get_string(pkg, PKG_ATTR_NAME, name);
- 
					pkg_get_string(pkg, PKG_ATTR_VERSION, version);
+ 
					pkg_get(pkg, PKG_ATTR_NAME, &name);
+ 
					pkg_get(pkg, PKG_ATTR_VERSION, &version);

					if (version != NULL)

						ucl_object_insert_key(obj, ucl_object_fromstring(version), "version", 7 , false);

					ucl_object_insert_key(obj, ucl_object_fromint(issues->count), "issue_count", 11, false);
@@ -437,7 +437,7 @@ exec_audit(int argc, char **argv)
					pkghash *seen = pkghash_new();



					if (name == NULL)
- 
						pkg_get_string(pkg, PKG_ATTR_NAME, name);
+ 
						pkg_get(pkg, PKG_ATTR_NAME, &name);

					if (top == NULL) {

						printf("  Packages that depend on %s: ", name);

					} else {
modified src/check.c
@@ -59,7 +59,7 @@ check_deps(struct pkgdb *db, struct pkg *p, deps_entries *dh, bool noinstall, xs
	struct pkgdb_it *it;

	const char *buf;

	int nbpkgs = 0;
- 
	struct pkg_stringlist	*sl;
+ 
	struct pkg_stringlist *sl = NULL;

	struct pkg_stringlist_iterator	*slit;



	assert(db != NULL);
@@ -79,7 +79,7 @@ check_deps(struct pkgdb *db, struct pkg *p, deps_entries *dh, bool noinstall, xs
	}



	/* checking libraries required */
- 
	pkg_get_stringlist(p, PKG_ATTR_SHLIBS_REQUIRED, sl);
+ 
	pkg_get(p, PKG_ATTR_SHLIBS_REQUIRED, &sl);

	slit = pkg_stringlist_iterator(sl);

	while ((buf = pkg_stringlist_next(slit))) {

		it = pkgdb_query_shlib_provide(db, buf);
@@ -99,7 +99,7 @@ check_deps(struct pkgdb *db, struct pkg *p, deps_entries *dh, bool noinstall, xs


	/* checking requires */

	buf = NULL;
- 
	pkg_get_stringlist(p, PKG_ATTR_REQUIRES, sl);
+ 
	pkg_get(p, PKG_ATTR_REQUIRES, &sl);

	slit = pkg_stringlist_iterator(sl);

	while ((buf = pkg_stringlist_next(slit))) {

		it = pkgdb_query_provide(db, buf);
modified src/clean.c
@@ -154,7 +154,7 @@ populate_sums(struct pkgdb *db)
	suml = pkghash_new();

	it = pkgdb_repo_search(db, "*", MATCH_GLOB, FIELD_NAME, FIELD_NONE, NULL);

	while (pkgdb_it_next(it, &p, PKG_LOAD_BASIC) == EPKG_OK) {
- 
		pkg_get_string(p, PKG_ATTR_CKSUM, sum);
+ 
		pkg_get(p, PKG_ATTR_CKSUM, &sum);

		slen = MIN(strlen(sum), PKG_FILE_CKSUM_CHARS);

		cksum = strndup(sum, slen);

		pkghash_safe_add(suml, cksum, NULL, NULL);
modified src/event.c
@@ -539,7 +539,7 @@ event_callback(void *data, struct pkg_event *ev)
	struct cleanup *evtmp;

	int *debug = data;

	struct pkg_event_conflict *cur_conflict;
- 
	const char *filename, *reponame;
+ 
	const char *filename, *reponame = NULL;



	if (msg_buf == NULL) {

		msg_buf = xstring_new();
@@ -876,14 +876,14 @@ event_callback(void *data, struct pkg_event *ev)
		pkg_fprintf(conflicts->fp, "  - %n-%v",

		    ev->e_conflicts.p1, ev->e_conflicts.p1);

		if (pkg_repos_total_count() > 1) {
- 
			pkg_get_string(ev->e_conflicts.p1, PKG_ATTR_REPONAME, reponame);
+ 
			pkg_get(ev->e_conflicts.p1, PKG_ATTR_REPONAME, &reponame);

			fprintf(conflicts->fp, " [%s]",

			    reponame == NULL ? "installed" : reponame);

		}

		pkg_fprintf(conflicts->fp, " conflicts with %n-%v",

		    ev->e_conflicts.p2, ev->e_conflicts.p2);

		if (pkg_repos_total_count() > 1) {
- 
			pkg_get_string(ev->e_conflicts.p2, PKG_ATTR_REPONAME, reponame);
+ 
			pkg_get(ev->e_conflicts.p2, PKG_ATTR_REPONAME, &reponame);

			fprintf(conflicts->fp, " [%s]",

			    reponame == NULL ? "installed" : reponame);

		}
modified src/info.c
@@ -448,7 +448,7 @@ exec_info(int argc, char **argv)
			gotone = true;

			const char *version;
- 
			pkg_get_string(pkg, PKG_ATTR_VERSION, version);
+ 
			pkg_get(pkg, PKG_ATTR_VERSION, &version);

			if (pkgversion != NULL) {

				switch (pkg_version_cmp(version, pkgversion)) {

				case -1:
modified src/query.c
@@ -80,9 +80,9 @@ static struct query_flags accepted_query_flags[] = {
static void

format_str(struct pkg *pkg, xstring *dest, const char *qstr, const void *data)

{
- 
	bool automatic;
- 
	bool locked;
- 
	bool vital;
+ 
	bool automatic = false;
+ 
	bool locked = false;
+ 
	bool vital = false;



	xstring_reset(dest);
@@ -115,11 +115,11 @@ format_str(struct pkg *pkg, xstring *dest, const char *qstr, const void *data)
				pkg_fprintf(dest->fp, "%w", pkg);

				break;

			case 'a':
- 
				pkg_get_bool(pkg, PKG_ATTR_AUTOMATIC, automatic);
+ 
				pkg_get(pkg, PKG_ATTR_AUTOMATIC, &automatic);

				fprintf(dest->fp, "%d", automatic);

				break;

			case 'k':
- 
				pkg_get_bool(pkg, PKG_ATTR_LOCKED, locked);
+ 
				pkg_get(pkg, PKG_ATTR_LOCKED, &locked);

				fprintf(dest->fp, "%d", locked);

				break;

			case 't':
@@ -295,7 +295,7 @@ format_str(struct pkg *pkg, xstring *dest, const char *qstr, const void *data)
					pkg_fprintf(dest->fp, "%M", pkg);

				break;

			case 'V':
- 
				pkg_get_bool(pkg, PKG_ATTR_VITAL, vital);
+ 
				pkg_get(pkg, PKG_ATTR_VITAL, &vital);

				fprintf(dest->fp, "%d", vital);

				break;

			case 'X':
@@ -346,11 +346,11 @@ print_query(struct pkg *pkg, char *qstr, char multiline)
	struct pkg_option	*option = NULL;

	struct pkg_file		*file   = NULL;

	struct pkg_dir		*dir    = NULL;
- 
	const char		*str;
- 
	struct pkg_kv		*kv;
- 
	struct pkg_stringlist	*sl;
+ 
	const char		*str = NULL;
+ 
	struct pkg_kv		*kv = NULL;
+ 
	struct pkg_stringlist	*sl = NULL;

	struct pkg_stringlist_iterator	*slit;
- 
	struct pkg_kvlist	*kl;
+ 
	struct pkg_kvlist	*kl = NULL;

	struct pkg_kvlist_iterator	*kit;



	output = xstring_new();
@@ -369,7 +369,7 @@ print_query(struct pkg *pkg, char *qstr, char multiline)
		}

		break;

	case 'C':
- 
		pkg_get_stringlist(pkg, PKG_ATTR_CATEGORIES, sl);
+ 
		pkg_get(pkg, PKG_ATTR_CATEGORIES, &sl);

		slit = pkg_stringlist_iterator(sl);

		while ((str = pkg_stringlist_next(slit))) {

			format_str(pkg, output, qstr, str);
@@ -397,7 +397,7 @@ print_query(struct pkg *pkg, char *qstr, char multiline)
		}

		break;

	case 'L':
- 
		pkg_get_stringlist(pkg, PKG_ATTR_LICENSES, sl);
+ 
		pkg_get(pkg, PKG_ATTR_LICENSES, &sl);

		slit = pkg_stringlist_iterator(sl);

		while ((str = pkg_stringlist_next(slit))) {

			format_str(pkg, output, qstr, str);
@@ -407,7 +407,7 @@ print_query(struct pkg *pkg, char *qstr, char multiline)
		free(sl);

		break;

	case 'U':
- 
		pkg_get_stringlist(pkg, PKG_ATTR_USERS, sl);
+ 
		pkg_get(pkg, PKG_ATTR_USERS, &sl);

		slit = pkg_stringlist_iterator(sl);

		while ((str = pkg_stringlist_next(slit))) {

			format_str(pkg, output, qstr, str);
@@ -415,7 +415,7 @@ print_query(struct pkg *pkg, char *qstr, char multiline)
		}

		break;

	case 'G':
- 
		pkg_get_stringlist(pkg, PKG_ATTR_GROUPS, sl);
+ 
		pkg_get(pkg, PKG_ATTR_GROUPS, &sl);

		slit = pkg_stringlist_iterator(sl);

		while ((str = pkg_stringlist_next(slit))) {

			format_str(pkg, output, qstr, str);
@@ -423,7 +423,7 @@ print_query(struct pkg *pkg, char *qstr, char multiline)
		}

		break;

	case 'B':
- 
		pkg_get_stringlist(pkg, PKG_ATTR_SHLIBS_REQUIRED, sl);
+ 
		pkg_get(pkg, PKG_ATTR_SHLIBS_REQUIRED, &sl);

		slit = pkg_stringlist_iterator(sl);

		while ((str = pkg_stringlist_next(slit))) {

			format_str(pkg, output, qstr, str);
@@ -431,7 +431,7 @@ print_query(struct pkg *pkg, char *qstr, char multiline)
		}

		break;

	case 'b':
- 
		pkg_get_stringlist(pkg, PKG_ATTR_SHLIBS_PROVIDED, sl);
+ 
		pkg_get(pkg, PKG_ATTR_SHLIBS_PROVIDED, &sl);

		slit = pkg_stringlist_iterator(sl);

		while ((str = pkg_stringlist_next(slit))) {

			format_str(pkg, output, qstr, str);
@@ -439,7 +439,7 @@ print_query(struct pkg *pkg, char *qstr, char multiline)
		}

		break;

	case 'A':
- 
		pkg_get_kv(pkg, PKG_ATTR_ANNOTATIONS, kl);
+ 
		pkg_get(pkg, PKG_ATTR_ANNOTATIONS, &kl);

		kit = pkg_kvlist_iterator(kl);

		while ((kv = pkg_kvlist_next(kit))) {

			format_str(pkg, output, qstr, kv);
modified src/set.c
@@ -294,7 +294,7 @@ exec_set(int argc, char **argv)
		while (pkgdb_it_next(it, &pkg, loads) == EPKG_OK) {

			gotone = true;

			if ((sets & AUTOMATIC) == AUTOMATIC) {
- 
				pkg_get_bool(pkg, PKG_ATTR_AUTOMATIC, automatic);
+ 
				pkg_get(pkg, PKG_ATTR_AUTOMATIC, &automatic);

				if (automatic == newautomatic)

					continue;

				if (!rc) {
@@ -312,7 +312,7 @@ exec_set(int argc, char **argv)
				rc = saved_rc;

			}

			if ((sets & VITAL) == VITAL) {
- 
				pkg_get_bool(pkg, PKG_ATTR_VITAL, vital);
+ 
				pkg_get(pkg, PKG_ATTR_VITAL, &vital);

				if (vital == newvital)

					continue;

				if (!rc) {
modified src/upgrade.c
@@ -64,9 +64,9 @@ usage_upgrade(void)
static void

add_to_check(pkghash *check, struct pkg *pkg)

{
- 
	const char *uid;
+ 
	const char *uid = NULL;
- 
	pkg_get_string(pkg, PKG_ATTR_UNIQUEID, uid);
+ 
	pkg_get(pkg, PKG_ATTR_UNIQUEID, &uid);

	pkghash_safe_add(check, uid, pkg, NULL);

}
@@ -141,7 +141,7 @@ check_vulnerable(struct pkg_audit *audit, struct pkgdb *db, int sock)
				issues = NULL;

				pkg = (struct pkg *)hit.value;

				if (pkg_audit_is_vulnerable(audit, pkg, &issues, true)) {
- 
					pkg_get_string(pkg, PKG_ATTR_UNIQUEID, uid);
+ 
					pkg_get(pkg, PKG_ATTR_UNIQUEID, &uid);

					fprintf(out, "%s\n", uid);

					fflush(out);

				}
modified src/utils.c
@@ -337,7 +337,7 @@ print_info(struct pkg * const pkg, uint64_t options)
	int info_num;		/* Number of different data items to print */

	int outflags = PKG_MANIFEST_EMIT_LOCAL_METADATA;
- 
	pkg_get_string(pkg, PKG_ATTR_REPOURL, repourl);
+ 
	pkg_get(pkg, PKG_ATTR_REPOURL, &repourl);



	if (options & INFO_RAW) {

		switch (options & (INFO_RAW_YAML|INFO_RAW_JSON|INFO_RAW_JSON_COMPACT|INFO_RAW_UCL)) {
@@ -692,7 +692,7 @@ set_jobs_summary_pkg(struct pkg_jobs *jobs, struct pkg *new_pkg,
    int64_t *newsize, int64_t *dlsize, pkg_solved_display_t *disp,

    struct jobs_sum_number *sum)

{
- 
	const char *repopath, *destdir;
+ 
	const char *repopath = NULL, *destdir;

	char path[MAXPATHLEN];

	int ret;

	struct stat st;
@@ -701,11 +701,11 @@ set_jobs_summary_pkg(struct pkg_jobs *jobs, struct pkg *new_pkg,


	flatsize = oldflatsize = pkgsize = 0;
- 
	pkg_get_int(new_pkg, PKG_ATTR_FLATSIZE, flatsize);
- 
	pkg_get_int(new_pkg, PKG_ATTR_PKGSIZE, pkgsize);
- 
	pkg_get_string(new_pkg, PKG_ATTR_REPOPATH, repopath);
+ 
	pkg_get(new_pkg, PKG_ATTR_FLATSIZE, &flatsize);
+ 
	pkg_get(new_pkg, PKG_ATTR_PKGSIZE, &pkgsize);
+ 
	pkg_get(new_pkg, PKG_ATTR_REPOPATH, &repopath);

	if (old_pkg != NULL)
- 
		pkg_get_int(old_pkg, PKG_ATTR_FLATSIZE, oldflatsize);
+ 
		pkg_get(old_pkg, PKG_ATTR_FLATSIZE, &oldflatsize);



	it = malloc(sizeof (*it));

	if (it == NULL) {
@@ -811,12 +811,12 @@ set_jobs_summary_pkg(struct pkg_jobs *jobs, struct pkg *new_pkg,
static void

display_summary_item(struct pkg_solved_display *it, int64_t dlsize)

{
- 
	const char *why;
- 
	int64_t pkgsize;
+ 
	const char *why = NULL;
+ 
	int64_t pkgsize = 0;

	char size[8], tlsize[8];

	const char *type;
- 
	pkg_get_int(it->new, PKG_ATTR_PKGSIZE, pkgsize);
+ 
	pkg_get(it->new, PKG_ATTR_PKGSIZE, &pkgsize);



	switch (it->display_type) {

	case PKG_DISPLAY_LOCKED:
@@ -855,7 +855,7 @@ display_summary_item(struct pkg_solved_display *it, int64_t dlsize)
		}

		break;

	case PKG_DISPLAY_DELETE:
- 
		pkg_get_string(it->new, PKG_ATTR_REASON, why);
+ 
		pkg_get(it->new, PKG_ATTR_REASON, &why);

		pkg_printf("\t%n: %v", it->new, it->new);

		if (why != NULL)

			printf(" (%s)", why);
@@ -880,7 +880,7 @@ display_summary_item(struct pkg_solved_display *it, int64_t dlsize)
		printf("\n");

		break;

	case PKG_DISPLAY_REINSTALL:
- 
		pkg_get_string(it->new, PKG_ATTR_REASON, why);
+ 
		pkg_get(it->new, PKG_ATTR_REASON, &why);

		pkg_printf("\t%n-%v", it->new, it->new);

		if (pkg_repos_total_count() > 1)

			pkg_printf(" [%N]", it->new);
modified src/version.c
@@ -81,10 +81,10 @@ print_version(struct pkg *pkg, const char *source, const char *ver,
	      char limchar, unsigned int opt)

{

	const char	*key;
- 
	const char	*version;
+ 
	const char	*version = NULL;

	int		 cout;
- 
	pkg_get_string(pkg, PKG_ATTR_VERSION, version);
+ 
	pkg_get(pkg, PKG_ATTR_VERSION, &version);

	if (ver == NULL) {

		if (source == NULL)

			key = "!";
@@ -398,8 +398,8 @@ do_source_index(unsigned int opt, char limchar, char *pattern, match_t match,
	struct pkgdb	*db = NULL;

	struct pkgdb_it	*it = NULL;

	struct pkg	*pkg = NULL;
- 
	const char	*name;
- 
	const char	*origin;
+ 
	const char	*name = NULL;
+ 
	const char	*origin = NULL;



	if ( (opt & VERSION_SOURCES) != VERSION_SOURCE_INDEX) {

		usage_version();
@@ -424,8 +424,8 @@ do_source_index(unsigned int opt, char limchar, char *pattern, match_t match,
		goto cleanup;



	while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
- 
		pkg_get_string(pkg, PKG_ATTR_NAME, name);
- 
		pkg_get_string(pkg, PKG_ATTR_ORIGIN, origin);
+ 
		pkg_get(pkg, PKG_ATTR_NAME, &name);
+ 
		pkg_get(pkg, PKG_ATTR_ORIGIN, &origin);



		/* If -O was specified, check if this origin matches */

		if ((opt & VERSION_WITHORIGIN) &&
@@ -462,9 +462,9 @@ do_source_remote(unsigned int opt, char limchar, char *pattern, match_t match,
	struct pkgdb_it	*it_remote = NULL;

	struct pkg	*pkg = NULL;

	struct pkg	*pkg_remote = NULL;
- 
	const char	*name;
- 
	const char	*origin;
- 
	const char	*version_remote;
+ 
	const char	*name = NULL;
+ 
	const char	*origin = NULL;
+ 
	const char	*version_remote = NULL;

	bool		is_origin = false;



	int		 retcode = EPKG_OK;
@@ -500,8 +500,8 @@ do_source_remote(unsigned int opt, char limchar, char *pattern, match_t match,
	}



	while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
- 
		pkg_get_string(pkg, PKG_ATTR_NAME, name);
- 
		pkg_get_string(pkg, PKG_ATTR_ORIGIN, origin);
+ 
		pkg_get(pkg, PKG_ATTR_NAME, &name);
+ 
		pkg_get(pkg, PKG_ATTR_ORIGIN, &origin);



		/* If -O was specified, check if this origin matches */

		if ((opt & VERSION_WITHORIGIN) &&
@@ -525,7 +525,7 @@ do_source_remote(unsigned int opt, char limchar, char *pattern, match_t match,


		if (pkgdb_it_next(it_remote, &pkg_remote, PKG_LOAD_BASIC)

		    == EPKG_OK) {
- 
			pkg_get_string(pkg_remote, PKG_ATTR_VERSION, version_remote);
+ 
			pkg_get(pkg_remote, PKG_ATTR_VERSION, &version_remote);

			print_version(pkg, "remote", version_remote, limchar,

			    opt);

		} else {
@@ -720,9 +720,9 @@ do_source_ports(unsigned int opt, char limchar, char *pattern, match_t match,
	struct pkgdb_it	*it = NULL;

	struct pkg	*pkg = NULL;

	xstring		*cmd;
- 
	const char	*name;
- 
	const char	*origin;
- 
	const char	*version;
+ 
	const char	*name = NULL;
+ 
	const char	*origin = NULL;
+ 
	const char	*version = NULL;



	if ( (opt & VERSION_SOURCES) != VERSION_SOURCE_PORTS ) {

		usage_version();
@@ -748,8 +748,8 @@ do_source_ports(unsigned int opt, char limchar, char *pattern, match_t match,
	cmd = xstring_new();



	while (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == EPKG_OK) {
- 
		pkg_get_string(pkg, PKG_ATTR_NAME, name);
- 
		pkg_get_string(pkg, PKG_ATTR_ORIGIN, origin);
+ 
		pkg_get(pkg, PKG_ATTR_NAME, &name);
+ 
		pkg_get(pkg, PKG_ATTR_ORIGIN, &origin);



		/* If -O was specified, check if this origin matches */

		if ((opt & VERSION_WITHORIGIN) &&