b0ea945 Do not load mtree by default. — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -165,7 +165,7 @@ pkg_resolvdeps(struct pkg *pkg, struct pkgdb *db) {

 	for (i = 0; deps[i] != NULL; i++) {
 		it = pkgdb_query(db, pkg_get(deps[i], PKG_ORIGIN), MATCH_EXACT);
 		if (pkgdb_it_next(it, &p, PKG_BASIC) == 0) {
 		if (pkgdb_it_next(it, &p, PKG_LOAD_BASIC) == 0) {
 			deps[i]->type = PKG_INSTALLED;
 		} else {
 			deps[i]->type = PKG_NOTFOUND;

@@ -358,6 +358,7 @@ pkg_new(struct pkg **pkg)

 	(*pkg)->fields[PKG_MESSAGE].optional = 1;
 	(*pkg)->fields[PKG_WWW].optional = 1;
 	(*pkg)->fields[PKG_MTREE].optional = 1;
 	return (EPKG_OK);
 }

modified libpkg/pkg.h

@@ -316,26 +316,27 @@ int pkgdb_unregister_pkg(struct pkgdb *, const char *);

 struct pkgdb_it * pkgdb_query(struct pkgdb *, const char *, match_t);
 struct pkgdb_it * pkgdb_query_which(struct pkgdb *, const char *);
 #define PKG_BASIC 0
 #define PKG_DEPS (1<<0)
 #define PKG_RDEPS (1<<1)
 #define PKG_CONFLICTS (1<<2)
 #define PKG_FILES (1<<3)
 #define PKG_EXECS (1<<4)
 #define PKG_SCRIPTS (1<<5)
 #define PKG_OPTIONS (1<<6)
 #define PKG_ALL PKG_BASIC|PKG_DEPS|PKG_RDEPS|PKG_CONFLICTS|PKG_FILES|PKG_EXECS|PKG_SCRIPTS|PKG_OPTIONS
 #define PKG_LOAD_BASIC 0
 #define PKG_LOAD_DEPS (1<<0)
 #define PKG_LOAD_RDEPS (1<<1)
 #define PKG_LOAD_CONFLICTS (1<<2)
 #define PKG_LOAD_FILES (1<<3)
 #define PKG_LOAD_EXECS (1<<4)
 #define PKG_LOAD_SCRIPTS (1<<5)
 #define PKG_LOAD_OPTIONS (1<<6)
 #define PKG_LOAD_MTREE (1<<7)
 int pkgdb_it_next(struct pkgdb_it *, struct pkg **, int);
 void pkgdb_it_free(struct pkgdb_it *);
 int pkgdb_pkg_loaddeps(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_pkg_loadrdeps(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_pkg_loadconflicts(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_pkg_loadfiles(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_pkg_loadexecs(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_pkg_loadscripts(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_pkg_loadoptions(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loaddeps(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadrdeps(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadconflicts(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadfiles(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadexecs(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadscripts(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadoptions(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadmtree(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_compact(struct pkgdb *db);
 const char *pkgdb_get_dir(void);

modified libpkg/pkg_add.c

@@ -71,7 +71,7 @@ pkg_add(struct pkgdb *db, const char *path)

 		goto error;
 	}
 	ret = pkgdb_it_next(it, &p, PKG_BASIC);
 	ret = pkgdb_it_next(it, &p, PKG_LOAD_BASIC);
 	pkgdb_it_free(it);
 	pkg_free(p);

modified libpkg/pkg_create.c

@@ -142,6 +142,8 @@ pkg_create(const char *mpath, pkg_formats format, const char *outdir, const char

 	(void)mpath;
 	/* TODO: get stuff from db */
 	pkg_archive = archive_write_new();
 	if ((ext = pkg_create_set_format(pkg_archive, format)) == NULL) {

modified libpkg/pkg_delete.c

@@ -48,13 +48,15 @@ pkg_delete(struct pkg *pkg, struct pkgdb *db, int force)

 	/*
 	 * Ensure that we have all the informations we need
 	 */
 	if ((ret = pkgdb_pkg_loadrdeps(db, pkg)) != EPKG_OK)
 	if ((ret = pkgdb_loadrdeps(db, pkg)) != EPKG_OK)
 		return (ret);
 	if ((ret = pkgdb_pkg_loadfiles(db, pkg)) != EPKG_OK)
 	if ((ret = pkgdb_loadfiles(db, pkg)) != EPKG_OK)
 		return (ret);
 	if ((ret = pkgdb_pkg_loadscripts(db, pkg)) != EPKG_OK)
 	if ((ret = pkgdb_loadscripts(db, pkg)) != EPKG_OK)
 		return (ret);
 	if ((ret = pkgdb_pkg_loadexecs(db, pkg)) != EPKG_OK)
 	if ((ret = pkgdb_loadexecs(db, pkg)) != EPKG_OK)
 		return (ret);
 	if ((ret = pkgdb_loadmtree(db, pkg)) != EPKG_OK)
 		return (ret);
 	rdeps = pkg_rdeps(pkg);

modified libpkg/pkg_elf.c

@@ -66,7 +66,7 @@ analyse_elf(struct pkgdb *db, struct pkg *pkg, const char *fpath)

 			if ((it = pkgdb_query_which(db, map->l_name)) == NULL)
 				return (EPKG_FATAL);
 			if (pkgdb_it_next(it, &pkg, PKG_BASIC) == 0) {
 			if (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) == 0) {
 				found = false;
 				if (( deps = pkg_deps(pkg) ) != NULL) {
 					for (i = 0; deps[i]; i++) {

modified libpkg/pkgdb.c

@@ -293,41 +293,44 @@ pkgdb_it_next(struct pkgdb_it *it, struct pkg **pkg_p, int flags)

 		pkg_set(pkg, PKG_VERSION, sqlite3_column_text(it->stmt, 3));
 		pkg_set(pkg, PKG_COMMENT, sqlite3_column_text(it->stmt, 4));
 		pkg_set(pkg, PKG_DESC, sqlite3_column_text(it->stmt, 5));
 		pkg_set(pkg, PKG_MTREE, sqlite3_column_text(it->stmt, 6));
 		pkg_set(pkg, PKG_MESSAGE, sqlite3_column_text(it->stmt, 7));
 		pkg_set(pkg, PKG_ARCH, sqlite3_column_text(it->stmt, 8));
 		pkg_set(pkg, PKG_OSVERSION, sqlite3_column_text(it->stmt, 9));
 		pkg_set(pkg, PKG_MAINTAINER, sqlite3_column_text(it->stmt, 10));
 		pkg_set(pkg, PKG_WWW, sqlite3_column_text(it->stmt, 11));
 		pkg_set(pkg, PKG_PREFIX, sqlite3_column_text(it->stmt, 12));
 		pkg_setflatsize(pkg, sqlite3_column_int64(it->stmt, 13));
 		if (flags & PKG_DEPS)
 			if ((ret = pkgdb_pkg_loaddeps(it->db, pkg)) != EPKG_OK)
 		pkg_set(pkg, PKG_MESSAGE, sqlite3_column_text(it->stmt, 6));
 		pkg_set(pkg, PKG_ARCH, sqlite3_column_text(it->stmt, 7));
 		pkg_set(pkg, PKG_OSVERSION, sqlite3_column_text(it->stmt, 8));
 		pkg_set(pkg, PKG_MAINTAINER, sqlite3_column_text(it->stmt, 9));
 		pkg_set(pkg, PKG_WWW, sqlite3_column_text(it->stmt, 10));
 		pkg_set(pkg, PKG_PREFIX, sqlite3_column_text(it->stmt, 11));
 		pkg_setflatsize(pkg, sqlite3_column_int64(it->stmt, 12));
 		if (flags & PKG_LOAD_DEPS)
 			if ((ret = pkgdb_loaddeps(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_RDEPS)
 			if ((ret = pkgdb_pkg_loadrdeps(it->db, pkg)) != EPKG_OK)
 		if (flags & PKG_LOAD_RDEPS)
 			if ((ret = pkgdb_loadrdeps(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_CONFLICTS)
 			if ((ret = pkgdb_pkg_loadconflicts(it->db, pkg)) != EPKG_OK)
 		if (flags & PKG_LOAD_CONFLICTS)
 			if ((ret = pkgdb_loadconflicts(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_FILES)
 			if ((ret = pkgdb_pkg_loadfiles(it->db, pkg)) != EPKG_OK)
 		if (flags & PKG_LOAD_FILES)
 			if ((ret = pkgdb_loadfiles(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_EXECS)
 			if ((ret = pkgdb_pkg_loadexecs(it->db, pkg)) != EPKG_OK)
 		if (flags & PKG_LOAD_EXECS)
 			if ((ret = pkgdb_loadexecs(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_SCRIPTS)
 			if ((ret = pkgdb_pkg_loadscripts(it->db, pkg)) != EPKG_OK)
 		if (flags & PKG_LOAD_SCRIPTS)
 			if ((ret = pkgdb_loadscripts(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_OPTIONS)
 			if ((ret = pkgdb_pkg_loadoptions(it->db, pkg)) != EPKG_OK)
 		if (flags & PKG_LOAD_OPTIONS)
 			if ((ret = pkgdb_loadoptions(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_MTREE)
 			if ((ret = pkgdb_loadmtree(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		return (EPKG_OK);

@@ -369,36 +372,35 @@ pkgdb_query(struct pkgdb *db, const char *pattern, match_t match)

 		break;
 	case MATCH_EXACT:
 		if (checkorigin == NULL)
 			comp = " AND name = ?1";
 			comp = " WHERE p.name = ?1";
 		else
 			comp = " AND origin = ?1";
 			comp = " WHERE p.origin = ?1";
 		break;
 	case MATCH_GLOB:
 		if (checkorigin == NULL)
 			comp = " AND name GLOB ?1";
 			comp = " WHERE p.name GLOB ?1";
 		else
 			comp = " AND origin GLOB ?1";
 			comp = " WHERE p.origin GLOB ?1";
 		break;
 	case MATCH_REGEX:
 		if (checkorigin == NULL)
 			comp = " AND name REGEXP ?1";
 			comp = " WHERE p.name REGEXP ?1";
 		else
 			comp = " AND origin REGEXP ?1";
 			comp = " WHERE p.origin REGEXP ?1";
 		break;
 	case MATCH_EREGEX:
 		if (checkorigin == NULL)
 			comp = " AND EREGEXP(?1, name)";
 			comp = " WHERE EREGEXP(?1, p.name)";
 		else
 			comp = " AND EREGEXP(?1, origin)";
 			comp = " WHERE EREGEXP(?1, p.origin)";
 		break;
 	}
 	snprintf(sql, sizeof(sql),
 			"SELECT p.rowid, p.origin, p.name, p.version, p.comment, p.desc, m.content, "
 			"SELECT p.rowid, p.origin, p.name, p.version, p.comment, p.desc, "
 				"p.message, p.arch, p.osversion, p.maintainer, p.www, "
 				"p.prefix, p.flatsize "
 			"FROM packages AS p, mtree AS m "
 			"WHERE m.rowid = p.mtree_id%s;", comp);
 			"FROM packages AS p%s;", comp);
 	if (sqlite3_prepare(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(db->sqlite);

@@ -416,12 +418,11 @@ pkgdb_query_which(struct pkgdb *db, const char *path)

 {
 	sqlite3_stmt *stmt;
 	const char sql[] = ""
 		"SELECT p.rowid, p.origin, p.name, p.version, p.comment, p.desc, m.content, "
 		"SELECT p.rowid, p.origin, p.name, p.version, p.comment, p.desc, "
 			"p.message, p.arch, p.osversion, p.maintainer, p.www, "
 			"p.prefix, p.flatsize "
 			"FROM packages AS p, mtree AS m, files AS f "
 			"WHERE m.rowid = p.mtree_id "
 				"AND p.rowid = f.package_id "
 			"FROM packages AS p, files AS f "
 			"WHERE p.rowid = f.package_id "
 				"AND f.path = ?1;";
 	if (sqlite3_prepare(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {

@@ -435,25 +436,24 @@ pkgdb_query_which(struct pkgdb *db, const char *path)

 }
 int
 pkgdb_pkg_loaddeps(struct pkgdb *db, struct pkg *pkg)
 pkgdb_loaddeps(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt;
 	struct pkgdb_it it;
 	struct pkg *p;
 	int ret;
 	const char sql[] = ""
 	"SELECT p.rowid, p.origin, p.name, p.version, p.comment, p.desc, m.content, "
 	"SELECT p.rowid, p.origin, p.name, p.version, p.comment, p.desc, "
 		"p.message, p.arch, p.osversion, p.maintainer, p.www, "
 		"p.prefix, p.flatsize "
 	"FROM packages AS p, mtree AS m, deps AS d "
 	"WHERE m.rowid = p.mtree_id "
 		"AND p.origin = d.origin "
 	"FROM packages AS p, deps AS d "
 	"WHERE p.origin = d.origin "
 		"AND d.package_id = ?1;";
 	if (pkg->type != PKG_INSTALLED)
 		return (ERROR_BAD_ARG("pkg"));
 	if (pkg->flags & PKG_DEPS)
 	if (pkg->flags & PKG_LOAD_DEPS)
 		return (EPKG_OK);
 	array_init(&pkg->deps, 10);

@@ -467,7 +467,7 @@ pkgdb_pkg_loaddeps(struct pkgdb *db, struct pkg *pkg)

 	it.db = db;
 	p = NULL;
 	while ((ret = pkgdb_it_next(&it, &p, PKG_BASIC)) == EPKG_OK) {
 	while ((ret = pkgdb_it_next(&it, &p, PKG_LOAD_BASIC)) == EPKG_OK) {
 		array_append(&pkg->deps, p);
 		p = NULL;
 	}

@@ -479,30 +479,29 @@ pkgdb_pkg_loaddeps(struct pkgdb *db, struct pkg *pkg)

 		return (ret);
 	}
 	pkg->flags |= PKG_DEPS;
 	pkg->flags |= PKG_LOAD_DEPS;
 	return (EPKG_OK);
 }
 int
 pkgdb_pkg_loadrdeps(struct pkgdb *db, struct pkg *pkg)
 pkgdb_loadrdeps(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt;
 	struct pkgdb_it it;
 	struct pkg *p;
 	int ret;
 	const char sql[] = ""
 		"SELECT p.rowid, p.origin, p.name, p.version, p.comment, p.desc, m.content, "
 		"SELECT p.rowid, p.origin, p.name, p.version, p.comment, p.desc, "
 			"p.message, p.arch, p.osversion, p.maintainer, p.www, "
 			"p.prefix, p.flatsize "
 		"FROM packages AS p, mtree AS m, deps AS d "
 		"WHERE m.id = p.mtree_id "
 			"AND p.rowid = d.package_id "
 		"FROM packages AS p, deps AS d "
 		"WHERE p.rowid = d.package_id "
 			"AND d.origin = ?1;";
 	if (pkg->type != PKG_INSTALLED)
 		return (ERROR_BAD_ARG("pkg"));
 	if (pkg->flags & PKG_RDEPS)
 	if (pkg->flags & PKG_LOAD_RDEPS)
 		return (EPKG_OK);
 	array_init(&pkg->rdeps, 5);

@@ -516,7 +515,7 @@ pkgdb_pkg_loadrdeps(struct pkgdb *db, struct pkg *pkg)

 	it.db = db;
 	p = NULL;
 	while ((ret = pkgdb_it_next(&it, &p, PKG_BASIC)) == EPKG_OK) {
 	while ((ret = pkgdb_it_next(&it, &p, PKG_LOAD_BASIC)) == EPKG_OK) {
 		array_append(&pkg->rdeps, p);
 		p = NULL;
 	}

@@ -527,12 +526,12 @@ pkgdb_pkg_loadrdeps(struct pkgdb *db, struct pkg *pkg)

 		return (ret);
 	}
 	pkg->flags |= PKG_RDEPS;
 	pkg->flags |= PKG_LOAD_RDEPS;
 	return (EPKG_OK);
 }
 int
 pkgdb_pkg_loadconflicts(struct pkgdb *db, struct pkg *pkg)
 pkgdb_loadconflicts(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt;
 	struct pkg_conflict *c;

@@ -545,7 +544,7 @@ pkgdb_pkg_loadconflicts(struct pkgdb *db, struct pkg *pkg)

 	if (pkg->type != PKG_INSTALLED)
 		return (ERROR_BAD_ARG("pkg"));
 	if (pkg->flags & PKG_CONFLICTS)
 	if (pkg->flags & PKG_LOAD_CONFLICTS)
 		return (EPKG_OK);
 	array_init(&pkg->conflicts, 5);

@@ -567,13 +566,13 @@ pkgdb_pkg_loadconflicts(struct pkgdb *db, struct pkg *pkg)

 		return (ERROR_SQLITE(db->sqlite));
 	}
 	pkg->flags |= PKG_CONFLICTS;
 	pkg->flags |= PKG_LOAD_CONFLICTS;
 	return (EPKG_OK);
 }
 int
 pkgdb_pkg_loadfiles(struct pkgdb *db, struct pkg *pkg)
 pkgdb_loadfiles(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt;
 	struct pkg_file *f;

@@ -586,7 +585,7 @@ pkgdb_pkg_loadfiles(struct pkgdb *db, struct pkg *pkg)

 	if (pkg->type != PKG_INSTALLED)
 		return (ERROR_BAD_ARG("pkg"));
 	if (pkg->flags & PKG_FILES)
 	if (pkg->flags & PKG_LOAD_FILES)
 		return (EPKG_OK);
 	array_init(&pkg->files, 10);

@@ -609,12 +608,12 @@ pkgdb_pkg_loadfiles(struct pkgdb *db, struct pkg *pkg)

 		return (ERROR_SQLITE(db->sqlite));
 	}
 	pkg->flags |= PKG_FILES;
 	pkg->flags |= PKG_LOAD_FILES;
 	return (EPKG_OK);
 }
 int
 pkgdb_pkg_loadexecs(struct pkgdb *db, struct pkg *pkg)
 pkgdb_loadexecs(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt;
 	struct pkg_exec *e;

@@ -627,7 +626,7 @@ pkgdb_pkg_loadexecs(struct pkgdb *db, struct pkg *pkg)

 	if (pkg->type != PKG_INSTALLED)
 		return (ERROR_BAD_ARG("pkg"));
 	if (pkg->flags & PKG_EXECS)
 	if (pkg->flags & PKG_LOAD_EXECS)
 		return (EPKG_OK);
 	array_init(&pkg->exec, 5);

@@ -650,12 +649,12 @@ pkgdb_pkg_loadexecs(struct pkgdb *db, struct pkg *pkg)

 		return (ERROR_SQLITE(db->sqlite));
 	}
 	pkg->flags |= PKG_EXECS;
 	pkg->flags |= PKG_LOAD_EXECS;
 	return (EPKG_OK);
 }
 int
 pkgdb_pkg_loadscripts(struct pkgdb *db, struct pkg *pkg)
 pkgdb_loadscripts(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt;
 	struct pkg_script *s;

@@ -668,7 +667,7 @@ pkgdb_pkg_loadscripts(struct pkgdb *db, struct pkg *pkg)

 	if (pkg->type != PKG_INSTALLED)
 		return (ERROR_BAD_ARG("pkg"));
 	if (pkg->flags & PKG_SCRIPTS)
 	if (pkg->flags & PKG_LOAD_SCRIPTS)
 		return (EPKG_OK);
 	array_init(&pkg->scripts, 6);

@@ -691,12 +690,12 @@ pkgdb_pkg_loadscripts(struct pkgdb *db, struct pkg *pkg)

 		return (ERROR_SQLITE(db->sqlite));
 	}
 	pkg->flags |= PKG_SCRIPTS;
 	pkg->flags |= PKG_LOAD_SCRIPTS;
 	return (EPKG_OK);
 }
 int
 pkgdb_pkg_loadoptions(struct pkgdb *db, struct pkg *pkg)
 pkgdb_loadoptions(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt;
 	struct pkg_option *o;

@@ -709,7 +708,7 @@ pkgdb_pkg_loadoptions(struct pkgdb *db, struct pkg *pkg)

 	if (pkg->type != PKG_INSTALLED)
 		return (ERROR_BAD_ARG("pkg"));
 	if (pkg->flags & PKG_OPTIONS)
 	if (pkg->flags & PKG_LOAD_OPTIONS)
 		return (EPKG_OK);
 	array_init(&pkg->options, 5);

@@ -732,7 +731,45 @@ pkgdb_pkg_loadoptions(struct pkgdb *db, struct pkg *pkg)

 		return (ERROR_SQLITE(db->sqlite));
 	}
 	pkg->flags |= PKG_OPTIONS;
 	pkg->flags |= PKG_LOAD_OPTIONS;
 	return (EPKG_OK);
 }
 int
 pkgdb_loadmtree(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt;
 	int ret;
 	const char sql[] = ""
 		"SELECT m.content "
 		"FROM mtree AS m, packages AS p "
 		"WHERE id = p.mtree_id "
 			" AND p.id = ?1;";
 	if (pkg->type != PKG_INSTALLED)
 		return (ERROR_BAD_ARG("pkg"));
 	if (pkg->flags & PKG_LOAD_MTREE)
 		return (EPKG_OK);
 	if (sqlite3_prepare(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK)
 		return (ERROR_SQLITE(db->sqlite));
 	sqlite3_bind_int64(stmt, 1, pkg->rowid);
 	ret = sqlite3_step(stmt);
 	if (ret == SQLITE_ROW) {
 		sbuf_set(&pkg->fields[PKG_MTREE].value,
 				 sqlite3_column_text(stmt, 1));
 		ret = SQLITE_DONE;
 	}
 	sqlite3_finalize(stmt);
 	if (ret != SQLITE_DONE)
 		return (ERROR_SQLITE(db->sqlite));
 	pkg->flags |= PKG_LOAD_MTREE;
 	return (EPKG_OK);
 }

modified pkg/create.c

@@ -115,7 +115,7 @@ exec_create(int argc, char **argv)

 		}
 		pkg_new(&pkg);
 		while ((ret = pkgdb_it_next(it, &pkg, PKG_ALL)) == EPKG_OK) {
 		while ((ret = pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC)) == EPKG_OK) {
 			printf("Creating package for %s-%s\n", pkg_get(pkg, PKG_NAME),
 				   pkg_get(pkg, PKG_VERSION));

modified pkg/delete.c

@@ -24,7 +24,7 @@ exec_delete(int argc, char **argv)

 	char *origin = NULL;
 	char ch;
 	int ret;
 	int flags = PKG_BASIC|PKG_FILES|PKG_RDEPS;
 	int flags = PKG_LOAD_BASIC;
 	int force = 0;
 	int retcode = 0;

modified pkg/info.c

@@ -62,7 +62,7 @@ exec_info(int argc, char **argv)

 {
 	struct pkgdb *db;
 	struct pkgdb_it *it;
 	int query_flags = PKG_BASIC;
 	int query_flags = PKG_LOAD_BASIC;
 	struct pkg *pkg = NULL;
 	struct pkg **deps;
 	struct pkg_file **files;

@@ -95,15 +95,15 @@ exec_info(int argc, char **argv)

 				break;
 			case 'd':
 				opt |= INFO_PRINT_DEP;
 				query_flags |= PKG_DEPS;
 				query_flags |= PKG_LOAD_DEPS;
 				break;
 			case 'r':
 				opt |= INFO_PRINT_RDEP;
 				query_flags |= PKG_RDEPS;
 				query_flags |= PKG_LOAD_RDEPS;
 				break;
 			case 'l':
 				opt |= INFO_LIST_FILES;
 				query_flags |= PKG_FILES;
 				query_flags |= PKG_LOAD_FILES;
 				break;
 			case 's':
 				opt |= INFO_SIZE;

modified pkg/which.c

@@ -48,7 +48,7 @@ exec_which(int argc, char **argv)

 	}
 	pkg_new(&pkg);
 	if (( ret = pkgdb_it_next(it, &pkg, PKG_BASIC)) == EPKG_OK) {
 	if (( ret = pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC)) == EPKG_OK) {
 		retcode = 0;
 		printf("%s was installed by package %s-%s\n", pathabs, pkg_get(pkg, PKG_NAME),
 			   pkg_get(pkg, PKG_VERSION));