Radish alpha
H
HardenedBSD-pkg
rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9
HardenedBSD Package Manager
Radicle
Git
Commits › d9c65f6
pkg_attribute: avoid collision with pkg_list
Baptiste Daroussin committed 3 years ago
commit d9c65f6896cf264bcf9926d553c32d92ddfb1ffb
parent 9cbe456
21 files changed +219 -212
modified libpkg/pkg.c
@@ -190,38 +190,38 @@ pkg_vset(struct pkg *pkg, va_list ap)
	ucl_object_t *obj;



	while ((attr = va_arg(ap, int)) > 0) {
- 
		if (attr >= PKG_NUM_FIELDS || attr <= 0) {
+ 
		if (attr >= PKG_ATTR_NUM_FIELDS || attr <= 0) {

			pkg_emit_error("Bad argument on pkg_set %d", attr);

			return (EPKG_FATAL);

		}



		switch (attr) {
- 
		case PKG_NAME:
+ 
		case PKG_ATTR_NAME:

			free(pkg->name);

			pkg->name = xstrdup(va_arg(ap, const char *));

			free(pkg->uid);

			pkg->uid = xstrdup(pkg->name);

			break;
- 
		case PKG_ORIGIN:
+ 
		case PKG_ATTR_ORIGIN:

			free(pkg->origin);

			pkg->origin = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_VERSION:
+ 
		case PKG_ATTR_VERSION:

			free(pkg->version);

			pkg->version = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_COMMENT:
+ 
		case PKG_ATTR_COMMENT:

			free(pkg->comment);

			pkg->comment = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_DESC:
+ 
		case PKG_ATTR_DESC:

			free(pkg->desc);

			pkg->desc = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_MTREE:
+ 
		case PKG_ATTR_MTREE:

			(void)va_arg(ap, const char *);

			break;
- 
		case PKG_MESSAGE:
+ 
		case PKG_ATTR_MESSAGE:

			tll_free_and_free(pkg->message, pkg_message_free);

			buf = va_arg(ap, const char *);

			if (*buf == '[') {
@@ -233,83 +233,83 @@ pkg_vset(struct pkg *pkg, va_list ap)
				ucl_object_unref(obj);

			}

			break;
- 
		case PKG_ARCH:
+ 
		case PKG_ATTR_ARCH:

			free(pkg->arch);

			pkg->arch = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_ABI:
+ 
		case PKG_ATTR_ABI:

			free(pkg->abi);

			pkg->abi = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_MAINTAINER:
+ 
		case PKG_ATTR_MAINTAINER:

			free(pkg->maintainer);

			pkg->maintainer = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_WWW:
+ 
		case PKG_ATTR_WWW:

			free(pkg->www);

			pkg->www = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_PREFIX:
+ 
		case PKG_ATTR_PREFIX:

			free(pkg->prefix);

			pkg->prefix = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_REPOPATH:
+ 
		case PKG_ATTR_REPOPATH:

			free(pkg->repopath);

			pkg->repopath = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_CKSUM:
+ 
		case PKG_ATTR_CKSUM:

			free(pkg->sum);

			pkg->sum = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_OLD_VERSION:
+ 
		case PKG_ATTR_OLD_VERSION:

			free(pkg->old_version);

			pkg->old_version = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_REPONAME:
+ 
		case PKG_ATTR_REPONAME:

			free(pkg->reponame);

			pkg->reponame = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_REPOURL:
+ 
		case PKG_ATTR_REPOURL:

			free(pkg->repourl);

			pkg->repourl = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_DIGEST:
+ 
		case PKG_ATTR_DIGEST:

			free(pkg->digest);

			pkg->digest = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_REASON:
+ 
		case PKG_ATTR_REASON:

			free(pkg->reason);

			pkg->reason = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_FLATSIZE:
+ 
		case PKG_ATTR_FLATSIZE:

			pkg->flatsize = va_arg(ap, int64_t);

			break;
- 
		case PKG_OLD_FLATSIZE:
+ 
		case PKG_ATTR_OLD_FLATSIZE:

			pkg->old_flatsize = va_arg(ap, int64_t);

			break;
- 
		case PKG_PKGSIZE:
+ 
		case PKG_ATTR_PKGSIZE:

			pkg->pkgsize = va_arg(ap, int64_t);

			break;
- 
		case PKG_LICENSE_LOGIC:
+ 
		case PKG_ATTR_LICENSE_LOGIC:

			pkg->licenselogic = (lic_t)va_arg(ap, int);

			break;
- 
		case PKG_AUTOMATIC:
+ 
		case PKG_ATTR_AUTOMATIC:

			pkg->automatic = (bool)va_arg(ap, int);

			break;
- 
		case PKG_ROWID:
+ 
		case PKG_ATTR_ROWID:

			pkg->id = va_arg(ap, int64_t);

			break;
- 
		case PKG_LOCKED:
+ 
		case PKG_ATTR_LOCKED:

			pkg->locked = (bool)va_arg(ap, int);

			break;
- 
		case PKG_TIME:
+ 
		case PKG_ATTR_TIME:

			pkg->timestamp = va_arg(ap, int64_t);

			break;
- 
		case PKG_DEP_FORMULA:
+ 
		case PKG_ATTR_DEP_FORMULA:

			free(pkg->dep_formula);

			pkg->dep_formula = xstrdup(va_arg(ap, const char *));

			break;
- 
		case PKG_VITAL:
+ 
		case PKG_ATTR_VITAL:

			pkg->vital = (bool)va_arg(ap, int);

			break;

		}
modified libpkg/pkg.h.in
@@ -241,41 +241,48 @@ typedef enum {
 * Used by pkg_get() and pkg_set()

 */

typedef enum {
- 
	PKG_ORIGIN = 1U,
- 
	PKG_NAME,
- 
	PKG_VERSION,
- 
	PKG_COMMENT,
- 
	PKG_DESC,
- 
	PKG_MTREE,
- 
	PKG_MESSAGE,
- 
	PKG_ARCH,
- 
	PKG_ABI,
- 
	PKG_MAINTAINER,
- 
	PKG_WWW,
- 
	PKG_PREFIX,
- 
	PKG_REPOPATH,
- 
	PKG_CKSUM,
- 
	PKG_OLD_VERSION,
- 
	PKG_REPONAME,
- 
	PKG_REPOURL,
- 
	PKG_DIGEST,
- 
	PKG_REASON,
- 
	PKG_FLATSIZE,
- 
	PKG_OLD_FLATSIZE,
- 
	PKG_PKGSIZE,
- 
	PKG_LICENSE_LOGIC,
- 
	PKG_AUTOMATIC,
- 
	PKG_LOCKED,
- 
	PKG_ROWID,
- 
	PKG_TIME,
- 
	PKG_ANNOTATIONS,
- 
	PKG_UNIQUEID,
- 
	PKG_OLD_DIGEST,
- 
	PKG_DEP_FORMULA,
- 
	PKG_VITAL,
- 
	PKG_CATEGORIES,
- 
	PKG_LICENSES,
- 
	PKG_NUM_FIELDS,		/* end of fields */
+ 
	PKG_ATTR_ORIGIN = 1U,
+ 
	PKG_ATTR_NAME,
+ 
	PKG_ATTR_VERSION,
+ 
	PKG_ATTR_COMMENT,
+ 
	PKG_ATTR_DESC,
+ 
	PKG_ATTR_MTREE,
+ 
	PKG_ATTR_MESSAGE,
+ 
	PKG_ATTR_ARCH,
+ 
	PKG_ATTR_ABI,
+ 
	PKG_ATTR_MAINTAINER,
+ 
	PKG_ATTR_WWW,
+ 
	PKG_ATTR_PREFIX,
+ 
	PKG_ATTR_REPOPATH,
+ 
	PKG_ATTR_CKSUM,
+ 
	PKG_ATTR_OLD_VERSION,
+ 
	PKG_ATTR_REPONAME,
+ 
	PKG_ATTR_REPOURL,
+ 
	PKG_ATTR_DIGEST,
+ 
	PKG_ATTR_REASON,
+ 
	PKG_ATTR_FLATSIZE,
+ 
	PKG_ATTR_OLD_FLATSIZE,
+ 
	PKG_ATTR_PKGSIZE,
+ 
	PKG_ATTR_LICENSE_LOGIC,
+ 
	PKG_ATTR_AUTOMATIC,
+ 
	PKG_ATTR_LOCKED,
+ 
	PKG_ATTR_ROWID,
+ 
	PKG_ATTR_TIME,
+ 
	PKG_ATTR_ANNOTATIONS,
+ 
	PKG_ATTR_UNIQUEID,
+ 
	PKG_ATTR_OLD_DIGEST,
+ 
	PKG_ATTR_DEP_FORMULA,
+ 
	PKG_ATTR_VITAL,
+ 
	PKG_ATTR_CATEGORIES,
+ 
	PKG_ATTR_LICENSES,
+ 
	PKG_ATTR_GROUPS,
+ 
	PKG_ATTR_USERS,
+ 
	PKG_ATTR_SHLIBS_REQUIRED,
+ 
	PKG_ATTR_SHLIBS_PROVIDED,
+ 
	PKG_ATTR_PROVIDES,
+ 
	PKG_ATTR_REQUIRES,
+ 
	PKG_ATTR_CONFLICTS,
+ 
	PKG_ATTR_NUM_FIELDS,		/* end of fields */

} pkg_attr;



typedef enum {
modified libpkg/pkg_attributes.c
@@ -219,107 +219,107 @@ pkg_get_element(struct pkg *p, pkg_attr a)
	struct pkg_el *e = xcalloc(1, sizeof(*e));



	switch (a) {
- 
	case PKG_NAME:
+ 
	case PKG_ATTR_NAME:

		e->string = p->name;

		e->type = PKG_STR;

		break;
- 
	case PKG_VERSION:
+ 
	case PKG_ATTR_VERSION:

		e->string = p->version;

		e->type = PKG_STR;

		break;
- 
	case PKG_ORIGIN:
+ 
	case PKG_ATTR_ORIGIN:

		e->string = p->origin;

		e->type = PKG_STR;

		break;
- 
	case PKG_UNIQUEID:
+ 
	case PKG_ATTR_UNIQUEID:

		e->string = p->uid;

		e->type = PKG_STR;

		break;
- 
	case PKG_CKSUM:
+ 
	case PKG_ATTR_CKSUM:

		e->string = p->sum;

		e->type = PKG_STR;

		break;
- 
	case PKG_REPONAME:
+ 
	case PKG_ATTR_REPONAME:

		e->string = p->reponame;

		e->type = PKG_STR;

		break;
- 
	case PKG_REPOPATH:
+ 
	case PKG_ATTR_REPOPATH:

		e->string = p->repopath;

		e->type = PKG_STR;

		break;
- 
	case PKG_REPOURL:
+ 
	case PKG_ATTR_REPOURL:

		e->string = p->repourl;

		e->type = PKG_STR;

		break;
- 
	case PKG_REASON:
+ 
	case PKG_ATTR_REASON:

		e->string = p->reason;

		e->type = PKG_STR;

		break;
- 
	case PKG_AUTOMATIC:
+ 
	case PKG_ATTR_AUTOMATIC:

		e->boolean = p->automatic;

		e->type = PKG_BOOLEAN;

		break;
- 
	case PKG_LOCKED:
+ 
	case PKG_ATTR_LOCKED:

		e->boolean = p->locked;

		e->type = PKG_BOOLEAN;

		break;
- 
	case PKG_VITAL:
+ 
	case PKG_ATTR_VITAL:

		e->boolean = p->vital;

		e->type = PKG_BOOLEAN;

		break;
- 
	case PKG_FLATSIZE:
+ 
	case PKG_ATTR_FLATSIZE:

		e->integer = p->flatsize;

		e->type = PKG_INTEGER;

		break;
- 
	case PKG_OLD_FLATSIZE:
+ 
	case PKG_ATTR_OLD_FLATSIZE:

		e->integer = p->old_flatsize;

		e->type = PKG_INTEGER;

		break;
- 
	case PKG_PKGSIZE:
+ 
	case PKG_ATTR_PKGSIZE:

		e->integer = p->pkgsize;

		e->type = PKG_INTEGER;

		break;
- 
	case PKG_CATEGORIES:
+ 
	case PKG_ATTR_CATEGORIES:

		e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));

		e->stringlist->list = &p->categories;

		e->type = PKG_STRINGLIST;

		break;
- 
	case PKG_ANNOTATIONS:
+ 
	case PKG_ATTR_ANNOTATIONS:

		e->kvlist = xcalloc(1, sizeof(struct pkg_kvlist *));

		e->kvlist->list = &p->annotations;

		e->type = PKG_KVLIST;

		break;
- 
	case PKG_SHLIBS_REQUIRED:
+ 
	case PKG_ATTR_SHLIBS_REQUIRED:

		e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));

		e->stringlist->list = &p->shlibs_required;

		e->type = PKG_STRINGLIST;

		break;
- 
	case PKG_SHLIBS_PROVIDED:
+ 
	case PKG_ATTR_SHLIBS_PROVIDED:

		e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));

		e->stringlist->list = &p->shlibs_provided;

		e->type = PKG_STRINGLIST;

		break;
- 
	case PKG_PROVIDES:
+ 
	case PKG_ATTR_PROVIDES:

		e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));

		e->stringlist->list = &p->provides;

		e->type = PKG_STRINGLIST;

		break;
- 
	case PKG_REQUIRES:
+ 
	case PKG_ATTR_REQUIRES:

		e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));

		e->stringlist->list = &p->requires;

		e->type = PKG_STRINGLIST;

		break;
- 
	case PKG_USERS:
+ 
	case PKG_ATTR_USERS:

		e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));

		e->stringlist->list = &p->users;

		e->type = PKG_STRINGLIST;

		break;
- 
	case PKG_GROUPS:
+ 
	case PKG_ATTR_GROUPS:

		e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));

		e->stringlist->list = &p->groups;

		e->type = PKG_STRINGLIST;

		break;
- 
	case PKG_LICENSES:
+ 
	case PKG_ATTR_LICENSES:

		e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));

		e->stringlist->list = &p->licenses;

		e->type = PKG_STRINGLIST;
modified libpkg/pkg_create.c
@@ -501,7 +501,7 @@ load_metadata(struct pkg *pkg, const char *metadata, const char *plist,


	pkg_load_message_from_file(fd, pkg, "+DISPLAY");

	if (pkg->desc == NULL)
- 
		pkg_set_from_fileat(fd, pkg, PKG_DESC, "+DESC", false);
+ 
		pkg_set_from_fileat(fd, pkg, PKG_ATTR_DESC, "+DESC", false);



	for (i = 0; scripts[i] != NULL; i++) {

		if (faccessat(fd, scripts[i], F_OK, 0) == 0)
modified libpkg/pkgdb_iterator.c
@@ -73,35 +73,35 @@ static struct column_mapping {
		PKG_SQLITE_BOOL

	} pkg_type;

} columns[] = {
- 
	{ "arch",	PKG_ABI, PKG_SQLITE_STRING },
- 
	{ "automatic",	PKG_AUTOMATIC, PKG_SQLITE_BOOL },
- 
	{ "cksum",	PKG_CKSUM, PKG_SQLITE_STRING },
- 
	{ "comment",	PKG_COMMENT, PKG_SQLITE_STRING },
- 
	{ "dbname",	PKG_REPONAME, PKG_SQLITE_STRING },
- 
	{ "dep_formula",	PKG_DEP_FORMULA, PKG_SQLITE_STRING },
- 
	{ "desc",	PKG_DESC, PKG_SQLITE_STRING },
- 
	{ "flatsize",	PKG_FLATSIZE, PKG_SQLITE_INT64 },
- 
	{ "id",		PKG_ROWID, PKG_SQLITE_INT64 },
- 
	{ "licenselogic", PKG_LICENSE_LOGIC, PKG_SQLITE_INT64 },
- 
	{ "locked",	PKG_LOCKED, PKG_SQLITE_BOOL },
- 
	{ "maintainer",	PKG_MAINTAINER, PKG_SQLITE_STRING },
- 
	{ "manifestdigest",	PKG_DIGEST, PKG_SQLITE_STRING },
- 
	{ "message",	PKG_MESSAGE, PKG_SQLITE_STRING },
- 
	{ "name",	PKG_NAME, PKG_SQLITE_STRING },
- 
	{ "oldflatsize", PKG_OLD_FLATSIZE, PKG_SQLITE_INT64 },
- 
	{ "oldversion",	PKG_OLD_VERSION, PKG_SQLITE_STRING },
- 
	{ "origin",	PKG_ORIGIN, PKG_SQLITE_STRING },
- 
	{ "pkgsize",	PKG_PKGSIZE, PKG_SQLITE_INT64 },
- 
	{ "prefix",	PKG_PREFIX, PKG_SQLITE_STRING },
- 
	{ "repopath",	PKG_REPOPATH, PKG_SQLITE_STRING },
- 
	{ "repourl",	PKG_REPOURL, PKG_SQLITE_STRING },
- 
	{ "rowid",	PKG_ROWID, PKG_SQLITE_INT64 },
- 
	{ "time",	PKG_TIME, PKG_SQLITE_INT64 },
- 
	{ "uniqueid",	PKG_UNIQUEID, PKG_SQLITE_STRING },
- 
	{ "version",	PKG_VERSION, PKG_SQLITE_STRING },
- 
	{ "vital",	PKG_VITAL, PKG_SQLITE_BOOL },
+ 
	{ "arch",	PKG_ATTR_ABI, PKG_SQLITE_STRING },
+ 
	{ "automatic",	PKG_ATTR_AUTOMATIC, PKG_SQLITE_BOOL },
+ 
	{ "cksum",	PKG_ATTR_CKSUM, PKG_SQLITE_STRING },
+ 
	{ "comment",	PKG_ATTR_COMMENT, PKG_SQLITE_STRING },
+ 
	{ "dbname",	PKG_ATTR_REPONAME, PKG_SQLITE_STRING },
+ 
	{ "dep_formula",	PKG_ATTR_DEP_FORMULA, PKG_SQLITE_STRING },
+ 
	{ "desc",	PKG_ATTR_DESC, PKG_SQLITE_STRING },
+ 
	{ "flatsize",	PKG_ATTR_FLATSIZE, PKG_SQLITE_INT64 },
+ 
	{ "id",		PKG_ATTR_ROWID, PKG_SQLITE_INT64 },
+ 
	{ "licenselogic", PKG_ATTR_LICENSE_LOGIC, PKG_SQLITE_INT64 },
+ 
	{ "locked",	PKG_ATTR_LOCKED, PKG_SQLITE_BOOL },
+ 
	{ "maintainer",	PKG_ATTR_MAINTAINER, PKG_SQLITE_STRING },
+ 
	{ "manifestdigest",	PKG_ATTR_DIGEST, PKG_SQLITE_STRING },
+ 
	{ "message",	PKG_ATTR_MESSAGE, PKG_SQLITE_STRING },
+ 
	{ "name",	PKG_ATTR_NAME, PKG_SQLITE_STRING },
+ 
	{ "oldflatsize", PKG_ATTR_OLD_FLATSIZE, PKG_SQLITE_INT64 },
+ 
	{ "oldversion",	PKG_ATTR_OLD_VERSION, PKG_SQLITE_STRING },
+ 
	{ "origin",	PKG_ATTR_ORIGIN, PKG_SQLITE_STRING },
+ 
	{ "pkgsize",	PKG_ATTR_PKGSIZE, PKG_SQLITE_INT64 },
+ 
	{ "prefix",	PKG_ATTR_PREFIX, PKG_SQLITE_STRING },
+ 
	{ "repopath",	PKG_ATTR_REPOPATH, PKG_SQLITE_STRING },
+ 
	{ "repourl",	PKG_ATTR_REPOURL, PKG_SQLITE_STRING },
+ 
	{ "rowid",	PKG_ATTR_ROWID, PKG_SQLITE_INT64 },
+ 
	{ "time",	PKG_ATTR_TIME, PKG_SQLITE_INT64 },
+ 
	{ "uniqueid",	PKG_ATTR_UNIQUEID, PKG_SQLITE_STRING },
+ 
	{ "version",	PKG_ATTR_VERSION, PKG_SQLITE_STRING },
+ 
	{ "vital",	PKG_ATTR_VITAL, PKG_SQLITE_BOOL },

	{ "weight",	-1, PKG_SQLITE_INT64 },
- 
	{ "www",	PKG_WWW, PKG_SQLITE_STRING },
+ 
	{ "www",	PKG_ATTR_WWW, PKG_SQLITE_STRING },

	{ NULL,		-1, PKG_SQLITE_STRING }

};
@@ -544,7 +544,7 @@ pkgdb_load_license(sqlite3 *sqlite, struct pkg *pkg)
	assert(pkg != NULL);



	return (load_val(sqlite, pkg, sql, PKG_LOAD_LICENSES,
- 
	    pkg_addlicense, PKG_LICENSES));
+ 
	    pkg_addlicense, PKG_ATTR_LICENSES));

}



static int
@@ -560,7 +560,7 @@ pkgdb_load_category(sqlite3 *sqlite, struct pkg *pkg)
	assert(pkg != NULL);



	return (load_val(sqlite, pkg, sql, PKG_LOAD_CATEGORIES,
- 
	    pkg_addcategory, PKG_CATEGORIES));
+ 
	    pkg_addcategory, PKG_ATTR_CATEGORIES));

}



static int
@@ -578,7 +578,7 @@ pkgdb_load_user(sqlite3 *sqlite, struct pkg *pkg)
	assert(pkg->type == PKG_INSTALLED);



	ret = load_val(sqlite, pkg, sql, PKG_LOAD_USERS,
- 
	    pkg_adduser, PKG_USERS);
+ 
	    pkg_adduser, PKG_ATTR_USERS);



	return (ret);

}
@@ -598,7 +598,7 @@ pkgdb_load_group(sqlite3 *sqlite, struct pkg *pkg)
	assert(pkg->type == PKG_INSTALLED);



	ret = load_val(sqlite, pkg, sql, PKG_LOAD_GROUPS,
- 
	    pkg_addgroup, PKG_GROUPS);
+ 
	    pkg_addgroup, PKG_ATTR_GROUPS);



	return (ret);

}
@@ -616,7 +616,7 @@ pkgdb_load_shlib_required(sqlite3 *sqlite, struct pkg *pkg)
	assert(pkg != NULL);



	return (load_val(sqlite, pkg, sql, PKG_LOAD_SHLIBS_REQUIRED,
- 
	    pkg_addshlib_required, PKG_SHLIBS_REQUIRED));
+ 
	    pkg_addshlib_required, PKG_ATTR_SHLIBS_REQUIRED));

}
@@ -648,7 +648,7 @@ pkgdb_load_annotations(sqlite3 *sqlite, struct pkg *pkg)
		"  ORDER BY tag, value";



	return (load_tag_val(sqlite, pkg, sql, PKG_LOAD_ANNOTATIONS,
- 
		   pkg_addannotation, PKG_ANNOTATIONS));
+ 
		   pkg_addannotation, PKG_ATTR_ANNOTATIONS));

}



static int
@@ -816,7 +816,7 @@ pkgdb_load_conflicts(sqlite3 *sqlite, struct pkg *pkg)
	assert(pkg != NULL);



	return (load_val(sqlite, pkg, sql, PKG_LOAD_CONFLICTS,
- 
			pkg_addconflict, PKG_CONFLICTS));
+ 
			pkg_addconflict, PKG_ATTR_CONFLICTS));

}



static int
@@ -832,7 +832,7 @@ pkgdb_load_provides(sqlite3 *sqlite, struct pkg *pkg)
	assert(pkg != NULL);



	return (load_val(sqlite, pkg, sql, PKG_LOAD_PROVIDES,
- 
	    pkg_addprovide, PKG_PROVIDES));
+ 
	    pkg_addprovide, PKG_ATTR_PROVIDES));

}



static int
@@ -872,28 +872,28 @@ populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {
			}



			switch (column->type) {
- 
			case PKG_ABI:
+ 
			case PKG_ATTR_ABI:

				pkg->abi = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_CKSUM:
+ 
			case PKG_ATTR_CKSUM:

				pkg->sum = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_COMMENT:
+ 
			case PKG_ATTR_COMMENT:

				pkg->comment = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_REPONAME:
+ 
			case PKG_ATTR_REPONAME:

				pkg->reponame = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_DESC:
+ 
			case PKG_ATTR_DESC:

				pkg->desc = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_MAINTAINER:
+ 
			case PKG_ATTR_MAINTAINER:

				pkg->maintainer = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_DIGEST:
+ 
			case PKG_ATTR_DIGEST:

				pkg->digest = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_MESSAGE:
+ 
			case PKG_ATTR_MESSAGE:

				msg = sqlite3_column_text(stmt, icol);

				if (msg) {

					/* A stupid logic to detect legacy pkg message */
@@ -908,34 +908,34 @@ populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {
					}

				}

				break;
- 
			case PKG_NAME:
+ 
			case PKG_ATTR_NAME:

				pkg->name = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_OLD_VERSION:
+ 
			case PKG_ATTR_OLD_VERSION:

				pkg->old_version = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_ORIGIN:
+ 
			case PKG_ATTR_ORIGIN:

				pkg->origin = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_PREFIX:
+ 
			case PKG_ATTR_PREFIX:

				pkg->prefix = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_REPOPATH:
+ 
			case PKG_ATTR_REPOPATH:

				pkg->repopath = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_REPOURL:
+ 
			case PKG_ATTR_REPOURL:

				pkg->repourl = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_UNIQUEID:
+ 
			case PKG_ATTR_UNIQUEID:

				pkg->uid = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_VERSION:
+ 
			case PKG_ATTR_VERSION:

				pkg->version = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_WWW:
+ 
			case PKG_ATTR_WWW:

				pkg->www = xstrdup(sqlite3_column_text(stmt, icol));

				break;
- 
			case PKG_DEP_FORMULA:
+ 
			case PKG_ATTR_DEP_FORMULA:

				pkg->dep_formula = xstrdup(sqlite3_column_text(stmt, icol));

				break;

			default:
@@ -952,31 +952,31 @@ populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {
			}



			switch (column->type) {
- 
			case PKG_AUTOMATIC:
+ 
			case PKG_ATTR_AUTOMATIC:

				pkg->automatic = (bool)sqlite3_column_int64(stmt, icol);

				break;
- 
			case PKG_LOCKED:
+ 
			case PKG_ATTR_LOCKED:

				pkg->locked = (bool)sqlite3_column_int64(stmt, icol);

				break;
- 
			case PKG_FLATSIZE:
+ 
			case PKG_ATTR_FLATSIZE:

				pkg->flatsize = sqlite3_column_int64(stmt, icol);

				break;
- 
			case PKG_ROWID:
+ 
			case PKG_ATTR_ROWID:

				pkg->id = sqlite3_column_int64(stmt, icol);

				break;
- 
			case PKG_LICENSE_LOGIC:
+ 
			case PKG_ATTR_LICENSE_LOGIC:

				pkg->licenselogic = (lic_t)sqlite3_column_int64(stmt, icol);

				break;
- 
			case PKG_OLD_FLATSIZE:
+ 
			case PKG_ATTR_OLD_FLATSIZE:

				pkg->old_flatsize = sqlite3_column_int64(stmt, icol);

				break;
- 
			case PKG_PKGSIZE:
+ 
			case PKG_ATTR_PKGSIZE:

				pkg->pkgsize = sqlite3_column_int64(stmt, icol);

				break;
- 
			case PKG_VITAL:
+ 
			case PKG_ATTR_VITAL:

				pkg->vital = (bool)sqlite3_column_int64(stmt, icol);

				break;
- 
			case PKG_TIME:
+ 
			case PKG_ATTR_TIME:

				pkg->timestamp = sqlite3_column_int64(stmt, icol);

				break;

			default:
modified src/annotate.c
@@ -146,7 +146,7 @@ do_show(struct pkg *pkg, const char *tag)
	struct pkg_kv *note;

	int ret = EPKG_OK;
- 
	pkg_get_kv(pkg, PKG_ANNOTATIONS, kl);
+ 
	pkg_get_kv(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_UNIQUEID, uid);
+ 
	pkg_get_string(pkg, PKG_ATTR_UNIQUEID, uid);

	pkghash_safe_add(check, uid, pkg, NULL);

}
@@ -122,7 +122,7 @@ print_issue(struct pkg *p, struct pkg_audit_issue *issue)
	const struct pkg_audit_entry *e;

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



	e = issue->audit;

	if (version == NULL) {
@@ -299,9 +299,9 @@ exec_audit(int argc, char **argv)
			if (pkg_new(&pkg, PKG_FILE) != EPKG_OK)

				err(EXIT_FAILURE, "malloc");

			if (version != NULL)
- 
				pkg_set(pkg, PKG_NAME, name, PKG_VERSION, version);
+ 
				pkg_set(pkg, PKG_ATTR_NAME, name, PKG_ATTR_VERSION, version);

			else
- 
				pkg_set(pkg, PKG_NAME, name);
+ 
				pkg_set(pkg, PKG_ATTR_NAME, name);

			add_to_check(check, pkg);

			pkg = NULL;

		}
@@ -395,7 +395,7 @@ exec_audit(int argc, char **argv)


				if (top == NULL) {

					affected += issues->count;
- 
					pkg_get_string(pkg, PKG_VERSION, version);
+ 
					pkg_get_string(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_NAME, name);
- 
					pkg_get_string(pkg, PKG_VERSION, version);
+ 
					pkg_get_string(pkg, PKG_ATTR_NAME, name);
+ 
					pkg_get_string(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_NAME, name);
+ 
						pkg_get_string(pkg, PKG_ATTR_NAME, name);

					if (top == NULL) {

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

					} else {
modified src/check.c
@@ -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_SHLIBS_REQUIRED, sl);
+ 
	pkg_get_stringlist(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_REQUIRES, sl);
+ 
	pkg_get_stringlist(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_CKSUM, sum);
+ 
		pkg_get_string(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
@@ -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_REPONAME, reponame);
+ 
			pkg_get_string(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_REPONAME, reponame);
+ 
			pkg_get_string(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_VERSION, version);
+ 
			pkg_get_string(pkg, PKG_ATTR_VERSION, version);

			if (pkgversion != NULL) {

				switch (pkg_version_cmp(version, pkgversion)) {

				case -1:
modified src/query.c
@@ -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_AUTOMATIC, automatic);
+ 
				pkg_get_bool(pkg, PKG_ATTR_AUTOMATIC, automatic);

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

				break;

			case 'k':
- 
				pkg_get_bool(pkg, PKG_LOCKED, locked);
+ 
				pkg_get_bool(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_VITAL, vital);
+ 
				pkg_get_bool(pkg, PKG_ATTR_VITAL, vital);

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

				break;

			case 'X':
@@ -369,7 +369,7 @@ print_query(struct pkg *pkg, char *qstr, char multiline)
		}

		break;

	case 'C':
- 
		pkg_get_stringlist(pkg, PKG_CATEGORIES, sl);
+ 
		pkg_get_stringlist(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_LICENSES, sl);
+ 
		pkg_get_stringlist(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_USERS, sl);
+ 
		pkg_get_stringlist(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_GROUPS, sl);
+ 
		pkg_get_stringlist(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_SHLIBS_REQUIRED, sl);
+ 
		pkg_get_stringlist(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_SHLIBS_PROVIDED, sl);
+ 
		pkg_get_stringlist(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_ANNOTATIONS, kl);
+ 
		pkg_get_kv(pkg, PKG_ATTR_ANNOTATIONS, kl);

		kit = pkg_kvlist_iterator(kl);

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

			format_str(pkg, output, qstr, kv);
modified src/register.c
@@ -89,7 +89,7 @@ exec_register(int argc, char **argv)
		switch (ch) {

		case 'A':

		case 'd':
- 
			pkg_set(pkg, PKG_AUTOMATIC, (bool)true);
+ 
			pkg_set(pkg, PKG_ATTR_AUTOMATIC, (bool)true);

			break;

		case 'f':

			plist = optarg;
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_AUTOMATIC, automatic);
+ 
				pkg_get_bool(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_VITAL, vital);
+ 
				pkg_get_bool(pkg, PKG_ATTR_VITAL, vital);

				if (vital == newvital)

					continue;

				if (!rc) {
modified src/upgrade.c
@@ -66,7 +66,7 @@ add_to_check(pkghash *check, struct pkg *pkg)
{

	const char *uid;
- 
	pkg_get_string(pkg, PKG_UNIQUEID, uid);
+ 
	pkg_get_string(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_UNIQUEID, uid);
+ 
					pkg_get_string(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_REPOURL, repourl);
+ 
	pkg_get_string(pkg, PKG_ATTR_REPOURL, repourl);



	if (options & INFO_RAW) {

		switch (options & (INFO_RAW_YAML|INFO_RAW_JSON|INFO_RAW_JSON_COMPACT|INFO_RAW_UCL)) {
@@ -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_FLATSIZE, flatsize);
- 
	pkg_get_int(new_pkg, PKG_PKGSIZE, pkgsize);
- 
	pkg_get_string(new_pkg, PKG_REPOPATH, repopath);
+ 
	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);

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



	it = malloc(sizeof (*it));

	if (it == NULL) {
@@ -816,7 +816,7 @@ display_summary_item(struct pkg_solved_display *it, int64_t dlsize)
	char size[8], tlsize[8];

	const char *type;
- 
	pkg_get_int(it->new, PKG_PKGSIZE, pkgsize);
+ 
	pkg_get_int(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_REASON, why);
+ 
		pkg_get_string(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_REASON, why);
+ 
		pkg_get_string(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
@@ -84,7 +84,7 @@ print_version(struct pkg *pkg, const char *source, const char *ver,
	const char	*version;

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

	if (ver == NULL) {

		if (source == NULL)

			key = "!";
@@ -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_NAME, name);
- 
		pkg_get_string(pkg, PKG_ORIGIN, origin);
+ 
		pkg_get_string(pkg, PKG_ATTR_NAME, name);
+ 
		pkg_get_string(pkg, PKG_ATTR_ORIGIN, origin);



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

		if ((opt & VERSION_WITHORIGIN) &&
@@ -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_NAME, name);
- 
		pkg_get_string(pkg, PKG_ORIGIN, origin);
+ 
		pkg_get_string(pkg, PKG_ATTR_NAME, name);
+ 
		pkg_get_string(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_VERSION, version_remote);
+ 
			pkg_get_string(pkg_remote, PKG_ATTR_VERSION, version_remote);

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

			    opt);

		} else {
@@ -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_NAME, name);
- 
		pkg_get_string(pkg, PKG_ORIGIN, origin);
+ 
		pkg_get_string(pkg, PKG_ATTR_NAME, name);
+ 
		pkg_get_string(pkg, PKG_ATTR_ORIGIN, origin);



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

		if ((opt & VERSION_WITHORIGIN) &&
modified tests/lib/checksum.c
@@ -155,9 +155,9 @@ ATF_TC_BODY(check_pkg, tc)
{

	struct pkg *p = NULL;

	pkg_new(&p, PKG_INSTALLED);
- 
	pkg_set(p, PKG_NAME, "test");
- 
	pkg_set(p, PKG_ORIGIN, "origin");
- 
	pkg_set(p, PKG_ARCH, "*");
+ 
	pkg_set(p, PKG_ATTR_NAME, "test");
+ 
	pkg_set(p, PKG_ATTR_ORIGIN, "origin");
+ 
	pkg_set(p, PKG_ATTR_ARCH, "*");

	char *sum = xcalloc(pkg_checksum_type_size(PKG_HASH_TYPE_SHA256_HEX) * 2, sizeof(char));



	ATF_REQUIRE_EQ(pkg_checksum_generate(NULL, sum, pkg_checksum_type_size(PKG_HASH_TYPE_SHA256_HEX) * 2, PKG_HASH_TYPE_SHA256_HEX, false, false, false), EPKG_FATAL);
modified tests/lib/lua.c
@@ -497,7 +497,7 @@ ATF_TC_BODY(prefix_path, tc)
{

	struct pkg *pkg = NULL;

	pkg_new(&pkg, PKG_INSTALLED);
- 
	pkg_set(pkg, PKG_PREFIX, "/myprefix");
+ 
	pkg_set(pkg, PKG_ATTR_PREFIX, "/myprefix");

	lua_State *L = luaL_newstate();

	static const luaL_Reg test_lib[] = {

		{ "prefix_path", lua_prefix_path },
modified tests/lib/pkg_add_dir_to_del.c
@@ -36,7 +36,7 @@ ATF_TC_BODY(pkg_add_dir_to_del, tc)
	struct pkg *p = NULL;



	ATF_REQUIRE_EQ(EPKG_OK, pkg_new(&p, PKG_FILE));
- 
	pkg_set(p, PKG_PREFIX, "/usr/local");
+ 
	pkg_set(p, PKG_ATTR_PREFIX, "/usr/local");



	ATF_REQUIRE_EQ(tll_length(p->dir_to_del), 0);
modified tests/lib/pkg_validation.c
@@ -69,42 +69,42 @@ check_valid(struct pkg *p)
	fflush(msg->fp);

	ATF_REQUIRE_STREQ(msg->buf, "Invalid package: object has missing property origin");
- 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_ORIGIN, "test/bla"));
+ 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_ATTR_ORIGIN, "test/bla"));

	ATF_REQUIRE_EQ(EPKG_FATAL, pkg_is_valid(p));

	fflush(msg->fp);

	ATF_REQUIRE_STREQ(msg->buf, "Invalid package: object has missing property name");
- 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_NAME, "test"));
+ 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_ATTR_NAME, "test"));

	ATF_REQUIRE_EQ(EPKG_FATAL, pkg_is_valid(p));

	fflush(msg->fp);

	ATF_REQUIRE_STREQ(msg->buf, "Invalid package: object has missing property comment");
- 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_COMMENT, "test comment"));
+ 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_ATTR_COMMENT, "test comment"));

	ATF_REQUIRE_EQ(EPKG_FATAL, pkg_is_valid(p));

	fflush(msg->fp);

	ATF_REQUIRE_STREQ(msg->buf, "Invalid package: object has missing property version");
- 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_VERSION, "1.1.0"));
+ 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_ATTR_VERSION, "1.1.0"));

	ATF_REQUIRE_EQ(EPKG_FATAL, pkg_is_valid(p));

	fflush(msg->fp);

	ATF_REQUIRE_STREQ(msg->buf, "Invalid package: object has missing property desc");
- 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_DESC, "test description"));
+ 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_ATTR_DESC, "test description"));

	ATF_REQUIRE_EQ(EPKG_FATAL, pkg_is_valid(p));

	fflush(msg->fp);

	ATF_REQUIRE_STREQ(msg->buf, "Invalid package: object has missing property maintainer");
- 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_MAINTAINER, "tester"));
+ 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_ATTR_MAINTAINER, "tester"));

	ATF_REQUIRE_EQ(EPKG_FATAL, pkg_is_valid(p));

	fflush(msg->fp);

	ATF_REQUIRE_STREQ(msg->buf, "Invalid package: object has missing property www");
- 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_WWW, "test website"));
+ 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_ATTR_WWW, "test website"));

	ATF_REQUIRE_EQ(EPKG_FATAL, pkg_is_valid(p));

	fflush(msg->fp);

	ATF_REQUIRE_STREQ(msg->buf, "Invalid package: object has missing property prefix");
- 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_PREFIX, "/usr/local"));
+ 
	ATF_REQUIRE_EQ(EPKG_OK, pkg_set(p, PKG_ATTR_PREFIX, "/usr/local"));

	ATF_REQUIRE_EQ(EPKG_OK, pkg_is_valid(p));



	xstring_free(msg);