b708227 Better error handling on pkg.c and add testing for pkg.c functions — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -14,6 +14,9 @@ static void pkg_free_void(void*);

 pkg_t
 pkg_type(struct pkg *pkg)
 {
 	if (pkg == NULL)
 		return (PKG_NONE);
 	return (pkg->type);
 }

@@ -57,11 +60,11 @@ int

 pkg_set(struct pkg *pkg, pkg_attr attr, const char *value)
 {
 	if (pkg == NULL)
 		return (EPKG_FATAL);
 		return (EPKG_NULL_PKG);
 	if (value == NULL) {
 		pkg_set(pkg, PKG_ERR, "Value can not be NULL");
 		return (EPKG_FATAL);
 		return (EPKG_NULL_VALUE);
 	}
 	switch (attr) {

@@ -98,13 +101,17 @@ int

 pkg_set_from_file(struct pkg *pkg, pkg_attr attr, const char *path)
 {
 	char *buf = NULL;
 	off_t size = 0;
 	int ret = EPKG_OK;
 	if (file_to_buffer(path, &buf) <= 0) {
 		sbuf_reset(pkg->err);
 		sbuf_printf(pkg->err, "Unable to read %s: %s\n", path, strerror(errno));
 		return (EPKG_FATAL);
 	}
 	if (pkg == NULL)
 		return (EPKG_NULL_PKG);
 	if (path == NULL)
 		return (EPKG_NULL_VALUE);
 	if ((ret = file_to_buffer(path, &buf, &size)) !=  EPKG_OK)
 		return (ret);
 	ret = pkg_set(pkg, attr, buf);

@@ -116,24 +123,36 @@ pkg_set_from_file(struct pkg *pkg, pkg_attr attr, const char *path)

 struct pkg_script **
 pkg_scripts(struct pkg *pkg)
 {
 	if (pkg == NULL)
 		return (NULL);
 	return ((struct pkg_script **)pkg->scripts.data);
 }
 struct pkg_exec **
 pkg_execs(struct pkg *pkg)
 {
 	if (pkg == NULL)
 		return (NULL);
 	return (struct pkg_exec **) pkg->exec.data;
 }
 struct pkg **
 pkg_deps(struct pkg *pkg)
 {
 	if (pkg == NULL)
 		return (NULL);
 	return ((struct pkg **)pkg->deps.data);
 }
 struct pkg_option **
 pkg_options(struct pkg *pkg)
 {
 	if (pkg == NULL)
 		return (NULL);
 	return ((struct pkg_option **)pkg->options.data);
 }

@@ -161,24 +180,33 @@ pkg_resolvdeps(struct pkg *pkg, struct pkgdb *db) {

 	}
 	pkg_free(p);
 	return (0);
 	return (1);
 }
 struct pkg **
 pkg_rdeps(struct pkg *pkg)
 {
 	if (pkg == NULL)
 		return (NULL);
 	return ((struct pkg **)pkg->rdeps.data);
 }
 struct pkg_file **
 pkg_files(struct pkg *pkg)
 {
 	if (pkg == NULL)
 		return (NULL);
 	return ((struct pkg_file **)pkg->files.data);
 }
 struct pkg_conflict **
 pkg_conflicts(struct pkg *pkg)
 {
 	if (pkg == NULL)
 		return (NULL);
 	return ((struct pkg_conflict **)pkg->conflicts.data);
 }

@@ -196,6 +224,9 @@ pkg_open(const char *path, struct pkg **pkg_p, int query_flags)

 	const char *fpath;
 	char buf[1024];
 	if (path == NULL)
 		return (EPKG_NULL_VALUE);
 	/* search for http(s) or ftp(s) */
 	if (STARTS_WITH(path, "http://") || STARTS_WITH(path, "https://")
 			|| STARTS_WITH(path, "ftp://")) {

@@ -290,7 +321,7 @@ pkg_open(const char *path, struct pkg **pkg_p, int query_flags)

 error:
 	archive_read_finish(a);
 	return (EPKG_FATAL);
 	return (EPKG_ERROR_ARCHIVE);
 }
 #define EXTRACT_ARCHIVE_FLAGS  (ARCHIVE_EXTRACT_OWNER |ARCHIVE_EXTRACT_PERM| \

@@ -411,12 +442,17 @@ pkg_addscript(struct pkg *pkg, const char *path)

 	struct pkg_script *script;
 	char *filename;
 	char *raw_script;
 	int ret = EPKG_OK;
 	off_t sz = 0;
 	if (pkg == NULL)
 		return (EPKG_NULL_PKG);
 	if (path == NULL)
 		return (-1);
 		return (EPKG_NULL_VALUE);
 	if (file_to_buffer(path, &raw_script) <= 0)
 		return (-1);
 	if ((ret = file_to_buffer(path, &raw_script, &sz)) != EPKG_OK)
 		return (ret);
 	pkg_script_new(&script);

@@ -445,14 +481,13 @@ pkg_addscript(struct pkg *pkg, const char *path)

 	} else if (strcmp(filename, "pkg-upgrade") == 0) {
 		script->type = PKG_SCRIPT_UPGRADE;
 	} else {
 		/* unknown script */
 		return (-1);
 		return (EPKG_UNKNOWN_SCRIPT);
 	}
 	array_init(&pkg->scripts, 6);
 	array_append(&pkg->scripts, script);
 	return (0);
 	return (EPKG_OK);
 }
 int

@@ -460,8 +495,11 @@ pkg_addexec(struct pkg *pkg, const char *cmd, pkg_exec_t type)

 {
 	struct pkg_exec *exec;
 	if (pkg == NULL)
 		return (EPKG_NULL_PKG);
 	if (cmd == NULL || cmd[0] == '\0')
 		return (-1);
 		return (EPKG_NULL_VALUE);
 	pkg_exec_new(&exec);

@@ -471,7 +509,7 @@ pkg_addexec(struct pkg *pkg, const char *cmd, pkg_exec_t type)

 	array_init(&pkg->exec, 5);
 	array_append(&pkg->exec, exec);
 	return (0);
 	return (EPKG_OK);
 }
 int

@@ -479,8 +517,11 @@ pkg_addoption(struct pkg *pkg, const char *opt, const char *value)

 {
 	struct pkg_option *option;
 	if (pkg == NULL)
 		return (EPKG_NULL_PKG);
 	if (opt == NULL || opt[0] == '\0' || value == NULL || value[0] == '\0')
 		return (-1);
 		return (EPKG_NULL_VALUE);
 	pkg_option_new(&option);

@@ -490,7 +531,7 @@ pkg_addoption(struct pkg *pkg, const char *opt, const char *value)

 	array_init(&pkg->options, 5);
 	array_append(&pkg->options, option);
 	return (0);
 	return (EPKG_OK);
 }
 int

@@ -498,9 +539,12 @@ pkg_adddep(struct pkg *pkg, const char *name, const char *origin, const char *ve

 {
 	struct pkg *dep;
 	if (pkg == NULL)
 		return (EPKG_NULL_PKG);
 	if (name == NULL || name[0] == '\0' || origin == NULL || origin[0] == '\0'
 		|| version == NULL || version[0] == '\0')
 		return (-1);
 		return (EPKG_NULL_VALUE);
 	pkg_new(&dep);

@@ -512,15 +556,19 @@ pkg_adddep(struct pkg *pkg, const char *name, const char *origin, const char *ve

 	array_init(&pkg->deps, 5);
 	array_append(&pkg->deps, dep);
 	return (0);
 	return (EPKG_OK);
 }
 int
 pkg_addfile(struct pkg *pkg, const char *path, const char *sha256, int64_t sz)
 {
 	struct pkg_file *file;
 	if (pkg == NULL)
 		return (EPKG_NULL_PKG);
 	if (path == NULL || path[0] == '\0')
 		return (-1);
 		return (EPKG_NULL_VALUE);
 	pkg_file_new(&file);

@@ -534,7 +582,7 @@ pkg_addfile(struct pkg *pkg, const char *path, const char *sha256, int64_t sz)

 	array_init(&pkg->files, 10);
 	array_append(&pkg->files, file);
 	return (0);
 	return (EPKG_OK);
 }
 int

@@ -542,8 +590,11 @@ pkg_addconflict(struct pkg *pkg, const char *glob)

 {
 	struct pkg_conflict *conflict;
 	if (pkg == NULL)
 		return (EPKG_NULL_PKG);
 	if (glob == NULL || glob[0] == '\0')
 		return (-1);
 		return (EPKG_NULL_VALUE);
 	pkg_conflict_new(&conflict);
 	sbuf_set(&conflict->glob, glob);

@@ -551,5 +602,5 @@ pkg_addconflict(struct pkg *pkg, const char *glob)

 	array_init(&pkg->conflicts, 5);
 	array_append(&pkg->conflicts, conflict);
 	return (0);
 	return (EPKG_OK);
 }

modified libpkg/pkg.h

@@ -24,7 +24,8 @@ typedef enum {

 	PKG_FILE,
 	PKG_REMOTE,
 	PKG_INSTALLED,
 	PKG_NOTFOUND
 	PKG_NOTFOUND,
 	PKG_NONE,
 } pkg_t;
 typedef enum {

@@ -64,6 +65,16 @@ typedef enum {

 	EPKG_END,
 	EPKG_WARNING,
 	EPKG_FATAL,
 	EPKG_NULL_PKG,
 	EPKG_NULL_VALUE,
 	EPKG_ERROR_MALLOC,
 	EPKG_ERROR_STAT,
 	EPKG_ERROR_OPEN,
 	EPKG_ERROR_READ,
 	EPKG_ERROR_ARCHIVE,
 	EPKG_UNKNOWN_SCRIPT,
 	EPKG_NOT_ORIGIN,
 	EPKG_NOT_NAME,
 } pkg_error_t;
 /* pkg */

modified libpkg/pkg_ports.c

@@ -17,19 +17,20 @@ ports_parse_plist(struct pkg *pkg, char *plist, const char *prefix)

 	size_t next;
 	char sha256[65];
 	char path[MAXPATHLEN];
 	int ret = 0;
 	char *last_plist_file = NULL;
 	char *cmd = NULL;
 	struct stat st;
 	int ret = EPKG_OK;
 	off_t sz = 0;
 	buf = NULL;
 	p = NULL;
 	if (plist == NULL)
 		return (-1);
 		return (EPKG_NULL_VALUE);
 	if (file_to_buffer(plist, &plist_buf) <= 0)
 		return (-1);
 	if ((ret = file_to_buffer(plist, &plist_buf, &sz)) != EPKG_OK)
 		return (ret);
 	if (prefix == NULL)
 		prefix = "/usr/local";

modified libpkg/pkg_util.c

@@ -13,6 +13,7 @@

 #include <libutil.h>
 #include "pkg_util.h"
 #include "pkg.h"
 void
 array_init(struct array *a, size_t c)

@@ -111,8 +112,8 @@ sbuf_free(struct sbuf *buf)

 		sbuf_delete(buf);
 }
 off_t
 file_to_buffer(const char *path, char **buffer)
 int
 file_to_buffer(const char *path, char **buffer, off_t *sz)
 {
 	int fd;
 	struct stat st;

@@ -121,26 +122,24 @@ file_to_buffer(const char *path, char **buffer)

 	assert(buffer != NULL);
 	if ((fd = open(path, O_RDONLY)) == -1) {
 		warn("open(%s)", path);
 		return (-1);
 		return (EPKG_ERROR_OPEN);
 	}
 	if (fstat(fd, &st) == -1) {
 		warn("fstat(%d)", fd);
 		close(fd);
 		return (-1);
 		return (EPKG_ERROR_STAT);
 	}
 	if ((*buffer = malloc(st.st_size + 1)) == NULL) {
 		warn("malloc(%llu)", (unsigned long long)st.st_size + 1);
 		close(fd);
 		return (-1);
 		return (EPKG_ERROR_MALLOC);
 	}
 	if (read(fd, *buffer, st.st_size) == -1) {
 		warn("read()");
 		close(fd);
 		return (-1);
 		return (EPKG_ERROR_READ);
 	}
 	close(fd);

@@ -148,7 +147,8 @@ file_to_buffer(const char *path, char **buffer)

 	/* NULL terminate the buffer so it can be used by stdio.h functions */
 	(*buffer)[st.st_size] = '\0';
 	return (st.st_size);
 	*sz = st.st_size;
 	return (EPKG_OK);
 }
 int

modified libpkg/pkg_util.h

@@ -22,7 +22,7 @@ const char * sbuf_get(struct sbuf *);

 void sbuf_reset(struct sbuf *);
 void sbuf_free(struct sbuf *);
 off_t file_to_buffer(const char *path, char **buffer);
 int file_to_buffer(const char *, char **, off_t *);
 int format_exec_cmd(char **, const char *, const char *, const char *);
 int split_chr(char *, char);
 int file_fetch(const char *, const char *);

modified tests/pkg.c

@@ -4,11 +4,40 @@

 START_TEST(pkg_null)
 {
 	struct pkg *p = NULL;
 	fail_unless(pkg_get(p, PKG_NAME) ==NULL);
 	fail_unless(pkg_set(p, PKG_NAME, "foobar") == EPKG_FATAL);
 	fail_unless(pkg_set(p, PKG_NAME, "foobar") == EPKG_NULL_PKG);
 	fail_unless(pkg_type(p) == PKG_NONE);
 	fail_unless(pkg_set_from_file(p, PKG_NAME, "path") == EPKG_NULL_PKG);
 	fail_unless(pkg_scripts(p) == NULL);
 	fail_unless(pkg_deps(p) == NULL);
 	fail_unless(pkg_execs(p) == NULL);
 	fail_unless(pkg_options(p) == NULL);
 	fail_unless(pkg_rdeps(p) == NULL);
 	fail_unless(pkg_files(p) == NULL);
 	fail_unless(pkg_conflicts(p) == NULL);
 	fail_unless(pkg_addscript(p, "./bla") == EPKG_NULL_PKG);
 	fail_unless(pkg_addoption(p, "foo", "bar") == EPKG_NULL_PKG);
 	fail_unless(pkg_addexec(p, "bal", PKG_EXEC) == EPKG_NULL_PKG);
 	fail_unless(pkg_adddep(p, "foo", "foo/bar", "123") == EPKG_NULL_PKG);
 	fail_unless(pkg_new(&p) == EPKG_OK);
 	fail_unless(pkg_set(p, PKG_NAME, NULL) == EPKG_FATAL);
 	fail_unless(pkg_set(p, PKG_NAME, NULL) == EPKG_NULL_VALUE);
 	fail_unless(pkg_set_from_file(p, PKG_NAME, NULL) == EPKG_NULL_VALUE);
 	fail_unless(pkg_open(NULL, &p, 0) == EPKG_NULL_VALUE);
 	fail_unless(pkg_open("test", &p, 0) == EPKG_ERROR_ARCHIVE);
 	fail_unless(pkg_addscript(p, NULL) == EPKG_NULL_VALUE);
 	fail_unless(pkg_addscript(p, "./bla") == EPKG_ERROR_OPEN);
 	fail_unless(pkg_addoption(p, NULL, "bar") == EPKG_NULL_VALUE);
 	fail_unless(pkg_addoption(p, "foo", NULL) == EPKG_NULL_VALUE);
 	fail_unless(pkg_addexec(p, NULL, PKG_EXEC) == EPKG_NULL_VALUE);
 	fail_unless(pkg_adddep(p, NULL, "foo/bar", "123") == EPKG_NULL_VALUE);
 	fail_unless(pkg_adddep(p, "foo", NULL, "123") == EPKG_NULL_VALUE);
 	/* currently disabled until we get code to test origin format and name
 	 * format*/
 /*	fail_unless(pkg_adddep(p, "foo", "foobar", NULL) == EPKG_NOT_ORIGIN);
 	fail_unless(pkg_adddep(p, "fo/o", "foo/bar", NULL) == EPKG_NOT_NAME);*/
 }
 END_TEST