576780b Convert the solver and finish converting conflicts to uniqueid — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -627,6 +627,7 @@ pkg_adddep(struct pkg *pkg, const char *name, const char *origin, const char *ve

 	sbuf_set(&d->origin, origin);
 	sbuf_set(&d->name, name);
 	sbuf_set(&d->version, version);
 	asprintf(&d->uid, "%s~%s", name, origin);
 	d->locked = locked;
 	HASH_ADD_KEYPTR(hh, pkg->deps, pkg_dep_get(d, PKG_DEP_ORIGIN),

@@ -651,6 +652,7 @@ pkg_addrdep(struct pkg *pkg, const char *name, const char *origin, const char *v

 	sbuf_set(&d->origin, origin);
 	sbuf_set(&d->name, name);
 	sbuf_set(&d->version, version);
 	asprintf(&d->uid, "%s~%s", name, origin);
 	d->locked = locked;
 	HASH_ADD_KEYPTR(hh, pkg->rdeps, pkg_dep_get(d, PKG_DEP_ORIGIN),

@@ -1070,7 +1072,7 @@ pkg_addconflict(struct pkg *pkg, const char *uniqueid)

 	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)),
 	    __DECONST(char *, pkg_conflict_uniqueid(c)),
 	    sbuf_size(c->uniqueid), c);
 	return (EPKG_OK);

modified libpkg/pkg.h.in

@@ -921,7 +921,7 @@ const char *pkg_option_description(struct pkg_option const * const);

 const char *pkg_shlib_name(struct pkg_shlib const * const);
 /* pkg_conflict */
 const char *pkg_conflict_origin(const struct pkg_conflict *);
 const char *pkg_conflict_uniqueid(const struct pkg_conflict *);
 /* pkg_provide */
 const char *pkg_provide_name(const struct pkg_provide *);

modified libpkg/pkg_attributes.c

@@ -54,6 +54,7 @@ pkg_dep_free(struct pkg_dep *d)

 	sbuf_free(d->origin);
 	sbuf_free(d->name);
 	sbuf_free(d->version);
 	free(d->uid);
 	free(d);
 }

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

 }
 const char *
 pkg_conflict_origin(const struct pkg_conflict *c)
 pkg_conflict_uniqueid(const struct pkg_conflict *c)
 {
 	assert(c != NULL);

modified libpkg/pkg_conflicts.c

@@ -123,7 +123,7 @@ pkg_conflicts_request_resolve(struct pkg_jobs *j)

 			continue;
 		HASH_ITER(hh, req->item->pkg->conflicts, c, ctmp) {
 			HASH_FIND_STR(j->request_add, pkg_conflict_origin(c), found);
 			HASH_FIND_STR(j->request_add, pkg_conflict_uniqueid(c), found);
 			if (found && !found->skip) {
 				pkg_conflicts_request_add_chain(&chain, found);
 			}

@@ -160,14 +160,14 @@ pkg_conflicts_register(struct pkg *p1, struct pkg *p2, enum pkg_conflict_type ty

 		HASH_FIND_STR(p1->conflicts, u2, test);
 		if (test == NULL) {
 			sbuf_set(&c1->uniqueid, u2);
 			HASH_ADD_KEYPTR(hh, p1->conflicts, pkg_conflict_origin(c1), sbuf_size(c1->uniqueid), c1);
 			HASH_ADD_KEYPTR(hh, p1->conflicts, pkg_conflict_uniqueid(c1), sbuf_size(c1->uniqueid), c1);
 			pkg_debug(2, "registering conflict between %s and %s", u1, u2);
 		}
 		HASH_FIND_STR(p2->conflicts, u1, test);
 		if (test == NULL) {
 			sbuf_set(&c2->uniqueid, u1);
 			HASH_ADD_KEYPTR(hh, p2->conflicts, pkg_conflict_origin(c2), sbuf_size(c2->uniqueid), c2);
 			HASH_ADD_KEYPTR(hh, p2->conflicts, pkg_conflict_uniqueid(c2), sbuf_size(c2->uniqueid), c2);
 			pkg_debug(2, "registering conflict between %s and %s", u2, u1);
 		}
 	}

modified libpkg/pkg_cudf.c

@@ -165,7 +165,7 @@ cudf_emit_pkg(struct pkg *pkg, int version, FILE *f,

 		if (fprintf(f, "conflicts: ") < 0)
 			return (EPKG_FATAL);
 		HASH_ITER(hh, pkg->conflicts, conflict, ctmp) {
 			if (cudf_print_element(f, pkg_conflict_origin(conflict),
 			if (cudf_print_element(f, pkg_conflict_uniqueid(conflict),
 					(conflict->hh.next != NULL), &column) < 0) {
 				return (EPKG_FATAL);
 			}

modified libpkg/pkg_jobs.c

@@ -362,7 +362,7 @@ pkg_jobs_update_universe_priority(struct pkg_jobs *j,

 		}
 		if (it->pkg->type != PKG_INSTALLED) {
 			while (pkg_conflicts(it->pkg, &c) == EPKG_OK) {
 				HASH_FIND_STR(j->universe, pkg_conflict_origin(c), found);
 				HASH_FIND_STR(j->universe, pkg_conflict_uniqueid(c), found);
 				if (found != NULL) {
 					LL_FOREACH(found, cur) {
 						if (cur->pkg->type == PKG_INSTALLED) {

@@ -389,7 +389,7 @@ pkg_jobs_update_conflict_priority(struct pkg_jobs *j, struct pkg_solved *req)

 	while (pkg_conflicts(lp, &c) == EPKG_OK) {
 		rit = NULL;
 		HASH_FIND_STR(j->universe, pkg_conflict_origin(c), found);
 		HASH_FIND_STR(j->universe, pkg_conflict_uniqueid(c), found);
 		assert(found != NULL);
 		LL_FOREACH(found, cur) {

@@ -692,14 +692,14 @@ pkg_jobs_add_universe(struct pkg_jobs *j, struct pkg *pkg,

 		/* Examine conflicts */
 		while (pkg_conflicts(pkg, &c) == EPKG_OK) {
 			/* XXX: this assumption can be applied only for the current plain dependencies */
 			HASH_FIND_STR(j->universe, pkg_conflict_origin(c), unit);
 			HASH_FIND_STR(j->universe, pkg_conflict_uniqueid(c), unit);
 			if (unit != NULL)
 				continue;
 			/* Check local and remote conflicts */
 			if (pkg->type == PKG_INSTALLED) {
 				/* Installed packages can conflict with remote ones */
 				npkg = get_remote_pkg(j, pkg_conflict_origin(c), 0);
 				npkg = get_remote_pkg(j, pkg_conflict_uniqueid(c), 0);
 				if (npkg == NULL)
 					continue;

@@ -708,7 +708,7 @@ pkg_jobs_add_universe(struct pkg_jobs *j, struct pkg *pkg,

 			}
 			else {
 				/* Remote packages can conflict with remote and local */
 				npkg = get_local_pkg(j, pkg_conflict_origin(c), 0);
 				npkg = get_local_pkg(j, pkg_conflict_uniqueid(c), 0);
 				if (npkg == NULL)
 					continue;

@@ -716,7 +716,7 @@ pkg_jobs_add_universe(struct pkg_jobs *j, struct pkg *pkg,

 					return (EPKG_FATAL);
 				if (c->type != PKG_CONFLICT_REMOTE_LOCAL) {
 					npkg = get_remote_pkg(j, pkg_conflict_origin(c), 0);
 					npkg = get_remote_pkg(j, pkg_conflict_uniqueid(c), 0);
 					if (npkg == NULL)
 						continue;

@@ -1330,8 +1330,8 @@ pkg_need_upgrade(struct pkg *rp, struct pkg *lp, bool recursive)

 			return (true);
 		}
 		if (ret1 == EPKG_OK) {
 			if (strcmp(pkg_conflict_origin(rc),
 					pkg_conflict_origin(lc)) != 0) {
 			if (strcmp(pkg_conflict_uniqueid(rc),
 					pkg_conflict_uniqueid(lc)) != 0) {
 				pkg_set(rp, PKG_REASON, "direct conflict changed");
 				return (true);
 			}

modified libpkg/pkg_manifest.c

@@ -978,7 +978,7 @@ emit_manifest(struct pkg *pkg, struct sbuf **out, short flags)

 			map = ucl_object_typed_new(UCL_OBJECT);
 		ucl_object_insert_key(map,
 		    ucl_object_fromstring(pkg_option_value(option)),
 		    pkg_conflict_origin(conflict), 0, false);
 		    pkg_conflict_uniqueid(conflict), 0, false);
 	}
 	if (map)
 		ucl_object_insert_key(top, map, "conflicts", 9, false);

modified libpkg/pkg_repo_create.c

@@ -198,7 +198,7 @@ pkg_repo_new_conflict(const char *uniqueid, struct pkg_conflict_bulk *bulk)

 	sbuf_set(&new->uniqueid, uniqueid);
 	HASH_ADD_KEYPTR(hh, bulk->conflicts,
 			pkg_conflict_origin(new),
 			pkg_conflict_uniqueid(new),
 			sbuf_size(new->uniqueid), new);
 }

modified libpkg/pkg_solve.c

@@ -50,7 +50,7 @@ struct pkg_solve_variable {

 	int guess;
 	int priority;
 	const char *digest;
 	const char *origin;
 	const char *uid;
 	bool resolved;
 	struct _pkg_solve_var_rule {
 		struct pkg_solve_item *rule;

@@ -79,7 +79,7 @@ struct pkg_solve_problem {

 	struct pkg_jobs *j;
 	unsigned int rules_count;
 	struct pkg_solve_rule *rules;
 	struct pkg_solve_variable *variables_by_origin;
 	struct pkg_solve_variable *variables_by_uid;
 	struct pkg_solve_variable *variables_by_digest;
 };

@@ -125,14 +125,14 @@ pkg_debug_print_rule (struct pkg_solve_item *rule)

 	LL_FOREACH(rule, it) {
 		if (it->var->resolved) {
 			sbuf_printf(sb, "%s%s%s(%c)%s", it->inverse ? "!" : "",
 					it->var->origin,
 					it->var->uid,
 					(it->var->unit->pkg->type == PKG_INSTALLED) ? "(l)" : "(r)",
 					(it->var->to_install) ? '+' : '-',
 					it->next ? " | " : ")");
 		}
 		else {
 			sbuf_printf(sb, "%s%s%s%s", it->inverse ? "!" : "",
 					it->var->origin,
 					it->var->uid,
 					(it->var->unit->pkg->type == PKG_INSTALLED) ? "(l)" : "(r)",
 					it->next ? " | " : ")");
 		}

@@ -180,7 +180,7 @@ check_again:

 						LL_FOREACH(unresolved, it) {
 							sbuf_printf(err_msg, "%s %s(want %s), ",
 									it->var->unit->pkg->type == PKG_INSTALLED ? "local" : "remote",
 											it->var->origin,
 											it->var->uid,
 											it->var->to_install ? "install" : "remove");
 						}
 						sbuf_finish(err_msg);

@@ -213,7 +213,7 @@ check_again:

 								it->var->resolved = true;
 								pkg_solve_update_var_resolved(it->var);
 								pkg_debug(2, "propagate %s-%s(%d) to %s",
 										it->var->origin, it->var->digest,
 										it->var->uid, it->var->digest,
 										it->var->priority,
 										it->var->to_install ? "install" : "delete");
 								pkg_debug_print_rule(unresolved);

@@ -256,7 +256,7 @@ pkg_solve_propagate_pure(struct pkg_solve_problem *problem)

 			var->to_install = (var->unit->pkg->type == PKG_INSTALLED);
 			var->resolved = true;
 			pkg_debug(2, "leave %s-%s(%d) to %s",
 					var->origin, var->digest,
 					var->uid, var->digest,
 					var->priority, var->to_install ? "install" : "delete");
 		}
 		else {

@@ -266,7 +266,7 @@ pkg_solve_propagate_pure(struct pkg_solve_problem *problem)

 					it->var->to_install = (!it->inverse);
 					it->var->resolved = true;
 					pkg_debug(2, "requested %s-%s(%d) to %s",
 							it->var->origin, it->var->digest,
 							it->var->uid, it->var->digest,
 							it->var->priority, it->var->to_install ? "install" : "delete");
 					pkg_solve_update_var_resolved(it->var);
 				}

@@ -307,7 +307,7 @@ pkg_solve_test_guess(struct pkg_solve_problem *problem, struct pkg_solve_variabl

 			}
 			if (!test) {
 				pkg_debug(2, "solver: guess test failed at variable %s, trying to %d",
 						var->origin, var->guess);
 						var->uid, var->guess);
 				pkg_debug_print_rule(it);
 				return (false);
 			}

@@ -506,7 +506,7 @@ static struct pkg_solve_variable *

 pkg_solve_variable_new(struct pkg_job_universe_item *item)
 {
 	struct pkg_solve_variable *result;
 	const char *digest, *origin;
 	const char *digest, *uid;
 	result = calloc(1, sizeof(struct pkg_solve_variable));

@@ -516,11 +516,11 @@ pkg_solve_variable_new(struct pkg_job_universe_item *item)

 	}
 	result->unit = item;
 	pkg_get(item->pkg, PKG_ORIGIN, &origin, PKG_DIGEST, &digest);
 	pkg_get(item->pkg, PKG_UNIQUEID, &uid, PKG_DIGEST, &digest);
 	/* XXX: Is it safe to save a ptr here ? */
 	result->digest = digest;
 	result->guess = -1;
 	result->origin = origin;
 	result->uid = uid;
 	result->prev = result;
 	return (result);

@@ -558,17 +558,17 @@ pkg_solve_problem_free(struct pkg_solve_problem *problem)

 static int
 pkg_solve_add_universe_variable(struct pkg_solve_problem *problem,
 		const char *origin, struct pkg_solve_variable **var)
 		const char *uid, struct pkg_solve_variable **var)
 {
 	struct pkg_job_universe_item *unit, *cur;
 	struct pkg_solve_variable *nvar, *tvar = NULL, *found;
 	const char *digest;
 	struct pkg_jobs *j = problem->j;
 	HASH_FIND_STR(j->universe, origin, unit);
 	HASH_FIND_STR(j->universe, uid, unit);
 	/* If there is no package in universe, refuse continue */
 	if (unit == NULL) {
 		pkg_debug(2, "package %s is not found in universe", origin);
 		pkg_debug(2, "package %s is not found in universe", uid);
 		return (EPKG_FATAL);
 	}
 	/* Need to add a variable */

@@ -580,14 +580,14 @@ pkg_solve_add_universe_variable(struct pkg_solve_problem *problem,

 			strlen(nvar->digest), nvar);
 	/*
 	 * Now we check the origin variable and if there is no such origin then
 	 * Now we check the uid variable and if there is no such uid then
 	 * we need to add the whole conflict chain to it
 	 */
 	HASH_FIND(ho, problem->variables_by_origin, origin, strlen(origin), found);
 	HASH_FIND(ho, problem->variables_by_uid, uid, strlen(uid), found);
 	if (found == NULL) {
 		HASH_ADD_KEYPTR(ho, problem->variables_by_origin, nvar->origin,
 				strlen(nvar->origin), nvar);
 		pkg_debug(4, "solver: add variable from universe with origin %s", nvar->origin);
 		HASH_ADD_KEYPTR(ho, problem->variables_by_uid, nvar->uid,
 				strlen(nvar->uid), nvar);
 		pkg_debug(4, "solver: add variable from universe with uid %s", nvar->uid);
 		/* Rewind to the beginning of the list */
 		while (unit->prev->next != NULL)

@@ -605,8 +605,8 @@ pkg_solve_add_universe_variable(struct pkg_solve_problem *problem,

 				DL_APPEND(nvar, tvar);
 				HASH_ADD_KEYPTR(hd, problem->variables_by_digest, tvar->digest,
 						strlen(tvar->digest), tvar);
 				pkg_debug (4, "solver: add another variable with origin %s and digest %s",
 						tvar->origin, tvar->digest);
 				pkg_debug (4, "solver: add another variable with uid %s and digest %s",
 						tvar->uid, tvar->digest);
 			}
 		}
 	}

@@ -626,7 +626,7 @@ pkg_solve_add_var_rules (struct pkg_solve_variable *var,

 	LL_FOREACH(var, tvar) {
 		pkg_debug(4, "solver: add %d-ary %s clause to variable %s-%s",
 							nrules, desc, tvar->origin, tvar->digest);
 							nrules, desc, tvar->uid, tvar->digest);
 		tvar->nrules += nrules;
 		head = calloc(1, sizeof (struct _pkg_solve_var_rule));
 		if (head == NULL) {

@@ -653,7 +653,7 @@ pkg_solve_handle_provide (struct pkg_solve_problem *problem,

 		struct pkg_job_provide *pr, struct pkg_solve_rule *rule, int *cnt)
 {
 	struct pkg_solve_item *it = NULL;
 	const char *origin, *digest;
 	const char *uid, *digest;
 	struct pkg_solve_variable *var;
 	struct pkg_job_universe_item *un, *cur;
 	struct pkg_shlib *sh;

@@ -666,11 +666,12 @@ pkg_solve_handle_provide (struct pkg_solve_problem *problem,

 	LL_FOREACH(un, cur) {
 		/* For each provide */
 		pkg_get(un->pkg, PKG_DIGEST, &digest, PKG_ORIGIN, &origin);
 		pkg_get(un->pkg, PKG_DIGEST, &digest, PKG_UNIQUEID, &uid);
 		printf("%s\n", ucl_object_emit(un->pkg->fields, UCL_EMIT_CONFIG));
 		HASH_FIND(hd, problem->variables_by_digest, digest,
 				strlen(digest), var);
 		if (var == NULL) {
 			if (pkg_solve_add_universe_variable(problem, origin,
 			if (pkg_solve_add_universe_variable(problem, uid,
 					&var) != EPKG_OK)
 				continue;
 		}

@@ -706,7 +707,7 @@ pkg_solve_add_pkg_rule(struct pkg_solve_problem *problem,

 	int cnt;
 	struct pkg_jobs *j = problem->j;
 	const char *origin;
 	const char *uid;
 	/* Go through all deps in all variables*/
 	LL_FOREACH(pvar, cur_var) {

@@ -716,10 +717,10 @@ pkg_solve_add_pkg_rule(struct pkg_solve_problem *problem,

 			it = NULL;
 			var = NULL;
 			origin = pkg_dep_get(dep, PKG_DEP_ORIGIN);
 			HASH_FIND(ho, problem->variables_by_origin, origin, strlen(origin), var);
 			uid = dep->uid;
 			HASH_FIND(ho, problem->variables_by_uid, uid, strlen(uid), var);
 			if (var == NULL) {
 				if (pkg_solve_add_universe_variable(problem, origin, &var) != EPKG_OK)
 				if (pkg_solve_add_universe_variable(problem, uid, &var) != EPKG_OK)
 					continue;
 			}
 			/* Dependency rule: (!A | B) */

@@ -757,14 +758,14 @@ pkg_solve_add_pkg_rule(struct pkg_solve_problem *problem,

 			it = NULL;
 			var = NULL;
 			origin = pkg_conflict_origin(conflict);
 			HASH_FIND(ho, problem->variables_by_origin, origin, strlen(origin), var);
 			uid = pkg_conflict_uniqueid(conflict);
 			HASH_FIND(ho, problem->variables_by_uid, uid, strlen(uid), var);
 			if (var == NULL) {
 				if (pkg_solve_add_universe_variable(problem, origin, &var) != EPKG_OK)
 				if (pkg_solve_add_universe_variable(problem, uid, &var) != EPKG_OK)
 					continue;
 			}
 			/* Return the origin to the package's origin and not conflict */
 			pkg_get(pkg, PKG_ORIGIN, &origin);
 			/* Return the uid to the package's uid and not conflict */
 			pkg_get(pkg, PKG_UNIQUEID, &uid);
 			/* Add conflict rule from each of the alternative */
 			LL_FOREACH(var, tvar) {
 				if (conflict->type == PKG_CONFLICT_REMOTE_LOCAL) {

@@ -922,14 +923,14 @@ pkg_solve_add_universe_item(struct pkg_job_universe_item *un,

 {
 	struct pkg_job_universe_item *ucur;
 	struct pkg_solve_variable *var = NULL, *tvar;
 	const char *origin, *digest;
 	const char *uid, *digest;
 	/* Rewind universe pointer */
 	while (un->prev->next != NULL)
 		un = un->prev;
 	LL_FOREACH(un, ucur) {
 		pkg_get(ucur->pkg, PKG_ORIGIN, &origin, PKG_DIGEST, &digest);
 		pkg_get(ucur->pkg, PKG_UNIQUEID, &uid, PKG_DIGEST, &digest);
 		HASH_FIND(hd, problem->variables_by_digest, digest, strlen(digest), var);
 		if (var == NULL) {
 			/* Add new variable */

@@ -939,12 +940,12 @@ pkg_solve_add_universe_item(struct pkg_job_universe_item *un,

 			HASH_ADD_KEYPTR(hd, problem->variables_by_digest,
 					var->digest, strlen(var->digest), var);
 			/* Check origin */
 			HASH_FIND(ho, problem->variables_by_origin, origin, strlen(origin), tvar);
 			/* Check uid */
 			HASH_FIND(ho, problem->variables_by_uid, uid, strlen(uid), tvar);
 			if (tvar == NULL) {
 				pkg_debug(4, "solver: add variable from universe with origin %s", var->origin);
 				HASH_ADD_KEYPTR(ho, problem->variables_by_origin,
 						var->origin, strlen(var->origin), var);
 				pkg_debug(4, "solver: add variable from universe with uid %s", var->uid);
 				HASH_ADD_KEYPTR(ho, problem->variables_by_uid,
 						var->uid, strlen(var->uid), var);
 			}
 			else {
 				/* Insert a variable to a chain */

@@ -952,8 +953,8 @@ pkg_solve_add_universe_item(struct pkg_job_universe_item *un,

 			}
 		}
 	}
 	HASH_FIND(ho, problem->variables_by_origin, origin, strlen(origin), var);
 	/* Now `var' contains a variables chain related to this origin */
 	HASH_FIND(ho, problem->variables_by_uid, uid, strlen(uid), var);
 	/* Now `var' contains a variables chain related to this uid */
 	if (pkg_solve_add_pkg_rule(problem, var, true) == EPKG_FATAL)
 		return (EPKG_FATAL);

@@ -1000,8 +1001,8 @@ pkg_solve_jobs_to_sat(struct pkg_jobs *j)

 			goto err;
 		}
 		pkg_debug(4, "solver: add variable from install request with origin %s-%s",
 						var->origin, var->digest);
 		pkg_debug(4, "solver: add variable from install request with uid %s-%s",
 						var->uid, var->digest);
 		it = pkg_solve_item_new(var);
 		if (it == NULL)

@@ -1036,8 +1037,8 @@ pkg_solve_jobs_to_sat(struct pkg_jobs *j)

 			goto err;
 		}
 		pkg_debug(4, "solver: add variable from delete request with origin %s-%s",
 				var->origin, var->digest);
 		pkg_debug(4, "solver: add variable from delete request with uid %s-%s",
 				var->uid, var->digest);
 		it = pkg_solve_item_new(var);
 		if (it == NULL)

@@ -1140,7 +1141,7 @@ pkg_solve_insert_res_job (struct pkg_solve_variable *var,

 	}
 	if (seen_add > 1 || seen_del > 1) {
 		pkg_emit_error("internal solver error: more than two packages to install(%d) "
 				"or delete(%d) from the same origin: %s", seen_add, seen_del, var->origin);
 				"or delete(%d) from the same uid: %s", seen_add, seen_del, var->uid);
 		return;
 	}
 	else if (seen_add != 0 || seen_del != 0) {

@@ -1154,7 +1155,7 @@ pkg_solve_insert_res_job (struct pkg_solve_variable *var,

 			res->type = PKG_SOLVED_DELETE;
 			DL_APPEND(j->jobs, res);
 			pkg_debug(3, "pkg_solve: schedule deletion of %s %s",
 					del_var->origin, del_var->digest);
 					del_var->uid, del_var->digest);
 		}
 		else if (seen_del == 0 && seen_add != 0) {
 			res->items[0] = add_var->unit;

@@ -1162,7 +1163,7 @@ pkg_solve_insert_res_job (struct pkg_solve_variable *var,

 					PKG_SOLVED_FETCH : PKG_SOLVED_INSTALL;
 			DL_APPEND(j->jobs, res);
 			pkg_debug(3, "pkg_solve: schedule installation of %s %s",
 					add_var->origin, add_var->digest);
 					add_var->uid, add_var->digest);
 		}
 		else {
 			res->items[0] = add_var->unit;

@@ -1170,13 +1171,13 @@ pkg_solve_insert_res_job (struct pkg_solve_variable *var,

 			res->type = PKG_SOLVED_UPGRADE;
 			DL_APPEND(j->jobs, res);
 			pkg_debug(3, "pkg_solve: schedule upgrade of %s from %s to %s",
 					del_var->origin, del_var->digest, add_var->digest);
 					del_var->uid, del_var->digest, add_var->digest);
 		}
 		j->count ++;
 	}
 	else {
 		pkg_debug(2, "solver: ignoring package %s(%s) as its state has not been changed",
 				var->origin, var->digest);
 				var->uid, var->digest);
 	}
 }

@@ -1185,11 +1186,11 @@ pkg_solve_sat_to_jobs(struct pkg_solve_problem *problem)

 {
 	struct pkg_solve_variable *var, *vtmp;
 	HASH_ITER(ho, problem->variables_by_origin, var, vtmp) {
 	HASH_ITER(ho, problem->variables_by_uid, var, vtmp) {
 		if (!var->resolved)
 			return (EPKG_FATAL);
 		pkg_debug(4, "solver: check variable with origin %s", var->origin);
 		pkg_debug(4, "solver: check variable with uid %s", var->uid);
 		pkg_solve_insert_res_job(var, problem);
 	}

modified libpkg/pkgdb.c

@@ -2947,7 +2947,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 	 * Insert conflicts
 	 */
 	while (pkg_conflicts(pkg, &conflict) == EPKG_OK) {
 		if (run_prstmt(CONFLICT, package_id, pkg_conflict_origin(conflict))
 		if (run_prstmt(CONFLICT, package_id, pkg_conflict_uniqueid(conflict))
 				!= SQLITE_DONE) {
 			ERROR_SQLITE(s, SQL(CONFLICT));
 			goto cleanup;

modified libpkg/pkgdb_repo.c

@@ -905,7 +905,7 @@ pkgdb_repo_origins(sqlite3 *sqlite)

 	int ret;
 	static struct pkgdb repodb;
 	const char query_sql[] = ""
 		"SELECT id, origin, name, version, comment, "
 		"SELECT id, origin, name, name || \"~\" || origin as uniqueid, version, comment, "
 		"prefix, desc, arch, maintainer, www, "
 		"licenselogic, flatsize, pkgsize, "
 		"cksum, path AS repopath, manifestdigest "

@@ -1049,7 +1049,7 @@ pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match,

 	const char	*comp = NULL;
 	int		 ret;
 	char		 basesql[BUFSIZ] = ""
 		"SELECT id, origin, name, version, comment, "
 		"SELECT id, origin, name, name || \"~\" || origin as uniqueid, version, comment, "
 		"prefix, desc, arch, maintainer, www, "
 		"licenselogic, flatsize, pkgsize, "
 		"cksum, manifestdigest, path AS repopath, '%1$s' AS dbname "

@@ -1117,6 +1117,7 @@ pkgdb_rquery_provide(struct pkgdb *db, const char *provide, const char *repo)

 	int		 ret;
 	const char	 basesql[] = ""
 			"SELECT p.id, p.origin, p.name, p.version, p.comment, "
 			"p.name || \"~\" || p.origin as uniqueid, "
 			"p.prefix, p.desc, p.arch, p.maintainer, p.www, "
 			"p.licenselogic, p.flatsize, p.pkgsize, "
 			"p.cksum, p.manifestdigest, p.path AS repopath, '%1$s' AS dbname "

@@ -1172,6 +1173,7 @@ pkgdb_find_shlib_provide(struct pkgdb *db, const char *require, const char *repo

 	int		 ret;
 	const char	 basesql[] = ""
 			"SELECT p.id, p.origin, p.name, p.version, p.comment, "
 			"p.name || \"~\" || p.origin as uniqueid, "
 			"p.prefix, p.desc, p.arch, p.maintainer, p.www, "
 			"p.licenselogic, p.flatsize, p.pkgsize, "
 			"p.cksum, p.manifestdigest, p.path AS repopath, '%1$s' AS dbname "

@@ -1225,6 +1227,7 @@ pkgdb_find_shlib_require(struct pkgdb *db, const char *provide, const char *repo

 	int		 ret;
 	const char	 basesql[] = ""
 			"SELECT p.id, p.origin, p.name, p.version, p.comment, "
 			"p.name || \"~\" || p.origin as uniqueid, "
 			"p.prefix, p.desc, p.arch, p.maintainer, p.www, "
 			"p.licenselogic, p.flatsize, p.pkgsize, "
 			"p.cksum, p.manifestdigest, p.path AS repopath, '%1$s' AS dbname "

modified libpkg/private/pkg.h

@@ -133,6 +133,7 @@ struct pkg_dep {

 	struct sbuf	*origin;
 	struct sbuf	*name;
 	struct sbuf	*version;
 	char		*uid;
 	bool		 locked;
 	UT_hash_handle	 hh;
 };