f627c6b Improved management of sbuf. — HardenedBSD-pkg

modified libpkg/pkg.c

@@ -18,31 +18,31 @@ pkg_type(struct pkg *pkg)

 const char *
 pkg_origin(struct pkg *pkg)
 {
 	return (sbuf_data(pkg->origin));
 	return (sbuf_get(pkg->origin));
 }
 const char *
 pkg_name(struct pkg *pkg)
 {
 	return (sbuf_data(pkg->name));
 	return (sbuf_get(pkg->name));
 }
 const char *
 pkg_version(struct pkg *pkg)
 {
 	return (sbuf_data(pkg->version));
 	return (sbuf_get(pkg->version));
 }
 const char *
 pkg_comment(struct pkg *pkg)
 {
 	return (sbuf_data(pkg->comment));
 	return (sbuf_get(pkg->comment));
 }
 const char *
 pkg_desc(struct pkg *pkg)
 {
 	return (sbuf_data(pkg->desc));
 	return (sbuf_get(pkg->desc));
 }
 struct pkg **

@@ -183,12 +183,6 @@ pkg_new(struct pkg **pkg)

 	if ((*pkg = calloc(1, sizeof(struct pkg))) == NULL)
 		err(EXIT_FAILURE, "calloc()");
 	(*pkg)->name = sbuf_new_auto();
 	(*pkg)->version = sbuf_new_auto();
 	(*pkg)->origin = sbuf_new_auto();
 	(*pkg)->comment = sbuf_new_auto();
 	(*pkg)->desc = sbuf_new_auto();
 	return (0);
 }

@@ -198,11 +192,11 @@ pkg_reset(struct pkg *pkg)

 	if (pkg == NULL)
 		return;
 	sbuf_clear(pkg->name);
 	sbuf_clear(pkg->version);
 	sbuf_clear(pkg->origin);
 	sbuf_clear(pkg->comment);
 	sbuf_clear(pkg->desc);
 	sbuf_reset(pkg->origin);
 	sbuf_reset(pkg->name);
 	sbuf_reset(pkg->version);
 	sbuf_reset(pkg->comment);
 	sbuf_reset(pkg->desc);
 	array_reset(&pkg->deps, &pkg_free_void);
 	array_reset(&pkg->rdeps, &pkg_free_void);

@@ -216,11 +210,11 @@ pkg_free(struct pkg *pkg)

 	if (pkg == NULL)
 		return;
 	sbuf_delete(pkg->name);
 	sbuf_delete(pkg->version);
 	sbuf_delete(pkg->origin);
 	sbuf_delete(pkg->comment);
 	sbuf_delete(pkg->desc);
 	sbuf_free(pkg->name);
 	sbuf_free(pkg->version);
 	sbuf_free(pkg->origin);
 	sbuf_free(pkg->comment);
 	sbuf_free(pkg->desc);
 	array_free(&pkg->deps, &pkg_free_void);
 	array_free(&pkg->rdeps, &pkg_free_void);

@@ -237,65 +231,30 @@ pkg_free_void(void *p)

 		pkg_free((struct pkg*) p);
 }
 /* setters */
 /* Setters */
 int
 pkg_setname(struct pkg *pkg, const char *name)
 pkg_setorigin(struct pkg *pkg, const char *origin)
 {
 	if (name == NULL)
 		return (-1);
 	if (sbuf_done(pkg->name) != 0)
 		sbuf_clear(pkg->name);
 	sbuf_cat(pkg->name, name);
 	sbuf_finish(pkg->name);
 	return (0);
 	return (sbuf_set(&pkg->origin, origin));
 }
 int
 pkg_setversion(struct pkg *pkg, const char *version)
 pkg_setname(struct pkg *pkg, const char *name)
 {
 	if (version == NULL)
 		return (-1);
 	if (sbuf_done(pkg->version) != 0)
 		sbuf_clear(pkg->version);
 	sbuf_cat(pkg->version, version);
 	sbuf_finish(pkg->version);
 	return (0);
 	return (sbuf_set(&pkg->name, name));
 }
 int
 pkg_setcomment(struct pkg *pkg, const char *comment)
 pkg_setversion(struct pkg *pkg, const char *version)
 {
 	if (comment == NULL)
 		return (-1);
 	if (sbuf_done(pkg->comment) != 0)
 		sbuf_clear(pkg->comment);
 	sbuf_cat(pkg->comment, comment);
 	sbuf_finish(pkg->comment);
 	return (0);
 	return (sbuf_set(&pkg->version, version));
 }
 int
 pkg_setorigin(struct pkg *pkg, const char *origin)
 pkg_setcomment(struct pkg *pkg, const char *comment)
 {
 	if (origin == NULL)
 		return (-1);
 	if (sbuf_done(pkg->origin) != 0)
 		sbuf_clear(pkg->origin);
 	sbuf_cat(pkg->origin, origin);
 	sbuf_finish(pkg->origin);
 	return (0);
 	return (sbuf_set(&pkg->comment, comment));
 }
 int

@@ -317,16 +276,7 @@ pkg_setdesc_from_file(struct pkg *pkg, const char *desc_path)

 int
 pkg_setdesc(struct pkg *pkg, const char *desc)
 {
 	if (desc == NULL)
 		return (-1);
 	if (sbuf_done(pkg->desc) != 0)
 		sbuf_clear(pkg->desc);
 	sbuf_cat(pkg->desc, desc);
 	sbuf_finish(pkg->desc);
 	return (0);
 	return (sbuf_set(&pkg->desc, desc));
 }
 int

@@ -368,7 +318,7 @@ pkg_addconflict(struct pkg *pkg, const char *glob)

 		return (-1);
 	pkg_conflict_new(&conflict);
 	sbuf_cat(conflict->glob, glob);
 	sbuf_cpy(conflict->glob, glob);
 	sbuf_finish(conflict->glob);
 	array_init(&pkg->conflicts, 5);

modified libpkg/pkg_conflict.c

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

 const char *
 pkg_conflict_glob(struct pkg_conflict *c)
 {
 	return (sbuf_data(c->glob));
 	return (sbuf_get(c->glob));
 }
 int

@@ -15,15 +15,13 @@ pkg_conflict_new(struct pkg_conflict **c)

 	if ((*c = calloc(1, sizeof(struct pkg_conflict))))
 		return (-1);
 	(*c)->glob = sbuf_new_auto();
 	return (0);
 }
 void
 pkg_conflict_reset(struct pkg_conflict *c)
 {
 	sbuf_clear(c->glob);
 	sbuf_reset(c->glob);
 }
 void

@@ -32,7 +30,7 @@ pkg_conflict_free(struct pkg_conflict *c)

 	if (c == NULL)
 		return;
 	sbuf_delete(c->glob);
 	sbuf_free(c->glob);
 	free(c);
 }

modified libpkg/pkg_private.h

@@ -1,6 +1,7 @@

 #ifndef _PKG_PRIVATE_H
 #define _PKG_PRIVATE_H
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/sbuf.h>

modified libpkg/pkgdb.c

@@ -16,11 +16,6 @@

 #include "pkgdb.h"
 #include "util.h"
 #ifdef DEBUG
 #include <dirent.h>
 #include "pkg_compat.h"
 #endif
 #define PKG_DBDIR "/var/db/pkg"
 static struct pkgdb_it * pkgdb_it_new(struct pkgdb *, sqlite3_stmt *, pkgdb_it_t);

@@ -214,20 +209,11 @@ pkgdb_it_next_pkg(struct pkgdb_it *it, struct pkg **pkg_p, int flags)

 			pkg_reset(*pkg_p);
 		pkg = *pkg_p;
 		sbuf_cat(pkg->origin, sqlite3_column_text(it->stmt, 0));
 		sbuf_finish(pkg->origin);
 		sbuf_cat(pkg->name, sqlite3_column_text(it->stmt, 1));
 		sbuf_finish(pkg->name);
 		sbuf_cat(pkg->version, sqlite3_column_text(it->stmt, 2));
 		sbuf_finish(pkg->version);
 		sbuf_cat(pkg->comment, sqlite3_column_text(it->stmt, 3));
 		sbuf_finish(pkg->comment);
 		sbuf_cat(pkg->desc, sqlite3_column_text(it->stmt, 4));
 		sbuf_finish(pkg->desc);
 		pkg_setorigin(pkg, sqlite3_column_text(it->stmt, 0));
 		pkg_setname(pkg, sqlite3_column_text(it->stmt, 1));
 		pkg_setversion(pkg, sqlite3_column_text(it->stmt, 2));
 		pkg_setcomment(pkg, sqlite3_column_text(it->stmt, 3));
 		pkg_setdesc(pkg, sqlite3_column_text(it->stmt, 4));
 		if (flags & PKG_DEPS) {
 			array_init(&pkg->deps, 10);

@@ -308,8 +294,7 @@ pkgdb_it_next_conflict(struct pkgdb_it *it, struct pkg_conflict **c_p)

 			pkg_conflict_reset(*c_p);
 		c = *c_p;
 		sbuf_cat(c->glob, sqlite3_column_text(it->stmt, 0));
 		sbuf_finish(c->glob);
 		sbuf_set(&c->glob, sqlite3_column_text(it->stmt, 0));
 		return (0);
 	case SQLITE_DONE:

modified libpkg/util.c

@@ -69,6 +69,45 @@ array_free(struct array *a, void (*free_elm)(void*))

 	a->cap = 0;
 }
 int
 sbuf_set(struct sbuf **buf, const char *str)
 {
 	if (*buf == NULL)
 		*buf = sbuf_new_auto();
 	if (str == NULL)
 		return (-1);
 	sbuf_cpy(*buf, str);
 	sbuf_finish(*buf);
 	return (0);
 }
 const char *
 sbuf_get(struct sbuf *buf)
 {
 	if (buf == NULL)
 		return (NULL);
 	return sbuf_data(buf);
 }
 void
 sbuf_reset(struct sbuf *buf)
 {
 	if (buf != NULL) {
 		sbuf_clear(buf);
 		sbuf_finish(buf);
 	}
 }
 void
 sbuf_free(struct sbuf *buf)
 {
 	if (buf != NULL)
 		sbuf_delete(buf);
 }
 off_t
 file_to_buffer(const char *path, char **buffer)
 {

@@ -135,16 +174,6 @@ str_replace(char *string, const char *find, char *replace)

 }
 int
 select_dir(const struct dirent *dirent)
 {
 	if (dirent->d_type == DT_DIR && strcmp(dirent->d_name, ".") != 0
 		&& strcmp(dirent->d_name, "..") != 0)
 		return (1);
 	return (0);
 }
 int
 split_chr(char *str, char sep)
 {
 	char *next;

modified libpkg/util.h

@@ -1,8 +1,8 @@

 #ifndef _PKG_UTIL_H
 #define _PKG_UTIL_H
 #include <sys/param.h>
 #include <dirent.h>
 #include <sys/types.h>
 #include <sys/sbuf.h>
 struct array {
 	size_t cap;

@@ -17,9 +17,13 @@ void array_append(struct array *, void *);

 void array_reset(struct array *, void (*free_elm)(void*));
 void array_free(struct array *, void (*free_elm)(void*));
 int sbuf_set(struct sbuf **, const char *);
 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);
 char *str_replace(char *string, const char *find, char *replace);
 int select_dir(const struct dirent *);
 int split_chr(char *, char);
 int file_fetch(const char *, const char *);