Radish alpha
H
HardenedBSD-pkg
rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9
HardenedBSD Package Manager
Radicle
Git
Commits › cd69108
libpkg: store ignored shlibs in manifest and db
Isaac Freund committed 3 months ago
commit cd691081384eac80ce6da4071845978bc147c9c2
parent 3d87d1a
8 files changed +250 -5
modified libpkg/pkg.c
@@ -94,8 +94,12 @@ pkg_free(struct pkg *pkg)
	pkg->flags &= ~PKG_LOAD_GROUPS;

	vec_free_and_free(&pkg->shlibs_required, free);

	pkg->flags &= ~PKG_LOAD_SHLIBS_REQUIRED;
+ 
	vec_free_and_free(&pkg->shlibs_required_ignore, free);
+ 
	pkg->flags &= ~PKG_LOAD_SHLIBS_REQUIRED_IGNORE;

	vec_free_and_free(&pkg->shlibs_provided, free);
- 
	pkg->flags &= ~PKG_LOAD_SHLIBS_REQUIRED;
+ 
	pkg->flags &= ~PKG_LOAD_SHLIBS_PROVIDED;
+ 
	vec_free_and_free(&pkg->shlibs_provided_ignore, free);
+ 
	pkg->flags &= ~PKG_LOAD_SHLIBS_PROVIDED_IGNORE;

	vec_free_and_free(&pkg->provides, free);

	pkg->flags &= ~PKG_LOAD_PROVIDES;

	vec_free_and_free(&pkg->requires, free);
@@ -954,6 +958,25 @@ pkg_addshlib_required(struct pkg *pkg, const char *name,
}



int
+ 
pkg_addshlib_required_ignore(struct pkg *pkg, const char *name)
+ 
{
+ 
	assert(pkg != NULL);
+ 
	assert(name != NULL && name[0] != '\0');
+
+ 
	char *owned_name = xstrdup(name);
+
+ 
	/* silently ignore duplicates in case of shlibs */
+ 
	if (charv_insert_sorted(&pkg->shlibs_required_ignore, owned_name) != NULL) {
+ 
		free(owned_name);
+ 
		return (EPKG_OK);
+ 
	}
+
+ 
	dbg(3, "added shlib required ignore for %s on %s", pkg->name, owned_name);
+
+ 
	return (EPKG_OK);
+ 
}
+
+ 
int

pkg_addshlib_provided(struct pkg *pkg, const char *name,

    enum pkg_shlib_flags flags)

{
@@ -974,6 +997,25 @@ pkg_addshlib_provided(struct pkg *pkg, const char *name,
}



int
+ 
pkg_addshlib_provided_ignore(struct pkg *pkg, const char *name)
+ 
{
+ 
	assert(pkg != NULL);
+ 
	assert(name != NULL && name[0] != '\0');
+
+ 
	char *owned_name = xstrdup(name);
+
+ 
	/* silently ignore duplicates in case of shlibs */
+ 
	if (charv_insert_sorted(&pkg->shlibs_provided_ignore, owned_name) != NULL) {
+ 
		free(owned_name);
+ 
		return (EPKG_OK);
+ 
	}
+
+ 
	dbg(3, "added shlib provided ignore %s for %s", owned_name, pkg->name);
+
+ 
	return (EPKG_OK);
+ 
}
+
+ 
int

pkg_addconflict(struct pkg *pkg, const char *uniqueid)

{

	struct pkg_conflict *c = NULL;
modified libpkg/pkg.h.in
@@ -312,6 +312,8 @@ typedef enum {
	PKG_ATTR_REQUIRES,

	PKG_ATTR_CONFLICTS,

	PKG_ATTR_NUM_FIELDS,		/* end of fields */
+ 
	PKG_ATTR_SHLIBS_REQUIRED_IGNORE,
+ 
	PKG_ATTR_SHLIBS_PROVIDED_IGNORE,

} pkg_attr;



typedef enum {
@@ -1004,6 +1006,8 @@ int pkgdb_delete_annotation(struct pkgdb *db, struct pkg *pkg,
#define PKG_LOAD_PROVIDES		(1U << 14)

#define PKG_LOAD_REQUIRES		(1U << 15)

#define PKG_LOAD_LUA_SCRIPTS		(1u << 16)
+ 
#define PKG_LOAD_SHLIBS_REQUIRED_IGNORE	(1U << 17)
+ 
#define PKG_LOAD_SHLIBS_PROVIDED_IGNORE	(1U << 18)

/* Make sure new PKG_LOAD don't conflict with PKG_CONTAINS_* */



/**
modified libpkg/pkg_attributes.c
@@ -320,11 +320,21 @@ pkg_get_element(struct pkg *p, pkg_attr a)
		e->stringlist->list = &p->shlibs_required;

		e->type = PKG_STRINGLIST;

		break;
+ 
	case PKG_ATTR_SHLIBS_REQUIRED_IGNORE:
+ 
		e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));
+ 
		e->stringlist->list = &p->shlibs_required_ignore;
+ 
		e->type = PKG_STRINGLIST;
+ 
		break;

	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_ATTR_SHLIBS_PROVIDED_IGNORE:
+ 
		e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));
+ 
		e->stringlist->list = &p->shlibs_provided;
+ 
		e->type = PKG_STRINGLIST;
+ 
		break;

	case PKG_ATTR_PROVIDES:

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

		e->stringlist->list = &p->provides;
modified libpkg/pkg_manifest.c
@@ -46,6 +46,8 @@ enum {
	MANIFEST_SHLIBS_PROVIDED,

	MANIFEST_SHLIBS_REQUIRED,

	MANIFEST_USERS,
+ 
	MANIFEST_SHLIBS_REQUIRED_IGNORE,
+ 
	MANIFEST_SHLIBS_PROVIDED_IGNORE,

};



#define PKG_MESSAGE_LEGACY	1
@@ -180,9 +182,15 @@ static const struct pkg_manifest_key {
	{ "shlibs_provided",     MANIFEST_SHLIBS_PROVIDED,

			TYPE_SHIFT(UCL_ARRAY),  pkg_array},
+ 
	{ "shlibs_provided_ignore",     MANIFEST_SHLIBS_PROVIDED_IGNORE,
+ 
			TYPE_SHIFT(UCL_ARRAY),  pkg_array},
+ 


	{ "shlibs_required",     MANIFEST_SHLIBS_REQUIRED,

			TYPE_SHIFT(UCL_ARRAY),  pkg_array},
+ 
	{ "shlibs_required_ignore",     MANIFEST_SHLIBS_REQUIRED_IGNORE,
+ 
			TYPE_SHIFT(UCL_ARRAY),  pkg_array},
+ 


	{ "sum",                 offsetof(struct pkg, sum),

			TYPE_SHIFT(UCL_STRING), pkg_string},
@@ -394,12 +402,24 @@ pkg_array(struct pkg *pkg, const ucl_object_t *obj, uint32_t attr)
			else

				pkg_addshlib_required(pkg, ucl_object_tostring(cur), PKG_SHLIB_FLAGS_NONE);

			break;
+ 
		case MANIFEST_SHLIBS_REQUIRED_IGNORE:
+ 
			if (cur->type != UCL_STRING)
+ 
				pkg_emit_error("Skipping malformed required shared library ignore");
+ 
			else
+ 
				pkg_addshlib_required_ignore(pkg, ucl_object_tostring(cur));
+ 
			break;

		case MANIFEST_SHLIBS_PROVIDED:

			if (cur->type != UCL_STRING)

				pkg_emit_error("Skipping malformed provided shared library");

			else

				pkg_addshlib_provided(pkg, ucl_object_tostring(cur), PKG_SHLIB_FLAGS_NONE);

			break;
+ 
		case MANIFEST_SHLIBS_PROVIDED_IGNORE:
+ 
			if (cur->type != UCL_STRING)
+ 
				pkg_emit_error("Skipping malformed provided shared library ignore");
+ 
			else
+ 
				pkg_addshlib_provided_ignore(pkg, ucl_object_tostring(cur));
+ 
			break;

		case MANIFEST_CONFLICTS:

			if (cur->type != UCL_STRING)

				pkg_emit_error("Skipping malformed conflict name");
@@ -1075,6 +1095,16 @@ pkg_emit_object(struct pkg *pkg, short flags)
	if (seq)

		ucl_object_insert_key(top, seq, "shlibs_required", 15, false);
+ 
	dbg(4, "Emitting shibs_required_ignore");
+ 
	seq = NULL;
+ 
	vec_foreach(pkg->shlibs_required_ignore, i) {
+ 
		if (seq == NULL)
+ 
			seq = ucl_object_typed_new(UCL_ARRAY);
+ 
		ucl_array_append(seq, ucl_object_fromstring(pkg->shlibs_required_ignore.d[i]));
+ 
	}
+ 
	if (seq)
+ 
		ucl_object_insert_key(top, seq, "shlibs_required_ignore", 22, false);
+ 


	dbg(4, "Emitting shlibs_provided");

	seq = NULL;

	vec_foreach(pkg->shlibs_provided, i) {
@@ -1085,6 +1115,16 @@ pkg_emit_object(struct pkg *pkg, short flags)
	if (seq)

		ucl_object_insert_key(top, seq, "shlibs_provided", 15, false);
+ 
	dbg(4, "Emitting shlibs_provided_ignore");
+ 
	seq = NULL;
+ 
	vec_foreach(pkg->shlibs_provided_ignore, i) {
+ 
		if (seq == NULL)
+ 
			seq = ucl_object_typed_new(UCL_ARRAY);
+ 
		ucl_array_append(seq, ucl_object_fromstring(pkg->shlibs_provided_ignore.d[i]));
+ 
	}
+ 
	if (seq)
+ 
		ucl_object_insert_key(top, seq, "shlibs_provided_ignore", 22, false);
+ 


	dbg(4, "Emitting conflicts");

	seq = NULL;

	while (pkg_conflicts(pkg, &conflict) == EPKG_OK) {
modified libpkg/pkgdb.c
@@ -74,7 +74,7 @@ extern struct pkg_ctx ctx;
*/



#define DB_SCHEMA_MAJOR        0
- 
#define DB_SCHEMA_MINOR	37
+ 
#define DB_SCHEMA_MINOR	38



#define DBVERSION (DB_SCHEMA_MAJOR * 1000 + DB_SCHEMA_MINOR)
@@ -495,6 +495,13 @@ pkgdb_init(sqlite3 *sdb)
			" ON DELETE RESTRICT ON UPDATE RESTRICT,"

		"UNIQUE (package_id, shlib_id)"

	");"
+ 
	"CREATE TABLE pkg_shlibs_required_ignore ("
+ 
		"package_id INTEGER NOT NULL REFERENCES packages(id)"
+ 
			" ON DELETE CASCADE ON UPDATE CASCADE,"
+ 
		"shlib_id INTEGER NOT NULL REFERENCES shlibs(id)"
+ 
			" ON DELETE RESTRICT ON UPDATE RESTRICT,"
+ 
		"UNIQUE (package_id, shlib_id)"
+ 
	");"

	"CREATE TABLE pkg_shlibs_provided ("

		"package_id INTEGER NOT NULL REFERENCES packages(id)"

			" ON DELETE CASCADE ON UPDATE CASCADE,"
@@ -502,6 +509,13 @@ pkgdb_init(sqlite3 *sdb)
			" ON DELETE RESTRICT ON UPDATE RESTRICT,"

		"UNIQUE (package_id, shlib_id)"

	");"
+ 
	"CREATE TABLE pkg_shlibs_provided_ignore ("
+ 
		"package_id INTEGER NOT NULL REFERENCES packages(id)"
+ 
			" ON DELETE CASCADE ON UPDATE CASCADE,"
+ 
		"shlib_id INTEGER NOT NULL REFERENCES shlibs(id)"
+ 
			" ON DELETE RESTRICT ON UPDATE RESTRICT,"
+ 
		"UNIQUE (package_id, shlib_id)"
+ 
	");"

	"CREATE TABLE annotation ("

                "annotation_id INTEGER PRIMARY KEY,"

                "annotation TEXT NOT NULL UNIQUE"
@@ -560,7 +574,9 @@ pkgdb_init(sqlite3 *sdb)
	"CREATE INDEX pkg_users_package_id ON pkg_users (package_id);"

	"CREATE INDEX pkg_groups_package_id ON pkg_groups (package_id);"

	"CREATE INDEX pkg_shlibs_required_package_id ON pkg_shlibs_required (package_id);"
+ 
	"CREATE INDEX pkg_shlibs_required_ignore_package_id ON pkg_shlibs_required_ignore (package_id);"

	"CREATE INDEX pkg_shlibs_provided_package_id ON pkg_shlibs_provided (package_id);"
+ 
	"CREATE INDEX pkg_shlibs_provided_ignore_package_id ON pkg_shlibs_provided_ignore (package_id);"

	"CREATE INDEX pkg_directories_directory_id ON pkg_directories (directory_id);"

	"CREATE INDEX pkg_annotation_package_id ON pkg_annotation(package_id);"

	"CREATE INDEX pkg_digest_id ON packages(origin, manifestdigest);"
@@ -1318,7 +1334,9 @@ typedef enum _sql_prstmt_index {
	OPTION2,

	SHLIBS1,

	SHLIBS_REQD,
+ 
	SHLIBS_REQD_IGNORE,

	SHLIBS_PROV,
+ 
	SHLIBS_PROV_IGNORE,

	ANNOTATE1,

	ANNOTATE2,

	ANNOTATE_ADD1,
@@ -1451,11 +1469,21 @@ static sql_prstmt sql_prepared_statements[PRSTMT_LAST] = {
		"INSERT OR IGNORE INTO pkg_shlibs_required(package_id, shlib_id) "

		"VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))",

	},
+ 
	[SHLIBS_REQD_IGNORE] = {
+ 
		NULL,
+ 
		"INSERT OR IGNORE INTO pkg_shlibs_required_ignore(package_id, shlib_id) "
+ 
		"VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))",
+ 
	},

	[SHLIBS_PROV] = {

		NULL,

		"INSERT OR IGNORE INTO pkg_shlibs_provided(package_id, shlib_id) "

		"VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))",

	},
+ 
	[SHLIBS_PROV_IGNORE] = {
+ 
		NULL,
+ 
		"INSERT OR IGNORE INTO pkg_shlibs_provided_ignore(package_id, shlib_id) "
+ 
		"VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))",
+ 
	},

	[ANNOTATE1] = {

		NULL,

		"INSERT OR IGNORE INTO annotation(annotation) "
@@ -1970,8 +1998,12 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int forced,
	 */

	if (pkgdb_update_shlibs_required(pkg, package_id, s) != EPKG_OK)

		goto cleanup;
+ 
	if (pkgdb_update_shlibs_required_ignore(pkg, package_id, s) != EPKG_OK)
+ 
		goto cleanup;

	if (pkgdb_update_shlibs_provided(pkg, package_id, s) != EPKG_OK)

		goto cleanup;
+ 
	if (pkgdb_update_shlibs_provided_ignore(pkg, package_id, s) != EPKG_OK)
+ 
		goto cleanup;



	/*

	 * Insert annotation
@@ -2082,6 +2114,28 @@ pkgdb_update_shlibs_required(struct pkg *pkg, int64_t package_id, sqlite3 *s)
}



int
+ 
pkgdb_update_shlibs_required_ignore(struct pkg *pkg, int64_t package_id, sqlite3 *s)
+ 
{
+ 
	vec_foreach(pkg->shlibs_required_ignore, i) {
+ 
		sql_arg_t arg1[] = { SQL_ARG(pkg->shlibs_required_ignore.d[i]) };
+ 
		sql_arg_t arg2[] = {
+ 
			SQL_ARG(package_id),
+ 
			SQL_ARG(pkg->shlibs_required_ignore.d[i])
+ 
		};
+ 
		if (run_prstmt(SHLIBS1, arg1, NELEM(arg1))
+ 
		    != SQLITE_DONE
+ 
		    ||
+ 
		    run_prstmt(SHLIBS_REQD_IGNORE, arg2, NELEM(arg2))
+ 
		    != SQLITE_DONE) {
+ 
			ERROR_STMT_SQLITE(s, STMT(SHLIBS_REQD_IGNORE));
+ 
			return (EPKG_FATAL);
+ 
		}
+ 
	}
+
+ 
	return (EPKG_OK);
+ 
}
+
+ 
int

pkgdb_update_config_file_content(struct pkg *p, sqlite3 *s)

{

	struct pkg_config_file	*cf = NULL;
@@ -2124,6 +2178,28 @@ pkgdb_update_shlibs_provided(struct pkg *pkg, int64_t package_id, sqlite3 *s)
}



int
+ 
pkgdb_update_shlibs_provided_ignore(struct pkg *pkg, int64_t package_id, sqlite3 *s)
+ 
{
+ 
	vec_foreach(pkg->shlibs_provided_ignore, i) {
+ 
		sql_arg_t arg1[] = { SQL_ARG(pkg->shlibs_provided_ignore.d[i]) };
+ 
		sql_arg_t arg2[] = {
+ 
			SQL_ARG(package_id),
+ 
			SQL_ARG(pkg->shlibs_provided_ignore.d[i]),
+ 
		};
+ 
		if (run_prstmt(SHLIBS1, arg1, NELEM(arg1))
+ 
		    != SQLITE_DONE
+ 
		    ||
+ 
		    run_prstmt(SHLIBS_PROV_IGNORE, arg2, NELEM(arg2))
+ 
		    != SQLITE_DONE) {
+ 
			ERROR_STMT_SQLITE(s, STMT(SHLIBS_PROV_IGNORE));
+ 
			return (EPKG_FATAL);
+ 
		}
+ 
	}
+
+ 
	return (EPKG_OK);
+ 
}
+
+ 
int

pkgdb_update_requires(struct pkg *pkg, int64_t package_id, sqlite3 *s)

{

	vec_foreach(pkg->requires, i) {
@@ -2374,7 +2450,11 @@ pkgdb_unregister_pkg(struct pkgdb *db, int64_t id)
		"shlibs WHERE id NOT IN "

			"(SELECT DISTINCT shlib_id FROM pkg_shlibs_required)"

			"AND id NOT IN "
- 
			"(SELECT DISTINCT shlib_id FROM pkg_shlibs_provided)",
+ 
			"(SELECT DISTINCT shlib_id FROM pkg_shlibs_required_ignore)"
+ 
			"AND id NOT IN "
+ 
			"(SELECT DISTINCT shlib_id FROM pkg_shlibs_provided)"
+ 
			"AND id NOT IN "
+ 
			"(SELECT DISTINCT shlib_id FROM pkg_shlibs_provided_ignore)",

		"script WHERE script_id NOT IN "

		        "(SELECT DISTINCT script_id FROM pkg_script)",

		"lua_script WHERE lua_script_id NOT IN "
modified libpkg/pkgdb_iterator.c
@@ -592,6 +592,29 @@ pkgdb_load_shlib_required(sqlite3 *sqlite, struct pkg *pkg)
}



static int
+ 
addshlib_required_ignore_raw(struct pkg *pkg, const char *name)
+ 
{
+ 
	vec_push(&pkg->shlibs_required_ignore, xstrdup(name));
+ 
	return (EPKG_OK);
+ 
}
+
+ 
static int
+ 
pkgdb_load_shlib_required_ignore(sqlite3 *sqlite, struct pkg *pkg)
+ 
{
+ 
	const char	sql[] = ""
+ 
		"SELECT name"
+ 
		"  FROM pkg_shlibs_required_ignore, shlibs AS s"
+ 
		"  WHERE package_id = ?1"
+ 
		"    AND shlib_id = s.id"
+ 
		"  ORDER by name ASC";
+
+ 
	assert(pkg != NULL);
+
+ 
	return (load_val(sqlite, pkg, sql, PKG_LOAD_SHLIBS_REQUIRED,
+ 
	    addshlib_required_ignore_raw, PKG_ATTR_SHLIBS_REQUIRED_IGNORE));
+ 
}
+
+ 
static int

addshlib_provided_raw(struct pkg *pkg, const char *name)

{

	vec_push(&pkg->shlibs_provided, xstrdup(name));
@@ -615,6 +638,29 @@ pkgdb_load_shlib_provided(sqlite3 *sqlite, struct pkg *pkg)
}



static int
+ 
addshlib_provided_ignore_raw(struct pkg *pkg, const char *name)
+ 
{
+ 
	vec_push(&pkg->shlibs_provided_ignore, xstrdup(name));
+ 
	return (EPKG_OK);
+ 
}
+
+ 
static int
+ 
pkgdb_load_shlib_provided_ignore(sqlite3 *sqlite, struct pkg *pkg)
+ 
{
+ 
	const char	sql[] = ""
+ 
		"SELECT name"
+ 
		"  FROM pkg_shlibs_provided_ignore, shlibs AS s"
+ 
		"  WHERE package_id = ?1"
+ 
		"    AND shlib_id = s.id"
+ 
		"  ORDER by name ASC";
+
+ 
	assert(pkg != NULL);
+
+ 
	return (load_val(sqlite, pkg, sql, PKG_LOAD_SHLIBS_PROVIDED_IGNORE,
+ 
	    addshlib_provided_ignore_raw, PKG_ATTR_SHLIBS_PROVIDED_IGNORE));
+ 
}
+
+ 
static int

pkgdb_load_annotations(sqlite3 *sqlite, struct pkg *pkg)

{

	const char	sql[] = ""
@@ -1007,7 +1053,9 @@ static const struct load_on_flag {
	{ PKG_LOAD_USERS,		pkgdb_load_user },

	{ PKG_LOAD_GROUPS,		pkgdb_load_group },

	{ PKG_LOAD_SHLIBS_REQUIRED,	pkgdb_load_shlib_required },
+ 
	{ PKG_LOAD_SHLIBS_REQUIRED_IGNORE, pkgdb_load_shlib_required_ignore },

	{ PKG_LOAD_SHLIBS_PROVIDED,	pkgdb_load_shlib_provided },
+ 
	{ PKG_LOAD_SHLIBS_PROVIDED_IGNORE, pkgdb_load_shlib_provided_ignore },

	{ PKG_LOAD_ANNOTATIONS,		pkgdb_load_annotations },

	{ PKG_LOAD_CONFLICTS,		pkgdb_load_conflicts },

	{ PKG_LOAD_PROVIDES,		pkgdb_load_provides },
modified libpkg/private/db_upgrades.h
@@ -739,6 +739,23 @@ static struct db_upgrades {
	"ALTER TABLE directories ADD COLUMN gname TEXT; "

	"ALTER TABLE directories ADD COLUMN perm INTEGER; "

	"ALTER TABLE directories ADD COLUMN fflags INTEGER; "
+ 
	}, { 38,
+ 
	"CREATE TABLE pkg_shlibs_required_ignore ("
+ 
		"package_id INTEGER NOT NULL REFERENCES packages(id)"
+ 
			" ON DELETE CASCADE ON UPDATE CASCADE,"
+ 
		"shlib_id INTEGER NOT NULL REFERENCES shlibs(id)"
+ 
			" ON DELETE RESTRICT ON UPDATE RESTRICT,"
+ 
		"UNIQUE (package_id, shlib_id)"
+ 
	");"
+ 
	"CREATE TABLE pkg_shlibs_provided_ignore ("
+ 
		"package_id INTEGER NOT NULL REFERENCES packages(id)"
+ 
			" ON DELETE CASCADE ON UPDATE CASCADE,"
+ 
		"shlib_id INTEGER NOT NULL REFERENCES shlibs(id)"
+ 
			" ON DELETE RESTRICT ON UPDATE RESTRICT,"
+ 
		"UNIQUE (package_id, shlib_id)"
+ 
	");"
+ 
	"CREATE INDEX pkg_shlibs_required_ignore_package_id ON pkg_shlibs_required_ignore (package_id);"
+ 
	"CREATE INDEX pkg_shlibs_provided_ignore_package_id ON pkg_shlibs_provided_ignore (package_id);"

	},

	/* Mark the end of the array */

	{ -1, NULL }
modified libpkg/private/pkg.h
@@ -230,7 +230,9 @@ struct pkg {
	charv_t		 users;

	charv_t		 groups;

	charv_t		 shlibs_required;
+ 
	charv_t		 shlibs_required_ignore;

	charv_t		 shlibs_provided;
+ 
	charv_t		 shlibs_provided_ignore;

	pkghash			*conflictshash;

	struct pkg_conflict	*conflicts;

	charv_t		 provides;
@@ -763,7 +765,9 @@ int get_pragma(sqlite3 *, const char *sql, int64_t *res, bool silence);


int pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int forced, const char *);

int pkgdb_update_shlibs_required(struct pkg *pkg, int64_t package_id, sqlite3 *s);
+ 
int pkgdb_update_shlibs_required_ignore(struct pkg *pkg, int64_t package_id, sqlite3 *s);

int pkgdb_update_shlibs_provided(struct pkg *pkg, int64_t package_id, sqlite3 *s);
+ 
int pkgdb_update_shlibs_provided_ignore(struct pkg *pkg, int64_t package_id, sqlite3 *s);

int pkgdb_update_provides(struct pkg *pkg, int64_t package_id, sqlite3 *s);

int pkgdb_update_requires(struct pkg *pkg, int64_t package_id, sqlite3 *s);

int pkgdb_insert_annotations(struct pkg *pkg, int64_t package_id, sqlite3 *s);
@@ -863,9 +867,9 @@ enum pkg_shlib_flags pkg_shlib_flags_from_abi(const struct pkg_abi *shlib_abi);
 */

char *pkg_shlib_name_with_flags(const char *name, enum pkg_shlib_flags flags);

int pkg_addshlib_required(struct pkg *pkg, const char *name, enum pkg_shlib_flags);
- 
/* No checking for duplicates or filtering */
- 
int pkg_addshlib_required_raw(struct pkg *pkg, const char *name);
+ 
int pkg_addshlib_required_ignore(struct pkg *pkg, const char *name);

int pkg_addshlib_provided(struct pkg *pkg, const char *name, enum pkg_shlib_flags);
+ 
int pkg_addshlib_provided_ignore(struct pkg *pkg, const char *name);



int pkg_addconflict(struct pkg *pkg, const char *name);

int pkg_addprovide(struct pkg *pkg, const char *name);