156c4e7 finish the generic sbuf getter and setter — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -10,10 +10,6 @@

 static void pkg_free_void(void*);
 #define pkg_set_str(pkg, attr, value)  do { \
 	return (sbuf_set(&(pkg)->attr, value)); \
 } while (0)
 pkg_t
 pkg_type(struct pkg *pkg)
 {

@@ -21,33 +17,44 @@ pkg_type(struct pkg *pkg)

 }
 const char *
 pkg_origin(struct pkg *pkg)
 {
 	return (sbuf_get(pkg->origin));
 }
 const char *
 pkg_name(struct pkg *pkg)
 {
 	return (sbuf_get(pkg->name));
 }
 pkg_get(struct pkg *pkg, pkg_attr attr) {
 	switch (attr) {
 		case PKG_NAME:
 			return (sbuf_get(pkg->name));
 		case PKG_VERSION:
 			return (sbuf_get(pkg->version));
 		case PKG_COMMENT:
 			return (sbuf_get(pkg->comment));
 		case PKG_ORIGIN:
 			return (sbuf_get(pkg->origin));
 		case PKG_DESC:
 			return (sbuf_get(pkg->desc));
 		case PKG_MTREE:
 			return (sbuf_get(pkg->mtree));
 	}
 const char *
 pkg_version(struct pkg *pkg)
 {
 	return (sbuf_get(pkg->version));
 	return (NULL);
 }
 const char *
 pkg_comment(struct pkg *pkg)
 int
 pkg_set(struct pkg *pkg, pkg_attr attr, const char *value)
 {
 	return (sbuf_get(pkg->comment));
 }
 	switch (attr) {
 		case PKG_NAME:
 			return (sbuf_set(&pkg->name, value));
 		case PKG_VERSION:
 			return (sbuf_set(&pkg->version, value));
 		case PKG_COMMENT:
 			return (sbuf_set(&pkg->comment, value));
 		case PKG_ORIGIN:
 			return (sbuf_set(&pkg->origin, value));
 		case PKG_DESC:
 			return (sbuf_set(&pkg->desc, value));
 		case PKG_MTREE:
 			return (sbuf_set(&pkg->mtree, value));
 	}
 const char *
 pkg_desc(struct pkg *pkg)
 {
 	return (sbuf_get(pkg->desc));
 	return (-1);
 }
 struct pkg **

@@ -69,7 +76,7 @@ pkg_resolvdeps(struct pkg *pkg, struct pkgdb *db) {

 	pkg_new(&p);
 	for (i = 0; deps[i] != NULL; i++) {
 		it = pkgdb_query(db, pkg_origin(deps[i]), MATCH_EXACT);
 		it = pkgdb_query(db, pkg_get(deps[i], PKG_ORIGIN), MATCH_EXACT);
 		if (pkgdb_it_next_pkg(it, &p, PKG_BASIC) == 0) {
 			deps[i]->type = PKG_INSTALLED;

@@ -231,34 +238,7 @@ pkg_free_void(void *p)

 		pkg_free((struct pkg*) p);
 }
 /* Setters */
 int
 pkg_set(struct pkg *pkg, pkg_attr attr, const char *value)
 {
 	switch (attr) {
 		case PKG_NAME:
 			pkg_set_str(pkg, name, value);
 			break;
 		case PKG_VERSION:
 			pkg_set_str(pkg, version, value);
 			break;
 		case PKG_COMMENT:
 			pkg_set_str(pkg, comment, value);
 			break;
 		case PKG_ORIGIN:
 			pkg_set_str(pkg, origin, value);
 			break;
 		case PKG_DESC:
 			pkg_set_str(pkg, desc, value);
 			break;
 		case PKG_MTREE:
 			pkg_set_str(pkg, mtree, value);
 			break;
 	}
 	return (0);
 }
 /* specific Setters */
 int
 pkg_setdesc_from_file(struct pkg *pkg, const char *desc_path)

modified libpkg/pkg.h

@@ -24,25 +24,22 @@ typedef enum {

 } pkg_t;
 typedef enum {
 	PKG_ORIGIN = 0,
 	PKG_NAME,
 	PKG_VERSION,
 	PKG_ORIGIN,
 	PKG_COMMENT,
 	PKG_DESC,
 	PKG_MTREE
 } pkg_attr;
 /* pkg */
 int pkg_new(struct pkg **);
 int pkg_open(const char *, struct pkg **, int);
 pkg_t pkg_type(struct pkg *);
 void pkg_reset(struct pkg *);
 void pkg_free(struct pkg *);
 const char *pkg_name(struct pkg *);
 const char *pkg_version(struct pkg *);
 const char *pkg_comment(struct pkg *);
 const char *pkg_desc(struct pkg *);
 const char *pkg_origin(struct pkg *);
 const char *pkg_get(struct pkg *, pkg_attr);
 struct pkg ** pkg_deps(struct pkg *);
 struct pkg ** pkg_rdeps(struct pkg *);
 struct pkg_file ** pkg_files(struct pkg *);

modified libpkg/pkgdb.c

@@ -218,7 +218,7 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)

 		if (flags & PKG_DEPS) {
 			array_init(&pkg->deps, 10);
 			i = pkgdb_query_dep(it->db, pkg_origin(pkg));
 			i = pkgdb_query_dep(it->db, pkg_get(pkg, PKG_ORIGIN));
 			p = NULL;
 			while (pkgdb_it_next_pkg(i, &p, PKG_BASIC) == 0) {
 				array_append(&pkg->deps, p);

@@ -230,7 +230,7 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)

 		if (flags & PKG_RDEPS) {
 			array_init(&pkg->rdeps, 5);
 			i = pkgdb_query_rdep(it->db, pkg_origin(pkg));
 			i = pkgdb_query_rdep(it->db, pkg_get(pkg, PKG_ORIGIN));
 			p = NULL;
 			while (pkgdb_it_next_pkg(i, &p, PKG_BASIC) == 0) {
 				array_append(&pkg->rdeps, p);

@@ -242,7 +242,7 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)

 		if (flags & PKG_CONFLICTS) {
 			array_init(&pkg->conflicts, 5);
 			i = pkgdb_query_conflicts(it->db, pkg_origin(pkg));
 			i = pkgdb_query_conflicts(it->db, pkg_get(pkg, PKG_ORIGIN));
 			c = NULL;
 			while (pkgdb_it_next_conflict(i, &c) == 0) {
 				array_append(&pkg->conflicts, c);

@@ -254,7 +254,7 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)

 		if (flags & PKG_FILES) {
 			array_init(&pkg->files, 10);
 			i = pkgdb_query_files(it->db, pkg_origin(pkg));
 			i = pkgdb_query_files(it->db, pkg_get(pkg, PKG_ORIGIN));
 			f = NULL;
 			while (pkgdb_it_next_file(i, &f) == 0) {
 				array_append(&pkg->files, f);

@@ -510,11 +510,11 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)

 			"VALUES (?1, ?2, ?3);",
 			-1, &stmt_file, NULL);
 	sqlite3_bind_text(stmt_pkg, 1, pkg_origin(pkg), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 2, pkg_name(pkg), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 3, pkg_version(pkg), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 4, pkg_comment(pkg), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 5, pkg_desc(pkg), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 2, pkg_get(pkg, PKG_NAME), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 3, pkg_get(pkg, PKG_VERSION), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 4, pkg_get(pkg, PKG_COMMENT), -1, SQLITE_STATIC);
 	sqlite3_bind_text(stmt_pkg, 5, pkg_get(pkg, PKG_DESC), -1, SQLITE_STATIC);
 	sqlite3_step(stmt_pkg);

@@ -522,10 +522,10 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)

 	if (deps != NULL)
 		for (i = 0; deps[i] != NULL; i++) {
 			sqlite3_bind_text(stmt_dep, 1, pkg_origin(deps[i]), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_dep, 2, pkg_name(deps[i]), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_dep, 3, pkg_version(deps[i]), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_dep, 4, pkg_origin(pkg), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_dep, 1, pkg_get(deps[i], PKG_ORIGIN), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_dep, 2, pkg_get(deps[i], PKG_NAME), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_dep, 3, pkg_get(deps[i], PKG_VERSION), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_dep, 4, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
 			sqlite3_step(stmt_dep);
 			sqlite3_reset(stmt_dep);

@@ -535,7 +535,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)

 	if (conflicts != NULL)
 		for (i = 0; conflicts[i] != NULL; i++) {
 			sqlite3_bind_text(stmt_conflicts, 1, pkg_conflict_glob(conflicts[i]), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_conflicts, 2, pkg_origin(pkg), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_conflicts, 2, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
 		}

@@ -544,7 +544,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)

 		for (i = 0; files[i] != NULL; i++) {
 			sqlite3_bind_text(stmt_file, 1, pkg_file_path(files[i]), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_file, 2, pkg_file_sha256(files[i]), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_file, 3, pkg_origin(pkg), -1, SQLITE_STATIC);
 			sqlite3_bind_text(stmt_file, 3, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
 			sqlite3_step(stmt_file);
 			sqlite3_reset(stmt_file);

modified pkg/add.c

@@ -39,7 +39,7 @@ exec_add(int argc, char **argv)

 	}
 	/* check if already installed */
 	if ((it = pkgdb_query(db, pkg_name(pkg), MATCH_EXACT)) == NULL) {
 	if ((it = pkgdb_query(db, pkg_get(pkg, PKG_ORIGIN), MATCH_EXACT)) == NULL) {
 		pkgdb_warn(db);
 		return (-1);
 	}

@@ -53,7 +53,7 @@ exec_add(int argc, char **argv)

 	if (installed) {
 		err(1, "%s is already installed\n", pkg_name(pkg));
 		err(1, "%s is already installed\n", pkg_get(pkg, PKG_NAME));
 	}
 	deps = pkg_deps(pkg);

@@ -62,7 +62,7 @@ exec_add(int argc, char **argv)

 		for (i = 0; deps[i] != NULL; i++) {
 			if (pkg_type(deps[i]) == PKG_NOTFOUND) {
 				warnx("%s-%s: unresolved dependency %s-%s", pkg_name(pkg), pkg_version(pkg), pkg_name(deps[i]), pkg_version(deps[i]));
 				warnx("%s-%s: unresolved dependency %s-%s", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_get(deps[i], PKG_NAME), pkg_get(deps[i], PKG_VERSION));
 				ret = 1;
 			}
 		}

modified pkg/info.c

@@ -38,16 +38,16 @@ query_pkg(struct pkg *pkg, unsigned char opt) {

 	int i;
 	if (opt & INFO_PRINT_DEP) {
 		printf("%s-%s depends on: \n", pkg_name(pkg), pkg_version(pkg));
 		printf("%s-%s depends on: \n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 		deps = pkg_deps(pkg);
 		for (i = 0; deps[i] != NULL; i++) {
 			printf("%s-%s\n", pkg_name(deps[i]), pkg_version(deps[i]));
 			printf("%s-%s\n", pkg_get(deps[i], PKG_NAME), pkg_get(deps[i], PKG_VERSION));
 		}
 		printf("\n");
 	} else if (opt & INFO_LIST_FILES) {
 		printf("%s-%s owns the following files:\n", pkg_name(pkg), pkg_version(pkg));
 		printf("%s-%s owns the following files:\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 		files = pkg_files(pkg);
 		for (i = 0; files[i] != NULL; i++) {

@@ -56,7 +56,7 @@ query_pkg(struct pkg *pkg, unsigned char opt) {

 		printf("\n");
 	} else {
 		printf("%s-%s: %s\n", pkg_name(pkg), pkg_version(pkg), pkg_comment(pkg));
 		printf("%s-%s: %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_get(pkg, PKG_COMMENT));
 	}
 	pkg_free(pkg);

@@ -172,27 +172,27 @@ exec_info(int argc, char **argv)

 		if (opt & INFO_EXISTS) {
 			retcode = 0;
 		} else if (opt & INFO_PRINT_DEP) {
 			if (!opt & INFO_QUIET)
 				printf("%s-%s depends on:\n", pkg_name(pkg), pkg_version(pkg));
 			if (opt | INFO_QUIET)
 				printf("%s-%s depends on:\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 			deps = pkg_deps(pkg);
 			for (i = 0; deps[i] != NULL; i++) {
 				printf("%s-%s\n", pkg_name(deps[i]), pkg_version(deps[i]));
 				printf("%s-%s\n", pkg_get(deps[i], PKG_NAME), pkg_get(deps[i], PKG_VERSION));
 			}
 			if (!opt & INFO_QUIET)
 			if (opt | INFO_QUIET)
 				printf("\n");
 		} else if (opt & INFO_PRINT_RDEP) {
 			printf("%s-%s is required by:\n", pkg_name(pkg), pkg_version(pkg));
 			printf("%s-%s is required by:\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 			deps = pkg_rdeps(pkg);
 			for (i = 0; deps[i] != NULL; i++) {
 				printf("%s-%s\n", pkg_name(deps[i]), pkg_version(deps[i]));
 				printf("%s-%s\n", pkg_get(deps[i], PKG_NAME), pkg_get(deps[i], PKG_VERSION));
 			}
 			printf("\n");
 		} else if (opt & INFO_LIST_FILES) {
 			printf("%s-%s owns the following files:\n", pkg_name(pkg), pkg_version(pkg));
 			printf("%s-%s owns the following files:\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 			files = pkg_files(pkg);
 			for (i = 0; files[i] != NULL; i++) {

@@ -202,18 +202,18 @@ exec_info(int argc, char **argv)

 			printf("\n");
 		} else if (opt & INFO_SIZE) {
 			humanize_number(size, sizeof(size), pkg_size(pkg), "B", HN_AUTOSCALE, 0);
 			printf("%s-%s size is %s\n", pkg_name(pkg), pkg_version(pkg), size);
 			printf("%s-%s size is %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), size);
 		} else if (opt & INFO_ORIGIN) {
 			if (opt & INFO_QUIET)
 				printf("%s\n", pkg_origin(pkg));
 				printf("%s\n", pkg_get(pkg, PKG_ORIGIN));
 			else
 				printf("%s-%s: %s\n", pkg_name(pkg), pkg_version(pkg), pkg_origin(pkg));
 				printf("%s-%s: %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_get(pkg, PKG_ORIGIN));
 		} else {
 			if (opt & INFO_QUIET)
 				printf("%s-%s\n", pkg_name(pkg), pkg_version(pkg));
 				printf("%s-%s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
 			else
 				printf("%s-%s: %s\n", pkg_name(pkg), pkg_version(pkg), pkg_comment(pkg));
 				printf("%s-%s: %s\n", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION), pkg_get(pkg, PKG_COMMENT));
 		}
 	}
 	pkg_free(pkg);

modified pkg/which.c

@@ -48,8 +48,8 @@ exec_which(int argc, char **argv)

 	pkg_new(&pkg);
 	if (pkgdb_it_next_pkg(it, &pkg, PKG_BASIC) == 0) {
 		retcode = 0;
 		printf("%s was installed by package %s-%s\n", pathabs, pkg_name(pkg),
 			   pkg_version(pkg));
 		printf("%s was installed by package %s-%s\n", pathabs, pkg_get(pkg, PKG_NAME),
 			   pkg_get(pkg, PKG_VERSION));
 	}
 	pkg_free(pkg);
 	pkgdb_it_free(it);