2a1ca66 abort() in case of memory failure — HardenedBSD-pkg

modified libpkg/diff.c

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

 #include <utstring.h>
 #include "private/utils.h"
 #include "private/xmalloc.h"
 /*
 ** Maximum length of a line in a text file, in bytes.  (2**13 = 8192 bytes)

@@ -123,7 +124,7 @@ static DLine *break_into_lines(char *z, int *pnLine){

   if( j>LENGTH_MASK ){
     return 0;
   }
   a = calloc(nLine, sizeof(a[0]) );
   a = xcalloc(nLine, sizeof(a[0]) );
   if( n==0 ){
     *pnLine = 0;
     return a;

@@ -318,7 +319,7 @@ static void longestCommonSequence(

 ** Expand the size of aEdit[] array to hold at least nEdit elements.
 */
 static void expandEdit(DContext *p, int nEdit){
   p->aEdit = realloc(p->aEdit, nEdit*sizeof(int));
   p->aEdit = xrealloc(p->aEdit, nEdit*sizeof(int));
   p->nEditAlloc = nEdit;
 }

modified libpkg/dns_utils.c

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

 #include <bsd_compat.h>
 #include "private/utils.h"
 #include "private/xmalloc.h"
 #include "pkg.h"
 #ifndef HAVE_LDNS

@@ -133,7 +134,7 @@ compute_weight(struct dns_srvinfo **d, int first, int last)

 	if (totalweight == 0)
 		return;
 	chosen = malloc(sizeof(int) * (last - first + 1));
 	chosen = xmalloc(sizeof(int) * (last - first + 1));
 	for (i = 0; i <= last; i++) {
 		for (;;) {

@@ -180,10 +181,7 @@ dns_getsrvinfo(const char *zone)

 		p += len + NS_QFIXEDSZ;
 	}
 	res = calloc(ancount, sizeof(struct dns_srvinfo *));
 	if (res == NULL)
 		return (NULL);
 	res = xcalloc(ancount, sizeof(struct dns_srvinfo *));
 	n = 0;
 	while (ancount > 0 && p < end) {
 		ancount--;

@@ -219,7 +217,7 @@ dns_getsrvinfo(const char *zone)

 			return NULL;
 		}
 		res[n] = malloc(sizeof(struct dns_srvinfo));
 		res[n] = xmalloc(sizeof(struct dns_srvinfo));
 		if (res[n] == NULL) {
 			for (i = 0; i < n; i++)
 				free(res[i]);

@@ -334,7 +332,7 @@ compute_weight(struct dns_srvinfo *d, int first, int last)

 	if (totalweight == 0)
 		return;
 	chosen = malloc(sizeof(int) * (last - first + 1));
 	chosen = xmalloc(sizeof(int) * (last - first + 1));
 	for (i = 0; i <= last; i++) {
 		for (;;) {

@@ -388,9 +386,7 @@ dns_getsrvinfo(const char *zone)

 		return (NULL);
 	ancount = ldns_rr_list_rr_count(srv);
 	res = calloc(ancount, sizeof(struct dns_srvinfo));
 	if (res == NULL)
 		return (NULL);
 	res = xcalloc(ancount, sizeof(struct dns_srvinfo));
 	for (i = 0; i < ancount; i ++) {
 		ldns_rr *rr;

modified libpkg/elfhints.c

@@ -105,11 +105,7 @@ shlib_list_add(kh_shlib_t **shlib_list, const char *dir,

 	path_len = strlen(dir) + strlen(shlib_file) + 2;
 	sl = calloc(1, sizeof(struct shlib) + path_len);
 	if (sl == NULL) {
 		warnx("Out of memory");
 		return (EPKG_FATAL);
 	}
 	sl = xcalloc(1, sizeof(struct shlib) + path_len);
 	strlcpy(sl->path, dir, path_len);
 	dir_len = strlcat(sl->path, "/", path_len);

@@ -276,11 +272,7 @@ int shlib_list_from_rpath(const char *rpath_str, const char *dirpath)

 	if (i > 0)
 		buflen += i * numdirs;
 	dirlist = calloc(1, buflen);
 	if (dirlist == NULL) {
 		warnx("Out of memory");
 		return (EPKG_FATAL);
 	}
 	dirlist = xcalloc(1, buflen);
 	buf = (char *)dirlist + numdirs * sizeof(char *);
 	buf[0] = '\0';

@@ -424,8 +416,7 @@ read_dirs_from_file(const char *hintsfile, const char *listfile)

 			warnx("%s:%d: trailing characters ignored",
 			    listfile, linenum);
 		if ((sp = strdup(sp)) == NULL)
 			errx(1, "Out of memory");
 		sp = xstrdup(sp);
 		add_dir(hintsfile, sp, 0);
 	}

modified libpkg/fetch.c

@@ -73,7 +73,7 @@ gethttpmirrors(struct pkg_repo *repo, const char *url) {

 				continue;
 			if ((u = fetchParseURL(line)) != NULL) {
 				m = malloc(sizeof(struct http_mirror));
 				m = xmalloc(sizeof(struct http_mirror));
 				m->url = u;
 				LL_APPEND(repo->http, m);
 			}

@@ -517,10 +517,10 @@ pkg_fetch_file_to_fd(struct pkg_repo *repo, const char *url, int dest,

 		pkg_url_scheme = true;
 		LL_FOREACH(repo->env, kv) {
 			kvtmp = calloc(1, sizeof(*kvtmp));
 			kvtmp->key = strdup(kv->key);
 			kvtmp = xcalloc(1, sizeof(*kvtmp));
 			kvtmp->key = xstrdup(kv->key);
 			if ((tmp = getenv(kv->key)) != NULL) {
 				kvtmp->val = strdup(tmp);
 				kvtmp->val = xstrdup(tmp);
 				LL_APPEND(envtorestore, kvtmp);
 			} else {
 				LL_APPEND(envtounset, kvtmp);

modified libpkg/packing.c

@@ -56,10 +56,7 @@ packing_init(struct packing **pack, const char *path, pkg_formats format)

 	assert(pack != NULL);
 	if ((*pack = calloc(1, sizeof(struct packing))) == NULL) {
 		pkg_emit_errno("calloc", "packing");
 		return (EPKG_FATAL);
 	}
 	*pack = xcalloc(1, sizeof(struct packing));
 	(*pack)->aread = archive_read_disk_new();
 	archive_read_disk_set_standard_lookup((*pack)->aread);

modified libpkg/pkg.c

@@ -43,11 +43,7 @@

 int
 pkg_new(struct pkg **pkg, pkg_t type)
 {
 	if ((*pkg = calloc(1, sizeof(struct pkg))) == NULL) {
 		pkg_emit_errno("calloc", "pkg");
 		return EPKG_FATAL;
 	}
 	*pkg = xcalloc(1, sizeof(struct pkg));
 	(*pkg)->type = type;
 	(*pkg)->rootfd = -1;

@@ -321,25 +317,25 @@ pkg_vset(struct pkg *pkg, va_list ap)

 		switch (attr) {
 		case PKG_NAME:
 			free(pkg->name);
 			pkg->name = strdup(va_arg(ap, const char *));
 			pkg->name = xstrdup(va_arg(ap, const char *));
 			free(pkg->uid);
 			pkg->uid = strdup(pkg->name);
 			pkg->uid = xstrdup(pkg->name);
 			break;
 		case PKG_ORIGIN:
 			free(pkg->origin);
 			pkg->origin = strdup(va_arg(ap, const char *));
 			pkg->origin = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_VERSION:
 			free(pkg->version);
 			pkg->version = strdup(va_arg(ap, const char *));
 			pkg->version = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_COMMENT:
 			free(pkg->comment);
 			pkg->comment = strdup(va_arg(ap, const char *));
 			pkg->comment = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_DESC:
 			free(pkg->desc);
 			pkg->desc = strdup(va_arg(ap, const char *));
 			pkg->desc = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_MTREE:
 			(void)va_arg(ap, const char *);

@@ -360,51 +356,51 @@ pkg_vset(struct pkg *pkg, va_list ap)

 			break;
 		case PKG_ARCH:
 			free(pkg->arch);
 			pkg->arch = strdup(va_arg(ap, const char *));
 			pkg->arch = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_ABI:
 			free(pkg->abi);
 			pkg->abi = strdup(va_arg(ap, const char *));
 			pkg->abi = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_MAINTAINER:
 			free(pkg->maintainer);
 			pkg->maintainer = strdup(va_arg(ap, const char *));
 			pkg->maintainer = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_WWW:
 			free(pkg->www);
 			pkg->www = strdup(va_arg(ap, const char *));
 			pkg->www = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_PREFIX:
 			free(pkg->prefix);
 			pkg->prefix = strdup(va_arg(ap, const char *));
 			pkg->prefix = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_REPOPATH:
 			free(pkg->repopath);
 			pkg->repopath = strdup(va_arg(ap, const char *));
 			pkg->repopath = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_CKSUM:
 			free(pkg->sum);
 			pkg->sum = strdup(va_arg(ap, const char *));
 			pkg->sum = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_OLD_VERSION:
 			free(pkg->old_version);
 			pkg->old_version = strdup(va_arg(ap, const char *));
 			pkg->old_version = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_REPONAME:
 			free(pkg->reponame);
 			pkg->reponame = strdup(va_arg(ap, const char *));
 			pkg->reponame = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_REPOURL:
 			free(pkg->repourl);
 			pkg->repourl = strdup(va_arg(ap, const char *));
 			pkg->repourl = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_DIGEST:
 			free(pkg->digest);
 			pkg->digest = strdup(va_arg(ap, const char *));
 			pkg->digest = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_REASON:
 			free(pkg->reason);
 			pkg->reason = strdup(va_arg(ap, const char *));
 			pkg->reason = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_FLATSIZE:
 			pkg->flatsize = va_arg(ap, int64_t);

@@ -432,7 +428,7 @@ pkg_vset(struct pkg *pkg, va_list ap)

 			break;
 		case PKG_DEP_FORMULA:
 			free(pkg->dep_formula);
 			pkg->dep_formula = strdup(va_arg(ap, const char *));
 			pkg->dep_formula = xstrdup(va_arg(ap, const char *));
 			break;
 		case PKG_VITAL:
 			pkg->vital = (bool)va_arg(ap, int);

@@ -593,7 +589,7 @@ pkg_adduser(struct pkg *pkg, const char *name)

 		}
 	}
 	storename = strdup(name);
 	storename = xstrdup(name);
 	kh_add(strings, pkg->users, storename, storename, free);
 	return (EPKG_OK);

@@ -617,7 +613,7 @@ pkg_addgroup(struct pkg *pkg, const char *name)

 		}
 	}
 	storename = strdup(name);
 	storename = xstrdup(name);
 	kh_add(strings, pkg->groups, storename, storename, free);
 	return (EPKG_OK);

@@ -647,11 +643,11 @@ pkg_adddep(struct pkg *pkg, const char *name, const char *origin, const char *ve

 	pkg_dep_new(&d);
 	d->origin = strdup(origin);
 	d->name = strdup(name);
 	d->origin = xstrdup(origin);
 	d->name = xstrdup(name);
 	if (version != NULL && version[0] != '\0')
 		d->version = strdup(version);
 	d->uid = strdup(name);
 		d->version = xstrdup(version);
 	d->uid = xstrdup(name);
 	d->locked = locked;
 	kh_add(pkg_deps, pkg->depshash, d, d->name, pkg_dep_free);

@@ -672,11 +668,11 @@ pkg_addrdep(struct pkg *pkg, const char *name, const char *origin, const char *v

 	pkg_debug(3, "Pkg: add a new reverse dependency origin: %s, name: %s", origin, name);
 	pkg_dep_new(&d);
 	d->origin = strdup(origin);
 	d->name = strdup(name);
 	d->origin = xstrdup(origin);
 	d->name = xstrdup(name);
 	if (version != NULL && version[0] != '\0')
 		d->version = strdup(version);
 	d->uid = strdup(name);
 		d->version = xstrdup(version);
 	d->uid = xstrdup(name);
 	d->locked = locked;
 	kh_add(pkg_deps, pkg->rdepshash, d, d->name, pkg_dep_free);

@@ -719,7 +715,7 @@ pkg_addfile_attr(struct pkg *pkg, const char *path, const char *sum,

 	strlcpy(f->path, path, sizeof(f->path));
 	if (sum != NULL)
 		f->sum = strdup(sum);
 		f->sum = xstrdup(sum);
 	if (uname != NULL)
 		strlcpy(f->uname, uname, sizeof(f->uname));

@@ -760,7 +756,7 @@ pkg_addconfig_file(struct pkg *pkg, const char *path, const char *content)

 	strlcpy(f->path, path, sizeof(f->path));
 	if (content != NULL)
 		f->content = strdup(content);
 		f->content = xstrdup(content);
 	kh_add(pkg_config_files, pkg->config_files, f, f->path, pkg_config_file_free);

@@ -787,7 +783,7 @@ pkg_addstring(kh_strings_t **list, const char *val, const char *title)

 		}
 	}
 	store = strdup(val);
 	store = xstrdup(val);
 	kh_add(strings, *list, store, store, free);
 	return (EPKG_OK);

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

 	HASH_FIND_STR(pkg->options, key, o);
 	if (o == NULL) {
 		pkg_option_new(&o);
 		o->key = strdup(key);
 		o->key = xstrdup(key);
 	} else if ( o->value != NULL) {
 		if (developer_mode) {
 			pkg_emit_error("duplicate options listing: %s, fatal (developer mode)", key);

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

 		}
 	}
 	o->value = strdup(value);
 	o->value = xstrdup(value);
 	HASH_ADD_KEYPTR(hh, pkg->options, o->key, strlen(o->key), o);
 	return (EPKG_OK);

@@ -1042,7 +1038,7 @@ pkg_addoption_default(struct pkg *pkg, const char *key,

 	HASH_FIND_STR(pkg->options, key, o);
 	if (o == NULL) {
 		pkg_option_new(&o);
 		o->key = strdup(key);
 		o->key = xstrdup(key);
 	} else if ( o->default_value != NULL) {
 		if (developer_mode) {
 			pkg_emit_error("duplicate default value for option: %s, fatal (developer mode)", key);

@@ -1053,7 +1049,7 @@ pkg_addoption_default(struct pkg *pkg, const char *key,

 		}
 	}
 	o->default_value = strdup(default_value);
 	o->default_value = xstrdup(default_value);
 	HASH_ADD_KEYPTR(hh, pkg->options, o->default_value,
 	    strlen(o->default_value), o);

@@ -1078,7 +1074,7 @@ pkg_addoption_description(struct pkg *pkg, const char *key,

 	HASH_FIND_STR(pkg->options, key, o);
 	if (o == NULL) {
 		pkg_option_new(&o);
 		o->key = strdup(key);
 		o->key = xstrdup(key);
 	} else if ( o->description != NULL) {
 		if (developer_mode) {
 			pkg_emit_error("duplicate description for option: %s, fatal (developer mode)", key);

@@ -1089,7 +1085,7 @@ pkg_addoption_description(struct pkg *pkg, const char *key,

 		}
 	}
 	o->description = strdup(description);
 	o->description = xstrdup(description);
 	HASH_ADD_KEYPTR(hh, pkg->options, o->description,
 	    strlen(o->description), o);

@@ -1108,7 +1104,7 @@ pkg_addshlib_required(struct pkg *pkg, const char *name)

 	if (kh_contains(strings, pkg->shlibs_required, name))
 		return (EPKG_OK);
 	storename = strdup(name);
 	storename = xstrdup(name);
 	kh_add(strings, pkg->shlibs_required, storename, storename, free);
 	pkg_debug(3, "added shlib deps for %s on %s", pkg->name, name);

@@ -1132,7 +1128,7 @@ pkg_addshlib_provided(struct pkg *pkg, const char *name)

 	if (kh_contains(strings, pkg->shlibs_provided, name))
 		return (EPKG_OK);
 	storename = strdup(name);
 	storename = xstrdup(name);
 	kh_add(strings, pkg->shlibs_provided, storename, storename, free);
 	pkg_debug(3, "added shlib provide %s for %s", name, pkg->name);

@@ -1154,7 +1150,7 @@ pkg_addconflict(struct pkg *pkg, const char *uniqueid)

 		return (EPKG_OK);
 	pkg_conflict_new(&c);
 	c->uid = strdup(uniqueid);
 	c->uid = xstrdup(uniqueid);
 	pkg_debug(3, "Pkg: add a new conflict origin: %s, with %s", pkg->uid, uniqueid);
 	HASH_ADD_KEYPTR(hh, pkg->conflicts, c->uid, strlen(c->uid), c);

@@ -1174,7 +1170,7 @@ pkg_addrequire(struct pkg *pkg, const char *name)

 	if (kh_contains(strings, pkg->requires, name))
 		return (EPKG_OK);
 	storename = strdup(name);
 	storename = xstrdup(name);
 	kh_add(strings, pkg->requires, storename, storename, free);

@@ -1193,7 +1189,7 @@ pkg_addprovide(struct pkg *pkg, const char *name)

 	if (kh_contains(strings, pkg->provides, name))
 		return (EPKG_OK);
 	storename = strdup(name);
 	storename = xstrdup(name);
 	kh_add(strings, pkg->provides, storename, storename, free);

@@ -1448,7 +1444,7 @@ pkg_open2(struct pkg **pkg_p, struct archive **a, struct archive_entry **ae,

 			manifest = true;
 			size_t len = archive_entry_size(*ae);
 			buffer = malloc(len);
 			buffer = xmalloc(len);
 			archive_read_data(*a, buffer, archive_entry_size(*ae));
 			ret = pkg_parse_manifest(pkg, buffer, len, keys);
 			free(buffer);

@@ -1464,7 +1460,7 @@ pkg_open2(struct pkg **pkg_p, struct archive **a, struct archive_entry **ae,

 			char *buffer;
 			size_t len = archive_entry_size(*ae);
 			buffer = malloc(len);
 			buffer = xmalloc(len);
 			archive_read_data(*a, buffer, archive_entry_size(*ae));
 			ret = pkg_parse_manifest(pkg, buffer, len, keys);
 			free(buffer);

@@ -1529,7 +1525,7 @@ pkg_validate(struct pkg *pkg, struct pkgdb *db)

 		if (pkg->name == NULL)
 			return (EPKG_FATAL);
 		pkg->uid = strdup(pkg->name);
 		pkg->uid = xstrdup(pkg->name);
 	}
 	if (pkg->digest == NULL || !pkg_checksum_is_valid(pkg->digest,

@@ -1771,13 +1767,8 @@ pkg_message_from_ucl(struct pkg *pkg, const ucl_object_t *obj)

 	ucl_object_iter_t it = NULL;
 	if (ucl_object_type(obj) == UCL_STRING) {
 		msg = calloc(1, sizeof(*msg));
 		if (msg == NULL) {
 			pkg_emit_errno("malloc", "struct pkg_message");
 			return (EPKG_FATAL);
 		}
 		msg->str = strdup(ucl_object_tostring(obj));
 		msg = xcalloc(1, sizeof(*msg));
 		msg->str = xstrdup(ucl_object_tostring(obj));
 		msg->type = PKG_MESSAGE_ALWAYS;
 		LL_APPEND(pkg->message, msg);
 		return (EPKG_OK);

@@ -1798,14 +1789,9 @@ pkg_message_from_ucl(struct pkg *pkg, const ucl_object_t *obj)

 			return (EPKG_FATAL);
 		}
 		msg = calloc(1, sizeof(*msg));
 		if (msg == NULL) {
 			pkg_emit_errno("malloc", "struct pkg_message");
 			return (EPKG_FATAL);
 		}
 		msg = xcalloc(1, sizeof(*msg));
 		msg->str = strdup(ucl_object_tostring(elt));
 		msg->str = xstrdup(ucl_object_tostring(elt));
 		msg->type = PKG_MESSAGE_ALWAYS;
 		elt = ucl_object_find_key(cur, "type");
 		if (elt != NULL && ucl_object_type(elt) == UCL_STRING) {

@@ -1826,12 +1812,12 @@ pkg_message_from_ucl(struct pkg *pkg, const ucl_object_t *obj)

 		elt = ucl_object_find_key(cur, "minimum_version");
 		if (elt != NULL && ucl_object_type(elt) == UCL_STRING) {
 			msg->minimum_version = strdup(ucl_object_tostring(elt));
 			msg->minimum_version = xstrdup(ucl_object_tostring(elt));
 		}
 		elt = ucl_object_find_key(cur, "maximum_version");
 		if (elt != NULL && ucl_object_type(elt) == UCL_STRING) {
 			msg->maximum_version = strdup(ucl_object_tostring(elt));
 			msg->maximum_version = xstrdup(ucl_object_tostring(elt));
 		}
 		LL_APPEND(pkg->message, msg);

modified libpkg/pkg_add.c

@@ -173,7 +173,7 @@ attempt_to_merge(int rootfd, struct pkg_config_file *rcf, struct pkg *local,

 	if (merge_3way(lcf->content, localconf, rcf->content, newconf) != 0) {
 		pkg_emit_error("Impossible to merge configuration file");
 	} else {
 		rcf->newcontent = strdup(utstring_body(newconf));
 		rcf->newcontent = xstrdup(utstring_body(newconf));
 		rcf->status = MERGE_SUCCESS;
 	}
 	utstring_free(newconf);

@@ -522,7 +522,7 @@ retry:

 			pkg_debug(1, "Populating config_file %s", f->path);
 			len = archive_entry_size(ae);
 			f->config->content = malloc(len + 1);
 			f->config->content = xmalloc(len + 1);
 			archive_read_data(a, f->config->content, len);
 			f->config->content[len] = '\0';
 			cfdata = f->config->content;

@@ -773,7 +773,7 @@ pkg_globmatch(char *pattern, const char *name)

 		if (pkg_version_cmp(path, g.gl_pathv[i]) == 1)
 			path = g.gl_pathv[i];
 	}
 	path = strdup(path);
 	path = xstrdup(path);
 	globfree(&g);
 	return (path);

@@ -1036,7 +1036,7 @@ pkg_add_common(struct pkgdb *db, const char *path, unsigned flags,

 		}
 		free(pkg->digest);
 		pkg->digest = strdup(remote->digest);
 		pkg->digest = xstrdup(remote->digest);
 		/* only preserve flags is -A has not been passed */
 		if ((flags & PKG_ADD_AUTOMATIC) == 0)
 			pkg->automatic = remote->automatic;

modified libpkg/pkg_attributes.c

@@ -38,8 +38,7 @@

 int
 pkg_dep_new(struct pkg_dep **d)
 {
 	if ((*d = calloc(1, sizeof(struct pkg_dep))) == NULL)
 		return (EPKG_FATAL);
 	*d = xcalloc(1, sizeof(struct pkg_dep));
 	return (EPKG_OK);
 }

@@ -93,8 +92,7 @@ pkg_dep_is_locked(struct pkg_dep const * const d)

 int
 pkg_file_new(struct pkg_file **file)
 {
 	if ((*file = calloc(1, sizeof(struct pkg_file))) == NULL)
 		return (EPKG_FATAL);
 	*file = xcalloc(1, sizeof(struct pkg_file));
 	(*file)->perm = 0;
 	(*file)->fflags = 0;

@@ -116,8 +114,7 @@ pkg_file_free(struct pkg_file *file)

 int
 pkg_dir_new(struct pkg_dir **d)
 {
 	if ((*d = calloc(1, sizeof(struct pkg_dir))) == NULL)
 		return (EPKG_FATAL);
 	*d = xcalloc(1, sizeof(struct pkg_dir));
 	(*d)->perm = 0;
 	(*d)->fflags = 0;

@@ -151,10 +148,8 @@ pkg_script_get(struct pkg const * const p, pkg_script i)

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

@@ -178,8 +173,7 @@ pkg_option_free(struct pkg_option *option)

 int
 pkg_conflict_new(struct pkg_conflict **c)
 {
 	if ((*c = calloc(1, sizeof(struct pkg_conflict))) == NULL)
 		return (EPKG_FATAL);
 	*c = xcalloc(1, sizeof(struct pkg_conflict));
 	return (EPKG_OK);
 }

@@ -201,8 +195,7 @@ pkg_conflict_free(struct pkg_conflict *c)

 int
 pkg_config_file_new(struct pkg_config_file **c)
 {
 	if ((*c = calloc(1, sizeof(struct pkg_config_file))) == NULL)
 		return (EPKG_FATAL);
 	*c = xcalloc(1, sizeof(struct pkg_config_file));
 	return (EPKG_OK);
 }

@@ -225,11 +218,10 @@ pkg_config_file_free(struct pkg_config_file *c)

 int
 pkg_kv_new(struct pkg_kv **c, const char *key, const char *val)
 {
 	if ((*c = calloc(1, sizeof(struct pkg_kv))) == NULL)
 		return (EPKG_FATAL);
 	*c = xcalloc(1, sizeof(struct pkg_kv));
 	(*c)->key = strdup(key);
 	(*c)->value = strdup(val);
 	(*c)->key = xstrdup(key);
 	(*c)->value = xstrdup(val);
 	return (EPKG_OK);
 }

modified libpkg/pkg_audit.c

@@ -339,9 +339,7 @@ pkg_audit_expand_entry(struct pkg_audit_entry *entry, struct pkg_audit_entry **h

 	LL_FOREACH(entry->packages, pcur) {
 		LL_FOREACH(pcur->names, ncur) {
 			n = calloc(1, sizeof(struct pkg_audit_entry));
 			if (n == NULL)
 				err(1, "calloc(audit_entry)");
 			n = xcalloc(1, sizeof(struct pkg_audit_entry));
 			n->pkgname = ncur->pkgname;
 			/* Set new entry as reference entry */
 			n->ref = true;

@@ -388,12 +386,10 @@ vulnxml_start_element(void *data, const char *element, const char **attributes)

 	int i;
 	if (ud->state == VULNXML_PARSE_INIT && strcasecmp(element, "vuln") == 0) {
 		ud->cur_entry = calloc(1, sizeof(struct pkg_audit_entry));
 		if (ud->cur_entry == NULL)
 			err(1, "calloc(audit_entry)");
 		ud->cur_entry = xcalloc(1, sizeof(struct pkg_audit_entry));
 		for (i = 0; attributes[i]; i += 2) {
 			if (strcasecmp(attributes[i], "vid") == 0) {
 				ud->cur_entry->id = strdup(attributes[i + 1]);
 				ud->cur_entry->id = xstrdup(attributes[i + 1]);
 				break;
 			}
 		}

@@ -404,9 +400,7 @@ vulnxml_start_element(void *data, const char *element, const char **attributes)

 		ud->state = VULNXML_PARSE_TOPIC;
 	}
 	else if (ud->state == VULNXML_PARSE_VULN && strcasecmp(element, "package") == 0) {
 		pkg_entry = calloc(1, sizeof(struct pkg_audit_package));
 		if (pkg_entry == NULL)
 			err(1, "calloc(audit_package_entry)");
 		pkg_entry = xcalloc(1, sizeof(struct pkg_audit_package));
 		LL_PREPEND(ud->cur_entry->packages, pkg_entry);
 		ud->state = VULNXML_PARSE_PACKAGE;
 	}

@@ -415,16 +409,12 @@ vulnxml_start_element(void *data, const char *element, const char **attributes)

 	}
 	else if (ud->state == VULNXML_PARSE_PACKAGE && strcasecmp(element, "name") == 0) {
 		ud->state = VULNXML_PARSE_PACKAGE_NAME;
 		name_entry = calloc(1, sizeof(struct pkg_audit_pkgname));
 		if (name_entry == NULL)
 			err(1, "calloc(audit_pkgname_entry)");
 		name_entry = xcalloc(1, sizeof(struct pkg_audit_pkgname));
 		LL_PREPEND(ud->cur_entry->packages->names, name_entry);
 	}
 	else if (ud->state == VULNXML_PARSE_PACKAGE && strcasecmp(element, "range") == 0) {
 		ud->state = VULNXML_PARSE_RANGE;
 		vers = calloc(1, sizeof(struct pkg_audit_versions_range));
 		if (vers == NULL)
 			err(1, "calloc(audit_versions)");
 		vers = xcalloc(1, sizeof(struct pkg_audit_versions_range));
 		LL_PREPEND(ud->cur_entry->packages->versions, vers);
 		ud->range_num = 0;
 	}

@@ -508,10 +498,10 @@ vulnxml_handle_data(void *data, const char *content, int length)

 		/* On these states we do not need any data */
 		break;
 	case VULNXML_PARSE_TOPIC:
 		ud->cur_entry->desc = strndup(content, length);
 		ud->cur_entry->desc = xstrndup(content, length);
 		break;
 	case VULNXML_PARSE_PACKAGE_NAME:
 		ud->cur_entry->packages->names->pkgname = strndup(content, length);
 		ud->cur_entry->packages->names->pkgname = xstrndup(content, length);
 		break;
 	case VULNXML_PARSE_RANGE_GT:
 		range_type = GT;

@@ -530,8 +520,8 @@ vulnxml_handle_data(void *data, const char *content, int length)

 		break;
 	case VULNXML_PARSE_CVE:
 		entry = ud->cur_entry;
 		cve = malloc(sizeof(struct pkg_audit_cve));
 		cve->cvename = strndup(content, length);
 		cve = xmalloc(sizeof(struct pkg_audit_cve));
 		cve->cvename = xstrndup(content, length);
 		LL_PREPEND(entry->cve, cve);
 		break;
 	}

@@ -539,11 +529,11 @@ vulnxml_handle_data(void *data, const char *content, int length)

 	if (range_type > 0) {
 		vers = ud->cur_entry->packages->versions;
 		if (ud->range_num == 1) {
 			vers->v1.version = strndup(content, length);
 			vers->v1.version = xstrndup(content, length);
 			vers->v1.type = range_type;
 		}
 		else if (ud->range_num == 2) {
 			vers->v2.version = strndup(content, length);
 			vers->v2.version = xstrndup(content, length);
 			vers->v2.type = range_type;
 		}
 	}

@@ -637,9 +627,7 @@ pkg_audit_preprocess(struct pkg_audit_entry *h)

 	LL_FOREACH(h, e)
 		n++;
 	ret = (struct pkg_audit_item *)calloc(n + 1, sizeof(ret[0]));
 	if (ret == NULL)
 		err(1, "calloc(audit_entry_sorted*)");
 	ret = xcalloc(n + 1, sizeof(ret[0]));
 	bzero((void *)ret, (n + 1) * sizeof(ret[0]));
 	n = 0;

@@ -855,7 +843,7 @@ pkg_audit_new(void)

 {
 	struct pkg_audit *audit;
 	audit = calloc(1, sizeof(struct pkg_audit));
 	audit = xcalloc(1, sizeof(struct pkg_audit));
 	return (audit);
 }

modified libpkg/pkg_checksum.c

@@ -173,14 +173,9 @@ pkg_checksum_add_entry(const char *key,

 {
 	struct pkg_checksum_entry *e;
 	e = malloc(sizeof(*e));
 	if (e == NULL) {
 		pkg_emit_errno("malloc", "pkg_checksum_entry");
 		return;
 	}
 	e = xmalloc(sizeof(*e));
 	e->field = key;
 	e->value = strdup(value);
 	e->value = xstrdup(value);
 	DL_APPEND(*entries, e);
 }

@@ -379,15 +374,9 @@ pkg_checksum_hash_sha256(struct pkg_checksum_entry *entries,

 		sha256_update(&sign_ctx, entries->value, strlen(entries->value));
 		entries = entries->next;
 	}
 	*out = malloc(SHA256_BLOCK_SIZE);
 	if (*out != NULL) {
 		sha256_final(&sign_ctx, *out);
 		*outlen = SHA256_BLOCK_SIZE;
 	}
 	else {
 		pkg_emit_errno("malloc", "pkg_checksum_hash_sha256");
 		*outlen = 0;
 	}
 	*out = xmalloc(SHA256_BLOCK_SIZE);
 	sha256_final(&sign_ctx, *out);
 	*outlen = SHA256_BLOCK_SIZE;
 }
 static void

@@ -396,7 +385,7 @@ pkg_checksum_hash_sha256_bulk(const unsigned char *in, size_t inlen,

 {
 	SHA256_CTX sign_ctx;
 	*out = malloc(SHA256_BLOCK_SIZE);
 	*out = xmalloc(SHA256_BLOCK_SIZE);
 	sha256_init(&sign_ctx);
 	sha256_update(&sign_ctx, in, inlen);
 	sha256_final(&sign_ctx, *out);

@@ -410,7 +399,7 @@ pkg_checksum_hash_sha256_file(int fd, unsigned char **out, size_t *outlen)

 	size_t r;
 	SHA256_CTX sign_ctx;
 	*out = malloc(SHA256_BLOCK_SIZE);
 	*out = xmalloc(SHA256_BLOCK_SIZE);
 	sha256_init(&sign_ctx);
 	while ((r = read(fd, buffer, sizeof(buffer))) > 0)
 		sha256_update(&sign_ctx, buffer, r);

@@ -431,22 +420,16 @@ pkg_checksum_hash_blake2(struct pkg_checksum_entry *entries,

 		blake2b_update (&st, entries->value, strlen(entries->value));
 		entries = entries->next;
 	}
 	*out = malloc(BLAKE2B_OUTBYTES);
 	if (*out != NULL) {
 		blake2b_final (&st, *out, BLAKE2B_OUTBYTES);
 		*outlen = BLAKE2B_OUTBYTES;
 	}
 	else {
 		pkg_emit_errno("malloc", "pkg_checksum_hash_blake2");
 		*outlen = 0;
 	}
 	*out = xmalloc(BLAKE2B_OUTBYTES);
 	blake2b_final (&st, *out, BLAKE2B_OUTBYTES);
 	*outlen = BLAKE2B_OUTBYTES;
 }
 static void
 pkg_checksum_hash_blake2_bulk(const unsigned char *in, size_t inlen,
 				unsigned char **out, size_t *outlen)
 {
 	*out = malloc(BLAKE2B_OUTBYTES);
 	*out = xmalloc(BLAKE2B_OUTBYTES);
 	blake2b(*out, BLAKE2B_OUTBYTES,  in, inlen, NULL, 0);
 	*outlen = BLAKE2B_OUTBYTES;
 }

@@ -463,7 +446,7 @@ pkg_checksum_hash_blake2_file(int fd, unsigned char **out, size_t *outlen)

 	while ((r = read(fd, buffer, sizeof(buffer))) > 0)
 		blake2b_update(&st, buffer, r);
 	*out = malloc(BLAKE2B_OUTBYTES);
 	*out = xmalloc(BLAKE2B_OUTBYTES);
 	blake2b_final(&st, *out, BLAKE2B_OUTBYTES);
 	*outlen = BLAKE2B_OUTBYTES;
 }

@@ -481,22 +464,16 @@ pkg_checksum_hash_blake2s(struct pkg_checksum_entry *entries,

 		blake2s_update (&st, entries->value, strlen(entries->value));
 		entries = entries->next;
 	}
 	*out = malloc(BLAKE2S_OUTBYTES);
 	if (*out != NULL) {
 		blake2s_final (&st, *out, BLAKE2S_OUTBYTES);
 		*outlen = BLAKE2S_OUTBYTES;
 	}
 	else {
 		pkg_emit_errno("malloc", "pkg_checksum_hash_blake2s");
 		*outlen = 0;
 	}
 	*out = xmalloc(BLAKE2S_OUTBYTES);
 	blake2s_final (&st, *out, BLAKE2S_OUTBYTES);
 	*outlen = BLAKE2S_OUTBYTES;
 }
 static void
 pkg_checksum_hash_blake2s_bulk(const unsigned char *in, size_t inlen,
 				unsigned char **out, size_t *outlen)
 {
 	*out = malloc(BLAKE2S_OUTBYTES);
 	*out = xmalloc(BLAKE2S_OUTBYTES);
 	blake2s(*out, BLAKE2S_OUTBYTES,  in, inlen, NULL, 0);
 	*outlen = BLAKE2S_OUTBYTES;
 }

@@ -513,7 +490,7 @@ pkg_checksum_hash_blake2s_file(int fd, unsigned char **out, size_t *outlen)

 	while ((r = read(fd, buffer, sizeof(buffer))) > 0)
 		blake2s_update(&st, buffer, r);
 	*out = malloc(BLAKE2S_OUTBYTES);
 	*out = xmalloc(BLAKE2S_OUTBYTES);
 	blake2s_final(&st, *out, BLAKE2S_OUTBYTES);
 	*outlen = BLAKE2S_OUTBYTES;
 }

@@ -644,12 +621,7 @@ pkg_checksum_calculate(struct pkg *pkg, struct pkgdb *db)

 			type = repo->meta->digest_format;
 	}
 	new_digest = malloc(pkg_checksum_type_size(type));
 	if (new_digest == NULL) {
 		pkg_emit_errno("malloc", "pkg_checksum_type_t");
 		return (EPKG_FATAL);
 	}
 	new_digest = xmalloc(pkg_checksum_type_size(type));
 	if (pkg_checksum_generate(pkg, new_digest, pkg_checksum_type_size(type), type)
 			!= EPKG_OK) {
 		free(new_digest);

@@ -687,7 +659,7 @@ pkg_checksum_data(const unsigned char *in, size_t inlen,

 	cksum->hbulkfunc(in, inlen, &out, &outlen);
 	if (out != NULL) {
 		if (cksum->encfunc != NULL) {
 			res = malloc(cksum->hlen);
 			res = xmalloc(cksum->hlen);
 			cksum->encfunc(out, outlen, res, cksum->hlen);
 			free(out);
 		}

@@ -749,7 +721,7 @@ pkg_checksum_fd(int fd, pkg_checksum_type_t type)

 	cksum->hfilefunc(fd, &out, &outlen);
 	if (out != NULL) {
 		if (cksum->encfunc != NULL) {
 			res = malloc(cksum->hlen);
 			res = xmalloc(cksum->hlen);
 			cksum->encfunc(out, outlen, res, cksum->hlen);
 			free(out);
 		} else {

modified libpkg/pkg_config.c

@@ -645,12 +645,12 @@ add_repo(const ucl_object_t *obj, struct pkg_repo *r, const char *rname, pkg_ini

 	if (fingerprints != NULL) {
 		free(r->fingerprints);
 		r->fingerprints = strdup(fingerprints);
 		r->fingerprints = xstrdup(fingerprints);
 	}
 	if (pubkey != NULL) {
 		free(r->pubkey);
 		r->pubkey = strdup(pubkey);
 		r->pubkey = xstrdup(pubkey);
 	}
 	r->enable = enable;

@@ -681,9 +681,9 @@ add_repo(const ucl_object_t *obj, struct pkg_repo *r, const char *rname, pkg_ini

 	if (env != NULL) {
 		it = NULL;
 		while ((cur = ucl_iterate_object(env, &it, true))) {
 			kv = calloc(1, sizeof(*kv));
 			kv->key = strdup(ucl_object_key(cur));
 			kv->val = strdup(ucl_object_tostring_forced(cur));
 			kv = xcalloc(1, sizeof(*kv));
 			kv->key = xstrdup(ucl_object_key(cur));
 			kv->val = xstrdup(ucl_object_tostring_forced(cur));
 			LL_APPEND(r->env, kv);
 		}
 	}

@@ -1254,14 +1254,14 @@ pkg_repo_new(const char *name, const char *url, const char *type)

 {
 	struct pkg_repo *r;
 	r = calloc(1, sizeof(struct pkg_repo));
 	r = xcalloc(1, sizeof(struct pkg_repo));
 	r->ops = pkg_repo_find_type(type);
 	r->url = strdup(url);
 	r->url = xstrdup(url);
 	r->signature_type = SIG_NONE;
 	r->mirror_type = NOMIRROR;
 	r->enable = true;
 	r->meta = pkg_repo_meta_default();
 	r->name = strdup(name);
 	r->name = xstrdup(name);
 	HASH_ADD_KEYPTR(hh, repos, r->name, strlen(r->name), r);
 	return (r);

@@ -1273,10 +1273,10 @@ pkg_repo_overwrite(struct pkg_repo *r, const char *name, const char *url,

 {
 	free(r->name);
 	r->name = strdup(name);
 	r->name = xstrdup(name);
 	if (url != NULL) {
 		free(r->url);
 		r->url = strdup(url);
 		r->url = xstrdup(url);
 	}
 	r->ops = pkg_repo_find_type(type);
 	HASH_DEL(repos, r);

modified libpkg/pkg_create.c

@@ -347,7 +347,7 @@ pkg_load_metadata(struct pkg *pkg, const char *mfile, const char *md_dir,

 	/* if no arch autodetermine it */
 	if (pkg->abi == NULL) {
 		pkg_get_myarch(arch, BUFSIZ);
 		pkg->abi = strdup(arch);
 		pkg->abi = xstrdup(arch);
 		defaultarch = true;
 	}

@@ -372,9 +372,9 @@ pkg_load_metadata(struct pkg *pkg, const char *mfile, const char *md_dir,

 		    REG_EXTENDED|REG_ICASE|REG_NEWLINE);
 		if (regexec(&preg, pkg->desc, 2, pmatch, 0) == 0) {
 			size = pmatch[1].rm_eo - pmatch[1].rm_so;
 			pkg->www = strndup(&pkg->desc[pmatch[1].rm_so], size);
 			pkg->www = xstrndup(&pkg->desc[pmatch[1].rm_so], size);
 		} else {
 			pkg->www = strdup("UNKNOWN");
 			pkg->www = xstrdup("UNKNOWN");
 		}
 		regfree(&preg);
 	}

modified libpkg/pkg_cudf.c

@@ -308,9 +308,7 @@ cudf_strdup(const char *in)

 	char *out, *d;
 	const char *s;
 	out = malloc(len + 1);
 	if (out == NULL)
 		return (NULL);
 	out = xmalloc(len + 1);
 	s = in;
 	d = out;

@@ -334,11 +332,7 @@ pkg_jobs_cudf_insert_res_job (struct pkg_solved **target,

 {
 	struct pkg_solved *res;
 	res = calloc(1, sizeof(struct pkg_solved));
 	if (res == NULL) {
 		pkg_emit_errno("calloc", "pkg_solved");
 		return;
 	}
 	res = xcalloc(1, sizeof(struct pkg_solved));
 	res->items[0] = it_new;
 	res->type = type;

modified libpkg/pkg_delete.c

@@ -168,7 +168,7 @@ pkg_add_dir_to_del(struct pkg *pkg, const char *file, const char *dir)

 			pkg_debug(1, "Replacing in deletion %s with %s",
 			    pkg->dir_to_del[i], path);
 			free(pkg->dir_to_del[i]);
 			pkg->dir_to_del[i] = strdup(path);
 			pkg->dir_to_del[i] = xstrdup(path);
 			return;
 		}
 	}

@@ -177,11 +177,11 @@ pkg_add_dir_to_del(struct pkg *pkg, const char *file, const char *dir)

 	if (pkg->dir_to_del_len + 1 > pkg->dir_to_del_cap) {
 		pkg->dir_to_del_cap += 64;
 		pkg->dir_to_del = realloc(pkg->dir_to_del,
 		pkg->dir_to_del = xrealloc(pkg->dir_to_del,
 		    pkg->dir_to_del_cap * sizeof(char *));
 	}
 	pkg->dir_to_del[pkg->dir_to_del_len++] = strdup(path);
 	pkg->dir_to_del[pkg->dir_to_del_len++] = xstrdup(path);
 }
 static void

@@ -406,10 +406,10 @@ pkg_delete_dir(struct pkg *pkg, struct pkg_dir *dir)

 	} else {
 		if (pkg->dir_to_del_len + 1 > pkg->dir_to_del_cap) {
 			pkg->dir_to_del_cap += 64;
 			pkg->dir_to_del = realloc(pkg->dir_to_del,
 			pkg->dir_to_del = xrealloc(pkg->dir_to_del,
 			    pkg->dir_to_del_cap * sizeof(char *));
 		}
 		pkg->dir_to_del[pkg->dir_to_del_len++] = strdup(path);
 		pkg->dir_to_del[pkg->dir_to_del_len++] = xstrdup(path);
 	}
 }

modified libpkg/pkg_deps.c

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

 #include "pkg.h"
 #include "private/event.h"
 #include "private/pkg_deps.h"
 #include "private/xmalloc.h"
 #include "utlist.h"
 struct pkg_dep_formula *

@@ -81,21 +82,8 @@ pkg_deps_parse_formula(const char *in)

 				}
 				else {
 					/* Spaces after the name */
 					cur_item = calloc(1, sizeof(*cur_item));
 					if (cur_item == NULL) {
 						pkg_emit_errno("malloc", "struct pkg_dep_formula_item");
 						return (NULL);
 					}
 					cur_item->name = malloc(p - c + 1);
 					if (cur_item->name == NULL) {
 						pkg_emit_errno("malloc", "cur->name");
 						return (NULL);
 					}
 					cur_item = xcalloc(1, sizeof(*cur_item));
 					cur_item->name = xmalloc(p - c + 1);
 					strlcpy(cur_item->name, c, p - c + 1);
 					next_state = st_parse_after_name;
 				}

@@ -105,21 +93,8 @@ pkg_deps_parse_formula(const char *in)

 					state = st_error;
 				}
 				else {
 					cur_item = calloc(1, sizeof(*cur_item));
 					if (cur_item == NULL) {
 						pkg_emit_errno("malloc", "struct pkg_dep_formula_item");
 						return (NULL);
 					}
 					cur_item->name = malloc(p - c + 1);
 					if (cur_item->name == NULL) {
 						pkg_emit_errno("malloc", "cur->name");
 						return (NULL);
 					}
 					cur_item = xcalloc(1, sizeof(*cur_item));
 					cur_item->name = xmalloc(p - c + 1);
 					strlcpy(cur_item->name, c, p - c + 1);
 					state = st_parse_after_name;
 				}

@@ -235,21 +210,8 @@ pkg_deps_parse_formula(const char *in)

 			}
 			else {
 				if (p - c > 0) {
 					cur_ver = calloc(1, sizeof(*cur_ver));
 					if (cur_ver == NULL) {
 						pkg_emit_errno("malloc", "struct pkg_dep_version");
 						return (NULL);
 					}
 					cur_ver->ver = malloc(p - c + 1);
 					if (cur_ver->ver == NULL) {
 						pkg_emit_errno("malloc", "cur_ver->ver");
 						return (NULL);
 					}
 					cur_ver = xcalloc(1, sizeof(*cur_ver));
 					cur_ver->ver = xmalloc(p - c + 1);
 					strlcpy(cur_ver->ver, c, p - c + 1);
 					cur_ver->op = cur_op;
 					assert(cur_item != NULL);

@@ -264,13 +226,7 @@ pkg_deps_parse_formula(const char *in)

 			break;
 		case st_parse_option_start:
 			cur_opt = calloc(1, sizeof(*cur_opt));
 			if (cur_opt == NULL) {
 				pkg_emit_errno("malloc", "struct pkg_dep_option");
 				return (NULL);
 			}
 			cur_opt = xcalloc(1, sizeof(*cur_opt));
 			if (*p == '+') {
 				cur_opt->on = true;
 			}

@@ -289,14 +245,7 @@ pkg_deps_parse_formula(const char *in)

 			}
 			else {
 				if (p - c > 0) {
 					cur_opt->opt = malloc(p - c + 1);
 					if (cur_opt->opt == NULL) {
 						pkg_emit_errno("malloc", "cur_opt->opt");
 						return (NULL);
 					}
 					cur_opt->opt = xmalloc(p - c + 1);
 					strlcpy(cur_opt->opt, c, p - c + 1);
 					assert(cur_item != NULL);
 					DL_APPEND(cur_item->options, cur_opt);

@@ -313,13 +262,7 @@ pkg_deps_parse_formula(const char *in)

 			assert(cur_item != NULL);
 			if (cur == NULL) {
 				cur = calloc(1, sizeof(*cur));
 				if (cur == NULL) {
 					pkg_emit_errno("malloc", "struct pkg_dep_formula");
 					return (NULL);
 				}
 				cur = xcalloc(1, sizeof(*cur));
 			}
 			DL_APPEND(cur->items, cur_item);

@@ -335,13 +278,7 @@ pkg_deps_parse_formula(const char *in)

 			assert(cur_item != NULL);
 			if (cur == NULL) {
 				cur = calloc(1, sizeof(*cur));
 				if (cur == NULL) {
 					pkg_emit_errno("malloc", "struct pkg_dep_formula");
 					return (NULL);
 				}
 				cur = xcalloc(1, sizeof(*cur));
 			}
 			DL_APPEND(cur->items, cur_item);

@@ -486,13 +423,7 @@ pkg_deps_formula_tostring(struct pkg_dep_formula *f)

 		return (NULL);
 	}
 	res = malloc(rlen + 1);
 	if (res == NULL) {
 		pkg_emit_errno("malloc", "string");
 		return (NULL);
 	}
 	res = xmalloc(rlen + 1);
 	p = res;

@@ -553,13 +484,7 @@ pkg_deps_formula_tosql(struct pkg_dep_formula_item *f)

 		return (NULL);
 	}
 	res = malloc(rlen + 1);
 	if (res == NULL) {
 		pkg_emit_errno("malloc", "string");
 		return (NULL);
 	}
 	res = xmalloc(rlen + 1);
 	p = res;

modified libpkg/pkg_jobs.c

@@ -77,10 +77,7 @@ pkg_jobs_new(struct pkg_jobs **j, pkg_jobs_t t, struct pkgdb *db)

 {
 	assert(db != NULL);
 	if ((*j = calloc(1, sizeof(struct pkg_jobs))) == NULL) {
 		pkg_emit_errno("calloc", "pkg_jobs");
 		return (EPKG_FATAL);
 	}
 	*j = xcalloc(1, sizeof(struct pkg_jobs));
 	(*j)->universe = pkg_jobs_universe_new(*j);

@@ -206,7 +203,7 @@ pkg_jobs_maybe_match_file(struct job_pattern *jp, const char *pattern)

 				pkg_debug(1, "Jobs> Adding file: %s", pattern);
 				jp->flags |= PKG_PATTERN_FLAG_FILE;
 				jp->path = pkg_path;
 				jp->pattern = malloc(len);
 				jp->pattern = xmalloc(len);
 				strlcpy(jp->pattern, pattern, len);
 				return (true);

@@ -218,8 +215,8 @@ pkg_jobs_maybe_match_file(struct job_pattern *jp, const char *pattern)

 		 * Read package from stdin
 		 */
 		jp->flags = PKG_PATTERN_FLAG_FILE;
 		jp->path = strdup(pattern);
 		jp->pattern = strdup(pattern);
 		jp->path = xstrdup(pattern);
 		jp->pattern = xstrdup(pattern);
 	}
 	return (false);

@@ -238,17 +235,17 @@ pkg_jobs_add(struct pkg_jobs *j, match_t match, char **argv, int argc)

 	}
 	for (i = 0; i < argc; i++) {
 		jp = calloc(1, sizeof(struct job_pattern));
 		jp = xcalloc(1, sizeof(struct job_pattern));
 		if (j->type == PKG_JOBS_DEINSTALL ||
 		    !pkg_jobs_maybe_match_file(jp, argv[i])) {
 			jp->pattern = strdup(argv[i]);
 			jp->pattern = xstrdup(argv[i]);
 			jp->match = match;
 		}
 		HASH_ADD_KEYPTR(hh, j->patterns, jp->pattern, strlen(jp->pattern), jp);
 	}
 	if (argc == 0 && match == MATCH_ALL) {
 		jp = calloc(1, sizeof(struct job_pattern));
 		jp = xcalloc(1, sizeof(struct job_pattern));
 		jp->pattern = NULL;
 		jp->match = match;
 		HASH_ADD_KEYPTR(hh, j->patterns, "all", 3, jp);

@@ -296,11 +293,7 @@ pkg_jobs_add_req_from_universe(struct pkg_job_request **head,

 	HASH_FIND_STR(*head, un->pkg->uid, req);
 	if (req == NULL) {
 		req = calloc(1, sizeof(*req));
 		if (req == NULL) {
 			pkg_emit_errno("malloc", "struct pkg_job_request");
 			return (NULL);
 		}
 		req = xcalloc(1, sizeof(*req));
 		new_req = true;
 		req->automatic = automatic;
 		pkg_debug(4, "add new uid %s to the request", un->pkg->uid);

@@ -315,12 +308,7 @@ pkg_jobs_add_req_from_universe(struct pkg_job_request **head,

 	DL_FOREACH(un, uit) {
 		if ((uit->pkg->type == PKG_INSTALLED && local) ||
 				(uit->pkg->type != PKG_INSTALLED && !local)) {
 			nit = calloc(1, sizeof(*nit));
 			if (nit == NULL) {
 				pkg_emit_errno("malloc", "struct pkg_job_request_item");
 				free(req);
 				return (NULL);
 			}
 			nit = xcalloc(1, sizeof(*nit));
 			nit->pkg = uit->pkg;
 			nit->unit = uit;
 			DL_APPEND(req->item, nit);

@@ -399,22 +387,13 @@ pkg_jobs_add_req(struct pkg_jobs *j, struct pkg *pkg)

 	HASH_FIND_STR(*head, pkg->uid, req);
 	nit = calloc(1, sizeof(*nit));
 	if (nit == NULL) {
 		pkg_emit_errno("malloc", "struct pkg_job_request_item");
 		return (NULL);
 	}
 	nit = xcalloc(1, sizeof(*nit));
 	nit->pkg = pkg;
 	nit->unit = un;
 	if (req == NULL) {
 		/* Allocate new unique request item */
 		req = calloc(1, sizeof(*req));
 		if (req == NULL) {
 			pkg_emit_errno("malloc", "struct pkg_job_request");
 			free(nit);
 			return (NULL);
 		}
 		req = xcalloc(1, sizeof(*req));
 		HASH_ADD_KEYPTR(hh, *head, pkg->uid, strlen(pkg->uid), req);
 	}

@@ -582,12 +561,7 @@ pkg_jobs_set_execute_priority(struct pkg_jobs *j, struct pkg_solved *solved)

 			/*
 			 * Split conflicting upgrade request into delete -> upgrade request
 			 */
 			ts = calloc(1, sizeof(struct pkg_solved));
 			if (ts == NULL) {
 				pkg_emit_errno("calloc", "pkg_solved");
 				return (EPKG_FATAL);
 			}
 			ts = xcalloc(1, sizeof(struct pkg_solved));
 			ts->type = PKG_SOLVED_UPGRADE_REMOVE;
 			ts->items[0] = solved->items[1];
 			solved->items[1] = NULL;

@@ -907,7 +881,7 @@ pkg_jobs_guess_upgrade_candidate(struct pkg_jobs *j, const char *pattern)

 	if (olen != len) {
 		/* Try exact pattern without numbers */
 		cpy = malloc(len + 1);
 		cpy = xmalloc(len + 1);
 		strlcpy(cpy, pos, len + 1);
 		if (pkg_jobs_try_remote_candidate(j, cpy, opattern, MATCH_EXACT) != EPKG_OK) {
 			free(cpy);

@@ -1183,13 +1157,13 @@ pkg_jobs_need_upgrade(struct pkg *rp, struct pkg *lp)

 		ret2 = pkg_conflicts(lp, &lc);
 		if (ret1 != ret2) {
 			free(rp->reason);
 			rp->reason = strdup("direct conflict changed");
 			rp->reason = xstrdup("direct conflict changed");
 			return (true);
 		}
 		if (ret1 == EPKG_OK) {
 			if (strcmp(rc->uid, lc->uid) != 0) {
 				free(rp->reason);
 				rp->reason = strdup("direct conflict changed");
 				rp->reason = xstrdup("direct conflict changed");
 				return (true);
 			}
 		}

@@ -1204,13 +1178,13 @@ pkg_jobs_need_upgrade(struct pkg *rp, struct pkg *lp)

 		ret2 = pkg_provides(lp, &lb);
 		if (ret1 != ret2) {
 			free(rp->reason);
 			rp->reason = strdup("provides changed");
 			rp->reason = xstrdup("provides changed");
 			return (true);
 		}
 		if (ret1 == EPKG_OK) {
 			if (strcmp(rb, lb) != 0) {
 				free(rp->reason);
 				rp->reason = strdup("provides changed");
 				rp->reason = xstrdup("provides changed");
 				return (true);
 			}
 		}

@@ -1224,13 +1198,13 @@ pkg_jobs_need_upgrade(struct pkg *rp, struct pkg *lp)

 		ret1 = pkg_requires(lp, &lb);
 		if (ret1 != ret2) {
 			free(rp->reason);
 			rp->reason = strdup("requires changed");
 			rp->reason = xstrdup("requires changed");
 			return (true);
 		}
 		if (ret1 == EPKG_OK) {
 			if (strcmp(rb, lb) != 0) {
 				free(rp->reason);
 				rp->reason = strdup("requires changed");
 				rp->reason = xstrdup("requires changed");
 				return (true);
 			}
 		}

@@ -1245,13 +1219,13 @@ pkg_jobs_need_upgrade(struct pkg *rp, struct pkg *lp)

 		ret2 = pkg_shlibs_provided(lp, &lb);
 		if (ret1 != ret2) {
 			free(rp->reason);
 			rp->reason = strdup("provided shared library changed");
 			rp->reason = xstrdup("provided shared library changed");
 			return (true);
 		}
 		if (ret1 == EPKG_OK) {
 			if (strcmp(rb, lb) != 0) {
 				free(rp->reason);
 				rp->reason = strdup("provided shared library changed");
 				rp->reason = xstrdup("provided shared library changed");
 				pkg_debug(1, "provided shlib changed %s -> %s",
 				    lb, rb);
 				return (true);

@@ -1267,13 +1241,13 @@ pkg_jobs_need_upgrade(struct pkg *rp, struct pkg *lp)

 		ret2 = pkg_shlibs_required(lp, &lb);
 		if (ret1 != ret2) {
 			free(rp->reason);
 			rp->reason = strdup("needed shared library changed");
 			rp->reason = xstrdup("needed shared library changed");
 			return (true);
 		}
 		if (ret1 == EPKG_OK) {
 			if (strcmp(rb, lb) != 0) {
 				free(rp->reason);
 				rp->reason = strdup("needed shared library changed");
 				rp->reason = xstrdup("needed shared library changed");
 				pkg_debug(1, "Required shlib changed %s -> %s",
 				    lb, rb);
 				return (true);

@@ -1480,11 +1454,7 @@ pkg_jobs_new_candidate(struct pkg *pkg)

 {
 	struct pkg_jobs_install_candidate *n;
 	n = malloc(sizeof(*n));
 	if (n == NULL) {
 		pkg_emit_errno("malloc", "pkg_jobs_install_candidate");
 		return (NULL);
 	}
 	n = xmalloc(sizeof(*n));
 	n->id = pkg->id;
 	return (n);
 }

@@ -1962,7 +1932,7 @@ pkg_jobs_handle_install(struct pkg_solved *ps, struct pkg_jobs *j,

 		 */
 		target = req->item->jp->path;
 		free(new->reponame);
 		new->reponame = strdup("local file");
 		new->reponame = xstrdup("local file");
 	}
 	else {
 		pkg_snprintf(path, sizeof(path), "%R", new);

@@ -1972,7 +1942,7 @@ pkg_jobs_handle_install(struct pkg_solved *ps, struct pkg_jobs *j,

 	}
 	if (old != NULL)
 		new->old_version = strdup(old->version);
 		new->old_version = xstrdup(old->version);
 	if ((j->flags & PKG_FLAG_FORCE) == PKG_FLAG_FORCE)
 		flags |= PKG_ADD_FORCE;

modified libpkg/pkg_jobs_conflicts.c

@@ -51,7 +51,7 @@ pkg_conflicts_sipkey_init(void)

 	static struct sipkey *kinit;
 	if (kinit == NULL) {
 		kinit = malloc(sizeof(*kinit));
 		kinit = xmalloc(sizeof(*kinit));
 		arc4random_buf((unsigned char*)kinit, sizeof(*kinit));
 	}

@@ -117,11 +117,7 @@ pkg_conflicts_request_add_chain(struct pkg_conflict_chain **chain, struct pkg_jo

 {
 	struct pkg_conflict_chain *elt;
 	elt = calloc(1, sizeof(struct pkg_conflict_chain));
 	if (elt == NULL) {
 		pkg_emit_errno("resolve_request_conflicts", "calloc: struct pkg_conflict_chain");
 		return;
 	}
 	elt = xcalloc(1, sizeof(struct pkg_conflict_chain));
 	elt->req = req;
 	LL_PREPEND(*chain, elt);
 }

@@ -180,7 +176,7 @@ pkg_conflicts_register(struct pkg *p1, struct pkg *p2, enum pkg_conflict_type ty

 	c1->type = c2->type = type;
 	HASH_FIND_STR(p1->conflicts, p2->uid, test);
 	if (test == NULL) {
 		c1->uid = strdup(p2->uid);
 		c1->uid = xstrdup(p2->uid);
 		HASH_ADD_KEYPTR(hh, p1->conflicts, c1->uid, strlen(c1->uid), c1);
 		pkg_debug(2, "registering conflict between %s(%s) and %s(%s)",
 				p1->uid, p1->type == PKG_INSTALLED ? "l" : "r",

@@ -191,7 +187,7 @@ pkg_conflicts_register(struct pkg *p1, struct pkg *p2, enum pkg_conflict_type ty

 	HASH_FIND_STR(p2->conflicts, p1->uid, test);
 	if (test == NULL) {
 		c2->uid = strdup(p1->uid);
 		c2->uid = xstrdup(p1->uid);
 		HASH_ADD_KEYPTR(hh, p2->conflicts, c2->uid, strlen(c2->uid), c2);
 		pkg_debug(2, "registering conflict between %s(%s) and %s(%s)",
 				p2->uid, p2->type == PKG_INSTALLED ? "l" : "r",

@@ -272,10 +268,10 @@ pkg_conflicts_register_unsafe(struct pkg *p1, struct pkg *p2,

 	if (c1 == NULL) {
 		pkg_conflict_new(&c1);
 		c1->type = type;
 		c1->uid = strdup(p2->uid);
 		c1->uid = xstrdup(p2->uid);
 		if (use_digest) {
 			c1->digest = strdup(p2->digest);
 			c1->digest = xstrdup(p2->digest);
 		}
 		HASH_ADD_KEYPTR(hh, p1->conflicts, c1->uid, strlen(c1->uid), c1);

@@ -285,12 +281,12 @@ pkg_conflicts_register_unsafe(struct pkg *p1, struct pkg *p2,

 		pkg_conflict_new(&c2);
 		c2->type = type;
 		c2->uid = strdup(p1->uid);
 		c2->uid = xstrdup(p1->uid);
 		if (use_digest) {
 			/* We also add digest information into account */
 			c2->digest = strdup(p1->digest);
 			c2->digest = xstrdup(p1->digest);
 		}
 		HASH_ADD_KEYPTR(hh, p2->conflicts, c2->uid, strlen(c2->uid), c2);

@@ -424,15 +420,10 @@ pkg_conflicts_check_all_paths(struct pkg_jobs *j, const char *path,

 	if (cit == NULL) {
 		/* New entry */
 		cit = calloc(1, sizeof(*cit));
 		if (cit == NULL) {
 			pkg_emit_errno("malloc failed", "pkg_conflicts_check_all_paths");
 		}
 		else {
 			cit->hash = hv;
 			cit->item = it;
 			TREE_INSERT(j->conflict_items, pkg_jobs_conflict_item, entry, cit);
 		}
 		cit = xcalloc(1, sizeof(*cit));
 		cit->hash = hv;
 		cit->item = it;
 		TREE_INSERT(j->conflict_items, pkg_jobs_conflict_item, entry, cit);
 	}
 	else {
 		/* Check the same package */

@@ -531,7 +522,7 @@ pkg_conflicts_append_chain(struct pkg_job_universe_item *it,

 	/* Ensure that we have a tree initialized */
 	if (j->conflict_items == NULL) {
 		j->conflict_items = malloc(sizeof(*j->conflict_items));
 		j->conflict_items = xmalloc(sizeof(*j->conflict_items));
 		TREE_INIT(j->conflict_items, pkg_conflicts_item_cmp);
 	}

modified libpkg/pkg_jobs_universe.c

@@ -138,7 +138,7 @@ pkg_jobs_universe_get_remote(struct pkg_jobs_universe *universe,

 	while (pkgdb_it_next(it, &pkg, flag) == EPKG_OK) {
 		if (result == NULL)
 			result = calloc(1, sizeof(pkg_chain_t));
 			result = xcalloc(1, sizeof(pkg_chain_t));
 		kv_prepend(typeof(pkg), *result, pkg);
 		pkg = NULL;
 	}

@@ -206,12 +206,7 @@ pkg_jobs_universe_add_pkg(struct pkg_jobs_universe *universe, struct pkg *pkg,

 	    (pkg->type == PKG_INSTALLED ? "local" : "remote"), pkg->uid,
 	    pkg->name, pkg->version, pkg->digest);
 	item = calloc(1, sizeof (struct pkg_job_universe_item));
 	if (item == NULL) {
 		pkg_emit_errno("pkg_jobs_pkg_insert_universe", "calloc: struct pkg_job_universe_item");
 		return (EPKG_FATAL);
 	}
 	item = xcalloc(1, sizeof (struct pkg_job_universe_item));
 	item->pkg = pkg;

@@ -442,13 +437,7 @@ pkg_jobs_universe_handle_provide(struct pkg_jobs_universe *universe,

 			rpkg = NULL;
 		}
 		pr = calloc (1, sizeof (*pr));
 		if (pr == NULL) {
 			pkg_emit_errno("pkg_jobs_add_universe", "calloc: "
 					"struct pkg_job_provide");
 			return (EPKG_FATAL);
 		}
 		pr = xcalloc (1, sizeof (*pr));
 		pr->un = unit;
 		pr->provide = name;
 		pr->is_shlib = is_shlib;

@@ -839,12 +828,7 @@ pkg_jobs_universe_new(struct pkg_jobs *j)

 {
 	struct pkg_jobs_universe *universe;
 	universe = calloc(1, sizeof(struct pkg_jobs_universe));
 	if (universe == NULL) {
 		pkg_emit_errno("pkg_jobs_universe_new", "calloc");
 		return (NULL);
 	}
 	universe = xcalloc(1, sizeof(struct pkg_jobs_universe));
 	universe->j = j;
 	return (universe);

@@ -886,23 +870,21 @@ pkg_jobs_universe_change_uid(struct pkg_jobs_universe *universe,

 				while (pkg_deps(found->pkg, &d) == EPKG_OK) {
 					if (strcmp(d->uid, unit->pkg->uid) == 0) {
 						free(d->uid);
 						d->uid = strdup(new_uid);
 						d->uid = xstrdup(new_uid);
 					}
 				}
 			}
 		}
 	}
 	replacement = calloc(1, sizeof(*replacement));
 	if (replacement != NULL) {
 		replacement->old_uid = strdup(unit->pkg->uid);
 		replacement->new_uid = strdup(new_uid);
 		LL_PREPEND(universe->uid_replaces, replacement);
 	}
 	replacement = xcalloc(1, sizeof(*replacement));
 	replacement->old_uid = xstrdup(unit->pkg->uid);
 	replacement->new_uid = xstrdup(new_uid);
 	LL_PREPEND(universe->uid_replaces, replacement);
 	HASH_DELETE(hh, universe->items, unit);
 	free(unit->pkg->uid);
 	unit->pkg->uid = strdup(new_uid);
 	unit->pkg->uid = xstrdup(new_uid);
 	HASH_FIND(hh, universe->items, new_uid, uidlen, found);
 	if (found != NULL)

modified libpkg/pkg_macho.c

@@ -177,7 +177,7 @@ parse_major_release(const char *src, long long *release)

 	const char *errstr;
 	char *eos;
 	parsed = strdup(src);
 	parsed = xstrdup(src);
 	eos = strchr(parsed, '.');
 	if (eos == NULL) {
 		pkg_emit_error("failed to parse major release version from %s", src);

modified libpkg/pkg_manifest.c

@@ -223,7 +223,7 @@ pkg_manifest_keys_new(struct pkg_manifest_key **key)

 	for (i = 0; manifest_keys[i].key != NULL; i++) {
 		HASH_FIND_STR(*key, manifest_keys[i].key, k);
 		if (k == NULL) {
 			k = calloc(1, sizeof(struct pkg_manifest_key));
 			k = xcalloc(1, sizeof(struct pkg_manifest_key));
 			k->key = manifest_keys[i].key;
 			k->type = manifest_keys[i].type;
 			k->valid_type = manifest_keys[i].valid_type;

@@ -366,7 +366,7 @@ pkg_string(struct pkg *pkg, const ucl_object_t *obj, uint32_t offset)

 		/* Remove flags from the offset */
 		offset &= STRING_FLAG_MASK;
 		dest = (char **) ((unsigned char *)pkg + offset);
 		*dest = strdup(str);
 		*dest = xstrdup(str);
 		if (buf) {
 			utstring_free(buf);

@@ -950,9 +950,9 @@ pkg_emit_object(struct pkg *pkg, short flags)

 	ucl_object_t *top = ucl_object_typed_new(UCL_OBJECT);
 	if (pkg->abi == NULL && pkg->arch != NULL)
 		pkg->abi = strdup(pkg->arch);
 		pkg->abi = xstrdup(pkg->arch);
 	pkg_arch_to_legacy(pkg->abi, legacyarch, BUFSIZ);
 	pkg->arch = strdup(legacyarch);
 	pkg->arch = xstrdup(legacyarch);
 	pkg_debug(4, "Emitting basic metadata");
 	ucl_object_insert_key(top, ucl_object_fromstring_common(pkg->name, 0,
 	    UCL_STRING_TRIM), "name", 4, false);

@@ -1153,7 +1153,7 @@ pkg_emit_object(struct pkg *pkg, short flags)

 			map = NULL;
 			while (pkg_files(pkg, &file) == EPKG_OK) {
 				if (file->sum == NULL)
 					file->sum = strdup("-");
 					file->sum = xstrdup("-");
 				urlencode(file->path, &tmpsbuf);
 				if (map == NULL)

@@ -1298,8 +1298,8 @@ pkg_emit_manifest_generic(struct pkg *pkg, void *out, short flags,

 	int rc;
 	if (pdigest != NULL) {
 		*pdigest = malloc(sizeof(digest) * 2 + 1);
 		sign_ctx = malloc(sizeof(SHA256_CTX));
 		*pdigest = xmalloc(sizeof(digest) * 2 + 1);
 		sign_ctx = xmalloc(sizeof(SHA256_CTX));
 		sha256_init(sign_ctx);
 	}

@@ -1354,7 +1354,7 @@ pkg_emit_manifest(struct pkg *pkg, char **dest, short flags, char **pdigest)

 		return (rc);
 	}
 	*dest = strdup(utstring_body(b));
 	*dest = xstrdup(utstring_body(b));
 	utstring_free(b);
 	return (rc);

modified libpkg/pkg_old.c

@@ -93,14 +93,14 @@ pkg_old_load_from_path(struct pkg *pkg, const char *path)

 	}
 	pkg_get_myarch(myarch, BUFSIZ);
 	pkg->arch = strdup(myarch);
 	pkg->maintainer = strdup("unknown");
 	pkg->arch = xstrdup(myarch);
 	pkg->maintainer = xstrdup("unknown");
 	regcomp(&preg, "^WWW:[[:space:]]*(.*)$", REG_EXTENDED|REG_ICASE|REG_NEWLINE);
 	if (regexec(&preg, pkg->desc, 2, pmatch, 0) == 0) {
 		size = pmatch[1].rm_eo - pmatch[1].rm_so;
 		pkg->www = strndup(&pkg->desc[pmatch[1].rm_so], size);
 		pkg->www = xstrndup(&pkg->desc[pmatch[1].rm_so], size);
 	} else {
 		pkg->www = strdup("UNKNOWN");
 		pkg->www = xstrdup("UNKNOWN");
 	}
 	regfree(&preg);

modified libpkg/pkg_ports.c

@@ -177,7 +177,7 @@ setprefix(struct plist *p, char *line, struct file_attr *a)

 		strlcpy(p->prefix, line, sizeof(p->prefix));
 	if (p->pkg->prefix == NULL)
 		p->pkg->prefix = strdup(line);
 		p->pkg->prefix = xstrdup(line);
 	p->slash = p->prefix[strlen(p->prefix) -1] == '/' ? "" : "/";

@@ -199,8 +199,8 @@ name_key(struct plist *p, char *line, struct file_attr *a)

 	tmp = strrchr(line, '-');
 	tmp[0] = '\0';
 	tmp++;
 	p->pkg->name = strdup(line);
 	p->pkg->version = strdup(tmp);
 	p->pkg->name = xstrdup(line);
 	p->pkg->version = xstrdup(tmp);
 	return (EPKG_OK);
 }

@@ -210,7 +210,7 @@ pkgdep(struct plist *p, char *line, struct file_attr *a)

 {
 	if (*line != '\0') {
 		free(p->pkgdep);
 		p->pkgdep = strdup(line);
 		p->pkgdep = xstrdup(line);
 	}
 	return (EPKG_OK);
 }

@@ -431,9 +431,9 @@ setowner(struct plist *p, char *line, struct file_attr *a)

 {
 	free(p->uname);
 	if (line[0] == '\0')
 		p->uname = strdup("root");
 		p->uname = xstrdup("root");
 	else
 		p->uname = strdup(line);
 		p->uname = xstrdup(line);
 	return (EPKG_OK);
 }

@@ -442,9 +442,9 @@ setgroup(struct plist *p, char *line, struct file_attr *a)

 {
 	free(p->gname);
 	if (line[0] == '\0')
 		p->gname = strdup("wheel");
 		p->gname = xstrdup("wheel");
 	else
 		p->gname = strdup(line);
 		p->gname = xstrdup(line);
 	return (EPKG_OK);
 }

@@ -467,12 +467,12 @@ comment_key(struct plist *p, char *line, struct file_attr *a)

 	} else if (strncmp(line, "ORIGIN:", 7) == 0) {
 		line += 7;
 		free(p->pkg->origin);
 		p->pkg->origin = strdup(line);
 		p->pkg->origin = xstrdup(line);
 	} else if (strncmp(line, "OPTIONS:", 8) == 0) {
 		line += 8;
 		/* OPTIONS:+OPTION -OPTION */
 		if (line[0] != '\0') {
 			line_options2 = line_options = strdup(line);
 			line_options2 = line_options = xstrdup(line);
 			while ((option = strsep(&line_options, " ")) != NULL) {
 				if ((option[0] == '+' || option[0] == '-') &&
 				    option[1] != '\0' && isupper(option[1]))

@@ -506,13 +506,13 @@ parse_post(struct plist *p)

 	if ((env = getenv("FORCE_POST")) == NULL)
 		return;
 	p->post_patterns.buf = strdup(env);
 	p->post_patterns.buf = xstrdup(env);
 	while ((token = strsep(&p->post_patterns.buf, " \t")) != NULL) {
 		if (token[0] == '\0')
 			continue;
 		if (p->post_patterns.len >= p->post_patterns.cap) {
 			p->post_patterns.cap += 10;
 			p->post_patterns.patterns = realloc(p->post_patterns.patterns, p->post_patterns.cap * sizeof (char *));
 			p->post_patterns.patterns = xrealloc(p->post_patterns.patterns, p->post_patterns.cap * sizeof (char *));
 		}
 		p->post_patterns.patterns[p->post_patterns.len++] = token;
 	}

@@ -736,8 +736,8 @@ populate_keywords(struct plist *p)

 	int i;
 	for (i = 0; keyacts[i].key != NULL; i++) {
 		k = calloc(1, sizeof(struct keyword));
 		a = malloc(sizeof(struct action));
 		k = xcalloc(1, sizeof(struct keyword));
 		a = xmalloc(sizeof(struct action));
 		strlcpy(k->keyword, keyacts[i].key, sizeof(k->keyword));
 		a->perform = keyacts[i].action;
 		LL_APPEND(k->actions, a);

@@ -804,7 +804,7 @@ parse_attributes(const ucl_object_t *o, struct file_attr **a)

 	const char *key;
 	if (*a == NULL)
 		*a = calloc(1, sizeof(struct file_attr));
 		*a = xcalloc(1, sizeof(struct file_attr));
 	while ((cur = ucl_iterate_object(o, &it, true))) {
 		key = ucl_object_key(cur);

@@ -812,12 +812,12 @@ parse_attributes(const ucl_object_t *o, struct file_attr **a)

 			continue;
 		if (!strcasecmp(key, "owner") && cur->type == UCL_STRING) {
 			free((*a)->owner);
 			(*a)->owner = strdup(ucl_object_tostring(cur));
 			(*a)->owner = xstrdup(ucl_object_tostring(cur));
 			continue;
 		}
 		if (!strcasecmp(key, "group") && cur->type == UCL_STRING) {
 			free((*a)->group);
 			(*a)->group = strdup(ucl_object_tostring(cur));
 			(*a)->group = xstrdup(ucl_object_tostring(cur));
 			continue;
 		}
 		if (!strcasecmp(key, "mode")) {

@@ -851,11 +851,8 @@ apply_keyword_file(ucl_object_t *obj, struct plist *p, char *line, struct file_a

 	if ((o = ucl_object_find_key(obj,  "arguments")) && ucl_object_toboolean(o)) {
 		spaces = pkg_utils_count_spaces(line);
 		args = malloc((spaces + 1)* sizeof(char *));
 		if (args == NULL) {
 			return (EPKG_FATAL);
 		}
 		tofree = buf = strdup(line);
 		args = xmalloc((spaces + 1)* sizeof(char *));
 		tofree = buf = xstrdup(line);
 		while (buf != NULL) {
 			args[argc++] = pkg_utils_tokenize(&buf);
 		}

@@ -915,14 +912,8 @@ apply_keyword_file(ucl_object_t *obj, struct plist *p, char *line, struct file_a

 	if ((o = ucl_object_find_key(obj, "messages"))) {
 		while ((cur = ucl_iterate_object(o, &it, true))) {
 			elt = ucl_object_find_key(cur, "message");
 			msg = calloc(1, sizeof(*msg));
 			if (msg == NULL) {
 				pkg_emit_errno("malloc", "struct pkg_message");
 				goto keywords_cleanup;
 			}
 			msg->str = strdup(ucl_object_tostring(elt));
 			msg = xcalloc(1, sizeof(*msg));
 			msg->str = xstrdup(ucl_object_tostring(elt));
 			msg->type = PKG_MESSAGE_ALWAYS;
 			elt = ucl_object_find_key(cur, "type");
 			if (elt != NULL) {

@@ -1049,11 +1040,11 @@ parse_keyword_args(char *args, char *keyword)

 		}
 	}
 	attr = calloc(1, sizeof(struct file_attr));
 	attr = xcalloc(1, sizeof(struct file_attr));
 	if (owner != NULL && *owner != '\0')
 		attr->owner = strdup(owner);
 		attr->owner = xstrdup(owner);
 	if (group != NULL && *group != '\0')
 		attr->group = strdup(group);
 		attr->group = xstrdup(group);
 	if (set != NULL) {
 		attr->mode = getmode(set, 0);
 		free(set);

@@ -1176,7 +1167,7 @@ plist_new(struct pkg *pkg, const char *stage)

 {
 	struct plist *p;
 	p = calloc(1, sizeof(struct plist));
 	p = xcalloc(1, sizeof(struct plist));
 	if (p == NULL)
 		return (NULL);

@@ -1185,8 +1176,8 @@ plist_new(struct pkg *pkg, const char *stage)

 		strlcpy(p->prefix, pkg->prefix, sizeof(p->prefix));
 	p->slash = p->prefix[strlen(p->prefix) - 1] == '/' ? "" : "/";
 	p->stage = stage;
 	p->uname = strdup("root");
 	p->gname = strdup("wheel");
 	p->uname = xstrdup("root");
 	p->gname = xstrdup("wheel");
 	utstring_new(p->pre_install_buf);
 	utstring_new(p->post_install_buf);

modified libpkg/pkg_printf.c

@@ -1926,16 +1926,9 @@ new_percent_esc(void)

 {
 	struct percent_esc	*p;
 	p = calloc(1, sizeof(struct percent_esc));
 	if (p != NULL) {
 		utstring_new(p->item_fmt);
 		utstring_new(p->sep_fmt);
 	}
 	if (p == NULL || p->item_fmt == NULL || p->sep_fmt == NULL) {
 		/* out of memory */
 		free_percent_esc(p);
 		return NULL;
 	}
 	p = xcalloc(1, sizeof(struct percent_esc));
 	utstring_new(p->item_fmt);
 	utstring_new(p->sep_fmt);
 	return (p);
 }

modified libpkg/pkg_repo.c

@@ -248,12 +248,7 @@ pkg_repo_meta_extract_signature_pubkey(int fd, void *ud)

 	while (archive_read_next_header(a, &ae) == ARCHIVE_OK) {
 		if (cb->need_sig && strcmp(archive_entry_pathname(ae), "signature") == 0) {
 			siglen = archive_entry_size(ae);
 			sig = malloc(siglen);
 			if (sig == NULL) {
 				pkg_emit_errno("pkg_repo_meta_extract_signature",
 						"malloc failed");
 				return (EPKG_FATAL);
 			}
 			sig = xmalloc(siglen);
 			if (archive_read_data(a, sig, siglen) == -1) {
 				pkg_emit_errno("pkg_repo_meta_extract_signature",
 						"archive_read_data failed");

@@ -317,12 +312,7 @@ pkg_repo_meta_extract_signature_fingerprints(int fd, void *ud)

 					(int) strlen(archive_entry_pathname(ae)) - 4,
 					archive_entry_pathname(ae));
 			siglen = archive_entry_size(ae);
 			sig = malloc(siglen);
 			if (sig == NULL) {
 				pkg_emit_errno("pkg_repo_meta_extract_signature",
 						"malloc failed");
 				return (EPKG_FATAL);
 			}
 			sig = xmalloc(siglen);
 			if (archive_read_data(a, sig, siglen) == -1) {
 				pkg_emit_errno("pkg_repo_meta_extract_signature",
 						"archive_read_data failed");

@@ -356,12 +346,7 @@ pkg_repo_meta_extract_signature_fingerprints(int fd, void *ud)

 					(int) strlen(archive_entry_pathname(ae)) - 4,
 					archive_entry_pathname(ae));
 			siglen = archive_entry_size(ae);
 			sig = malloc(siglen);
 			if (sig == NULL) {
 				pkg_emit_errno("pkg_repo_meta_extract_signature",
 						"malloc failed");
 				return (EPKG_FATAL);
 			}
 			sig = xmalloc(siglen);
 			if (archive_read_data(a, sig, siglen) == -1) {
 				pkg_emit_errno("pkg_repo_meta_extract_signature",
 						"archive_read_data failed");

@@ -464,11 +449,7 @@ pkg_repo_parse_sigkeys(const char *in, int inlen, struct sig_cert **sc)

 			}
 			HASH_FIND(hh, *sc, p, len, s);
 			if (s == NULL) {
 				s = calloc(1, sizeof(struct sig_cert));
 				if (s == NULL) {
 					pkg_emit_errno("pkg_repo_parse_sigkeys", "calloc failed");
 					return (EPKG_FATAL);
 				}
 				s = xcalloc(1, sizeof(struct sig_cert));
 				tlen = MIN(len, sizeof(s->name) - 1);
 				memcpy(s->name, p, tlen);
 				s->name[tlen] = '\0';

@@ -506,12 +487,7 @@ pkg_repo_parse_sigkeys(const char *in, int inlen, struct sig_cert **sc)

 				free(s);
 				return (EPKG_FATAL);
 			}
 			sig = malloc(len);
 			if (sig == NULL) {
 				pkg_emit_errno("pkg_repo_parse_sigkeys", "malloc failed");
 				free(s);
 				return (EPKG_FATAL);
 			}
 			sig = xmalloc(len);
 			memcpy(sig, p, len);
 			if (type == 0) {
 				s->sig = sig;

@@ -577,13 +553,7 @@ pkg_repo_archive_extract_archive(int fd, const char *file,

 		cbdata.need_sig = true;
 		if (pkg_emit_sandbox_get_string(pkg_repo_meta_extract_signature_pubkey,
 				&cbdata, (char **)&sig, &siglen) == EPKG_OK && sig != NULL) {
 			s = calloc(1, sizeof(struct sig_cert));
 			if (s == NULL) {
 				pkg_emit_errno("pkg_repo_archive_extract_archive",
 						"malloc failed");
 				rc = EPKG_FATAL;
 				goto cleanup;
 			}
 			s = xcalloc(1, sizeof(struct sig_cert));
 			s->sig = sig;
 			s->siglen = siglen;
 			strlcpy(s->name, "signature", sizeof(s->name));

@@ -1051,7 +1021,7 @@ pkg_repo_parse_fingerprint(ucl_object_t *obj)

 		return (NULL);
 	}
 	f = calloc(1, sizeof(struct fingerprint));
 	f = xcalloc(1, sizeof(struct fingerprint));
 	f->type = fct;
 	strlcpy(f->hash, fp, sizeof(f->hash));

modified libpkg/pkg_repo_create.c

@@ -90,7 +90,7 @@ pkg_repo_new_conflict(const char *uniqueid, struct pkg_conflict_bulk *bulk)

 	struct pkg_conflict *new;
 	pkg_conflict_new(&new);
 	new->uid = strdup(uniqueid);
 	new->uid = xstrdup(uniqueid);
 	HASH_ADD_KEYPTR(hh, bulk->conflicts, new->uid, strlen(new->uid), new);
 }

@@ -110,23 +110,18 @@ pkg_create_repo_fts_new(FTSENT *fts, const char *root_path)

 	struct pkg_fts_item *item;
 	char *pkg_path;
 	item = malloc(sizeof(*item));
 	if (item != NULL) {
 		item->fts_accpath = strdup(fts->fts_accpath);
 		item->fts_name = strdup(fts->fts_name);
 		item->fts_size = fts->fts_statp->st_size;
 		item->fts_info = fts->fts_info;
 	item = xmalloc(sizeof(*item));
 	item->fts_accpath = xstrdup(fts->fts_accpath);
 	item->fts_name = xstrdup(fts->fts_name);
 	item->fts_size = fts->fts_statp->st_size;
 	item->fts_info = fts->fts_info;
 		pkg_path = fts->fts_path;
 		pkg_path += strlen(root_path);
 		while (pkg_path[0] == '/')
 			pkg_path++;
 	pkg_path = fts->fts_path;
 	pkg_path += strlen(root_path);
 	while (pkg_path[0] == '/')
 		pkg_path++;
 		item->pkg_path = strdup(pkg_path);
 	}
 	else {
 		pkg_emit_errno("malloc", "struct pkg_fts_item");
 	}
 	item->pkg_path = xstrdup(pkg_path);
 	return (item);
 }

@@ -303,7 +298,7 @@ pkg_create_repo_worker(struct pkg_fts_item *start, size_t nelts,

 			pkg->sum = pkg_checksum_file(cur->fts_accpath,
 			    PKG_HASH_TYPE_SHA256_HEX);
 			pkg->pkgsize = cur->fts_size;
 			pkg->repopath = strdup(cur->pkg_path);
 			pkg->repopath = xstrdup(cur->pkg_path);
 			/*
 			 * TODO: use pkg_checksum for new manifests

@@ -312,7 +307,7 @@ pkg_create_repo_worker(struct pkg_fts_item *start, size_t nelts,

 			if (legacy)
 				pkg_emit_manifest_buf(pkg, b, PKG_MANIFEST_EMIT_COMPACT, &mdigest);
 			else {
 				mdigest = malloc(pkg_checksum_type_size(meta->digest_format));
 				mdigest = xmalloc(pkg_checksum_type_size(meta->digest_format));
 				pkg_emit_manifest_buf(pkg, b, PKG_MANIFEST_EMIT_COMPACT, NULL);
 				if (pkg_checksum_generate(pkg, mdigest,

@@ -442,13 +437,13 @@ pkg_create_repo_read_pipe(int fd, struct digest_list_entry **dlist)

 			if (buf[i] == ':') {
 				switch(state) {
 				case s_set_origin:
 					dig = calloc(1, sizeof(*dig));
 					dig->origin = malloc(i - start + 1);
 					dig = xcalloc(1, sizeof(*dig));
 					dig->origin = xmalloc(i - start + 1);
 					strlcpy(dig->origin, &buf[start], i - start + 1);
 					state = s_set_digest;
 					break;
 				case s_set_digest:
 					dig->digest = malloc(i - start + 1);
 					dig->digest = xmalloc(i - start + 1);
 					strlcpy(dig->digest, &buf[start], i - start + 1);
 					state = s_set_mpos;
 					break;

@@ -465,7 +460,7 @@ pkg_create_repo_read_pipe(int fd, struct digest_list_entry **dlist)

 					state = s_set_checksum;
 					break;
 				case s_set_checksum:
 					dig->checksum =  malloc(i - start + 1);
 					dig->checksum =  xmalloc(i - start + 1);
 					strlcpy(dig->digest, &buf[start], i - start + 1);
 					state = s_set_origin;
 					break;

@@ -477,7 +472,7 @@ pkg_create_repo_read_pipe(int fd, struct digest_list_entry **dlist)

 					dig->manifest_length = strtol(&buf[start], NULL, 10);
 				}
 				else if (state == s_set_checksum) {
 					dig->checksum =  malloc(i - start + 1);
 					dig->checksum =  xmalloc(i - start + 1);
 					strlcpy(dig->checksum, &buf[start], i - start + 1);
 				}
 				assert(dig->origin != NULL);

@@ -615,7 +610,7 @@ pkg_create_repo(char *path, const char *output_dir, bool filelist,

 	/* Launch workers */
 	pkg_emit_progress_start("Creating repository in %s", output_dir);
 	pfd = calloc(num_workers, sizeof(struct pollfd));
 	pfd = xcalloc(num_workers, sizeof(struct pollfd));
 	ntask = 0;
 	cur_jobs = (remain > 0) ? tasks_per_worker + 1 : tasks_per_worker;
 	remain_jobs = cur_jobs;

modified libpkg/pkg_repo_meta.c

@@ -41,12 +41,12 @@ pkg_repo_meta_set_default(struct pkg_repo_meta *meta)

 	/* Not use conflicts for now */
 	meta->conflicts = NULL;
 	meta->conflicts_archive = NULL;
 	meta->manifests = strdup("packagesite.yaml");
 	meta->manifests_archive = strdup("packagesite");
 	meta->digests = strdup("digests");
 	meta->digests_archive = strdup("digests");
 	meta->filesite = strdup("filesite.yaml");
 	meta->filesite_archive = strdup("filesite");
 	meta->manifests = xstrdup("packagesite.yaml");
 	meta->manifests_archive = xstrdup("packagesite");
 	meta->digests = xstrdup("digests");
 	meta->digests_archive = xstrdup("digests");
 	meta->filesite = xstrdup("filesite.yaml");
 	meta->filesite_archive = xstrdup("filesite");
 	/* Not using fulldb */
 	meta->fulldb = NULL;
 	meta->fulldb_archive = NULL;

@@ -149,18 +149,14 @@ pkg_repo_meta_parse_cert(const ucl_object_t *obj)

 {
 	struct pkg_repo_meta_key *key;
 	key = calloc(1, sizeof(*key));
 	if (key == NULL) {
 		pkg_emit_errno("pkg_repo_meta_parse", "malloc failed for pkg_repo_meta_key");
 		return (NULL);
 	}
 	key = xcalloc(1, sizeof(*key));
 	/*
 	 * It is already validated so just use it as is
 	 */
 	key->name = strdup(ucl_object_tostring(ucl_object_find_key(obj, "name")));
 	key->pubkey = strdup(ucl_object_tostring(ucl_object_find_key(obj, "data")));
 	key->pubkey_type = strdup(ucl_object_tostring(ucl_object_find_key(obj, "type")));
 	key->name = xstrdup(ucl_object_tostring(ucl_object_find_key(obj, "name")));
 	key->pubkey = xstrdup(ucl_object_tostring(ucl_object_find_key(obj, "data")));
 	key->pubkey_type = xstrdup(ucl_object_tostring(ucl_object_find_key(obj, "type")));
 	return (key);
 }

@@ -169,7 +165,7 @@ pkg_repo_meta_parse_cert(const ucl_object_t *obj)

 	obj = ucl_object_find_key(top, (#field)); 					\
 	if (obj != NULL && obj->type == UCL_STRING) { 				\
 	    free(meta->field);									\
 	    meta->field = strdup(ucl_object_tostring(obj));			\
 	    meta->field = xstrdup(ucl_object_tostring(obj));			\
 	}															\
 } while (0)

@@ -181,11 +177,7 @@ pkg_repo_meta_parse(ucl_object_t *top, struct pkg_repo_meta **target, int versio

 	struct pkg_repo_meta *meta;
 	struct pkg_repo_meta_key *cert;
 	meta = calloc(1, sizeof(*meta));
 	if (meta == NULL) {
 		pkg_emit_errno("pkg_repo_meta_parse", "malloc failed for pkg_repo_meta");
 		return (EPKG_FATAL);
 	}
 	meta = xcalloc(1, sizeof(*meta));
 	pkg_repo_meta_set_default(meta);
 	meta->version = version;

@@ -307,12 +299,7 @@ pkg_repo_meta_default(void)

 {
 	struct pkg_repo_meta *meta;
 	meta = calloc(1, sizeof(*meta));
 	if (meta == NULL) {
 		pkg_emit_errno("pkg_repo_meta_default", "malloc failed for pkg_repo_meta");
 		return (NULL);
 	}
 	meta = xcalloc(1, sizeof(*meta));
 	pkg_repo_meta_set_default(meta);
 	return (meta);

modified libpkg/pkg_solve.c

@@ -128,13 +128,7 @@ pkg_solve_item_new(struct pkg_solve_variable *var)

 {
 	struct pkg_solve_item *result;
 	result = calloc(1, sizeof(struct pkg_solve_item));
 	if(result == NULL) {
 		pkg_emit_errno("calloc", "pkg_solve_item");
 		return (NULL);
 	}
 	result = xcalloc(1, sizeof(struct pkg_solve_item));
 	result->var = var;
 	result->inverse = 1;

@@ -146,13 +140,7 @@ pkg_solve_rule_new(enum pkg_solve_rule_type reason)

 {
 	struct pkg_solve_rule *result;
 	result = calloc(1, sizeof(struct pkg_solve_rule));
 	if(result == NULL) {
 		pkg_emit_errno("calloc", "pkg_solve_rule");
 		return (NULL);
 	}
 	result = xcalloc(1, sizeof(struct pkg_solve_rule));
 	result->reason = reason;
 	return (result);

@@ -842,16 +830,11 @@ pkg_solve_jobs_to_sat(struct pkg_jobs *j)

 	struct pkg_job_universe_item *un, *utmp;
 	size_t i = 0;
 	problem = calloc(1, sizeof(struct pkg_solve_problem));
 	if (problem == NULL) {
 		pkg_emit_errno("calloc", "pkg_solve_problem");
 		return (NULL);
 	}
 	problem = xcalloc(1, sizeof(struct pkg_solve_problem));
 	problem->j = j;
 	problem->nvars = j->universe->nitems;
 	problem->variables = calloc(problem->nvars, sizeof(struct pkg_solve_variable));
 	problem->variables = xcalloc(problem->nvars, sizeof(struct pkg_solve_variable));
 	problem->sat = picosat_init();
 	kv_init(problem->rules);

@@ -860,11 +843,6 @@ pkg_solve_jobs_to_sat(struct pkg_jobs *j)

 		return (NULL);
 	}
 	if (problem->variables == NULL) {
 		pkg_emit_errno("calloc", "variables");
 		return (NULL);
 	}
 	picosat_adjust(problem->sat, problem->nvars);
 	/* Parse universe */

@@ -1377,11 +1355,7 @@ pkg_solve_insert_res_job (struct pkg_solve_variable *var,

 	}
 	else if (seen_add != 0 || seen_del != 0) {
 		if (seen_add > 0) {
 			res = calloc(1, sizeof(struct pkg_solved));
 			if (res == NULL) {
 				pkg_emit_errno("calloc", "pkg_solved");
 				return;
 			}
 			res = xcalloc(1, sizeof(struct pkg_solved));
 			/* Pure install */
 			if (seen_del == 0) {
 				res->items[0] = add_var->unit;

@@ -1414,11 +1388,7 @@ pkg_solve_insert_res_job (struct pkg_solve_variable *var,

 				if (seen_add > 0 && cur_var == del_var)
 					continue;
 				res = calloc(1, sizeof(struct pkg_solved));
 				if (res == NULL) {
 					pkg_emit_errno("calloc", "pkg_solved");
 					return;
 				}
 				res = xcalloc(1, sizeof(struct pkg_solved));
 				res->items[0] = cur_var->unit;
 				res->type = PKG_SOLVED_DELETE;
 				DL_APPEND(j->jobs, res);

modified libpkg/pkgdb.c

@@ -127,7 +127,7 @@ pkgdb_regex(sqlite3_context *ctx, int argc, sqlite3_value **argv)

 		else
 			cflags = REG_EXTENDED | REG_NOSUB | REG_ICASE;
 		re = malloc(sizeof(regex_t));
 		re = xmalloc(sizeof(regex_t));
 		if (regcomp(re, regex, cflags) != 0) {
 			sqlite3_result_error(ctx, "Invalid regex\n", -1);
 			free(re);

@@ -947,12 +947,7 @@ pkgdb_open_repos(struct pkgdb *db, const char *reponame)

 		if (reponame == NULL || strcasecmp(r->name, reponame) == 0) {
 			/* We need read only access here */
 			if (r->ops->open(r, R_OK) == EPKG_OK) {
 				item = malloc(sizeof(*item));
 				if (item == NULL) {
 					pkg_emit_errno("malloc", "_pkg_repo_list_item");
 					return (EPKG_FATAL);
 				}
 				item = xmalloc(sizeof(*item));
 				r->ops->init(r);
 				item->repo = r;
 				LL_PREPEND(db->repos, item);

@@ -1060,11 +1055,8 @@ pkgdb_open_all(struct pkgdb **db_p, pkgdb_t type, const char *reponame)

 		db = *db_p;
 	}
 	if (!reopen && (db = calloc(1, sizeof(struct pkgdb))) == NULL) {
 		pkg_emit_errno("malloc", "pkgdb");
 		return (EPKG_FATAL);
 	}
 	if (!reopen)
 		db = xcalloc(1, sizeof(struct pkgdb));
 	db->prstmt_initialized = false;
 	if (!reopen) {

@@ -2451,7 +2443,7 @@ get_sql_string(sqlite3 *s, const char *sql, char **res)

 	if (ret == SQLITE_ROW) {
 		const unsigned char *tmp;
 		tmp = sqlite3_column_text(stmt, 0);
 		*res = (tmp == NULL ? NULL : strdup(tmp));
 		*res = (tmp == NULL ? NULL : xstrdup(tmp));
 	}
 	if (ret == SQLITE_DONE)

@@ -2654,7 +2646,7 @@ pkgdb_file_set_cksum(struct pkgdb *db, struct pkg_file *file,

 		return (EPKG_FATAL);
 	}
 	sqlite3_finalize(stmt);
 	file->sum = strdup(sum);
 	file->sum = xstrdup(sum);
 	return (EPKG_OK);
 }

@@ -2701,7 +2693,7 @@ pkgshell_open(const char **reponame)

 	dbdir = pkg_object_string(pkg_config_get("PKG_DBDIR"));
 	snprintf(localpath, sizeof(localpath), "%s/local.sqlite", dbdir);
 	*reponame = strdup(localpath);
 	*reponame = xstrdup(localpath);
 }
 static int

modified libpkg/pkgdb_iterator.c

@@ -796,25 +796,25 @@ populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {

 			switch (column->type) {
 			case PKG_ABI:
 				pkg->abi = strdup(sqlite3_column_text(stmt, icol));
 				pkg->abi = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_CKSUM:
 				pkg->sum = strdup(sqlite3_column_text(stmt, icol));
 				pkg->sum = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_COMMENT:
 				pkg->comment = strdup(sqlite3_column_text(stmt, icol));
 				pkg->comment = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_REPONAME:
 				pkg->reponame = strdup(sqlite3_column_text(stmt, icol));
 				pkg->reponame = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_DESC:
 				pkg->desc = strdup(sqlite3_column_text(stmt, icol));
 				pkg->desc = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_MAINTAINER:
 				pkg->maintainer = strdup(sqlite3_column_text(stmt, icol));
 				pkg->maintainer = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_DIGEST:
 				pkg->digest = strdup(sqlite3_column_text(stmt, icol));
 				pkg->digest = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_MESSAGE:
 				msg = sqlite3_column_text(stmt, icol);

@@ -824,8 +824,8 @@ populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {

 						pkg_message_from_str(pkg, msg, 0);
 					}
 					else {
 						pkg->message = calloc(1, sizeof(*pkg->message));
 						pkg->message->str = strdup(msg);
 						pkg->message = xcalloc(1, sizeof(*pkg->message));
 						pkg->message->str = xstrdup(msg);
 					}
 				}
 				else {

@@ -833,34 +833,34 @@ populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {

 				}
 				break;
 			case PKG_NAME:
 				pkg->name = strdup(sqlite3_column_text(stmt, icol));
 				pkg->name = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_OLD_VERSION:
 				pkg->old_version = strdup(sqlite3_column_text(stmt, icol));
 				pkg->old_version = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_ORIGIN:
 				pkg->origin = strdup(sqlite3_column_text(stmt, icol));
 				pkg->origin = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_PREFIX:
 				pkg->prefix = strdup(sqlite3_column_text(stmt, icol));
 				pkg->prefix = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_REPOPATH:
 				pkg->repopath = strdup(sqlite3_column_text(stmt, icol));
 				pkg->repopath = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_REPOURL:
 				pkg->repourl = strdup(sqlite3_column_text(stmt, icol));
 				pkg->repourl = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_UNIQUEID:
 				pkg->uid = strdup(sqlite3_column_text(stmt, icol));
 				pkg->uid = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_VERSION:
 				pkg->version = strdup(sqlite3_column_text(stmt, icol));
 				pkg->version = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_WWW:
 				pkg->www = strdup(sqlite3_column_text(stmt, icol));
 				pkg->www = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			case PKG_DEP_FORMULA:
 				pkg->dep_formula = strdup(sqlite3_column_text(stmt, icol));
 				pkg->dep_formula = xstrdup(sqlite3_column_text(stmt, icol));
 				break;
 			default:
 				pkg_emit_error("Unexpected text value for %s", colname);

@@ -920,7 +920,7 @@ populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {

 	}
 	pkg_arch_to_legacy(pkg->abi, legacyarch, BUFSIZ);
 	pkg->arch = strdup(legacyarch);
 	pkg->arch = xstrdup(legacyarch);
 }
 static struct load_on_flag {

@@ -1164,11 +1164,7 @@ pkgdb_it_new_sqlite(struct pkgdb *db, sqlite3_stmt *s, int type, short flags)

 	assert(!(flags & (PKGDB_IT_FLAG_CYCLED & PKGDB_IT_FLAG_ONCE)));
 	assert(!(flags & (PKGDB_IT_FLAG_AUTO & (PKGDB_IT_FLAG_CYCLED | PKGDB_IT_FLAG_ONCE))));
 	if ((it = malloc(sizeof(struct pkgdb_it))) == NULL) {
 		pkg_emit_errno("malloc", "pkgdb_it");
 		sqlite3_finalize(s);
 		return (NULL);
 	}
 	it = xmalloc(sizeof(struct pkgdb_it));
 	it->type = PKGDB_IT_LOCAL;

@@ -1188,10 +1184,7 @@ pkgdb_it_new_repo(struct pkgdb *db)

 {
 	struct pkgdb_it	*it;
 	if ((it = malloc(sizeof(struct pkgdb_it))) == NULL) {
 		pkg_emit_errno("malloc", "pkgdb_it");
 		return (NULL);
 	}
 	it = xmalloc(sizeof(struct pkgdb_it));
 	it->type = PKGDB_IT_REPO;

@@ -1207,13 +1200,9 @@ pkgdb_it_repo_attach(struct pkgdb_it *it, struct pkg_repo_it *rit)

 {
 	struct _pkg_repo_it_set *item;
 	if ((item = malloc(sizeof(struct _pkg_repo_it_set))) == NULL) {
 		pkg_emit_errno("malloc", "_pkg_repo_it_set");
 	}
 	else {
 		item->it = rit;
 		LL_PREPEND(it->un.remote, item);
 	}
 	item = xmalloc(sizeof(struct _pkg_repo_it_set));
 	item->it = rit;
 	LL_PREPEND(it->un.remote, item);
 }
 int

modified libpkg/plugins.c

@@ -111,11 +111,7 @@ pkg_plugin_hook_register(struct pkg_plugin *p, pkg_plugin_hook_t hook, pkg_plugi

 	assert(p != NULL);
 	assert(callback != NULL);
 	if ((new = calloc(1, sizeof(struct plugin_hook))) == NULL) {
 		pkg_emit_error("Cannot allocate memory");
 		return (EPKG_FATAL);
 	}
 	new = xcalloc(1, sizeof(struct plugin_hook));
 	new->hook = hook;
 	new->callback = callback;

@@ -295,7 +291,7 @@ pkg_plugins_init(void)

 		snprintf(pluginfile, sizeof(pluginfile), "%s/%s.so", plugdir,
 		    pkg_object_string(cur));
 		p = calloc(1, sizeof(struct pkg_plugin));
 		p = xcalloc(1, sizeof(struct pkg_plugin));
 		if ((p->lh = dlopen(pluginfile, RTLD_LAZY)) == NULL) {
 			pkg_emit_error("Loading of plugin '%s' failed: %s",
 			    pkg_object_string(cur), dlerror());

modified libpkg/private/pkg.h

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

 #include <utstring.h>
 #include <ucl.h>
 #include "private/xmalloc.h"
 #include "private/utils.h"
 #define UCL_COUNT(obj) ((obj)?((obj)->len):0)

added libpkg/private/xmalloc.h

@@ -0,0 +1,43 @@

 #ifndef XMALLOC_H
 #define XMALLOC_H
 static inline void *xmalloc(size_t size)
 {
 	void *ptr = malloc(size);
 	if (ptr == NULL)
 		abort();
 	return (ptr);
 }
 static inline void *xcalloc(size_t n, size_t size)
 {
 	void *ptr = calloc(n, size);
 	if (ptr == NULL)
 		abort();
 	return (ptr);
 }
 static inline void *xrealloc(void *ptr, size_t size)
 {
 	ptr = realloc(ptr, size);
 	if (ptr == NULL)
 		abort();
 	return (ptr);
 }
 static inline char *xstrdup(const char *str)
 {
 	char *s = strdup(str);
 	if (s == NULL)
 		abort();
 	return (s);
 }
 static inline char *xstrndup(const char *str, size_t n)
 {
 	char *s = strndup(str, n);
 	if (s == NULL)
 		abort();
 	return (s);
 }
 #endif

modified libpkg/repo/binary/fetch.c

@@ -166,8 +166,8 @@ pkg_repo_binary_try_fetch(struct pkg_repo *repo, struct pkg *pkg,

 	}
 	/* Create the dirs in cachedir */
 	dir = strdup(dest);
 	if (dir == NULL || (path = dirname(dir)) == NULL) {
 	dir = xstrdup(dest);
 	if ((path = dirname(dir)) == NULL) {
 		pkg_emit_errno("dirname", dest);
 		retcode = EPKG_FATAL;
 		goto cleanup;

modified libpkg/repo/binary/query.c

@@ -59,12 +59,7 @@ pkg_repo_binary_it_new(struct pkg_repo *repo, sqlite3_stmt *s, short flags)

 	struct pkg_repo_it *it;
 	struct pkgdb fakedb;
 	it = malloc(sizeof(*it));
 	if (it == NULL) {
 		pkg_emit_errno("malloc", "pkg_repo_it");
 		sqlite3_finalize(s);
 		return (NULL);
 	}
 	it = xmalloc(sizeof(*it));
 	it->ops = &pkg_repo_binary_it_ops;
 	it->flags = flags;

modified libpkg/repo/binary/update.c

@@ -396,7 +396,7 @@ pkg_repo_binary_add_from_manifest(char *buf, sqlite3 *sqlite, size_t len,

 	}
 	free(pkg->reponame);
 	pkg->reponame = strdup(repo->name);
 	pkg->reponame = xstrdup(repo->name);
 	rc = pkg_repo_binary_add_pkg(pkg, NULL, sqlite, true);

@@ -431,7 +431,7 @@ pkg_repo_binary_parse_conflicts(FILE *f, sqlite3 *sqlite)

 				ndep ++;
 			pdep ++;
 		}
 		deps = malloc(sizeof(char *) * ndep);
 		deps = xmalloc(sizeof(char *) * ndep);
 		for (i = 0; i < ndep; i ++) {
 			deps[i] = strsep(&p, ",\n");
 		}

modified libpkg/rsa.c

@@ -261,7 +261,7 @@ rsa_sign(char *path, struct rsa_key *rsa, unsigned char **sigret, unsigned int *

 	}
 	max_len = RSA_size(rsa->key);
 	*sigret = calloc(1, max_len + 1);
 	*sigret = xcalloc(1, max_len + 1);
 	sha256 = pkg_checksum_file(path, PKG_HASH_TYPE_SHA256_HEX);
 	if (sha256 == NULL)

@@ -286,7 +286,7 @@ rsa_new(struct rsa_key **rsa, pkg_password_cb *cb, char *path)

 {
 	assert(*rsa == NULL);
 	*rsa = calloc(1, sizeof(struct rsa_key));
 	*rsa = xcalloc(1, sizeof(struct rsa_key));
 	(*rsa)->path = path;
 	(*rsa)->pw_cb = cb;

modified libpkg/utils.c

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

 #include "pkg.h"
 #include "private/event.h"
 #include "private/utils.h"
 #include "private/xmalloc.h"
 int
 mkdirs(const char *_path)

@@ -106,11 +107,7 @@ file_to_bufferat(int dfd, const char *path, char **buffer, off_t *sz)

 		goto cleanup;
 	}
 	if ((*buffer = malloc(st.st_size + 1)) == NULL) {
 		pkg_emit_errno("malloc", "");
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}
 	*buffer = xmalloc(st.st_size + 1);
 	if (read(fd, *buffer, st.st_size) == -1) {
 		pkg_emit_errno("read", path);

@@ -155,11 +152,7 @@ file_to_buffer(const char *path, char **buffer, off_t *sz)

 		goto cleanup;
 	}
 	if ((*buffer = malloc(st.st_size + 1)) == NULL) {
 		pkg_emit_errno("malloc", "");
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}
 	*buffer = xmalloc(st.st_size + 1);
 	if (read(fd, *buffer, st.st_size) == -1) {
 		pkg_emit_errno("read", path);

@@ -284,7 +277,7 @@ format_exec_cmd(char **dest, const char *in, const char *prefix,

 		in++;
 	}
 	*dest = strdup(utstring_body(buf));
 	*dest = xstrdup(utstring_body(buf));
 	utstring_free(buf);
 	return (EPKG_OK);

@@ -736,7 +729,7 @@ mkdirat_p(int fd, const char *path)

 	const char *next;
 	char *walk, pathdone[MAXPATHLEN];
 	walk = strdup(path);
 	walk = xstrdup(path);
 	pathdone[0] = '\0';
 	while ((next = strsep(&walk, "/")) != NULL) {