7aa1d7d Convert conflicts to uniqueid — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -1051,27 +1051,27 @@ pkg_addshlib_provided(struct pkg *pkg, const char *name)

 }
 int
 pkg_addconflict(struct pkg *pkg, const char *name)
 pkg_addconflict(struct pkg *pkg, const char *uniqueid)
 {
 	struct pkg_conflict *c = NULL;
 	const char *origin;
 	const char *uid;
 	assert(pkg != NULL);
 	assert(name != NULL && name[0] != '\0');
 	assert(uniqueid != NULL && uniqueid[0] != '\0');
 	HASH_FIND_STR(pkg->conflicts, __DECONST(char *, name), c);
 	HASH_FIND_STR(pkg->conflicts, __DECONST(char *, uniqueid), c);
 	/* silently ignore duplicates in case of conflicts */
 	if (c != NULL)
 		return (EPKG_OK);
 	pkg_conflict_new(&c);
 	sbuf_set(&c->origin, name);
 	pkg_get(pkg, PKG_ORIGIN, &origin);
 	pkg_debug(3, "Pkg: add a new conflict origin: %s, with %s", origin, name);
 	sbuf_set(&c->uniqueid, uniqueid);
 	pkg_get(pkg, PKG_UNIQUEID, &uid);
 	pkg_debug(3, "Pkg: add a new conflict origin: %s, with %s", uid, uniqueid);
 	HASH_ADD_KEYPTR(hh, pkg->conflicts,
 	    __DECONST(char *, pkg_conflict_origin(c)),
 	    sbuf_size(c->origin), c);
 	    sbuf_size(c->uniqueid), c);
 	return (EPKG_OK);
 }

modified libpkg/pkg_attributes.c

@@ -409,7 +409,7 @@ pkg_conflict_free(struct pkg_conflict *c)

 	if (c == NULL)
 		return;
 	sbuf_free(c->origin);
 	sbuf_free(c->uniqueid);
 	free(c);
 }

@@ -418,7 +418,7 @@ pkg_conflict_origin(const struct pkg_conflict *c)

 {
 	assert(c != NULL);
 	return (sbuf_get(c->origin));
 	return (sbuf_get(c->uniqueid));
 }
 /*

modified libpkg/pkg_conflicts.c

@@ -148,27 +148,27 @@ void

 pkg_conflicts_register(struct pkg *p1, struct pkg *p2, enum pkg_conflict_type type)
 {
 	struct pkg_conflict *c1, *c2, *test;
 	const char *o1, *o2;
 	const char *u1, *u2;
 	pkg_get(p1, PKG_ORIGIN, &o1);
 	pkg_get(p2, PKG_ORIGIN, &o2);
 	pkg_get(p1, PKG_UNIQUEID, &u1);
 	pkg_get(p2, PKG_UNIQUEID, &u2);
 	pkg_conflict_new(&c1);
 	pkg_conflict_new(&c2);
 	if (c1 != NULL && c2 != NULL) {
 		c1->type = c2->type = type;
 		HASH_FIND_STR(p1->conflicts, o2, test);
 		HASH_FIND_STR(p1->conflicts, u2, test);
 		if (test == NULL) {
 			sbuf_set(&c1->origin, o2);
 			HASH_ADD_KEYPTR(hh, p1->conflicts, pkg_conflict_origin(c1), sbuf_size(c1->origin), c1);
 			pkg_debug(2, "registering conflict between %s and %s", o1, o2);
 			sbuf_set(&c1->uniqueid, u2);
 			HASH_ADD_KEYPTR(hh, p1->conflicts, pkg_conflict_origin(c1), sbuf_size(c1->uniqueid), c1);
 			pkg_debug(2, "registering conflict between %s and %s", u1, u2);
 		}
 		HASH_FIND_STR(p2->conflicts, o1, test);
 		HASH_FIND_STR(p2->conflicts, u1, test);
 		if (test == NULL) {
 			sbuf_set(&c2->origin, o1);
 			HASH_ADD_KEYPTR(hh, p2->conflicts, pkg_conflict_origin(c2), sbuf_size(c2->origin), c2);
 			pkg_debug(2, "registering conflict between %s and %s", o2, o1);
 			sbuf_set(&c2->uniqueid, u1);
 			HASH_ADD_KEYPTR(hh, p2->conflicts, pkg_conflict_origin(c2), sbuf_size(c2->uniqueid), c2);
 			pkg_debug(2, "registering conflict between %s and %s", u2, u1);
 		}
 	}
 }

modified libpkg/pkg_repo_create.c

@@ -190,16 +190,16 @@ pkg_digest_sort_compare_func(struct digest_list_entry *d1,

 }
 static void
 pkg_repo_new_conflict(const char *origin, struct pkg_conflict_bulk *bulk)
 pkg_repo_new_conflict(const char *uniqueid, struct pkg_conflict_bulk *bulk)
 {
 	struct pkg_conflict *new;
 	pkg_conflict_new(&new);
 	sbuf_set(&new->origin, origin);
 	sbuf_set(&new->uniqueid, uniqueid);
 	HASH_ADD_KEYPTR(hh, bulk->conflicts,
 			pkg_conflict_origin(new),
 			sbuf_size(new->origin), new);
 			sbuf_size(new->uniqueid), new);
 }
 static void

@@ -217,7 +217,7 @@ pkg_repo_write_conflicts (struct pkg_conflict_bulk *bulk, FILE *out)

 	HASH_ITER (hh, bulk, cur, tmp) {
 		HASH_ITER (hh, cur->conflicts, c1, c1tmp) {
 			HASH_FIND_STR(pkg_bulk, sbuf_get(c1->origin), s);
 			HASH_FIND_STR(pkg_bulk, sbuf_get(c1->uniqueid), s);
 			if (s == NULL) {
 				/* New entry required */
 				s = malloc(sizeof(struct pkg_conflict_bulk));

@@ -226,18 +226,18 @@ pkg_repo_write_conflicts (struct pkg_conflict_bulk *bulk, FILE *out)

 					goto out;
 				}
 				memset(s, 0, sizeof(struct pkg_conflict_bulk));
 				s->file = sbuf_get(c1->origin);
 				s->file = sbuf_get(c1->uniqueid);
 				HASH_ADD_KEYPTR(hh, pkg_bulk, s->file, strlen(s->file), s);
 			}
 			/* Now add all new entries from this file to this conflict structure */
 			HASH_ITER (hh, cur->conflicts, c2, c2tmp) {
 				new = true;
 				if (strcmp(sbuf_get(c1->origin), sbuf_get(c2->origin)) == 0)
 				if (strcmp(sbuf_get(c1->uniqueid), sbuf_get(c2->uniqueid)) == 0)
 					continue;
 				HASH_FIND_STR(s->conflicts, sbuf_get(c2->origin), ctmp);
 				HASH_FIND_STR(s->conflicts, sbuf_get(c2->uniqueid), ctmp);
 				if (ctmp == NULL)
 					pkg_repo_new_conflict(sbuf_get(c2->origin), s);
 					pkg_repo_new_conflict(sbuf_get(c2->uniqueid), s);
 			}
 		}
 	}

@@ -246,16 +246,16 @@ pkg_repo_write_conflicts (struct pkg_conflict_bulk *bulk, FILE *out)

 		fprintf(out, "%s:", cur->file);
 		HASH_ITER (hh, cur->conflicts, c1, c1tmp) {
 			if (c1->hh.next != NULL)
 				fprintf(out, "%s,", sbuf_get(c1->origin));
 				fprintf(out, "%s,", sbuf_get(c1->uniqueid));
 			else
 				fprintf(out, "%s\n", sbuf_get(c1->origin));
 				fprintf(out, "%s\n", sbuf_get(c1->uniqueid));
 		}
 	}
 out:
 	HASH_ITER (hh, pkg_bulk, cur, tmp) {
 		HASH_ITER (hh, cur->conflicts, c1, c1tmp) {
 			HASH_DEL(cur->conflicts, c1);
 			sbuf_free(c1->origin);
 			sbuf_free(c1->uniqueid);
 			free(c1);
 		}
 		HASH_DEL(pkg_bulk, cur);

@@ -419,7 +419,7 @@ pkg_create_repo(char *path, const char *output_dir, bool filelist,

 cleanup:
 	HASH_ITER (hh, conflicts, curcb, tmpcb) {
 		HASH_ITER (hh, curcb->conflicts, c, ctmp) {
 			sbuf_free(c->origin);
 			sbuf_free(c->uniqueid);
 			HASH_DEL(curcb->conflicts, c);
 			free(c);
 		}

modified libpkg/pkgdb.c

@@ -3821,23 +3821,24 @@ pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata)

 	sqlite3_stmt	*stmt;
 	sqlite3_stmt	*stmt_conflicts;
 	struct sbuf	*conflictmsg = NULL;
 	struct sbuf *origin;
 	struct sbuf	*uniqueid;
 	assert (db != NULL);
 	const char	 sql_local_conflict[] = ""
 		"SELECT p.name, p.version, p.origin FROM packages AS p, files AS f "
 		"SELECT p.name, p.version, p.origin, p.name || \"~\" || p.origin as uniqueid FROM packages AS p, files AS f "
 		"WHERE p.id = f.package_id AND f.path = ?1;";
 	const char	 sql_conflicts[] = ""
 		"SELECT name, version, origin FROM integritycheck WHERE path = ?1;";
 		"SELECT name, version, origin, name || \"~\" || origin as uniqueid FROM integritycheck WHERE path = ?1;";
 	const char sql_integrity_prepare[] = ""
 		"SELECT f.path FROM files as f, integritycheck as i "
 		"LEFT JOIN packages as p ON "
 		"p.id = f.package_id "
 		"WHERE f.path = i.path AND "
 		"p.origin != i.origin GROUP BY f.path";
 		"p.name || \"~\" || p.origin != i.name || \"~\" || i.origin "
 		"GROUP BY f.path";
 	pkg_debug(4, "Pkgdb: running '%s'", sql_integrity_prepare);
 	if (sqlite3_prepare_v2(db->sqlite,

@@ -3848,11 +3849,11 @@ pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata)

 	}
 	conflictmsg = sbuf_new_auto();
 	origin = sbuf_new_auto();
 	uniqueid = sbuf_new_auto();
 	while (sqlite3_step(stmt) != SQLITE_DONE) {
 		sbuf_clear(conflictmsg);
 		sbuf_clear(origin);
 		sbuf_clear(uniqueid);
 		pkg_debug(4, "Pkgdb: running '%s'", sql_local_conflict);
 		ret = sqlite3_prepare_v2(db->sqlite, sql_local_conflict, -1,

@@ -3860,7 +3861,7 @@ pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata)

 		if (ret != SQLITE_OK) {
 			ERROR_SQLITE(db->sqlite, sql_local_conflict);
 			sqlite3_finalize(stmt);
 			sbuf_delete(origin);
 			sbuf_delete(uniqueid);
 			sbuf_delete(conflictmsg);
 			return (EPKG_FATAL);
 		}

@@ -3875,7 +3876,7 @@ pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata)

 		    sqlite3_column_text(stmt_conflicts, 0),
 		    sqlite3_column_text(stmt_conflicts, 1),
 		    sqlite3_column_text(stmt, 0));
 		sbuf_cpy(origin, sqlite3_column_text(stmt_conflicts, 2));
 		sbuf_cpy(uniqueid, sqlite3_column_text(stmt_conflicts, 3));
 		sqlite3_finalize(stmt_conflicts);
 		pkg_debug(4, "Pkgdb: running '%s'", sql_conflicts);

@@ -3885,11 +3886,11 @@ pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata)

 			ERROR_SQLITE(db->sqlite, sql_conflicts);
 			sqlite3_finalize(stmt);
 			sbuf_delete(conflictmsg);
 			sbuf_delete(origin);
 			sbuf_delete(uniqueid);
 			return (EPKG_FATAL);
 		}
 		sbuf_finish(origin);
 		sbuf_finish(uniqueid);
 		sqlite3_bind_text(stmt_conflicts, 1,
 		    sqlite3_column_text(stmt, 0), -1, SQLITE_STATIC);

@@ -3899,7 +3900,7 @@ pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata)

 			    sqlite3_column_text(stmt_conflicts, 0),
 			    sqlite3_column_text(stmt_conflicts, 1));
 			if (cb != NULL)
 				cb (sbuf_data(origin), sqlite3_column_text(stmt_conflicts, 2), cbdata);
 				cb (sbuf_data(uniqueid), sqlite3_column_text(stmt_conflicts, 2), cbdata);
 		}
 		sbuf_finish(conflictmsg);

@@ -3911,7 +3912,7 @@ pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata)

 	sqlite3_finalize(stmt);
 	sbuf_delete(conflictmsg);
 	sbuf_delete(origin);
 	sbuf_delete(uniqueid);
 	assert (sql_exec(db->sqlite, "DROP TABLE IF EXISTS integritycheck") == EPKG_OK);

@@ -3919,19 +3920,20 @@ pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata)

 }
 struct pkgdb_it *
 pkgdb_integrity_conflict_local(struct pkgdb *db, const char *origin)
 pkgdb_integrity_conflict_local(struct pkgdb *db, const char *uniqueid)
 {
 	sqlite3_stmt	*stmt;
 	int		 ret;
 	assert(db != NULL && origin != NULL);
 	assert(db != NULL && uniqueid != NULL);
 	const char	sql_conflicts [] = ""
 		"SELECT DISTINCT p.id AS rowid, p.origin, p.name, p.version, "
 		    "p.prefix "
 		"FROM packages AS p, files AS f, integritycheck AS i "
 		"WHERE p.id = f.package_id AND f.path = i.path "
 		"AND i.origin = ?1 AND i.origin != p.origin";
 		"AND i.name || \"~\" || i.origin = ?1 AND "
 		"i.name || \"~\" || i.origin != p.name || \"~\" || p.origin";
 	pkg_debug(4, "Pkgdb: running '%s'", sql_conflicts);
 	ret = sqlite3_prepare_v2(db->sqlite, sql_conflicts, -1, &stmt, NULL);

@@ -3940,7 +3942,7 @@ pkgdb_integrity_conflict_local(struct pkgdb *db, const char *origin)

 		return (NULL);
 	}
 	sqlite3_bind_text(stmt, 1, origin, -1, SQLITE_TRANSIENT);
 	sqlite3_bind_text(stmt, 1, uniqueid, -1, SQLITE_TRANSIENT);
 	return (pkgdb_it_new(db, stmt, PKG_INSTALLED, PKGDB_IT_FLAG_ONCE));
 }

modified libpkg/private/pkg.h

@@ -145,7 +145,7 @@ enum pkg_conflict_type {

 };
 struct pkg_conflict {
 	struct sbuf		*origin;
 	struct sbuf		*uniqueid;
 	enum pkg_conflict_type type;
 	UT_hash_handle	hh;
 };

@@ -489,7 +489,7 @@ int pkgdb_integrity_append(struct pkgdb *db, struct pkg *p,

 		conflict_func_cb cb, void *cbdata);
 int pkgdb_integrity_check(struct pkgdb *db, conflict_func_cb cb, void *cbdata);
 struct pkgdb_it *pkgdb_integrity_conflict_local(struct pkgdb *db,
 						const char *origin);
 						const char *uniqueid);
 int pkg_set_mtree(struct pkg *, const char *mtree);