04b1071 New install timestanp in database new infos field — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -51,6 +51,7 @@ static struct _fields {

 	[PKG_MAINTAINER] = {PKG_FILE|PKG_REMOTE|PKG_INSTALLED, 0},
 	[PKG_WWW] = {PKG_FILE|PKG_REMOTE|PKG_INSTALLED, 1},
 	[PKG_PREFIX] = {PKG_FILE|PKG_REMOTE|PKG_INSTALLED, 0},
 	[PKG_INFOS] = {PKG_FILE|PKG_REMOTE|PKG_INSTALLED, 1},
 	[PKG_REPOPATH] = {PKG_REMOTE, 0},
 	[PKG_CKSUM] = {PKG_REMOTE, 0},
 	[PKG_NEWVERSION] = {PKG_REMOTE, 1},

@@ -99,6 +100,7 @@ pkg_reset(struct pkg *pkg, pkg_t type)

 	pkg->flatsize = 0;
 	pkg->new_flatsize = 0;
 	pkg->new_pkgsize = 0;
 	pkg->time = 0;
 	pkg->automatic = false;
 	pkg->licenselogic = LICENSE_SINGLE;

@@ -197,6 +199,9 @@ pkg_vget(struct pkg const *const pkg, va_list ap)

 			case PKG_AUTOMATIC:
 				*va_arg(ap, bool *) = pkg->automatic;
 				break;
 			case PKG_TIME:
 				*va_arg(ap, int64_t *) = pkg->time;
 				break;
 			case PKG_ROWID:
 				*va_arg(ap, int64_t *) = pkg->rowid;
 				break;

@@ -276,6 +281,9 @@ pkg_vset(struct pkg *pkg, va_list ap)

 			case PKG_NEW_PKGSIZE:
 				pkg->new_pkgsize = va_arg(ap, int64_t);
 				break;
 			case PKG_TIME:
 				pkg->time = va_arg(ap, int64_t);
 				break;
 			case PKG_ROWID:
 				pkg->rowid = va_arg(ap, int64_t);
 				break;

modified libpkg/pkg.h

@@ -158,6 +158,7 @@ typedef enum {

 	PKG_MAINTAINER,
 	PKG_WWW,
 	PKG_PREFIX,
 	PKG_INFOS,
 	PKG_REPOPATH,
 	PKG_CKSUM,
 	PKG_NEWVERSION,

@@ -169,6 +170,7 @@ typedef enum {

 	PKG_LICENSE_LOGIC,
 	PKG_AUTOMATIC,
 	PKG_ROWID,
 	PKG_TIME,
 } pkg_attr;
 /**

modified libpkg/pkg_attributes.c

@@ -379,7 +379,6 @@ pkg_shlib_name(struct pkg_shlib *sl)

 void
 pkg_shlib_free(struct pkg_shlib *sl)
 {
 	if (sl == NULL)
 		return;

modified libpkg/pkg_manifest.c

@@ -87,6 +87,7 @@ static struct manifest_key {

 	{ "desc", PKG_DESC, YAML_SCALAR_NODE, pkg_set_from_node},
 	{ "scripts", PKG_SCRIPTS, YAML_MAPPING_NODE, parse_mapping},
 	{ "message", PKG_MESSAGE, YAML_SCALAR_NODE, pkg_set_from_node},
 	{ "infos", PKG_INFOS, YAML_SCALAR_NODE, pkg_set_from_node},
 	{ "categories", PKG_CATEGORIES, YAML_SEQUENCE_NODE, parse_sequence},
 	{ "options", PKG_OPTIONS, YAML_MAPPING_NODE, parse_mapping},
 	{ "users", PKG_USERS, YAML_SEQUENCE_NODE, parse_sequence}, /* compatibility with old format */

@@ -674,7 +675,7 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 	const char *script_types = NULL;
 	struct sbuf *destbuf = sbuf_new_auto();
 	const char *name, *version, *pkgorigin, *comment, *pkgarch, *www, *pkgmaintainer, *prefix;
 	const char *desc, *message;
 	const char *desc, *message, *infos;
 	lic_t licenselogic;
 	int64_t flatsize;

@@ -699,7 +700,8 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 	    PKG_ARCH, &pkgarch, PKG_WWW, &www,
 	    PKG_MAINTAINER, &pkgmaintainer, PKG_PREFIX, &prefix,
 	    PKG_LICENSE_LOGIC, &licenselogic, PKG_DESC, &desc,
 	    PKG_FLATSIZE, &flatsize, PKG_MESSAGE, &message, PKG_VERSION, &version);
 	    PKG_FLATSIZE, &flatsize, PKG_MESSAGE, &message, PKG_VERSION, &version,
 	    PKG_INFOS, &infos);
 	manifest_append_kv(mapping, "name", name, PLAIN);
 	manifest_append_kv(mapping, "version", version, PLAIN);
 	manifest_append_kv(mapping, "origin", pkgorigin, PLAIN);

@@ -835,6 +837,11 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 		urlencode(pkg_script_data(script), &tmpsbuf);
 		manifest_append_kv(map, script_types, sbuf_get(tmpsbuf), LITERAL);
 	}
 	if (infos != NULL && *infos != '\0') {
 		urlencode(infos, &tmpsbuf);
 		manifest_append_kv(mapping, "message", sbuf_get(tmpsbuf), LITERAL);
 	}
 	if (message != NULL && *message != '\0') {
 		urlencode(message, &tmpsbuf);
 		manifest_append_kv(mapping, "message", sbuf_get(tmpsbuf), LITERAL);

modified libpkg/pkgdb.c

@@ -49,7 +49,7 @@

 #include "private/utils.h"
 #include "private/db_upgrades.h"
 #define DBVERSION 10
 #define DBVERSION 11
 static struct pkgdb_it * pkgdb_it_new(struct pkgdb *, sqlite3_stmt *, int);
 static void pkgdb_regex(sqlite3_context *, int, sqlite3_value **, int);

@@ -88,6 +88,8 @@ static struct column_mapping {

 	{ "pkgsize", PKG_NEW_PKGSIZE },
 	{ "licenselogic", PKG_LICENSE_LOGIC},
 	{ "automatic", PKG_AUTOMATIC},
 	{ "time", PKG_TIME},
 	{ "infos", PKG_INFOS},
 	{ "rowid", PKG_ROWID},
 	{ "id", PKG_ROWID },
 	{ "weight", -1 },

@@ -222,6 +224,17 @@ pkgdb_regex_delete(void *p)

 }
 static void
 pkgdb_now(sqlite3_context *ctx, int argc, __unused sqlite3_value **argv)
 {
 	if (argc != 0) {
 		sqlite3_result_error(ctx, "Invalid usage of now() no arguments expected\n", -1);
 		return;
 	}
 	sqlite3_result_int64(ctx, (int64_t)time(NULL));
 }
 static void
 pkgdb_myarch(sqlite3_context *ctx, int argc, sqlite3_value **argv)
 {
 	const unsigned char *arch = NULL;

@@ -323,7 +336,7 @@ pkgdb_upgrade(struct pkgdb *db)

 			return (EPKG_FATAL);
 		if (sql_exec(db->sqlite, "COMMIT;") != EPKG_OK)
 			return (EPKG_OK);
 			return (EPKG_FATAL);
 	}
 	return (EPKG_OK);

@@ -365,6 +378,8 @@ pkgdb_init(sqlite3 *sdb)

 		"flatsize INTEGER NOT NULL,"
 		"automatic INTEGER NOT NULL,"
 		"licenselogic INTEGER NOT NULL,"
 		"infos TEXT, "
 		"time INTEGER, "
 		"pkg_format_version INTEGER"
 	");"
 	"CREATE TABLE mtree ("

@@ -456,21 +471,21 @@ pkgdb_init(sqlite3 *sdb)

 		"UNIQUE(package_id, group_id)"
 	");"
 	"CREATE TABLE shlibs ("
 	        "id INTEGER PRIMARY KEY,"
 	        "name TEXT NOT NULL UNIQUE"
 		"id INTEGER PRIMARY KEY,"
 		"name TEXT NOT NULL UNIQUE"
 	");"
 	"CREATE TABLE pkg_shlibs ("
 	        "package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE"
 	                " ON UPDATE CASCADE,"
 	        "shlib_id INTEGER REFERENCES shlibs(id) ON DELETE RESTRICT"
 	                " ON UPDATE RESTRICT,"
 		"package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE"
 			" ON UPDATE CASCADE,"
 		"shlib_id INTEGER REFERENCES shlibs(id) ON DELETE RESTRICT"
 			" ON UPDATE RESTRICT,"
 		"PRIMARY KEY (package_id, shlib_id)"
 	");"
 	/* Mark the end of the array */
 	"CREATE INDEX deporigini on deps(origin);"
 	"PRAGMA user_version = 10;"
 	"PRAGMA user_version = 11;"
 	"COMMIT;"
 	;

@@ -542,6 +557,8 @@ pkgdb_open(struct pkgdb **db_p, pkgdb_t type)

 		if (eaccess(localpath, W_OK) == 0)
 			db->writable = 1;
 		sqlite3_create_function(db->sqlite, "now", 0, SQLITE_ANY, NULL,
 				pkgdb_now, NULL, NULL);
 		sqlite3_create_function(db->sqlite, "myarch", 0, SQLITE_ANY, NULL,
 				pkgdb_myarch, NULL, NULL);
 		sqlite3_create_function(db->sqlite, "myarch", 1, SQLITE_ANY, NULL,

@@ -820,7 +837,8 @@ pkgdb_query(struct pkgdb *db, const char *pattern, match_t match)

 	snprintf(sql, sizeof(sql),
 			"SELECT id, origin, name, version, comment, desc, "
 				"message, arch, maintainer, www, "
 				"prefix, flatsize, licenselogic, automatic "
 				"prefix, flatsize, licenselogic, automatic, "
 				"time, infos "
 			"FROM packages AS p%s "
 			"ORDER BY p.name;", comp);

@@ -848,6 +866,7 @@ pkgdb_query_condition(struct pkgdb *db, const char *condition)

 	    "SELECT id, origin, name, version, comment, desc, "
 	        "message, arch, maintainer, www, "
 	        "prefix, flatsize, licenselogic, automatic "
 		"time, infos "
 	    "FROM packages AS p WHERE %s "
 	    "ORDER BY p.name;", condition);

@@ -866,7 +885,7 @@ pkgdb_query_which(struct pkgdb *db, const char *path)

 	const char sql[] = ""
 		"SELECT p.id, p.origin, p.name, p.version, p.comment, p.desc, "
 			"p.message, p.arch, p.maintainer, p.www, "
 			"p.prefix, p.flatsize "
 			"p.prefix, p.flatsize, p.time, p.infos "
 			"FROM packages AS p, files AS f "
 			"WHERE p.id = f.package_id "
 				"AND f.path = ?1;";

@@ -890,7 +909,7 @@ pkgdb_query_shlib(struct pkgdb *db, const char *shlib)

 	const char sql[] = ""
 		"SELECT p.id, p.origin, p.name, p.version, p.comment, p.desc, "
 			"p.message, p.arch, p.maintainer, p.www, "
 			"p.prefix, p.flatsize "
 			"p.prefix, p.flatsize, p.time, p.infos "
 			"FROM packages AS p, pkg_shlibs AS ps, shlibs AS s "
 			"WHERE p.id = ps.package_id "
 				"AND ps.shlib_id = s.id "

@@ -1368,9 +1387,9 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 		"INSERT OR REPLACE INTO packages( "
 			"origin, name, version, comment, desc, message, arch, "
 			"maintainer, www, prefix, flatsize, automatic, licenselogic, "
 			"mtree_id) "
 			"mtree_id, infos, time) "
 		"VALUES( ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, 13, "
 		"(SELECT id from mtree where content = ?14));";
 		"(SELECT id from mtree where content = ?14), ?15, now());";
 	const char sql_dep[] = ""
 		"INSERT OR ROLLBACK INTO deps (origin, name, version, package_id) "
 		"VALUES (?1, ?2, ?3, ?4);";

@@ -1411,7 +1430,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 		"UPDATE deps SET NAME=?1 , VERSION=?2 WHERE ORIGIN=?3;";
 	const char *mtree, *origin, *name, *version, *name2, *version2;
 	const char *comment, *desc, *message;
 	const char *comment, *desc, *message, *infos;
 	const char *arch, *maintainer, *www, *prefix;
 	bool automatic;

@@ -1436,7 +1455,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	    PKG_ARCH, &arch, PKG_MAINTAINER, &maintainer,
 	    PKG_WWW, &www, PKG_PREFIX, &prefix, PKG_FLATSIZE, &flatsize,
 	    PKG_AUTOMATIC, &automatic, PKG_LICENSE_LOGIC, &licenselogic,
 	    PKG_NAME, &name);
 	    PKG_NAME, &name, PKG_INFOS, &infos);
 	sqlite3_bind_text(stmt, 1, mtree, -1, SQLITE_STATIC);

@@ -1466,6 +1485,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	sqlite3_bind_int(stmt, 12, automatic);
 	sqlite3_bind_int64(stmt, 13, licenselogic);
 	sqlite3_bind_text(stmt, 14, mtree, -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt, 15, infos, -1, SQLITE_STATIC);
 	if ((ret = sqlite3_step(stmt)) != SQLITE_DONE) {
 		ERROR_SQLITE(s);

@@ -2459,7 +2479,7 @@ pkgdb_query_autoremove(struct pkgdb *db)

 		sql_exec(db->sqlite, "INSERT OR IGNORE into autoremove(origin, pkgid, weight) "
 				"SELECT distinct origin, id, %d FROM packages WHERE automatic=1 AND "
 				"origin NOT IN (SELECT DISTINCT deps.origin FROM deps WHERE "
 				" deps.origin = pkgs.origin AND package_id NOT IN "
 				" deps.origin = packages.origin AND package_id NOT IN "
 				" (select pkgid from autoremove));"
 				, weight);
 	} while (sqlite3_changes(db->sqlite) != 0);

modified libpkg/private/db_upgrades.h

@@ -96,7 +96,6 @@ static struct db_upgrades {

 		"END;"
 	"DROP TABLE todelete;"
 	},
 	{4,
 	"DROP VIEW pkg_mtree;"
 	"DROP TRIGGER CLEAN_MTREE;"

@@ -111,7 +110,6 @@ static struct db_upgrades {

 	"DROP TRIGGER licenses_insert;"
 	"ALTER TABLE pkg_licenses_assoc RENAME TO pkg_licenses;"
 	},
 	{5,
 	"CREATE TABLE users ("
 		"id INTEGER PRIMARY KEY, "

@@ -189,6 +187,38 @@ static struct db_upgrades {

 	"licenselogic, pkg_format_version FROM oldpkgs;"
 	"DROP TABLE oldpkgs;"
 	},
 	{11,
 	"ALTER TABLE packages RENAME TO oldpkgs;"
 	"CREATE TABLE packages ("
 		"id INTEGER PRIMARY KEY,"
 		"origin TEXT UNIQUE NOT NULL,"
 		"name TEXT NOT NULL,"
 		"version TEXT NOT NULL,"
 		"comment TEXT NOT NULL,"
 		"desc TEXT NOT NULL,"
 		"mtree_id INTEGER REFERENCES mtree(id) ON DELETE RESTRICT"
 			" ON UPDATE CASCADE,"
 		"message TEXT,"
 		"arch TEXT NOT NULL,"
 		"maintainer TEXT NOT NULL, "
 		"www TEXT,"
 		"prefix TEXT NOT NULL,"
 		"flatsize INTEGER NOT NULL,"
 		"automatic INTEGER NOT NULL,"
 		"licenselogic INTEGER NOT NULL,"
 		"infos TEXT, "
 		"time INTEGER,"
 		"pkg_format_version INTEGER"
 	");"
 	"INSERT INTO packages (id, origin, name, version, comment, desc, "
 		"mtree_id, message, arch, maintainer, www, prefix, flatsize, "
 		"automatic, licenselogic, pkg_format_version) "
 		"SELECT id, origin, name, version, comment, desc, "
 		"mtree_id, message, arch, maintainer, www, prefix, flatsize, "
 		"automatic, licenselogic, pkg_format_version "
 		"FROM oldpkgs;"
 	"DROP TABLE oldpkgs;"
 	},
 	/* Mark the end of the array */
 	{ -1, NULL },

modified libpkg/private/pkg.h

@@ -40,7 +40,7 @@

 #include "private/utils.h"
 #define PKG_NUM_FIELDS 17
 #define PKG_NUM_FIELDS 18
 #define EXTRACT_ARCHIVE_FLAGS  (ARCHIVE_EXTRACT_OWNER |ARCHIVE_EXTRACT_PERM| \
 		ARCHIVE_EXTRACT_TIME  |ARCHIVE_EXTRACT_ACL | \

@@ -73,6 +73,7 @@ struct pkg {

 	STAILQ_HEAD(shlibs, pkg_shlib) shlibs;
 	int flags;
 	int64_t rowid;
 	int64_t time;
 	lic_t licenselogic;
 	pkg_t type;
 	STAILQ_ENTRY(pkg) next;

modified pkg/pkg-query.8

@@ -73,6 +73,8 @@ Prefix of the matched package

 Maintainer of the matched package
 .It Cm \&%c
 Comment of the matched package
 .It cm \&%i
 Additionnal information about the package
 .It Cm \&%w
 Home page of the matched package
 .It Cm \&%l

modified pkg/query.c

@@ -41,34 +41,36 @@

 #include "pkgcli.h"
 static struct query_flags {
         const char flag;
         const char *options;
         const unsigned multiline;
         const int dbflags;
 	const char flag;
 	const char *options;
 	const unsigned multiline;
 	const int dbflags;
 } q_flags[] = {
         { 'd', "nov",		1, PKG_LOAD_DEPS },
         { 'r', "nov",		1, PKG_LOAD_RDEPS },
         { 'C', "",		1, PKG_LOAD_CATEGORIES },
         { 'F', "ps",		1, PKG_LOAD_FILES },
         { 'S', "",		1, PKG_LOAD_SCRIPTS },
         { 'O', "kv",		1, PKG_LOAD_OPTIONS },
         { 'D', "",		1, PKG_LOAD_DIRS },
         { 'L', "",		1, PKG_LOAD_LICENSES },
         { 'U', "",		1, PKG_LOAD_USERS },
         { 'G', "",		1, PKG_LOAD_GROUPS },
 	{ 'B', "",              1, PKG_LOAD_SHLIBS },
 	{ 'd', "nov",		1, PKG_LOAD_DEPS },
 	{ 'r', "nov",		1, PKG_LOAD_RDEPS },
 	{ 'C', "",		1, PKG_LOAD_CATEGORIES },
 	{ 'F', "ps",		1, PKG_LOAD_FILES },
 	{ 'S', "",		1, PKG_LOAD_SCRIPTS },
 	{ 'O', "kv",		1, PKG_LOAD_OPTIONS },
 	{ 'D', "",		1, PKG_LOAD_DIRS },
 	{ 'L', "",		1, PKG_LOAD_LICENSES },
 	{ 'U', "",		1, PKG_LOAD_USERS },
 	{ 'G', "",		1, PKG_LOAD_GROUPS },
 	{ 'B', "",		1, PKG_LOAD_SHLIBS },
 	{ '?', "drCFODLUGBK",	1, PKG_LOAD_BASIC },	/* dbflags handled in analyse_query_string() */
         { 's', "hb",		0, PKG_LOAD_BASIC },
         { 'n', "",		0, PKG_LOAD_BASIC },
         { 'v', "",		0, PKG_LOAD_BASIC },
         { 'o', "",		0, PKG_LOAD_BASIC },
         { 'p', "",		0, PKG_LOAD_BASIC },
         { 'm', "",		0, PKG_LOAD_BASIC },
         { 'c', "",		0, PKG_LOAD_BASIC },
         { 'w', "",		0, PKG_LOAD_BASIC },
         { 'l', "",		0, PKG_LOAD_BASIC },
         { 'a', "",		0, PKG_LOAD_BASIC },
         { 'M', "",		0, PKG_LOAD_BASIC },
 	{ 's', "hb",		0, PKG_LOAD_BASIC },
 	{ 'n', "",		0, PKG_LOAD_BASIC },
 	{ 'v', "",		0, PKG_LOAD_BASIC },
 	{ 'o', "",		0, PKG_LOAD_BASIC },
 	{ 'p', "",		0, PKG_LOAD_BASIC },
 	{ 'm', "",		0, PKG_LOAD_BASIC },
 	{ 'c', "",		0, PKG_LOAD_BASIC },
 	{ 'w', "",		0, PKG_LOAD_BASIC },
 	{ 'l', "",		0, PKG_LOAD_BASIC },
 	{ 'a', "",		0, PKG_LOAD_BASIC },
 	{ 'M', "",		0, PKG_LOAD_BASIC },
 	{ 'i', "",		0, PKG_LOAD_BASIC },
 	{ 't', "",		0, PKG_LOAD_BASIC },
 };
 typedef enum {

@@ -92,6 +94,7 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 	const char *tmp;
 	bool automatic;
 	int64_t flatsize;
 	int64_t time;
 	lic_t licenselogic;
 	sbuf_clear(dest);

@@ -102,36 +105,52 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 			switch (qstr[0]) {
 				case 'n':
 					pkg_get(pkg, PKG_NAME, &tmp);
 					sbuf_cat(dest, tmp);
 					if (tmp != NULL)
 						sbuf_cat(dest, tmp);
 					break;
 				case 'v':
 					pkg_get(pkg, PKG_VERSION, &tmp);
 					sbuf_cat(dest, tmp);
 					if (tmp != NULL)
 						sbuf_cat(dest, tmp);
 					break;
 				case 'o':
 					pkg_get(pkg, PKG_ORIGIN, &tmp);
 					sbuf_cat(dest, tmp);
 					if (tmp != NULL)
 						sbuf_cat(dest, tmp);
 					break;
 				case 'p':
 					pkg_get(pkg, PKG_PREFIX, &tmp);
 					sbuf_cat(dest, tmp);
 					if (tmp != NULL)
 						sbuf_cat(dest, tmp);
 					break;
 				case 'm':
 					pkg_get(pkg, PKG_MAINTAINER, &tmp);
 					sbuf_cat(dest, tmp);
 					if (tmp != NULL)
 						sbuf_cat(dest, tmp);
 					break;
 				case 'c':
 					pkg_get(pkg, PKG_COMMENT, &tmp);
 					sbuf_cat(dest, tmp);
 					if (tmp != NULL)
 						sbuf_cat(dest, tmp);
 					break;
 				case 'w':
 					pkg_get(pkg, PKG_WWW, &tmp);
 					sbuf_cat(dest, tmp);
 					if (tmp != NULL)
 						sbuf_cat(dest, tmp);
 					break;
 				case 'i':
 					pkg_get(pkg, PKG_INFOS, &tmp);
 					if (tmp != NULL)
 						sbuf_cat(dest, tmp);
 					break;
 				case 'a':
 					pkg_get(pkg, PKG_AUTOMATIC, &automatic);
 					sbuf_printf(dest, "%d", automatic);
 					break;
 				case 't':
 					pkg_get(pkg, PKG_TIME, &time);
 					sbuf_printf(dest, "%" PRId64, time);
 					break;
 				case 's':
 					qstr++;
 					pkg_get(pkg, PKG_FLATSIZE, &flatsize);

@@ -425,6 +444,14 @@ format_sql_condition(const char *str, struct sbuf *sqlcond)

 						sbuf_cat(sqlcond, "message");
 						state = OPERATOR_STRING;
 						break;
 					case 'i':
 						sbuf_cat(sqlcond, "infos");
 						state = OPERATOR_STRING;
 						break;
 					case 't':
 						sbuf_cat(sqlcond, "time");
 						state = OPERATOR_INT;
 						break;
 					default:
 						fprintf(stderr, "malformed evaluation string");
 						return (EPKG_FATAL);

@@ -730,6 +757,9 @@ exec_query(int argc, char **argv)

 		return (EXIT_SUCCESS);
 	}
 	if (ret != EPKG_OK)
 		return (EX_IOERR);
 	if (condition != NULL) {
 		sbuf_finish(sqlcond);
 		if ((it = pkgdb_query_condition(db, sbuf_data(sqlcond))) == NULL)