19fcedd A bit of refactoring for more consistency — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -125,7 +125,7 @@ pkg_type(struct pkg const * const pkg)

 }
 int
 pkg_isvalid(struct pkg *pkg)
 pkg_is_valid(struct pkg *pkg)
 {
 	int ret = EPKG_OK;
 	int i;

@@ -186,7 +186,7 @@ pkg_set(struct pkg * pkg, pkg_attr attr, const char *value)

 }
 int
 pkg_setmtree(struct pkg *pkg, const char *mtree) {
 pkg_set_mtree(struct pkg *pkg, const char *mtree) {
 	return (pkg_set(pkg, PKG_MTREE, mtree));
 }

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

 }
 int
 pkg_list_isempty(struct pkg *pkg, pkg_list list) {
 pkg_list_is_empty(struct pkg *pkg, pkg_list list) {
 	switch (list) {
 		case PKG_DEPS:
 			return (STAILQ_EMPTY(&pkg->deps));

modified libpkg/pkg.h

@@ -212,7 +212,7 @@ void pkg_free(struct pkg *);

 /**
  * Check if a package is valid according to its type.
  */
 int pkg_isvalid(struct pkg *);
 int pkg_is_valid(struct pkg *);
 /**
  * Open a package file archive and retrive informations.

@@ -250,7 +250,7 @@ int64_t pkg_new_flatsize(struct pkg *);

  */
 int64_t pkg_new_pkgsize(struct pkg *);
 int pkg_list_isempty(struct pkg *, pkg_list);
 int pkg_list_is_empty(struct pkg *, pkg_list);
 /**
  * Iterates over the dependencies of the package.
  * @param dep Must be set to NULL for the first call.

@@ -338,7 +338,7 @@ int pkg_analyse_files(struct pkgdb *, struct pkg *);

  * Generic setter for simple attributes.
  */
 int pkg_set(struct pkg *pkg, pkg_attr attr, const char *value);
 int pkg_setmtree(struct pkg *pkg, const char *value);
 int pkg_set_mtree(struct pkg *pkg, const char *value);
 /**
  * Read the content of a file into a buffer, then call pkg_set().

@@ -622,18 +622,18 @@ int pkgdb_it_next(struct pkgdb_it *, struct pkg **pkg, int flags);

  */
 void pkgdb_it_free(struct pkgdb_it *);
 int pkgdb_loaddeps(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadrdeps(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadconflicts(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadfiles(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loaddirs(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadscripts(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadoptions(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadmtree(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadcategory(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadlicense(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loaduser(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_loadgroup(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_deps(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_rdeps(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_conflicts(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_files(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_dirs(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_scripts(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_options(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_mtree(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_category(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_license(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_user(struct pkgdb *db, struct pkg *pkg);
 int pkgdb_load_group(struct pkgdb *db, struct pkg *pkg);
 /**
  * Compact the database to save space.

@@ -673,7 +673,7 @@ int pkg_jobs_add(struct pkg_jobs *jobs, struct pkg *pkg);

 /**
  * Returns true if there are no jobs.
  */
 int pkg_jobs_isempty(struct pkg_jobs *jobs);
 int pkg_jobs_is_empty(struct pkg_jobs *jobs);
 /**
  * Iterates over the packages in the jobs queue.

modified libpkg/pkg_delete.c

@@ -36,15 +36,15 @@ pkg_delete2(struct pkg *pkg, struct pkgdb *db, int force, int upgrade)

 	/*
 	 * Ensure that we have all the informations we need
 	 */
 	if ((ret = pkgdb_loadrdeps(db, pkg)) != EPKG_OK)
 	if ((ret = pkgdb_load_rdeps(db, pkg)) != EPKG_OK)
 		return (ret);
 	if ((ret = pkgdb_loadfiles(db, pkg)) != EPKG_OK)
 	if ((ret = pkgdb_load_files(db, pkg)) != EPKG_OK)
 		return (ret);
 	if ((ret = pkgdb_loaddirs(db, pkg)) != EPKG_OK)
 	if ((ret = pkgdb_load_dirs(db, pkg)) != EPKG_OK)
 		return (ret);
 	if ((ret = pkgdb_loadscripts(db, pkg)) != EPKG_OK)
 	if ((ret = pkgdb_load_scripts(db, pkg)) != EPKG_OK)
 		return (ret);
 	if ((ret = pkgdb_loadmtree(db, pkg)) != EPKG_OK)
 	if ((ret = pkgdb_load_mtree(db, pkg)) != EPKG_OK)
 		return (ret);
 	if (!upgrade)

modified libpkg/pkg_jobs.c

@@ -56,7 +56,7 @@ pkg_jobs_add(struct pkg_jobs *j, struct pkg *pkg)

 }
 int
 pkg_jobs_isempty(struct pkg_jobs *j)
 pkg_jobs_is_empty(struct pkg_jobs *j)
 {
 	assert(j != NULL);

@@ -215,7 +215,7 @@ add_dep(struct pkg_jobs *j, struct pkg_jobs_node *n)

 	struct pkg_dep *dep = NULL;
 	struct pkg_jobs_node *ndep;
 	pkgdb_loaddeps(j->db, n->pkg);
 	pkgdb_load_deps(j->db, n->pkg);
 	while (pkg_deps(n->pkg, &dep) == EPKG_OK) {
 		ndep = get_node(j, pkg_dep_origin(dep), 0);

@@ -230,7 +230,7 @@ add_rdep(struct pkg_jobs *j, struct pkg_jobs_node *n)

 	struct pkg_jobs_node *nrdep;
 	struct pkg_dep *rdep = NULL;
 	pkgdb_loadrdeps(j->db, n->pkg);
 	pkgdb_load_rdeps(j->db, n->pkg);
 	while (pkg_rdeps(n->pkg, &rdep) == EPKG_OK) {
 		nrdep = get_node(j, pkg_dep_origin(rdep), 0);

modified libpkg/pkgdb.c

@@ -68,7 +68,7 @@ static struct column_int_mapping {

 };
 static int
 loadval(sqlite3 *db, struct pkg *pkg, const char *sql, int flags, int (*pkg_adddata)(struct pkg *pkg, const char *data), int list)
 load_val(sqlite3 *db, struct pkg *pkg, const char *sql, int flags, int (*pkg_adddata)(struct pkg *pkg, const char *data), int list)
 {
 	sqlite3_stmt *stmt;
 	int ret;

@@ -589,51 +589,51 @@ pkgdb_it_next(struct pkgdb_it *it, struct pkg **pkg_p, int flags)

 		populate_pkg(it->stmt, pkg);
 		if (flags & PKG_LOAD_DEPS)
 			if ((ret = pkgdb_loaddeps(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_deps(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_RDEPS)
 			if ((ret = pkgdb_loadrdeps(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_rdeps(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_CONFLICTS)
 			if ((ret = pkgdb_loadconflicts(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_conflicts(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_FILES)
 			if ((ret = pkgdb_loadfiles(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_files(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_DIRS)
 			if ((ret = pkgdb_loaddirs(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_dirs(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_SCRIPTS)
 			if ((ret = pkgdb_loadscripts(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_scripts(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_OPTIONS)
 			if ((ret = pkgdb_loadoptions(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_options(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_MTREE)
 			if ((ret = pkgdb_loadmtree(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_mtree(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_CATEGORIES)
 			if ((ret = pkgdb_loadcategory(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_category(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_LICENSES)
 			if ((ret = pkgdb_loadlicense(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_license(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_USERS)
 			if ((ret = pkgdb_loaduser(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_user(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		if (flags & PKG_LOAD_GROUPS)
 			if ((ret = pkgdb_loadgroup(it->db, pkg)) != EPKG_OK)
 			if ((ret = pkgdb_load_group(it->db, pkg)) != EPKG_OK)
 				return (ret);
 		return (EPKG_OK);

@@ -787,7 +787,7 @@ pkgdb_is_dir_used(struct pkgdb *db, const char *dir, int64_t *res)

 }
 int
 pkgdb_loaddeps(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_deps(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt = NULL;
 	int ret;

@@ -834,7 +834,7 @@ pkgdb_loaddeps(struct pkgdb *db, struct pkg *pkg)

 }
 int
 pkgdb_loadrdeps(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_rdeps(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt = NULL;
 	int ret;

@@ -874,7 +874,7 @@ pkgdb_loadrdeps(struct pkgdb *db, struct pkg *pkg)

 }
 int
 pkgdb_loadfiles(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_files(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt = NULL;
 	int ret;

@@ -913,7 +913,7 @@ pkgdb_loadfiles(struct pkgdb *db, struct pkg *pkg)

 }
 int
 pkgdb_loaddirs(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_dirs(struct pkgdb *db, struct pkg *pkg)
 {
 	const char sql[] = ""
 		"SELECT path, try "

@@ -953,7 +953,7 @@ pkgdb_loaddirs(struct pkgdb *db, struct pkg *pkg)

 }
 int
 pkgdb_loadlicense(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_license(struct pkgdb *db, struct pkg *pkg)
 {
 	const char *sql = NULL;

@@ -975,11 +975,11 @@ pkgdb_loadlicense(struct pkgdb *db, struct pkg *pkg)

 			"ORDER by name DESC";
 	}
 	return (loadval(db->sqlite, pkg, sql, PKG_LOAD_LICENSES, pkg_addlicense, PKG_LICENSES));
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_LICENSES, pkg_addlicense, PKG_LICENSES));
 }
 int
 pkgdb_loadcategory(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_category(struct pkgdb *db, struct pkg *pkg)
 {
 	const char *sql = NULL;

@@ -1001,11 +1001,11 @@ pkgdb_loadcategory(struct pkgdb *db, struct pkg *pkg)

 			"ORDER by name DESC";
 	}
 	return (loadval(db->sqlite, pkg, sql, PKG_LOAD_CATEGORIES, pkg_addcategory, PKG_CATEGORIES));
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_CATEGORIES, pkg_addcategory, PKG_CATEGORIES));
 }
 int
 pkgdb_loaduser(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_user(struct pkgdb *db, struct pkg *pkg)
 {
 	const char sql[] = ""
 		"SELECT users.name "

@@ -1016,11 +1016,11 @@ pkgdb_loaduser(struct pkgdb *db, struct pkg *pkg)

 	assert(db != NULL && pkg != NULL);
 	return (loadval(db->sqlite, pkg, sql, PKG_LOAD_USERS, pkg_adduser, PKG_USERS));
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_USERS, pkg_adduser, PKG_USERS));
 }
 int
 pkgdb_loadgroup(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_group(struct pkgdb *db, struct pkg *pkg)
 {
 	const char sql[] = ""
 		"SELECT groups.name "

@@ -1031,11 +1031,11 @@ pkgdb_loadgroup(struct pkgdb *db, struct pkg *pkg)

 	assert(db != NULL && pkg != NULL);
 	return (loadval(db->sqlite, pkg, sql, PKG_LOAD_GROUPS, pkg_addgroup, PKG_GROUPS));
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_GROUPS, pkg_addgroup, PKG_GROUPS));
 }
 int
 pkgdb_loadconflicts(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_conflicts(struct pkgdb *db, struct pkg *pkg)
 {
 	const char sql[] = ""
 		"SELECT name "

@@ -1045,11 +1045,11 @@ pkgdb_loadconflicts(struct pkgdb *db, struct pkg *pkg)

 	assert(db != NULL && pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);
 	return (loadval(db->sqlite, pkg, sql, PKG_LOAD_CONFLICTS, pkg_addconflict, PKG_CONFLICTS));
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_CONFLICTS, pkg_addconflict, PKG_CONFLICTS));
 }
 int
 pkgdb_loadscripts(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_scripts(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt = NULL;
 	int ret;

@@ -1087,7 +1087,7 @@ pkgdb_loadscripts(struct pkgdb *db, struct pkg *pkg)

 }
 int
 pkgdb_loadoptions(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_options(struct pkgdb *db, struct pkg *pkg)
 {
 	sqlite3_stmt *stmt = NULL;
 	int ret;

@@ -1134,7 +1134,7 @@ pkgdb_loadoptions(struct pkgdb *db, struct pkg *pkg)

 }
 int
 pkgdb_loadmtree(struct pkgdb *db, struct pkg *pkg)
 pkgdb_load_mtree(struct pkgdb *db, struct pkg *pkg)
 {
 	const char sql[] = ""
 		"SELECT m.content "

@@ -1145,7 +1145,7 @@ pkgdb_loadmtree(struct pkgdb *db, struct pkg *pkg)

 	assert(db != NULL && pkg != NULL);
 	assert(pkg->type == PKG_INSTALLED);
 	return (loadval(db->sqlite, pkg, sql, PKG_LOAD_MTREE, pkg_setmtree, -1));
 	return (load_val(db->sqlite, pkg, sql, PKG_LOAD_MTREE, pkg_set_mtree, -1));
 }
 int

modified pkg/autoremove.c

@@ -85,7 +85,7 @@ exec_autoremove(int argc, char **argv)

 		humanize_number(size, sizeof(size), newsize - oldsize, "B", HN_AUTOSCALE, 0);
 	}
 	if (pkg_jobs_isempty(jobs)) {
 	if (pkg_jobs_is_empty(jobs)) {
 		printf("Nothing to do\n");
 		retcode = 0;
 		goto cleanup;

modified pkg/delete.c

@@ -107,7 +107,7 @@ exec_delete(int argc, char **argv)

 	}
 	/* check if we have something to deinstall */
 	if (pkg_jobs_isempty(jobs)) {
 	if (pkg_jobs_is_empty(jobs)) {
 		printf("Nothing to do\n");
 		retcode = 0;
 		goto cleanup;

modified pkg/install.c

@@ -83,7 +83,7 @@ exec_install(int argc, char **argv)

 		pkg = NULL;
 	}
 	if (pkg_jobs_isempty(jobs)) {
 	if (pkg_jobs_is_empty(jobs)) {
 		printf("Nothing to do\n");
 		retcode = 0;
 		goto cleanup;

@@ -113,7 +113,7 @@ exec_install(int argc, char **argv)

 		printf("\nthe installation will require %s more space\n", size);
 	}
 	humanize_number(size, sizeof(size), dlsize, "B", HN_AUTOSCALE, 0);
 	printf("%s to be downloaded\n", size);
 	printf("%s to be download_ed\n", size);
 	if (yes == 0)
 		yes = query_yesno("\nProceed with installing packages [y/N]: ");

modified pkg/query.c

@@ -92,34 +92,34 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

 					qstr++;
 					switch (qstr[0]) {
 						case 'd':
 							sbuf_printf(dest, "%d", !pkg_list_isempty(pkg, PKG_DEPS));
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_DEPS));
 							break;
 						case 'r':
 							sbuf_printf(dest, "%d", !pkg_list_isempty(pkg, PKG_RDEPS));
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_RDEPS));
 							break;
 						case 'C':
 							sbuf_printf(dest, "%d", !pkg_list_isempty(pkg, PKG_CATEGORIES));
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_CATEGORIES));
 							break;
 						case 'F':
 							sbuf_printf(dest, "%d", !pkg_list_isempty(pkg, PKG_FILES));
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_FILES));
 							break;
 						case 'O':
 							sbuf_printf(dest, "%d", !pkg_list_isempty(pkg, PKG_OPTIONS));
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_OPTIONS));
 							break;
 						case 'D':
 							sbuf_printf(dest, "%d", !pkg_list_isempty(pkg, PKG_DIRS));
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_DIRS));
 							break;
 						case 'L':
 							sbuf_printf(dest, "%d", !pkg_list_isempty(pkg, PKG_LICENSES));
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_LICENSES));
 							break;
 						case 'U':
 							sbuf_printf(dest, "%d", !pkg_list_isempty(pkg, PKG_USERS));
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_USERS));
 							break;
 						case 'G':
 							sbuf_printf(dest, "%d", !pkg_list_isempty(pkg, PKG_GROUPS));
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_GROUPS));
 							break;
 						case 'K':
 							sbuf_printf(dest, "%d", !pkg_list_isempty(pkg, PKG_CONFLICTS));
 							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_CONFLICTS));
 							break;
 					}
 					break;

modified pkg/upgrade.c

@@ -74,7 +74,7 @@ exec_upgrade(int argc, char **argv)

 		pkg = NULL;
 	}
 	if (pkg_jobs_isempty(jobs)) {
 	if (pkg_jobs_is_empty(jobs)) {
 		printf("Nothing to do\n");
 		retcode = 0;
 		goto cleanup;

@@ -103,7 +103,7 @@ exec_upgrade(int argc, char **argv)

 		printf("\nthe upgrade will require %s more space\n", size);
 	}
 	humanize_number(size, sizeof(size), dlsize, "B", HN_AUTOSCALE, 0);
 	printf("%s to be downloaded\n", size);
 	printf("%s to be download_ed\n", size);
 	if (yes == 0)
 		yes = query_yesno("\nProceed with upgrading packages [y/N]: ");

modified pkg/utils.c

@@ -44,14 +44,14 @@ print_info(struct pkg * const pkg, unsigned int opt)

                 printf("%-15s: %s\n", "Origin", pkg_get(pkg, PKG_ORIGIN));
                 printf("%-15s: %s\n", "Prefix", pkg_get(pkg, PKG_PREFIX));
                 if (!pkg_list_isempty(pkg, PKG_CATEGORIES)) {
                 if (!pkg_list_is_empty(pkg, PKG_CATEGORIES)) {
                         printf("%-15s:", "Categories");
                         while (pkg_categories(pkg, &cat) == EPKG_OK)
                                 printf(" %s", pkg_category_name(cat));
                         printf("\n");
                 }
                 if (!pkg_list_isempty(pkg, PKG_LICENSES)) {
                 if (!pkg_list_is_empty(pkg, PKG_LICENSES)) {
                         printf("%-15s:", "Licenses");
                         while (pkg_licenses(pkg, &lic) == EPKG_OK) {
                                 printf(" %s", pkg_license_name(lic));

@@ -66,7 +66,7 @@ print_info(struct pkg * const pkg, unsigned int opt)

                 printf("%-15s: %s\n", "WWW", pkg_get(pkg, PKG_WWW));
                 printf("%-15s: %s\n", "Comment", pkg_get(pkg, PKG_COMMENT));
                 if (!pkg_list_isempty(pkg, PKG_OPTIONS)) {
                 if (!pkg_list_is_empty(pkg, PKG_OPTIONS)) {
                         printf("%-15s: \n", "Options");
                         while (pkg_options(pkg, &option) == EPKG_OK)
                                 printf("\t%s: %s\n", pkg_option_opt(option), pkg_option_value(option));