d2b47eb Remove useless use of sbuf Remove useless accessors — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -1328,12 +1328,10 @@ pkg_addconflict(struct pkg *pkg, const char *uniqueid)

 		return (EPKG_OK);
 	pkg_conflict_new(&c);
 	sbuf_set(&c->uniqueid, uniqueid);
 	c->uid = strdup(uniqueid);
 	pkg_debug(3, "Pkg: add a new conflict origin: %s, with %s", pkg->uid, uniqueid);
 	HASH_ADD_KEYPTR(hh, pkg->conflicts,
 	    __DECONST(char *, pkg_conflict_uniqueid(c)),
 	    sbuf_size(c->uniqueid), c);
 	HASH_ADD_KEYPTR(hh, pkg->conflicts, c->uid, strlen(c->uid), c);
 	return (EPKG_OK);
 }

modified libpkg/pkg.h.in

@@ -758,9 +758,6 @@ const char *pkg_option_value(struct pkg_option const * const);

 const char *pkg_option_default_value(struct pkg_option const * const);
 const char *pkg_option_description(struct pkg_option const * const);
 /* 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

@@ -283,18 +283,10 @@ pkg_conflict_free(struct pkg_conflict *c)

 	if (c == NULL)
 		return;
 	sbuf_free(c->uniqueid);
 	free(c->uid);
 	free(c);
 }
 const char *
 pkg_conflict_uniqueid(const struct pkg_conflict *c)
 {
 	assert(c != NULL);
 	return (sbuf_get(c->uniqueid));
 }
 /*
  * Provides
  */

modified libpkg/pkg_cudf.c

@@ -156,7 +156,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_uniqueid(conflict),
 			if (cudf_print_element(f, conflict->uid,
 					(conflict->hh.next != NULL), &column) < 0) {
 				return (EPKG_FATAL);
 			}

modified libpkg/pkg_jobs.c

@@ -1115,8 +1115,7 @@ pkg_jobs_need_upgrade(struct pkg *rp, struct pkg *lp)

 			return (true);
 		}
 		if (ret1 == EPKG_OK) {
 			if (strcmp(pkg_conflict_uniqueid(rc),
 					pkg_conflict_uniqueid(lc)) != 0) {
 			if (strcmp(rc->uid, lc->uid) != 0) {
 				free(rp->reason);
 				rp->reason = strdup("direct conflict changed");
 				return (true);

modified libpkg/pkg_jobs_conflicts.c

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

 			continue;
 		HASH_ITER(hh, req->item->pkg->conflicts, c, ctmp) {
 			unit = pkg_jobs_universe_find(j->universe, pkg_conflict_uniqueid(c));
 			unit = pkg_jobs_universe_find(j->universe, c->uid);
 			if (unit != NULL) {
 				HASH_FIND_STR(j->request_add, unit->pkg->uid, found);
 				if (found && !found->skip) {

@@ -174,15 +174,15 @@ pkg_conflicts_register(struct pkg *p1, struct pkg *p2, enum pkg_conflict_type ty

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

@@ -247,12 +247,10 @@ pkg_conflicts_register_unsafe(struct pkg *p1, struct pkg *p2,

 	pkg_conflict_new(&c1);
 	pkg_conflict_new(&c2);
 	c1->type = c2->type = type;
 	sbuf_set(&c1->uniqueid, p2->uid);
 	sbuf_set(&c2->uniqueid, p1->uid);
 	HASH_ADD_KEYPTR(hh, p1->conflicts, pkg_conflict_uniqueid(c1),
 		sbuf_size(c1->uniqueid), c1);
 	HASH_ADD_KEYPTR(hh, p2->conflicts, pkg_conflict_uniqueid(c2),
 		sbuf_size(c2->uniqueid), c2);
 	c1->uid = strdup(p2->uid);
 	c2->uid = strdup(p2->uid);
 	HASH_ADD_KEYPTR(hh, p1->conflicts, c1->uid, strlen(c1->uid), c1);
 	HASH_ADD_KEYPTR(hh, p2->conflicts, c2->uid, strlen(c1->uid), c2);
 	pkg_debug(2, "registering conflict between %s and %s on path %s",
 		p1->uid, p2->uid, path);
 }

modified libpkg/pkg_jobs_universe.c

@@ -296,14 +296,14 @@ pkg_jobs_universe_process_conflicts(struct pkg_jobs_universe *universe,

 	struct pkg *npkg;
 	while (pkg_conflicts(pkg, &c) == EPKG_OK) {
 		HASH_FIND_STR(universe->items, pkg_conflict_uniqueid(c), unit);
 		HASH_FIND_STR(universe->items, c->uid, unit);
 		if (unit != NULL)
 			continue;
 		/* Check local and remote conflicts */
 		if (pkg->type == PKG_INSTALLED) {
 			/* Installed packages can conflict with remote ones */
 			npkg = pkg_jobs_universe_get_remote(universe, pkg_conflict_uniqueid(c), 0);
 			npkg = pkg_jobs_universe_get_remote(universe, c->uid, 0);
 			if (npkg == NULL)
 				continue;

@@ -311,14 +311,14 @@ pkg_jobs_universe_process_conflicts(struct pkg_jobs_universe *universe,

 		}
 		else {
 			/* Remote packages can conflict with remote and local */
 			npkg = pkg_jobs_universe_get_local(universe, pkg_conflict_uniqueid(c), 0);
 			npkg = pkg_jobs_universe_get_local(universe, c->uid, 0);
 			if (npkg != NULL) {
 				if (pkg_jobs_universe_process_item(universe, npkg, NULL) != EPKG_OK)
 					continue;
 				if (c->type != PKG_CONFLICT_REMOTE_LOCAL) {
 					npkg = pkg_jobs_universe_get_remote(universe,
 						pkg_conflict_uniqueid(c), 0);
 					    c->uid, 0);
 					if (npkg == NULL)
 						continue;

@@ -616,7 +616,7 @@ pkg_jobs_update_universe_item_priority(struct pkg_jobs_universe *universe,

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

@@ -644,7 +644,7 @@ pkg_jobs_update_conflict_priority(struct pkg_jobs_universe *universe,

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

modified libpkg/pkg_manifest.c

@@ -1069,7 +1069,7 @@ pkg_emit_object(struct pkg *pkg, short flags)

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

modified libpkg/pkg_repo_create.c

@@ -88,11 +88,9 @@ pkg_repo_new_conflict(const char *uniqueid, struct pkg_conflict_bulk *bulk)

 	struct pkg_conflict *new;
 	pkg_conflict_new(&new);
 	sbuf_set(&new->uniqueid, uniqueid);
 	new->uid = strdup(uniqueid);
 	HASH_ADD_KEYPTR(hh, bulk->conflicts,
 			pkg_conflict_uniqueid(new),
 			sbuf_size(new->uniqueid), new);
 	HASH_ADD_KEYPTR(hh, bulk->conflicts, new->uid, strlen(new->uid), new);
 }
 static void

@@ -109,7 +107,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->uniqueid), s);
 			HASH_FIND_STR(pkg_bulk, c1->uid, s);
 			if (s == NULL) {
 				/* New entry required */
 				s = malloc(sizeof(struct pkg_conflict_bulk));

@@ -118,17 +116,17 @@ 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->uniqueid);
 				s->file = c1->uid;
 				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) {
 				if (strcmp(sbuf_get(c1->uniqueid), sbuf_get(c2->uniqueid)) == 0)
 				if (strcmp(c1->uid, c2->uid) == 0)
 					continue;
 				HASH_FIND_STR(s->conflicts, sbuf_get(c2->uniqueid), ctmp);
 				HASH_FIND_STR(s->conflicts, c2->uid, ctmp);
 				if (ctmp == NULL)
 					pkg_repo_new_conflict(sbuf_get(c2->uniqueid), s);
 					pkg_repo_new_conflict(c2->uid, s);
 			}
 		}
 	}

@@ -137,16 +135,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->uniqueid));
 				fprintf(out, "%s,", c1->uid);
 			else
 				fprintf(out, "%s\n", sbuf_get(c1->uniqueid));
 				fprintf(out, "%s\n", c1->uid);
 		}
 	}
 out:
 	HASH_ITER (hh, pkg_bulk, cur, tmp) {
 		HASH_ITER (hh, cur->conflicts, c1, c1tmp) {
 			HASH_DEL(cur->conflicts, c1);
 			sbuf_free(c1->uniqueid);
 			free(c1->uid);
 			free(c1);
 		}
 		HASH_DEL(pkg_bulk, cur);

@@ -773,7 +771,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->uniqueid);
 			free(c->uid);
 			HASH_DEL(curcb->conflicts, c);
 			free(c);
 		}

modified libpkg/pkg_solve.c

@@ -379,7 +379,7 @@ pkg_solve_add_conflict_rule(struct pkg_solve_problem *problem,

 	struct pkg_solve_rule *rule = NULL;
 	struct pkg_solve_item *it = NULL;
 	uid = pkg_conflict_uniqueid(conflict);
 	uid = conflict->uid;
 	HASH_FIND_STR(problem->variables_by_uid, uid, confvar);
 	if (confvar == NULL) {
 		pkg_debug(2, "cannot find conflict %s", uid);

modified libpkg/pkgdb.c

@@ -1813,7 +1813,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_uniqueid(conflict))
 		if (run_prstmt(CONFLICT, package_id, conflict->uid)
 				!= SQLITE_DONE) {
 			ERROR_SQLITE(s, SQL(CONFLICT));
 			goto cleanup;

modified libpkg/private/pkg.h

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

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