363b22e Remove useless sbuf Remove useless accessor — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -1167,7 +1167,7 @@ pkg_addoption(struct pkg *pkg, const char *key, const char *value)

 	HASH_FIND_STR(pkg->options, key, o);
 	if (o == NULL) {
 		pkg_option_new(&o);
 		sbuf_set(&o->key, key);
 		o->key = strdup(key);
 	} else if ( o->value != NULL) {
 		if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) {
 			pkg_emit_error("duplicate options listing: %s, fatal (developer mode)", key);

@@ -1178,10 +1178,8 @@ pkg_addoption(struct pkg *pkg, const char *key, const char *value)

 		}
 	}
 	sbuf_set(&o->value, value);
 	HASH_ADD_KEYPTR(hh, pkg->options,
 			pkg_option_opt(o),
 			strlen(pkg_option_opt(o)), o);
 	o->value = strdup(value);
 	HASH_ADD_KEYPTR(hh, pkg->options, o->key, strlen(o->key), o);
 	return (EPKG_OK);
 }

@@ -1205,7 +1203,7 @@ pkg_addoption_default(struct pkg *pkg, const char *key,

 	HASH_FIND_STR(pkg->options, key, o);
 	if (o == NULL) {
 		pkg_option_new(&o);
 		sbuf_set(&o->key, key);
 		o->key = strdup(key);
 	} else if ( o->default_value != NULL) {
 		if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) {
 			pkg_emit_error("duplicate default value for option: %s, fatal (developer mode)", key);

@@ -1216,10 +1214,9 @@ pkg_addoption_default(struct pkg *pkg, const char *key,

 		}
 	}
 	sbuf_set(&o->default_value, default_value);
 	HASH_ADD_KEYPTR(hh, pkg->options,
 			pkg_option_default_value(o),
 			strlen(pkg_option_default_value(o)), o);
 	o->default_value = strdup(default_value);
 	HASH_ADD_KEYPTR(hh, pkg->options, o->default_value,
 	    strlen(o->default_value), o);
 	return (EPKG_OK);
 }

@@ -1242,7 +1239,7 @@ pkg_addoption_description(struct pkg *pkg, const char *key,

 	HASH_FIND_STR(pkg->options, key, o);
 	if (o == NULL) {
 		pkg_option_new(&o);
 		sbuf_set(&o->key, key);
 		o->key = strdup(key);
 	} else if ( o->description != NULL) {
 		if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) {
 			pkg_emit_error("duplicate description for option: %s, fatal (developer mode)", key);

@@ -1253,10 +1250,9 @@ pkg_addoption_description(struct pkg *pkg, const char *key,

 		}
 	}
 	sbuf_set(&o->description, description);
 	HASH_ADD_KEYPTR(hh, pkg->options,
 			pkg_option_description(o),
 			strlen(pkg_option_description(o)), o);
 	o->description = strdup(description);
 	HASH_ADD_KEYPTR(hh, pkg->options, o->description,
 	    strlen(o->description), o);
 	return (EPKG_OK);
 }

modified libpkg/pkg.h.in

@@ -752,12 +752,6 @@ const char *pkg_license_name(struct pkg_license const * const);

 /* pkg_script */
 const char *pkg_script_get(struct pkg const * const, pkg_script);
 /* pkg_option */
 const char *pkg_option_opt(struct pkg_option const * const);
 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);
 /**
  * @param db A pointer to a struct pkgdb object
  * @param origin Package origin

modified libpkg/pkg_attributes.c

@@ -203,45 +203,13 @@ pkg_option_free(struct pkg_option *option)

 	if (option == NULL)
 		return;
 	sbuf_free(option->key);
 	sbuf_free(option->value);
 	sbuf_free(option->default_value);
 	sbuf_free(option->description);
 	free(option->key);
 	free(option->value);
 	free(option->default_value);
 	free(option->description);
 	free(option);
 }
 const char *
 pkg_option_opt(struct pkg_option const * const option)
 {
 	assert(option != NULL);
 	return (sbuf_get(option->key));
 }
 const char *
 pkg_option_value(struct pkg_option const * const option)
 {
 	assert(option != NULL);
 	return (sbuf_get(option->value));
 }
 const char *
 pkg_option_default_value(struct pkg_option const * const option)
 {
 	assert(option != NULL);
 	return (sbuf_get(option->default_value));
 }
 const char *
 pkg_option_description(struct pkg_option const * const option)
 {
 	assert(option != NULL);
 	return (sbuf_get(option->description));
 }
 /*
  * Shared Libraries
  */

modified libpkg/pkg_checksum.c

@@ -148,8 +148,7 @@ pkg_checksum_generate(struct pkg *pkg, char *dest, size_t destlen,

 	pkg_checksum_add_entry("arch", pkg->arch, &entries);
 	while (pkg_options(pkg, &option) == EPKG_OK) {
 		pkg_checksum_add_entry(pkg_option_opt(option), pkg_option_value(option),
 			&entries);
 		pkg_checksum_add_entry(option->key, option->value, &entries);
 	}
 	while (pkg_shlibs_required(pkg, &shlib) == EPKG_OK) {

modified libpkg/pkg_jobs.c

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

 			return (true);
 		}
 		if (ret1 == EPKG_OK) {
 			if (strcmp(pkg_option_opt(lo), pkg_option_opt(ro)) != 0 ||
 					strcmp(pkg_option_value(lo), pkg_option_value(ro)) != 0) {
 			if (strcmp(lo->key, ro->key) != 0 ||
 			    strcmp(lo->value, ro->value) != 0) {
 				free(rp->reason);
 				rp->reason = strdup("options changed");
 				return (true);

modified libpkg/pkg_manifest.c

@@ -1063,38 +1063,34 @@ pkg_emit_object(struct pkg *pkg, short flags)

 		ucl_object_insert_key(top, seq, "shlibs_provided", 15, false);
 	pkg_debug(4, "Emitting conflicts");
 	map = NULL;
 	seq = NULL;
 	while (pkg_conflicts(pkg, &conflict) == EPKG_OK) {
 		if (map == NULL)
 			map = ucl_object_typed_new(UCL_OBJECT);
 		ucl_object_insert_key(map,
 		    ucl_object_fromstring(pkg_option_value(option)),
 		    conflict->uid, 0, false);
 		if (seq == NULL)
 			seq = ucl_object_typed_new(UCL_ARRAY);
 		ucl_array_append(seq, ucl_object_fromstring(conflict->uid));
 	}
 	if (map)
 		ucl_object_insert_key(top, map, "conflicts", 9, false);
 	if (seq)
 		ucl_object_insert_key(top, seq, "conflicts", 9, false);
 	pkg_debug(4, "Emitting provides");
 	map = NULL;
 	seq = NULL;
 	while (pkg_provides(pkg, &provide) == EPKG_OK) {
 		if (map == NULL)
 			map = ucl_object_typed_new(UCL_OBJECT);
 		ucl_object_insert_key(map,
 		    ucl_object_fromstring(pkg_option_value(option)),
 		    provide->provide, 0, false);
 		if (seq == NULL)
 			seq = ucl_object_typed_new(UCL_ARRAY);
 		ucl_array_append(seq, ucl_object_fromstring(provide->provide));
 	}
 	if (map)
 		ucl_object_insert_key(top, map, "provides", 8, false);
 	if (seq)
 		ucl_object_insert_key(top, seq, "provides", 8, false);
 	pkg_debug(4, "Emitting options");
 	map = NULL;
 	while (pkg_options(pkg, &option) == EPKG_OK) {
 		pkg_debug(2, "Emiting option: %s", pkg_option_value(option));
 		pkg_debug(2, "Emiting option: %s", option->value);
 		if (map == NULL)
 			map = ucl_object_typed_new(UCL_OBJECT);
 		ucl_object_insert_key(map,
 		    ucl_object_fromstring(pkg_option_value(option)),
 		    pkg_option_opt(option), 0, false);
 		    ucl_object_fromstring(option->value),
 		    option->key, 0, false);
 	}
 	if (map)
 		ucl_object_insert_key(top, map, "options", 7, false);

modified libpkg/pkg_old.c

@@ -156,13 +156,13 @@ pkg_old_emit_content(struct pkg *pkg, char **dest)

 		if (option_type != 0)
 			sbuf_cat(content, " ");
 		if (strcmp(pkg_option_value(option), "on") == 0)
 		if (strcmp(option->value, "on") == 0)
 			option_type = '+';
 		else
 			option_type = '-';
 		sbuf_printf(content, "%c%s",
 		    option_type,
 		    pkg_option_opt(option));
 		    option->key);
 	}
 	sbuf_printf(content, "\n");

modified libpkg/pkg_printf.c

@@ -1288,7 +1288,7 @@ format_option_name(struct sbuf *sbuf, const void *data, struct percent_esc *p)

 {
 	const struct pkg_option	*option = data;
 	return (string_val(sbuf, pkg_option_opt(option), p));
 	return (string_val(sbuf, option->key, p));
 }
 /*

@@ -1299,7 +1299,7 @@ format_option_value(struct sbuf *sbuf, const void *data, struct percent_esc *p)

 {
 	const struct pkg_option	*option = data;
 	return (string_val(sbuf, pkg_option_value(option), p));
 	return (string_val(sbuf, option->value, p));
 }
 /*

@@ -1310,7 +1310,7 @@ format_option_default(struct sbuf *sbuf, const void *data, struct percent_esc *p

 {
 	const struct pkg_option	*option = data;
 	return (string_val(sbuf, pkg_option_default_value(option), p));
 	return (string_val(sbuf, option->value, p));
 }
 /*

@@ -1321,7 +1321,7 @@ format_option_description(struct sbuf *sbuf, const void *data, struct percent_es

 {
 	const struct pkg_option	*option = data;
 	return (string_val(sbuf, pkg_option_description(option), p));
 	return (string_val(sbuf, option->description, p));
 }
 /*

modified libpkg/pkgdb.c

@@ -1786,10 +1786,10 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 	 */
 	while (pkg_options(pkg, &option) == EPKG_OK) {
 		if (run_prstmt(OPTION1, pkg_option_opt(option)) != SQLITE_DONE
 		if (run_prstmt(OPTION1, option->key) != SQLITE_DONE
 		    ||
 		    run_prstmt(OPTION2, package_id, pkg_option_opt(option),
 			       pkg_option_value(option)) != SQLITE_DONE) {
 		    run_prstmt(OPTION2, package_id, option->key, option->value)
 			       != SQLITE_DONE) {
 			ERROR_SQLITE(s, SQL(OPTION2));
 			goto cleanup;
 		}

modified libpkg/private/pkg.h

@@ -230,10 +230,10 @@ struct pkg_dir {

 };
 struct pkg_option {
 	struct sbuf	*key;
 	struct sbuf	*value;
 	struct sbuf	*default_value;
 	struct sbuf	*description;
 	char	*key;
 	char	*value;
 	char	*default_value;
 	char	*description;
 	UT_hash_handle	hh;
 };

modified libpkg/repo/binary/update.c

@@ -212,10 +212,10 @@ try_again:

 	option = NULL;
 	while (pkg_options(pkg, &option) == EPKG_OK) {
 		ret = pkg_repo_binary_run_prstatement(OPT1, pkg_option_opt(option));
 		ret = pkg_repo_binary_run_prstatement(OPT1, option->key);
 		if (ret == SQLITE_DONE)
 		    ret = pkg_repo_binary_run_prstatement(OPT2, pkg_option_opt(option),
 				pkg_option_value(option), package_id);
 		    ret = pkg_repo_binary_run_prstatement(OPT2, option->key,
 				option->value, package_id);
 		if(ret != SQLITE_DONE) {
 			ERROR_SQLITE(sqlite, pkg_repo_binary_sql_prstatement(OPT2));
 			return (EPKG_FATAL);