093841f Remove useless use of sbuf Remove useless accessor — HardenedBSD-pkg

modified libpkg/libpkg.ver

@@ -4,7 +4,6 @@ global:

 	pkg_add;
 	pkg_add_from_remote;
 	pkg_add_port;
 	pkg_addannotation;
 	pkg_adddep;
 	pkg_addrdep;
 	pkg_addscript_file;

@@ -140,7 +139,6 @@ global:

 	pkg_set2;
 	pkg_set_from_file;
 	pkg_set_from_fileat;
 	pkg_shlib_name;
 	pkg_shlibs_provided;
 	pkg_shlibs_required;
 	pkg_shutdown;

modified libpkg/pkg.c

@@ -1270,21 +1270,18 @@ pkg_addshlib_required(struct pkg *pkg, const char *name)

 	assert(name != NULL && name[0] != '\0');
 	pkg_shlib_new(&s);
 	sbuf_set(&s->name, name);
 	s->name = strdup(name);
 	HASH_FIND_STR(pkg->shlibs_required, pkg_shlib_name(s), f);
 	HASH_FIND_STR(pkg->shlibs_required, s->name, f);
 	/* silently ignore duplicates in case of shlibs */
 	if (f != NULL) {
 		pkg_shlib_free(s);
 		return (EPKG_OK);
 	}
 	HASH_ADD_KEYPTR(hh, pkg->shlibs_required,
 	    pkg_shlib_name(s),
 	    strlen(pkg_shlib_name(s)), s);
 	HASH_ADD_KEYPTR(hh, pkg->shlibs_required, s->name, strlen(s->name), s);
 	pkg_debug(3, "added shlib deps for %s on %s",
 	    pkg->name, name);
 	pkg_debug(3, "added shlib deps for %s on %s", pkg->name, name);
 	return (EPKG_OK);
 }

@@ -1302,20 +1299,17 @@ pkg_addshlib_provided(struct pkg *pkg, const char *name)

 		return (EPKG_OK);
 	pkg_shlib_new(&s);
 	sbuf_set(&s->name, name);
 	HASH_FIND_STR(pkg->shlibs_provided, pkg_shlib_name(s), f);
 	s->name = strdup(name);
 	HASH_FIND_STR(pkg->shlibs_provided, s->name, f);
 	/* silently ignore duplicates in case of shlibs */
 	if (f != NULL) {
 		pkg_shlib_free(s);
 		return (EPKG_OK);
 	}
 	HASH_ADD_KEYPTR(hh, pkg->shlibs_provided,
 	    pkg_shlib_name(s),
 	    strlen(pkg_shlib_name(s)), s);
 	HASH_ADD_KEYPTR(hh, pkg->shlibs_provided, s->name, strlen(s->name), s);
 	pkg_debug(3, "added shlib provide %s for %s",
 	    pkg->name, pkg->origin);
 	pkg_debug(3, "added shlib provide %s for %s", pkg->name, pkg->origin);
 	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_shlib */
 const char *pkg_shlib_name(struct pkg_shlib const * const);
 /* pkg_conflict */
 const char *pkg_conflict_uniqueid(const struct pkg_conflict *);

modified libpkg/pkg_attributes.c

@@ -260,18 +260,10 @@ pkg_shlib_free(struct pkg_shlib *sl)

 	if (sl == NULL)
 		return;
 	sbuf_free(sl->name);
 	free(sl->name);
 	free(sl);
 }
 const char *
 pkg_shlib_name(struct pkg_shlib const * const sl)
 {
 	assert(sl != NULL);
 	return (sbuf_get(sl->name));
 }
 /*
  * Conflicts
  */

modified libpkg/pkg_checksum.c

@@ -153,12 +153,12 @@ pkg_checksum_generate(struct pkg *pkg, char *dest, size_t destlen,

 	}
 	while (pkg_shlibs_required(pkg, &shlib) == EPKG_OK) {
 		pkg_checksum_add_entry("required_shlib", pkg_shlib_name(shlib), &entries);
 		pkg_checksum_add_entry("required_shlib", shlib->name, &entries);
 	}
 	shlib = NULL;
 	while (pkg_shlibs_provided(pkg, &shlib) == EPKG_OK) {
 		pkg_checksum_add_entry("provided_shlib", pkg_shlib_name(shlib), &entries);
 		pkg_checksum_add_entry("provided_shlib", shlib->name, &entries);
 	}
 	while (pkg_users(pkg, &user) == EPKG_OK) {

modified libpkg/pkg_elf.c

@@ -488,11 +488,11 @@ pkg_analyse_files(struct pkgdb *db, struct pkg *pkg, const char *stage)

 	 * Do not depend on libraries that a package provides itself
 	 */
 	HASH_ITER(hh, pkg->shlibs_required, sh, shtmp) {
 		HASH_FIND_STR(pkg->shlibs_provided, pkg_shlib_name(sh), found);
 		HASH_FIND_STR(pkg->shlibs_provided, sh->name, found);
 		if (found != NULL) {
 			pkg_debug(2, "remove %s from required shlibs as the "
 			    "package %s provides this library itself",
 			    pkg_shlib_name(sh), pkg->name);
 			    sh->name, pkg->name);
 			HASH_DEL(pkg->shlibs_required, sh);
 		}
 	}

modified libpkg/pkg_jobs.c

@@ -1157,11 +1157,11 @@ pkg_jobs_need_upgrade(struct pkg *rp, struct pkg *lp)

 			return (true);
 		}
 		if (ret1 == EPKG_OK) {
 			if (strcmp(pkg_shlib_name(rs),
 					pkg_shlib_name(ls)) != 0) {
 			if (strcmp(rs->name, ls->name) != 0) {
 				free(rp->reason);
 				rp->reason = strdup("needed shared library changed");
 				pkg_debug(1, "shlib changed %s->%s", pkg_shlib_name(ls), pkg_shlib_name(rs));
 				pkg_debug(1, "shlib changed %s -> %s",
 				    ls->name, rs->name);
 				return (true);
 			}
 		}

modified libpkg/pkg_jobs_universe.c

@@ -346,13 +346,13 @@ pkg_jobs_universe_process_shlibs(struct pkg_jobs_universe *universe,

 				PKG_LOAD_ANNOTATIONS|PKG_LOAD_CONFLICTS;
 	while (pkg_shlibs_required(pkg, &shlib) == EPKG_OK) {
 		HASH_FIND_STR(universe->provides, pkg_shlib_name(shlib), pr);
 		HASH_FIND_STR(universe->provides, shlib->name, pr);
 		if (pr != NULL)
 			continue;
 		/* Not found, search in the repos */
 		it = pkgdb_repo_shlib_provide(universe->j->db,
 			pkg_shlib_name(shlib), universe->j->reponame);
 			shlib->name, universe->j->reponame);
 		if (it != NULL) {
 			rpkg = NULL;
 			prhead = NULL;

@@ -416,7 +416,7 @@ pkg_jobs_universe_process_shlibs(struct pkg_jobs_universe *universe,

 				}
 				pr->un = unit;
 				pr->provide = pkg_shlib_name(shlib);
 				pr->provide = shlib->name;
 				if (prhead == NULL) {
 					DL_APPEND(prhead, pr);

@@ -430,7 +430,7 @@ pkg_jobs_universe_process_shlibs(struct pkg_jobs_universe *universe,

 			pkgdb_it_free(it);
 			if (prhead == NULL) {
 				pkg_debug(1, "cannot find packages that provide %s required for %s",
 				    pkg_shlib_name(shlib), pkg->name);
 				    shlib->name, pkg->name);
 				/*
 				 * XXX: this is not normal but it is very common for the existing
 				 * repos, hence we just ignore this stale dependency

modified libpkg/pkg_manifest.c

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

 	while (pkg_shlibs_required(pkg, &shlib) == EPKG_OK) {
 		if (seq == NULL)
 			seq = ucl_object_typed_new(UCL_ARRAY);
 		ucl_array_append(seq, ucl_object_fromstring(pkg_shlib_name(shlib)));
 		ucl_array_append(seq, ucl_object_fromstring(shlib->name));
 	}
 	if (seq)
 		ucl_object_insert_key(top, seq, "shlibs_required", 15, false);

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

 	while (pkg_shlibs_provided(pkg, &shlib) == EPKG_OK) {
 		if (seq == NULL)
 			seq = ucl_object_typed_new(UCL_ARRAY);
 		ucl_array_append(seq, ucl_object_fromstring(pkg_shlib_name(shlib)));
 		ucl_array_append(seq, ucl_object_fromstring(shlib->name));
 	}
 	if (seq)
 		ucl_object_insert_key(top, seq, "shlibs_provided", 15, false);

modified libpkg/pkg_printf.c

@@ -895,7 +895,7 @@ format_shlib_name(struct sbuf *sbuf, const void *data, struct percent_esc *p)

 {
 	const struct pkg_shlib	*shlib = data;
 	return (string_val(sbuf, pkg_shlib_name(shlib), p));
 	return (string_val(sbuf, shlib->name, p));
 }
 /*

modified libpkg/pkg_solve.c

@@ -443,7 +443,7 @@ pkg_solve_add_require_rule(struct pkg_solve_problem *problem,

 	struct pkg_job_provide *pr, *prhead;
 	int cnt;
 	HASH_FIND_STR(problem->j->universe->provides, pkg_shlib_name(shlib), prhead);
 	HASH_FIND_STR(problem->j->universe->provides, shlib->name, prhead);
 	if (prhead != NULL) {
 		/* Require rule !A | P1 | P2 | P3 ... */
 		rule = pkg_solve_rule_new(PKG_RULE_REQUIRE);

@@ -480,7 +480,7 @@ pkg_solve_add_require_rule(struct pkg_solve_problem *problem,

 		 * are really fixed.
 		 */
 		pkg_debug(1, "solver: cannot find provide for required shlib %s",
 			pkg_shlib_name(shlib));
 			shlib->name);
 	}
 	return (EPKG_OK);

modified libpkg/pkgdb.c

@@ -1861,10 +1861,10 @@ pkgdb_update_shlibs_required(struct pkg *pkg, int64_t package_id, sqlite3 *s)

 	struct pkg_shlib	*shlib = NULL;
 	while (pkg_shlibs_required(pkg, &shlib) == EPKG_OK) {
 		if (run_prstmt(SHLIBS1, pkg_shlib_name(shlib))
 		if (run_prstmt(SHLIBS1, shlib->name)
 		    != SQLITE_DONE
 		    ||
 		    run_prstmt(SHLIBS_REQD, package_id, pkg_shlib_name(shlib))
 		    run_prstmt(SHLIBS_REQD, package_id, shlib->name)
 		    != SQLITE_DONE) {
 			ERROR_SQLITE(s, SQL(SHLIBS_REQD));
 			return (EPKG_FATAL);

@@ -1896,10 +1896,10 @@ pkgdb_update_shlibs_provided(struct pkg *pkg, int64_t package_id, sqlite3 *s)

 	struct pkg_shlib	*shlib = NULL;
 	while (pkg_shlibs_provided(pkg, &shlib) == EPKG_OK) {
 		if (run_prstmt(SHLIBS1, pkg_shlib_name(shlib))
 		if (run_prstmt(SHLIBS1, shlib->name)
 		    != SQLITE_DONE
 		    ||
 		    run_prstmt(SHLIBS_PROV, package_id, pkg_shlib_name(shlib))
 		    run_prstmt(SHLIBS_PROV, package_id, shlib->name)
 		    != SQLITE_DONE) {
 			ERROR_SQLITE(s, SQL(SHLIBS_PROV));
 			return (EPKG_FATAL);

modified libpkg/private/pkg.h

@@ -250,7 +250,7 @@ struct pkg_group {

 };
 struct pkg_shlib {
 	struct sbuf	*name;
 	char *name;
 	UT_hash_handle	hh;
 };

modified libpkg/repo/binary/update.c

@@ -224,12 +224,10 @@ try_again:

 	shlib = NULL;
 	while (pkg_shlibs_required(pkg, &shlib) == EPKG_OK) {
 		const char *shlib_name = pkg_shlib_name(shlib);
 		ret = pkg_repo_binary_run_prstatement(SHLIB1, shlib_name);
 		ret = pkg_repo_binary_run_prstatement(SHLIB1, shlib->name);
 		if (ret == SQLITE_DONE)
 			ret = pkg_repo_binary_run_prstatement(SHLIB_REQD, package_id,
 					shlib_name);
 					shlib->name);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(SHLIB_REQD));
 			return (EPKG_FATAL);

@@ -238,12 +236,10 @@ try_again:

 	shlib = NULL;
 	while (pkg_shlibs_provided(pkg, &shlib) == EPKG_OK) {
 		const char *shlib_name = pkg_shlib_name(shlib);
 		ret = pkg_repo_binary_run_prstatement(SHLIB1, shlib_name);
 		ret = pkg_repo_binary_run_prstatement(SHLIB1, shlib->name);
 		if (ret == SQLITE_DONE)
 			ret = pkg_repo_binary_run_prstatement(SHLIB_PROV, package_id,
 					shlib_name);
 					shlib->name);
 		if (ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(SHLIB_PROV));
 			return (EPKG_FATAL);