2d6c6e0 Convert pkg_users pkg_groups to strings hash map — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -494,19 +494,19 @@ pkg_set_from_file(struct pkg *pkg, pkg_attr attr, const char *path, bool trimcr)

 }
 int
 pkg_users(const struct pkg *pkg, struct pkg_user **u)
 pkg_users(const struct pkg *pkg, char **u)
 {
 	assert(pkg != NULL);
 	HASH_NEXT(pkg->users, (*u));
 	kh_string_next(pkg->users, (*u));
 }
 int
 pkg_groups(const struct pkg *pkg, struct pkg_group **g)
 pkg_groups(const struct pkg *pkg, char **g)
 {
 	assert(pkg != NULL);
 	HASH_NEXT(pkg->groups, (*g));
 	kh_string_next(pkg->users, (*g));
 }
 int

@@ -600,13 +600,12 @@ pkg_requires(const struct pkg *pkg, char **c)

 int
 pkg_adduser(struct pkg *pkg, const char *name)
 {
 	struct pkg_user *u = NULL;
 	char *storename;
 	assert(pkg != NULL);
 	assert(name != NULL && name[0] != '\0');
 	HASH_FIND_STR(pkg->users, name, u);
 	if (u != NULL) {
 	if (kh_contains(strings, pkg->users, name)) {
 		if (developer_mode) {
 			pkg_emit_error("duplicate user listing: %s, fatal (developer mode)", name);
 			return (EPKG_FATAL);

@@ -616,11 +615,8 @@ pkg_adduser(struct pkg *pkg, const char *name)

 		}
 	}
 	pkg_user_new(&u);
 	strlcpy(u->name, name, sizeof(u->name));
 	HASH_ADD_STR(pkg->users, name, u);
 	storename = strdup(name);
 	kh_add(strings, pkg->users, storename, storename);
 	return (EPKG_OK);
 }

@@ -628,13 +624,12 @@ pkg_adduser(struct pkg *pkg, const char *name)

 int
 pkg_addgroup(struct pkg *pkg, const char *name)
 {
 	struct pkg_group *g = NULL;
 	char *storename;
 	assert(pkg != NULL);
 	assert(name != NULL && name[0] != '\0');
 	HASH_FIND_STR(pkg->groups, name, g);
 	if (g != NULL) {
 	if (kh_contains(strings, pkg->groups, name)) {
 		if (developer_mode) {
 			pkg_emit_error("duplicate group listing: %s, fatal (developer mode)", name);
 			return (EPKG_FATAL);

@@ -644,11 +639,8 @@ pkg_addgroup(struct pkg *pkg, const char *name)

 		}
 	}
 	pkg_group_new(&g);
 	strlcpy(g->name, name, sizeof(g->name));
 	HASH_ADD_STR(pkg->groups, name, g);
 	storename = strdup(name);
 	kh_add(strings, pkg->groups, storename, storename);
 	return (EPKG_OK);
 }

@@ -1286,9 +1278,9 @@ pkg_list_count(const struct pkg *pkg, pkg_list list)

 	case PKG_DIRS:
 		return (kh_count(pkg->dirs));
 	case PKG_USERS:
 		return (HASH_COUNT(pkg->users));
 		return (kh_count(pkg->users));
 	case PKG_GROUPS:
 		return (HASH_COUNT(pkg->groups));
 		return (kh_count(pkg->groups));
 	case PKG_SHLIBS_REQUIRED:
 		return (kh_count(pkg->shlibs_required));
 	case PKG_SHLIBS_PROVIDED:

@@ -1332,11 +1324,11 @@ pkg_list_free(struct pkg *pkg, pkg_list list) {

 		pkg->flags &= ~PKG_LOAD_DIRS;
 		break;
 	case PKG_USERS:
 		HASH_FREE(pkg->users, pkg_user_free);
 		kh_free(strings, pkg->users, char, free);
 		pkg->flags &= ~PKG_LOAD_USERS;
 		break;
 	case PKG_GROUPS:
 		HASH_FREE(pkg->groups, pkg_group_free);
 		kh_free(strings, pkg->groups, char, free);
 		pkg->flags &= ~PKG_LOAD_GROUPS;
 		break;
 	case PKG_SHLIBS_REQUIRED:

modified libpkg/pkg.h.in

@@ -99,8 +99,6 @@ struct pkg_dir;

 struct pkg_strel;
 struct pkg_option;
 struct pkg_license;
 struct pkg_user;
 struct pkg_group;
 struct pkg_config_file;
 struct pkgdb;

@@ -615,14 +613,14 @@ int pkg_dirs(const struct pkg *pkg, struct pkg_dir **dir);

  * @param Must be set to NULL for the first call.
  * @return An error code.
  */
 int pkg_users(const struct pkg *pkg, struct pkg_user **user);
 int pkg_users(const struct pkg *pkg, char **user);
 /**
  * Iterates over the groups of the package.
  * @param Must be set to NULL for the first call.
  * @return An error code.
  */
 int pkg_groups(const struct pkg *pkg, struct pkg_group **group);
 int pkg_groups(const struct pkg *pkg, char **group);
 /**
  * Iterates over the options of the package.

modified libpkg/pkg_attributes.c

@@ -132,48 +132,6 @@ pkg_dir_free(struct pkg_dir *d)

 }
 /*
  * User
  */
 int
 pkg_user_new(struct pkg_user **u)
 {
 	if ((*u = calloc(1, sizeof(struct pkg_user))) == NULL) {
 		pkg_emit_errno("calloc", "pkg_user");
 		return (EPKG_FATAL);
 	}
 	return (EPKG_OK);
 }
 void
 pkg_user_free(struct pkg_user *u)
 {
 	free(u);
 }
 /*
  * Group
  */
 int
 pkg_group_new(struct pkg_group **g)
 {
 	if ((*g = calloc(1, sizeof(struct pkg_group))) == NULL) {
 		pkg_emit_errno("calloc", "pkg_group");
 		return (EPKG_FATAL);
 	}
 	return (EPKG_OK);
 }
 void
 pkg_group_free(struct pkg_group *g)
 {
 	free(g);
 }
 /*
  * Script
  */

@@ -197,7 +155,7 @@ int

 pkg_option_new(struct pkg_option **option)
 {
 	if ((*option = calloc(1, sizeof(struct pkg_option))) == NULL) {
 		pkg_emit_errno("calloc", "pkg_user");
 		pkg_emit_errno("calloc", "pkg_option");
 		return (EPKG_FATAL);
 	}
 	return (EPKG_OK);

modified libpkg/pkg_checksum.c

@@ -193,8 +193,6 @@ pkg_checksum_generate(struct pkg *pkg, char *dest, size_t destlen,

 	size_t blen;
 	struct pkg_checksum_entry *entries = NULL;
 	struct pkg_option *option = NULL;
 	struct pkg_user *user = NULL;
 	struct pkg_group *group = NULL;
 	struct pkg_dep *dep = NULL;
 	int i;

@@ -221,12 +219,14 @@ pkg_checksum_generate(struct pkg *pkg, char *dest, size_t destlen,

 		pkg_checksum_add_entry("provided_shlib", buf, &entries);
 	}
 	while (pkg_users(pkg, &user) == EPKG_OK) {
 		pkg_checksum_add_entry("user", user->name, &entries);
 	buf = NULL;
 	while (pkg_users(pkg, &buf) == EPKG_OK) {
 		pkg_checksum_add_entry("user", buf, &entries);
 	}
 	while (pkg_groups(pkg, &group) == EPKG_OK) {
 		pkg_checksum_add_entry("group", group->name, &entries);
 	buf = NULL;
 	while (pkg_groups(pkg, &buf) == EPKG_OK) {
 		pkg_checksum_add_entry("group", buf, &entries);
 	}
 	while (pkg_deps(pkg, &dep) == EPKG_OK) {

modified libpkg/pkg_manifest.c

@@ -910,8 +910,6 @@ pkg_emit_object(struct pkg *pkg, short flags)

 	struct pkg_option	*option   = NULL;
 	struct pkg_file		*file     = NULL;
 	struct pkg_dir		*dir      = NULL;
 	struct pkg_user		*user     = NULL;
 	struct pkg_group	*group    = NULL;
 	struct pkg_conflict	*conflict = NULL;
 	struct pkg_config_file	*cf       = NULL;
 	struct sbuf		*tmpsbuf  = NULL;

@@ -1017,20 +1015,22 @@ pkg_emit_object(struct pkg *pkg, short flags)

 	pkg_debug(4, "Emitting users");
 	seq = NULL;
 	while (pkg_users(pkg, &user) == EPKG_OK) {
 	buf = NULL;
 	while (pkg_users(pkg, &buf) == EPKG_OK) {
 		if (seq == NULL)
 			seq = ucl_object_typed_new(UCL_ARRAY);
 		ucl_array_append(seq, ucl_object_fromstring(user->name));
 		ucl_array_append(seq, ucl_object_fromstring(buf));
 	}
 	if (seq)
 		ucl_object_insert_key(top, seq, "users", 5, false);
 	pkg_debug(4, "Emitting groups");
 	seq = NULL;
 	while (pkg_groups(pkg, &group) == EPKG_OK) {
 	buf = NULL;
 	while (pkg_groups(pkg, &buf) == EPKG_OK) {
 		if (seq == NULL)
 			seq = ucl_object_typed_new(UCL_ARRAY);
 		ucl_array_append(seq, ucl_object_fromstring(group->name));
 		ucl_array_append(seq, ucl_object_fromstring(buf));
 	}
 	if (seq)
 		ucl_object_insert_key(top, seq, "groups", 6, false);

modified libpkg/pkg_printf.c

@@ -1149,8 +1149,8 @@ format_groups(struct sbuf *sbuf, const void *data, struct percent_esc *p)

 	if (p->flags & (PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2))
 		return (list_count(sbuf, pkg_list_count(pkg, PKG_GROUPS), p));
 	else {
 		struct pkg_group	*group = NULL;
 		int			 count;
 		char	*group = NULL;
 		int	 count;
 		set_list_defaults(p, "%Gn\n", "");

@@ -1174,9 +1174,9 @@ format_groups(struct sbuf *sbuf, const void *data, struct percent_esc *p)

 struct sbuf *
 format_group_name(struct sbuf *sbuf, const void *data, struct percent_esc *p)
 {
 	const struct pkg_group	*group = data;
 	const char	*group = data;
 	return (string_val(sbuf, group->name, p));
 	return (string_val(sbuf, group, p));
 }
 /*

@@ -1374,8 +1374,8 @@ format_users(struct sbuf *sbuf, const void *data, struct percent_esc *p)

 	if (p->flags & (PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2))
 		return (list_count(sbuf, pkg_list_count(pkg, PKG_USERS), p));
 	else {
 		struct pkg_user	*user = NULL;
 		int		 count;
 		char	*user = NULL;
 		int	 count;
 		set_list_defaults(p, "%Un\n", "");

@@ -1399,9 +1399,9 @@ format_users(struct sbuf *sbuf, const void *data, struct percent_esc *p)

 struct sbuf *
 format_user_name(struct sbuf *sbuf, const void *data, struct percent_esc *p)
 {
 	const struct pkg_user	*user = data;
 	const char	*user = data;
 	return (string_val(sbuf, user->name, p));
 	return (string_val(sbuf, user, p));
 }
 /*

modified libpkg/pkgdb.c

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

 	struct pkg_file		*file = NULL;
 	struct pkg_dir		*dir = NULL;
 	struct pkg_option	*option = NULL;
 	struct pkg_user		*user = NULL;
 	struct pkg_group	*group = NULL;
 	struct pkg_conflict	*conflict = NULL;
 	struct pkg_config_file	*cf = NULL;
 	struct pkgdb_it		*it = NULL;
 	char			*buf;
 	sqlite3			*s;

@@ -1873,11 +1872,12 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 	 * Insert users
 	 */
 	while (pkg_users(pkg, &user) == EPKG_OK) {
 		if (run_prstmt(USERS1, user->name)
 	buf = NULL;
 	while (pkg_users(pkg, &buf) == EPKG_OK) {
 		if (run_prstmt(USERS1, buf)
 		    != SQLITE_DONE
 		    ||
 		    run_prstmt(USERS2, package_id, user->name)
 		    run_prstmt(USERS2, package_id, buf)
 		    != SQLITE_DONE) {
 			ERROR_SQLITE(s, SQL(USERS2));
 			goto cleanup;

@@ -1888,11 +1888,12 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)

 	 * Insert groups
 	 */
 	while (pkg_groups(pkg, &group) == EPKG_OK) {
 		if (run_prstmt(GROUPS1, group->name)
 	buf = NULL;
 	while (pkg_groups(pkg, &buf) == EPKG_OK) {
 		if (run_prstmt(GROUPS1, buf)
 		    != SQLITE_DONE
 		    ||
 		    run_prstmt(GROUPS2, package_id, group->name)
 		    run_prstmt(GROUPS2, package_id, buf)
 		    != SQLITE_DONE) {
 			ERROR_SQLITE(s, SQL(GROUPS2));
 			goto cleanup;

modified libpkg/private/pkg.h

@@ -242,8 +242,8 @@ struct pkg {

 	kh_pkg_files_t		*files;
 	kh_pkg_dirs_t		*dirs;
 	struct pkg_option	*options;
 	struct pkg_user		*users;
 	struct pkg_group	*groups;
 	kh_strings_t		*users;
 	kh_strings_t		*groups;
 	kh_strings_t		*shlibs_required;
 	kh_strings_t		*shlibs_provided;
 	struct pkg_conflict *conflicts;

@@ -309,16 +309,6 @@ struct pkg_option {

 	UT_hash_handle	hh;
 };
 struct pkg_user {
 	char		 name[MAXLOGNAME];
 	UT_hash_handle	hh;
 };
 struct pkg_group {
 	char		 name[MAXLOGNAME];
 	UT_hash_handle	hh;
 };
 struct http_mirror {
 	struct url *url;
 	struct http_mirror *next;

@@ -608,12 +598,6 @@ void pkg_dir_free(struct pkg_dir *);

 int pkg_option_new(struct pkg_option **);
 void pkg_option_free(struct pkg_option *);
 int pkg_user_new(struct pkg_user **);
 void pkg_user_free(struct pkg_user *);
 int pkg_group_new(struct pkg_group **);
 void pkg_group_free(struct pkg_group *);
 int pkg_jobs_resolv(struct pkg_jobs *jobs);
 int pkg_conflict_new(struct pkg_conflict **);

modified src/query.c

@@ -334,8 +334,6 @@ print_query(struct pkg *pkg, char *qstr, char multiline)

 	struct pkg_option	*option = NULL;
 	struct pkg_file		*file   = NULL;
 	struct pkg_dir		*dir    = NULL;
 	struct pkg_user		*user   = NULL;
 	struct pkg_group	*group  = NULL;
 	char			*buf;
 	struct pkg_kv		*kv;
 	struct pkg_strel	*list;

@@ -388,14 +386,16 @@ print_query(struct pkg *pkg, char *qstr, char multiline)

 		}
 		break;
 	case 'U':
 		while (pkg_users(pkg, &user) == EPKG_OK) {
 			format_str(pkg, output, qstr, user);
 		buf = NULL;
 		while (pkg_users(pkg, &buf) == EPKG_OK) {
 			format_str(pkg, output, qstr, buf);
 			printf("%s\n", sbuf_data(output));
 		}
 		break;
 	case 'G':
 		while (pkg_groups(pkg, &group) == EPKG_OK) {
 			format_str(pkg, output, qstr, group);
 		buf = NULL;
 		while (pkg_groups(pkg, &buf) == EPKG_OK) {
 			format_str(pkg, output, qstr, buf);
 			printf("%s\n", sbuf_data(output));
 		}
 		break;