e806101 Remove conflict informations from packages — HardenedBSD-pkg

modified libpkg/backup.c

@@ -14,9 +14,9 @@ pkgdb_dump(struct pkgdb *db, char *dest)

 	struct packing *pack = NULL;
 	char *m = NULL;
 	int ret = EPKG_OK;
 	int query_flags = PKG_LOAD_DEPS | PKG_LOAD_CONFLICTS | PKG_LOAD_FILES | PKG_LOAD_CATEGORIES |
 					  PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS | PKG_LOAD_OPTIONS |
 					  PKG_LOAD_MTREE | PKG_LOAD_LICENSES;
 	int query_flags = PKG_LOAD_DEPS | PKG_LOAD_FILES | PKG_LOAD_CATEGORIES |
 	    PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS | PKG_LOAD_OPTIONS |
 	    PKG_LOAD_MTREE | PKG_LOAD_LICENSES;
 	packing_init(&pack, dest ? dest : "./pkgdump", TXZ);

modified libpkg/pkg.c

@@ -52,7 +52,6 @@ pkg_new(struct pkg **pkg, pkg_t type)

 	STAILQ_INIT(&(*pkg)->rdeps);
 	STAILQ_INIT(&(*pkg)->files);
 	STAILQ_INIT(&(*pkg)->dirs);
 	STAILQ_INIT(&(*pkg)->conflicts);
 	STAILQ_INIT(&(*pkg)->scripts);
 	STAILQ_INIT(&(*pkg)->options);
 	STAILQ_INIT(&(*pkg)->users);

@@ -88,7 +87,6 @@ pkg_reset(struct pkg *pkg, pkg_t type)

 	pkg_list_free(pkg, PKG_RDEPS);
 	pkg_list_free(pkg, PKG_FILES);
 	pkg_list_free(pkg, PKG_DIRS);
 	pkg_list_free(pkg, PKG_CONFLICTS);
 	pkg_list_free(pkg, PKG_SCRIPTS);
 	pkg_list_free(pkg, PKG_OPTIONS);
 	pkg_list_free(pkg, PKG_USERS);

@@ -113,7 +111,6 @@ pkg_free(struct pkg *pkg)

 	pkg_list_free(pkg, PKG_RDEPS);
 	pkg_list_free(pkg, PKG_FILES);
 	pkg_list_free(pkg, PKG_DIRS);
 	pkg_list_free(pkg, PKG_CONFLICTS);
 	pkg_list_free(pkg, PKG_SCRIPTS);
 	pkg_list_free(pkg, PKG_OPTIONS);
 	pkg_list_free(pkg, PKG_USERS);

@@ -385,14 +382,6 @@ pkg_dirs(struct pkg *pkg, struct pkg_dir **d)

 }
 int
 pkg_conflicts(struct pkg *pkg, struct pkg_conflict **c)
 {
 	assert(pkg != NULL);
 	PKG_LIST_NEXT(&pkg->conflicts, *c);
 }
 int
 pkg_scripts(struct pkg *pkg, struct pkg_script **s)
 {
 	assert(pkg != NULL);

@@ -663,29 +652,6 @@ pkg_adddir_attr(struct pkg *pkg, const char *path, const char *uname, const char

 }
 int
 pkg_addconflict(struct pkg *pkg, const char *glob)
 {
 	struct pkg_conflict *c = NULL;
 	assert(pkg != NULL);
 	assert(glob != NULL && glob[0] != '\0');
 	while (pkg_conflicts(pkg, &c) != EPKG_END) {
 		if (!strcmp(glob, pkg_conflict_glob(c))) {
 			pkg_emit_error("duplicate conflict listing: %s, ignoring", glob);
 			return (EPKG_OK);
 		}
 	}
 	pkg_conflict_new(&c);
 	sbuf_set(&c->glob, glob);
 	STAILQ_INSERT_TAIL(&pkg->conflicts, c, next);
 	return (EPKG_OK);
 }
 int
 pkg_addscript(struct pkg *pkg, const char *data, pkg_script_t type)
 {
 	struct pkg_script *s;

@@ -833,8 +799,6 @@ pkg_list_is_empty(struct pkg *pkg, pkg_list list) {

 			return (STAILQ_EMPTY(&pkg->users));
 		case PKG_GROUPS:
 			return (STAILQ_EMPTY(&pkg->groups));
 		case PKG_CONFLICTS:
 			return (STAILQ_EMPTY(&pkg->conflicts));
 		case PKG_SCRIPTS:
 			return (STAILQ_EMPTY(&pkg->scripts));
 	}

@@ -861,7 +825,6 @@ pkg_list_free(struct pkg *pkg, pkg_list list) {

 	struct pkg_user *u;
 	struct pkg_group *g;
 	struct pkg_script *s;
 	struct pkg_conflict *conflict;
 	switch (list) {
 		case PKG_DEPS:

@@ -904,10 +867,6 @@ pkg_list_free(struct pkg *pkg, pkg_list list) {

 			LIST_FREE(&pkg->scripts, s, pkg_script_free);
 			pkg->flags &= ~PKG_LOAD_SCRIPTS;
 			break;
 		case PKG_CONFLICTS:
 			LIST_FREE(&pkg->conflicts, conflict, pkg_conflict_free);
 			pkg->flags &= ~PKG_LOAD_CONFLICTS;
 			break;
 	}
 }

modified libpkg/pkg.h

@@ -12,7 +12,6 @@ struct pkg_dep;

 struct pkg_file;
 struct pkg_dir;
 struct pkg_category;
 struct pkg_conflict;
 struct pkg_script;
 struct pkg_option;
 struct pkg_license;

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

 	PKG_DIRS,
 	PKG_USERS,
 	PKG_GROUPS,
 	PKG_CONFLICTS,
 	PKG_SCRIPTS
 } pkg_list;

@@ -342,13 +340,6 @@ int pkg_users(struct pkg *pkg, struct pkg_user **user);

 int pkg_groups(struct pkg *pkg, struct pkg_group **group);
 /**
  * Iterates over the conflicts of the package.
  * @param conflict Must be set to NULL for the first call.
  * @return An error code.
  */
 int pkg_conflicts(struct pkg *, struct pkg_conflict **conflict);
 /**
  * Iterates over the scripts of the package.
  * @param script Must be set to NULL for the first call.
  * @return An error code.

@@ -461,12 +452,6 @@ int pkg_adduid(struct pkg *pkg, const char *name, const char *uidstr);

 int pkg_addgid(struct pkg *pkg, const char *group, const char *gidstr);
 /**
  * Allocate a new struct pkg_conflict and add it to the conflicts of pkg.
  * @return An error code.
  */
 int pkg_addconflict(struct pkg *pkg, const char *glob);
 /**
  * Allocate a new struct pkg_script and add it to the scripts of pkg.
  * @param path The path to the script on disk.
  @ @return An error code.

@@ -520,9 +505,6 @@ const char *pkg_user_uidstr(struct pkg_user *);

 const char *pkg_group_name(struct pkg_group *);
 const char *pkg_group_gidstr(struct pkg_group *);
 /* pkg_conflict */
 const char * pkg_conflict_glob(struct pkg_conflict *);
 /* pkg_script */
 const char *pkg_script_data(struct pkg_script *);
 pkg_script_t pkg_script_type(struct pkg_script *);

@@ -614,16 +596,15 @@ struct pkgdb_it * pkgdb_query_which(struct pkgdb *db, const char *path);

 #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_SCRIPTS (1<<5)
 #define PKG_LOAD_OPTIONS (1<<6)
 #define PKG_LOAD_MTREE (1<<7)
 #define PKG_LOAD_DIRS (1<<8)
 #define PKG_LOAD_CATEGORIES (1<<9)
 #define PKG_LOAD_LICENSES (1<<10)
 #define PKG_LOAD_USERS (1<<11)
 #define PKG_LOAD_GROUPS (1<<12)
 #define PKG_LOAD_FILES (1<<2)
 #define PKG_LOAD_SCRIPTS (1<<3)
 #define PKG_LOAD_OPTIONS (1<<4)
 #define PKG_LOAD_MTREE (1<<5)
 #define PKG_LOAD_DIRS (1<<6)
 #define PKG_LOAD_CATEGORIES (1<<7)
 #define PKG_LOAD_LICENSES (1<<8)
 #define PKG_LOAD_USERS (1<<9)
 #define PKG_LOAD_GROUPS (1<<10)
 /**
  * Get the next pkg.

@@ -641,7 +622,6 @@ void pkgdb_it_free(struct pkgdb_it *);

 int pkgdb_load_deps(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_rdeps(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_conflicts(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_files(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_dirs(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_scripts(struct pkgdb *db, struct pkg *pkg);

modified libpkg/pkg_attributes.c

@@ -155,37 +155,6 @@ pkg_category_free(struct pkg_category *c)

 }
 /*
  * Conflict
  */
 int
 pkg_conflict_new(struct pkg_conflict **c)
 {
 	if ((*c = calloc(1, sizeof(struct pkg_conflict))) == NULL) {
 		pkg_emit_errno("calloc", "pkg_conflict");
 		return (EPKG_FATAL);
 	}
 	return (EPKG_OK);
 }
 void
 pkg_conflict_free(struct pkg_conflict *c)
 {
 	if (c == NULL)
 		return;
 	sbuf_free(c->glob);
 	free(c);
 }
 const char *
 pkg_conflict_glob(struct pkg_conflict *c)
 {
 	return (sbuf_get(c->glob));
 }
 /*
  * License
  */
 int

modified libpkg/pkg_create.c

@@ -159,9 +159,9 @@ int

 pkg_create_installed(const char *outdir, pkg_formats format, const char *rootdir, struct pkg *pkg)
 {
 	struct packing *pkg_archive;
 	int required_flags = PKG_LOAD_DEPS | PKG_LOAD_CONFLICTS | PKG_LOAD_FILES | PKG_LOAD_CATEGORIES |
 						 PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS | PKG_LOAD_OPTIONS |
 						 PKG_LOAD_MTREE | PKG_LOAD_LICENSES;
 	int required_flags = PKG_LOAD_DEPS | PKG_LOAD_FILES | PKG_LOAD_CATEGORIES |
 	    PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS | PKG_LOAD_OPTIONS |
 	    PKG_LOAD_MTREE | PKG_LOAD_LICENSES;
 	assert(pkg->type == PKG_INSTALLED);

modified libpkg/pkg_manifest.c

@@ -19,16 +19,15 @@

 #define PKG_UNKNOWN -1
 #define PKG_DEPS -2
 #define PKG_CONFLICTS -3
 #define PKG_FILES -4
 #define PKG_DIRS -5
 #define PKG_SCRIPTS -6
 #define PKG_CATEGORIES -7
 #define PKG_LICENSES -8
 #define PKG_OPTIONS -9
 #define PKG_USERS -10
 #define PKG_GROUPS -11
 #define PKG_DIRECTORIES -12
 #define PKG_FILES -3
 #define PKG_DIRS -4
 #define PKG_SCRIPTS -5
 #define PKG_CATEGORIES -6
 #define PKG_LICENSES -7
 #define PKG_OPTIONS -8
 #define PKG_USERS -9
 #define PKG_GROUPS -10
 #define PKG_DIRECTORIES -11
 static int pkg_set_from_node(struct pkg *, yaml_node_t *, yaml_document_t *, int);
 static int pkg_set_flatsize_from_node(struct pkg *, yaml_node_t *, yaml_document_t *, int);

@@ -55,7 +54,6 @@ static struct manifest_key {

 	{ "maintainer", PKG_MAINTAINER, YAML_SCALAR_NODE, pkg_set_from_node},
 	{ "prefix", PKG_PREFIX, YAML_SCALAR_NODE, pkg_set_from_node},
 	{ "deps", PKG_DEPS, YAML_MAPPING_NODE, parse_mapping},
 	{ "conflicts", PKG_CONFLICTS, YAML_SEQUENCE_NODE, parse_sequence},
 	{ "files", PKG_FILES, YAML_MAPPING_NODE, parse_mapping},
 	{ "dirs", PKG_DIRS, YAML_SEQUENCE_NODE, parse_sequence},
 	{ "directories", PKG_DIRECTORIES, YAML_MAPPING_NODE, parse_mapping},

@@ -213,12 +211,6 @@ parse_sequence(struct pkg * pkg, yaml_node_t *node, yaml_document_t *doc, int at

 	while (item < node->data.sequence.items.top) {
 		val = yaml_document_get_node(doc, *item);
 		switch (attr) {
 			case PKG_CONFLICTS:
 				if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0)
 					pkg_emit_error("Skipping malformed conflict");
 				else
 					pkg_addconflict(pkg, val->data.scalar.value);
 				break;
 			case PKG_CATEGORIES:
 				if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0)
 					pkg_emit_error("Skipping malformed category");

@@ -635,7 +627,6 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 	yaml_document_t doc;
 	char tmpbuf[BUFSIZ];
 	struct pkg_dep *dep = NULL;
 	struct pkg_conflict *conflict = NULL;
 	struct pkg_option *option = NULL;
 	struct pkg_file *file = NULL;
 	struct pkg_dir *dir = NULL;

@@ -754,10 +745,6 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)

 		manifest_append_kv(groups, pkg_group_name(group), group->gidstr);
 	}
 	seq = -1;
 	while (pkg_conflicts(pkg, &conflict) == EPKG_OK)
 		manifest_append_seqval(&doc, mapping, &seq, "conflicts", pkg_conflict_glob(conflict));
 	while (pkg_options(pkg, &option) == EPKG_OK) {
 		if (options == -1) {
 			options = yaml_document_add_mapping(&doc, NULL, YAML_FLOW_MAPPING_STYLE);

modified libpkg/pkg_private.h

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

 	STAILQ_HEAD(rdeps, pkg_dep) rdeps;
 	STAILQ_HEAD(files, pkg_file) files;
 	STAILQ_HEAD(dirs, pkg_dir) dirs;
 	STAILQ_HEAD(conflicts, pkg_conflict) conflicts;
 	STAILQ_HEAD(scripts, pkg_script) scripts;
 	STAILQ_HEAD(options, pkg_option) options;
 	STAILQ_HEAD(users, pkg_user) users;

@@ -80,11 +79,6 @@ struct pkg_dir {

 	STAILQ_ENTRY(pkg_dir) next;
 };
 struct pkg_conflict {
 	struct sbuf *glob;
 	STAILQ_ENTRY(pkg_conflict) next;
 };
 struct pkg_script {
 	struct sbuf *data;
 	pkg_script_t type;

@@ -143,9 +137,6 @@ void pkg_category_free(struct pkg_category *);

 int pkg_license_new(struct pkg_license **);
 void pkg_license_free(struct pkg_license *);
 int pkg_conflict_new(struct pkg_conflict **);
 void pkg_conflict_free(struct pkg_conflict *);
 int pkg_script_new(struct pkg_script **);
 void pkg_script_free(struct pkg_script *);

modified libpkg/pkgdb.c

@@ -357,12 +357,6 @@ pkgdb_init(sqlite3 *sdb)

 		"package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE"
 			" ON UPDATE CASCADE"
 	");"
 	"CREATE TABLE conflicts ("
 		"name TEXT NOT NULL,"
 		"package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE"
 			" ON UPDATE CASCADE,"
 		"PRIMARY KEY (package_id,name)"
 	");"
 	"CREATE TABLE directories ("
 		"id INTEGER PRIMARY KEY,"
 		"path TEXT NOT NULL UNIQUE"

@@ -646,10 +640,6 @@ pkgdb_it_next(struct pkgdb_it *it, struct pkg **pkg_p, int flags)

 			if ((ret = pkgdb_load_rdeps(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_CONFLICTS)
 			if ((ret = pkgdb_load_conflicts(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_FILES)
 			if ((ret = pkgdb_load_files(it->db, pkg)) != EPKG_OK)
 				return (ret);

@@ -1109,20 +1099,6 @@ pkgdb_load_group(struct pkgdb *db, struct pkg *pkg)

 }
 int
 pkgdb_load_conflicts(struct pkgdb *db, struct pkg *pkg)
 {
 	const char sql[] = ""
 		"SELECT name "
 		"FROM conflicts "
 		"WHERE package_id = ?1;";
 	assert(db != NULL && pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_CONFLICTS, pkg_addconflict, PKG_CONFLICTS));
 }
 int
 pkgdb_load_scripts(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt = NULL;

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

 	struct pkg_dep *dep = NULL;
 	struct pkg_file *file = NULL;
 	struct pkg_dir *dir = NULL;
 	struct pkg_conflict *conflict = NULL;
 	struct pkg_script *script = NULL;
 	struct pkg_option *option = NULL;
 	struct pkg_category *category = NULL;

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

 	sqlite3_stmt *stmt_pkg = NULL;
 	sqlite3_stmt *stmt_mtree = NULL;
 	sqlite3_stmt *stmt_dep = NULL;
 	sqlite3_stmt *stmt_conflict = NULL;
 	sqlite3_stmt *stmt_file = NULL;
 	sqlite3_stmt *stmt_script = NULL;
 	sqlite3_stmt *stmt_option = NULL;

@@ -1285,9 +1259,6 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	const char sql_dep[] = ""
 		"INSERT OR ROLLBACK INTO deps (origin, name, version, package_id) "
 		"VALUES (?1, ?2, ?3, ?4);";
 	const char sql_conflict[] = ""
 		"INSERT OR ROLLBACK INTO conflicts (name, package_id) "
 		"VALUES (?1, ?2);";
 	const char sql_file[] = ""
 		"INSERT OR ROLLBACK INTO files (path, sha256, package_id) "
 		"VALUES (?1, ?2, ?3);";

@@ -1411,26 +1382,6 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	}
 	/*
 	 * Insert conflicts list
 	 */
 	if (sqlite3_prepare_v2(s, sql_conflict, -1, &stmt_conflict, NULL) != SQLITE_OK) {
 		ERROR_SQLITE(s);
 		goto cleanup;
 	}
 	while (pkg_conflicts(pkg, &conflict) == EPKG_OK) {
 		sqlite3_bind_text(stmt_conflict, 1, pkg_conflict_glob(conflict), -1, SQLITE_STATIC);
 		sqlite3_bind_int64(stmt_conflict, 2, package_id);
 		if ((ret = sqlite3_step(stmt_conflict)) != SQLITE_DONE) {
 			ERROR_SQLITE(s);
 			goto cleanup;
 		}
 		sqlite3_reset(stmt_conflict);
 	}
 	/*
 	 * Insert files.
 	 */

@@ -1680,9 +1631,6 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete)

 	if (stmt_dep != NULL)
 		sqlite3_finalize(stmt_dep);
 	if (stmt_conflict != NULL)
 		sqlite3_finalize(stmt_conflict);
 	if (stmt_file != NULL)
 		sqlite3_finalize(stmt_file);

modified pkg/create.c

@@ -27,9 +27,9 @@ pkg_create_matches(int argc, char **argv, match_t match, pkg_formats fmt, const

 	struct pkgdb_it *it = NULL;
 	struct pkg *pkg = NULL;
 	const char *name, *version;
 	int query_flags = PKG_LOAD_DEPS | PKG_LOAD_CONFLICTS | PKG_LOAD_FILES | PKG_LOAD_CATEGORIES |
 					  PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS | PKG_LOAD_OPTIONS |
 					  PKG_LOAD_MTREE | PKG_LOAD_LICENSES | PKG_LOAD_USERS | PKG_LOAD_GROUPS;
 	int query_flags = PKG_LOAD_DEPS | PKG_LOAD_FILES | PKG_LOAD_CATEGORIES |
 	    PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS | PKG_LOAD_OPTIONS |
 	    PKG_LOAD_MTREE | PKG_LOAD_LICENSES | PKG_LOAD_USERS | PKG_LOAD_GROUPS;
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
 		pkgdb_close(db);

modified pkg/pkg-query.1

@@ -102,8 +102,6 @@ for licenses

 for users
 .It \fBG\fB
 for groups
 .It \fBK\fB
 for conflicts
 .El
 .Ss Multiline patterns:
 .Bl -tag -width F1

@@ -126,8 +124,6 @@ Expands to the list of license(s) for the matched package.

 Expands to the list of users needed by the matched package.
 .It \fB%G\fB
 Expands to the list of groups needed by the matched package.
 .It \fB%K\fB
 Expands to the list of conflicts registered by the matched package.
 .It \fB%S\fB
 Expands to the list of scripts for the matching packages - install, deinstall, etc.
 .El

modified pkg/query.c

@@ -28,7 +28,6 @@ static struct query_flags {

         { 'L', "",		1, PKG_LOAD_LICENSES },
         { 'U', "",		1, PKG_LOAD_USERS },
         { 'G', "",		1, PKG_LOAD_GROUPS },
         { 'K', "",		1, PKG_LOAD_CONFLICTS },
 	{ '?', "drCFODLUGK",	1, PKG_LOAD_BASIC },	/* dbflags handled in analyse_query_string() */
         { 's', "hb",		0, PKG_LOAD_BASIC },
         { 'n', "",		0, PKG_LOAD_BASIC },

@@ -131,9 +130,6 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 						case 'G':
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_GROUPS));
 							break;
 						case 'K':
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_CONFLICTS));
 							break;
 					}
 					break;
 				case 'l':

@@ -200,9 +196,6 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 				case 'G':
 					sbuf_cat(dest, pkg_group_name((struct pkg_group *)data));
 					break;
 				case 'K':
 					sbuf_cat(dest, pkg_conflict_glob((struct pkg_conflict *)data));
 					break;
 				case '%':
 					sbuf_putc(dest, '%');
 					break;

@@ -251,7 +244,6 @@ print_query(struct pkg *pkg, char *qstr, char multiline)

 	struct pkg_license *lic = NULL;
 	struct pkg_user *user = NULL;
 	struct pkg_group *group = NULL;
 	struct pkg_conflict *conflict = NULL;
 	struct pkg_script *scripts = NULL;
 	switch (multiline) {

@@ -309,12 +301,6 @@ print_query(struct pkg *pkg, char *qstr, char multiline)

 				printf("%s\n", sbuf_data(output));
 			}
 			break;
 		case 'K':
 			while (pkg_conflicts(pkg, &conflict) == EPKG_OK) {
 				format_str(pkg, output, qstr, conflict);
 				printf("%s\n", sbuf_data(output));
 			}
 			break;
 		case 'S':
 			while (pkg_scripts(pkg, &scripts) == EPKG_OK) {
 				format_str(pkg, output, qstr, scripts);

modified ports/bsd.pkgng.mk

@@ -61,16 +61,6 @@ fake-pkg:

 	@${ECHO_CMD} -n "${lic}," >> ${MANIFESTF}
 .endfor
 	@${ECHO_CMD} "]" >> ${MANIFESTF}
 .if !defined(DISABLE_CONFLICTS)
 	@${ECHO_CMD} -n "conflicts: [" >> ${MANIFESTF}
 .for conflicts in ${CONFLICTS:u}
 	@${ECHO_CMD} -n "\"${conflicts}\"," >> ${MANIFESTF}
 .endfor
 .for conflicts in ${CONFLICTS_INSTALL:u}
 	@${ECHO_CMD} -n "\"${conflicts}\"," >> ${MANIFESTF}
 .endfor
 	@${ECHO_CMD} "]" >> ${MANIFESTF}
 .endif
 	@${ECHO_CMD} -n "users: [" >> ${MANIFESTF}
 .for user in ${USERS:u}
 	@${ECHO_CMD} -n "${user}, " >> ${MANIFESTF}