db27b92 Replace emit macros by functions. — HardenedBSD-pkg

modified libpkg/backup.c

@@ -61,7 +61,8 @@ pkgdb_load(struct pkgdb *db, char *dest)

 	archive_read_support_format_tar(a);
 	if (archive_read_open_filename(a, dest, 4096) != ARCHIVE_OK) {
 		EMIT_PKG_ERROR("archive_read_open_filename(%s): %s", dest, archive_error_string(a));
 		pkg_emit_error("archive_read_open_filename(%s): %s", dest,
 					   archive_error_string(a));
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}

modified libpkg/fetch.c

@@ -29,7 +29,7 @@ pkg_fetch_file(const char *url, const char *dest)

 	int retcode = EPKG_OK;
 	if ((fd = open(dest, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, 0600)) == -1) {
 		EMIT_ERRNO("open", dest);
 		pkg_emit_errno("open", dest);
 		return(EPKG_FATAL);
 	}

@@ -38,7 +38,7 @@ pkg_fetch_file(const char *url, const char *dest)

 		if (remote == NULL) {
 			--retry;
 			if (retry == 0) {
 				EMIT_PKG_ERROR("%s: %s", url, fetchLastErrString);
 				pkg_emit_error("%s: %s", url, fetchLastErrString);
 				retcode = EPKG_FATAL;
 				goto cleanup;
 			}

@@ -52,7 +52,7 @@ pkg_fetch_file(const char *url, const char *dest)

 			break;
 		if (write(fd, buf, r) != r) {
 			EMIT_ERRNO("write", dest);
 			pkg_emit_errno("write", dest);
 			retcode = EPKG_FATAL;
 			goto cleanup;
 		}

@@ -61,13 +61,13 @@ pkg_fetch_file(const char *url, const char *dest)

 		now = time(NULL);
 		/* Only call the callback every second */
 		if (now > last || done == st.size) {
 			EMIT_FETCHING(url, st.size, done, (now - begin_dl));
 			pkg_emit_fetching(url, st.size, done, (now - begin_dl));
 			last = now;
 		}
 	}
 	if (ferror(remote)) {
 		EMIT_PKG_ERROR("%s: %s", url, fetchLastErrString);
 		pkg_emit_error("%s: %s", url, fetchLastErrString);
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}

modified libpkg/packing.c

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

 	assert(pack != NULL);
 	if ((*pack = calloc(1, sizeof(struct packing))) == NULL) {
 		EMIT_ERRNO("malloc", "");
 		pkg_emit_errno("malloc", "packing");
 		return (EPKG_FATAL);
 	}

@@ -98,13 +98,13 @@ packing_append_file_attr(struct packing *pack, const char *filepath, const char

 	archive_entry_copy_sourcepath(pack->entry, filepath);
 	if (lstat(filepath, &st) != 0) {
 		EMIT_ERRNO("lstat", filepath);
 		pkg_emit_errno("lstat", filepath);
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}
 	retcode = archive_read_disk_entry_from_file(pack->aread, pack->entry, -1, &st);
 	if (retcode != ARCHIVE_OK) {
 		EMIT_PKG_ERROR("%s: %s", filepath, archive_error_string(pack->aread));
 		pkg_emit_error("%s: %s", filepath, archive_error_string(pack->aread));
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}

@@ -130,7 +130,7 @@ packing_append_file_attr(struct packing *pack, const char *filepath, const char

 	if (archive_entry_size(pack->entry) > 0) {
 		if ((fd = open(filepath, O_RDONLY)) < 0) {
 			EMIT_ERRNO("open", filepath);
 			pkg_emit_errno("open", filepath);
 			retcode = EPKG_FATAL;
 			goto cleanup;
 		}

@@ -220,19 +220,19 @@ packing_set_format(struct archive *a, pkg_formats format)

 			if (archive_write_set_compression_xz(a) == ARCHIVE_OK) {
 				return ("txz");
 			} else {
 				EMIT_PKG_ERROR("%s", "xz is not supported, trying bzip2");
 				pkg_emit_error("%s", "xz is not supported, trying bzip2");
 			}
 		case TBZ:
 			if (archive_write_set_compression_bzip2(a) == ARCHIVE_OK) {
 				return ("tbz");
 			} else {
 				EMIT_PKG_ERROR("%s", "bzip2 is not supported, trying gzip");
 				pkg_emit_error("%s", "bzip2 is not supported, trying gzip");
 			}
 		case TGZ:
 			if (archive_write_set_compression_gzip(a) == ARCHIVE_OK) {
 				return ("tgz");
 			} else {
 				EMIT_PKG_ERROR("%s", "gzip is not supported, trying plain tar");
 				pkg_emit_error("%s", "gzip is not supported, trying plain tar");
 			}
 		case TAR:
 			archive_write_set_compression_none(a);

@@ -254,6 +254,6 @@ packing_format_from_string(const char *str)

 		return TGZ;
 	if (strcmp(str, "tar") == 0)
 		return TAR;
 	EMIT_PKG_ERROR("unknown format %s, using txz", str);
 	pkg_emit_error("unknown format %s, using txz", str);
 	return TXZ;
 }

modified libpkg/pkg.c

@@ -15,7 +15,7 @@ int

 pkg_new(struct pkg **pkg, pkg_t type)
 {
 	if ((*pkg = calloc(1, sizeof(struct pkg))) == NULL) {
 		EMIT_ERRNO("malloc", "");
 		pkg_emit_errno("malloc", "pkg");
 		return EPKG_FATAL;
 	}

@@ -135,7 +135,7 @@ pkg_get(struct pkg const * const pkg, const pkg_attr attr)

 	assert(attr < PKG_NUM_FIELDS);
 	if ((pkg->fields[attr].type & pkg->type) == 0)
 		EMIT_PKG_ERROR("%s", "wrong usage of `attr` for this type of `pkg`");
 		pkg_emit_error("wrong usage of `attr` for this type of `pkg`");
 	return (sbuf_get(pkg->fields[attr].value));
 }

@@ -475,7 +475,8 @@ pkg_addlicense(struct pkg *pkg, const char *name)

 	assert(name != NULL && name[0] != '\0');
 	if (pkg->licenselogic == LICENSE_SINGLE && !STAILQ_EMPTY(&pkg->licenses)) {
 		EMIT_PKG_ERROR("%s is said a have a single license which is already set", pkg_get(pkg, PKG_NAME));
 		pkg_emit_error("%s is have a single license which is already set",
 					   pkg_get(pkg, PKG_NAME));
 		return (EPKG_FATAL);
 	}

@@ -604,7 +605,7 @@ pkg_addcategory(struct pkg *pkg, const char *name)

 	while (pkg_categories(pkg, &c) == EPKG_OK) {
 		if (strcmp(name, pkg_category_name(c)) == 0) {
 			EMIT_PKG_ERROR("Duplicate category listing: %s, ignoring", name);
 			pkg_emit_error("duplicate category listing: %s, ignoring", name);
 			return (EPKG_OK);
 		}
 	}

@@ -633,7 +634,7 @@ pkg_adddir_attr(struct pkg *pkg, const char *path, const char *uname, const char

 	while (pkg_dirs(pkg, &d) == EPKG_OK) {
 		if (strcmp(path, pkg_dir_path(d)) == 0) {
 			EMIT_PKG_ERROR("Duplicate directory listing: %s, ignoring", path);
 			pkg_emit_error("duplicate directory listing: %s, ignoring", path);
 			return (EPKG_OK);
 		}
 	}

@@ -734,7 +735,7 @@ pkg_addscript_file(struct pkg *pkg, const char *path)

 			strcmp(filename, "+UPGRADE") == 0) {
 		type = PKG_SCRIPT_UPGRADE;
 	} else {
 		EMIT_PKG_ERROR("unknown script '%s'", filename);
 		pkg_emit_error("unknown script '%s'", filename);
 		return EPKG_FATAL;
 	}

@@ -991,7 +992,7 @@ pkg_open2(struct pkg **pkg_p, struct archive **a, struct archive_entry **ae, con

 	archive_read_support_format_tar(*a);
 	if (archive_read_open_filename(*a, path, 4096) != ARCHIVE_OK) {
 		EMIT_PKG_ERROR("archive_read_open_filename(%s): %s", path,
 		pkg_emit_error("archive_read_open_filename(%s): %s", path,
 					   archive_error_string(*a));
 		retcode = EPKG_FATAL;
 		goto cleanup;

@@ -1038,7 +1039,7 @@ pkg_open2(struct pkg **pkg_p, struct archive **a, struct archive_entry **ae, con

 	}
 	if (ret != ARCHIVE_OK && ret != ARCHIVE_EOF) {
 		EMIT_PKG_ERROR("archive_read_next_header(): %s",
 		pkg_emit_error("archive_read_next_header(): %s",
 					   archive_error_string(*a));
 		retcode = EPKG_FATAL;
 	}

modified libpkg/pkg.h

@@ -762,8 +762,6 @@ typedef enum {

 struct pkg_event {
 	pkg_event_t type;
 	uint16_t line;
 	const char *file;
 	union {
 		struct {
 			const char *func;

@@ -786,10 +784,13 @@ struct pkg_event {

 		} e_install_begin;
 		struct {
 			struct pkg *pkg;
 		} e_install_finished;
 		struct {
 			struct pkg *pkg;
 		} e_deinstall_begin;
 		struct {
 			struct pkg *pkg;
 		} e_install_finished;
 		} e_deinstall_finished;
 		struct {
 			struct pkg *pkg;
 		} e_upgrade_begin;

@@ -798,18 +799,12 @@ struct pkg_event {

 		} e_upgrade_finished;
 		struct {
 			struct pkg *pkg;
 		} e_install_end;
 		struct {
 			struct pkg *pkg;
 			struct pkg_dep *dep;
 		} e_missing_dep;
 		struct {
 			struct pkg *pkg;
 			int force;
 		} e_required;
 		struct {
 			struct pkg *pkg;
 		} e_failed_cksum;
 	};
 };

modified libpkg/pkg_add.c

@@ -42,7 +42,7 @@ do_extract(struct archive *a, struct archive_entry *ae)

 	do {
 		if (archive_read_extract(a, ae, EXTRACT_ARCHIVE_FLAGS) != ARCHIVE_OK) {
 			EMIT_PKG_ERROR("archive_read_extract(): %s",
 			pkg_emit_error("archive_read_extract(): %s",
 						   archive_error_string(a));
 			retcode = EPKG_FATAL;
 			break;

@@ -60,7 +60,7 @@ do_extract(struct archive *a, struct archive_entry *ae)

 		    && lstat(path, &st) == ENOENT) {
 			archive_entry_set_pathname(ae, path);
 			if (archive_read_extract(a, ae, EXTRACT_ARCHIVE_FLAGS) != ARCHIVE_OK) {
 				EMIT_PKG_ERROR("archive_read_extract(): %s",
 				pkg_emit_error("archive_read_extract(): %s",
 							   archive_error_string(a));
 				retcode = EPKG_FATAL;
 				break;

@@ -69,7 +69,7 @@ do_extract(struct archive *a, struct archive_entry *ae)

 	} while ((ret = archive_read_next_header(a, &ae)) == ARCHIVE_OK);
 	if (ret != ARCHIVE_EOF) {
 		EMIT_PKG_ERROR("archive_read_next_header(): %s",
 		pkg_emit_error("archive_read_next_header(): %s",
 					   archive_error_string(a));
 		retcode = EPKG_FATAL;
 	}

@@ -119,7 +119,7 @@ pkg_add2(struct pkgdb *db, const char *path, int upgrade, int automatic)

 		pkg_setautomatic(pkg);
 	if (uname(&u) != 0) {
 		EMIT_ERRNO("uname", "");
 		pkg_emit_errno("uname", "");
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}

@@ -128,7 +128,7 @@ pkg_add2(struct pkgdb *db, const char *path, int upgrade, int automatic)

 	 * Check the architecture
 	 */
 	if (strcmp(u.machine, pkg_get(pkg, PKG_ARCH)) != 0) {
 		EMIT_PKG_ERROR("wrong architecture: %s instead of %s",
 		pkg_emit_error("wrong architecture: %s instead of %s",
 					   pkg_get(pkg, PKG_ARCH), u.machine);
 		retcode = EPKG_FATAL;
 		goto cleanup;

@@ -151,7 +151,7 @@ pkg_add2(struct pkgdb *db, const char *path, int upgrade, int automatic)

 	pkgdb_it_free(it);
 	if (ret == EPKG_OK) {
 		EMIT_ALREADY_INSTALLED(pkg);
 		pkg_emit_already_installed(pkg);
 		retcode = EPKG_INSTALLED;
 		goto cleanup;
 	} else if (ret != EPKG_END) {

@@ -165,7 +165,7 @@ pkg_add2(struct pkgdb *db, const char *path, int upgrade, int automatic)

 	basedir = dirname(path);
 	if ((ext = strrchr(path, '.')) == NULL) {
 		EMIT_PKG_ERROR("%s has no extension", path);
 		pkg_emit_error("%s has no extension", path);
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}

@@ -183,7 +183,7 @@ pkg_add2(struct pkgdb *db, const char *path, int upgrade, int automatic)

 				}
 			} else {
 				retcode = EPKG_FATAL;
 				EMIT_MISSING_DEP(pkg, dep);
 				pkg_emit_missing_dep(pkg, dep);
 				goto cleanup;
 			}
 		}

@@ -196,7 +196,7 @@ pkg_add2(struct pkgdb *db, const char *path, int upgrade, int automatic)

 		goto cleanup_reg;
 	if (!upgrade)
 		EMIT_INSTALL_BEGIN(pkg);
 		pkg_emit_install_begin(pkg);
 	/*
 	 * Execute pre-install scripts

@@ -223,9 +223,9 @@ pkg_add2(struct pkgdb *db, const char *path, int upgrade, int automatic)

 		pkg_script_run(pkg, PKG_SCRIPT_POST_INSTALL);
 	if (upgrade)
 		EMIT_UPGRADE_FINISHED(pkg);
 		pkg_emit_upgrade_finished(pkg);
 	else
 		EMIT_INSTALL_FINISHED(pkg);
 		pkg_emit_install_finished(pkg);
 	cleanup_reg:
 	pkgdb_register_finale(db, retcode);

modified libpkg/pkg_attributes.c

@@ -135,7 +135,7 @@ int

 pkg_conflict_new(struct pkg_conflict **c)
 {
 	if ((*c = calloc(1, sizeof(struct pkg_conflict))) == NULL) {
 		EMIT_ERRNO("calloc", "pkg_conflict");
 		pkg_emit_errno("calloc", "pkg_conflict");
 		return (EPKG_FATAL);
 	}

@@ -165,7 +165,7 @@ int

 pkg_license_new(struct pkg_license **l)
 {
 	if ((*l = calloc(1, sizeof(struct pkg_license))) == NULL) {
 		EMIT_ERRNO("calloc", "pkg_license");
 		pkg_emit_errno("calloc", "pkg_license");
 		return (EPKG_FATAL);
 	}

@@ -196,7 +196,7 @@ int

 pkg_user_new(struct pkg_user **u)
 {
 	if ((*u = calloc(1, sizeof(struct pkg_user))) == NULL) {
 		EMIT_ERRNO("calloc", "pkg_user");
 		pkg_emit_errno("calloc", "pkg_user");
 		return (EPKG_FATAL);
 	}

@@ -226,7 +226,7 @@ int

 pkg_group_new(struct pkg_group **g)
 {
 	if ((*g = calloc(1, sizeof(struct pkg_group))) == NULL) {
 		EMIT_ERRNO("calloc", "pkg_group");
 		pkg_emit_errno("calloc", "pkg_group");
 		return (EPKG_FATAL);
 	}

@@ -257,7 +257,7 @@ int

 pkg_script_new(struct pkg_script **script)
 {
 	if ((*script = calloc(1, sizeof(struct pkg_script))) == NULL) {
 		EMIT_ERRNO("calloc", "pkg_script");
 		pkg_emit_errno("calloc", "pkg_script");
 		return (EPKG_FATAL);
 	}

modified libpkg/pkg_create.c

@@ -88,7 +88,7 @@ pkg_create_archive(const char *outdir, struct pkg *pkg, pkg_formats format, int

 		return NULL;
 	if (asprintf(&pkg_path, "%s/%s-%s", outdir, pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION)) == -1) {
 		EMIT_ERRNO("asprintf", "");
 		pkg_emit_errno("asprintf", "");
 		return (NULL);
 	}

@@ -165,7 +165,7 @@ pkg_create_installed(const char *outdir, pkg_formats format, const char *rootdir

 	pkg_archive = pkg_create_archive(outdir, pkg, format, required_flags);
 	if (pkg_archive == NULL) {
 		EMIT_PKG_ERROR("%s", "unable to create archive");
 		pkg_emit_error("unable to create archive");
 		return (EPKG_FATAL);
 	}

modified libpkg/pkg_delete.c

@@ -48,13 +48,13 @@ pkg_delete2(struct pkg *pkg, struct pkgdb *db, int force, int upgrade)

 		return (ret);
 	if (!upgrade)
 		EMIT_DEINSTALL_BEGIN(pkg);
 		pkg_emit_deinstall_begin(pkg);
 	else
 		EMIT_UPGRADE_BEGIN(pkg);
 		pkg_emit_upgrade_begin(pkg);
 	/* If there are dependencies */
 	if (pkg_rdeps(pkg, &rdep) == EPKG_OK) {
 		EMIT_REQUIRED(pkg, force);
 		pkg_emit_required(pkg, force);
 		if (!force)
 			return (EPKG_REQUIRED);
 	}

@@ -78,7 +78,7 @@ pkg_delete2(struct pkg *pkg, struct pkgdb *db, int force, int upgrade)

 		return (ret);
 	if (!upgrade)
 		EMIT_DEINSTALL_FINISHED(pkg);
 		pkg_emit_deinstall_finished(pkg);
 	return (pkgdb_unregister_pkg(db, pkg_get(pkg, PKG_ORIGIN)));
 }

@@ -97,16 +97,17 @@ pkg_delete_files(struct pkg *pkg, int force)

 		/* check sha256 */
 		if (!force && pkg_file_sha256(file)[0] != '\0') {
 			if (sha256_file(path, sha256) == -1) {
 				EMIT_PKG_ERROR("sha256 calculation failed for '%s'",
 				pkg_emit_error("sha256 calculation failed for '%s'",
 					  path);
 			} else if (strcmp(sha256, pkg_file_sha256(file)) != 0) {
 				EMIT_PKG_ERROR("%s fails original SHA256 checksum, not removing", path);
 				pkg_emit_error("%s fails original SHA256 checksum,"
 							   " not removing", path);
 				continue;
 			}
 		}
 		if (unlink(path) == -1) {
 			EMIT_ERRNO("unlink", path);
 			pkg_emit_errno("unlink", path);
 			continue;
 		}
 	}

@@ -130,7 +131,7 @@ pkg_delete_dirs(struct pkgdb *db, struct pkg *pkg, int force)

 			continue;
 		if (rmdir(pkg_dir_path(dir)) == -1 && errno != ENOTEMPTY && force != 1)
 			EMIT_ERRNO("rmdir", pkg_dir_path(dir));
 			pkg_emit_errno("rmdir", pkg_dir_path(dir));
 	}
 	return (EPKG_OK);

modified libpkg/pkg_elf.c

@@ -75,7 +75,9 @@ analyse_elf(struct pkgdb *db, struct pkg *pkg, const char *fpath)

 						found = true;
 				}
 				if (!found) {
 					EMIT_PKG_ERROR("adding forgotten depends (%s): %s-%s", map->l_name, pkg_get(p, PKG_NAME), pkg_get(p, PKG_VERSION));
 					pkg_emit_error("adding forgotten depends (%s): %s-%s",
 								   map->l_name, pkg_get(p, PKG_NAME),
 								   pkg_get(p, PKG_VERSION));
 					pkg_adddep(pkg, pkg_get(p, PKG_NAME), pkg_get(p, PKG_ORIGIN), pkg_get(p, PKG_VERSION));
 				}
 			}

modified libpkg/pkg_event.c

@@ -11,12 +11,153 @@ pkg_event_register(pkg_event_cb cb, void *data)

 	_data = data;
 }
 void
 pkg_emit_event(struct pkg_event *ev, const char *file, uint16_t line)
 static void
 pkg_emit_event(struct pkg_event *ev)
 {
 	ev->file = file;
 	ev->line = line;
 	if (_cb != NULL)
 		_cb(_data, ev);
 }
 void
 pkg_emit_error(const char *fmt, ...)
 {
 	struct pkg_event ev;
 	va_list ap;
 	ev.type = PKG_EVENT_ERROR;
 	va_start(ap, fmt);
 	vasprintf(&ev.e_pkg_error.msg, fmt, ap);
 	va_end(ap);
 	pkg_emit_event(&ev);
 	free(ev.e_pkg_error.msg);
 }
 void
 pkg_emit_errno(const char *func, const char *arg)
 {
 	struct pkg_event ev;
 	ev.type = PKG_EVENT_ERRNO;
 	ev.e_errno.func = func;
 	ev.e_errno.arg = arg;
 	pkg_emit_event(&ev);
 }
 void
 pkg_emit_already_installed(struct pkg *p)
 {
 	struct pkg_event ev;
 	ev.type = PKG_EVENT_ALREADY_INSTALLED;
 	ev.e_already_installed.pkg = p;
 	pkg_emit_event(&ev);
 }
 void
 pkg_emit_fetching(const char *url, off_t total, off_t done, time_t elapsed)
 {
 	struct pkg_event ev;
 	ev.type = PKG_EVENT_FETCHING;
 	ev.e_fetching.url = url;
         ev.e_fetching.total = total;
         ev.e_fetching.done = done;
         ev.e_fetching.elapsed = elapsed;
 	pkg_emit_event(&ev);
 }
 void
 pkg_emit_install_begin(struct pkg *p)
 {
 	struct pkg_event ev;
 	ev.type = PKG_EVENT_INSTALL_BEGIN;
 	ev.e_install_begin.pkg = p;
 	pkg_emit_event(&ev);
 }
 void
 pkg_emit_install_finished(struct pkg *p)
 {
 	struct pkg_event ev;
 	ev.type = PKG_EVENT_INSTALL_FINISHED;
 	ev.e_install_finished.pkg = p;
 	pkg_emit_event(&ev);
 }
 void
 pkg_emit_deinstall_begin(struct pkg *p)
 {
 	struct pkg_event ev;
 	ev.type = PKG_EVENT_DEINSTALL_BEGIN;
 	ev.e_deinstall_begin.pkg = p;
 	pkg_emit_event(&ev);
 }
 void
 pkg_emit_deinstall_finished(struct pkg *p)
 {
 	struct pkg_event ev;
 	ev.type = PKG_EVENT_DEINSTALL_FINISHED;
 	ev.e_deinstall_finished.pkg = p;
 	pkg_emit_event(&ev);
 }
 void
 pkg_emit_upgrade_begin(struct pkg *p)
 {
 	struct pkg_event ev;
 	ev.type = PKG_EVENT_UPGRADE_BEGIN;
 	ev.e_upgrade_begin.pkg = p;
 	pkg_emit_event(&ev);
 }
 void
 pkg_emit_upgrade_finished(struct pkg *p)
 {
 	struct pkg_event ev;
 	ev.type = PKG_EVENT_UPGRADE_FINISHED;
 	ev.e_upgrade_finished.pkg = p;
 	pkg_emit_event(&ev);
 }
 void
 pkg_emit_missing_dep(struct pkg *p, struct pkg_dep *d)
 {
 	struct pkg_event ev;
 	ev.type = PKG_EVENT_MISSING_DEP;
 	ev.e_missing_dep.pkg = p;
 	ev.e_missing_dep.dep = d;
 	pkg_emit_event(&ev);
 }
 void
 pkg_emit_required(struct pkg *p, int force)
 {
 	struct pkg_event ev;
 	ev.type = PKG_EVENT_REQUIRED;
 	ev.e_required.pkg = p;
 	ev.e_required.force = force;
 	pkg_emit_event(&ev);
 }

modified libpkg/pkg_event.h

@@ -1,114 +1,17 @@

 #ifndef _PKG_EVENT
 #define _PKG_EVENT
 #define _EV_START \
 	do { \
 		struct pkg_event ev
 #define _EV_EMIT \
 	pkg_emit_event(&ev, __FILE__, __LINE__)
 #define _EV_END \
 	} while(0)
 #define EMIT_PKG_ERROR(fmt, ...) \
 	_EV_START; \
 	ev.type = PKG_EVENT_ERROR; \
 	asprintf(&ev.e_pkg_error.msg, fmt, __VA_ARGS__); \
 	_EV_EMIT; \
 	free(ev.e_pkg_error.msg); \
 	_EV_END
 #define EMIT_ERRNO(f, a) \
 	_EV_START; \
 	ev.type = PKG_EVENT_ERRNO; \
 	ev.e_errno.func = f; \
 	ev.e_errno.arg = a; \
 	_EV_EMIT; \
 	_EV_END
 #define EMIT_ALREADY_INSTALLED(p) \
 	_EV_START; \
 	ev.type = PKG_EVENT_ALREADY_INSTALLED; \
 	ev.e_already_installed.pkg = p; \
 	_EV_EMIT; \
 	_EV_END
 #define EMIT_FETCHING(u, t, d, e) \
 	_EV_START; \
 	ev.type = PKG_EVENT_FETCHING; \
 	ev.e_fetching.url = u; \
 	ev.e_fetching.total = t; \
 	ev.e_fetching.done = d; \
 	ev.e_fetching.elapsed = e; \
 	_EV_EMIT; \
 	_EV_END
 #define EMIT_INSTALL_BEGIN(p) \
 	_EV_START; \
 	ev.type = PKG_EVENT_INSTALL_BEGIN; \
 	ev.e_install_begin.pkg = p; \
 	_EV_EMIT; \
 	_EV_END
 #define EMIT_INSTALL_FINISHED(p) \
 	_EV_START; \
 	ev.type = PKG_EVENT_INSTALL_FINISHED; \
 	ev.e_install_finished.pkg = p; \
 	_EV_EMIT; \
 	_EV_END
 #define EMIT_DEINSTALL_BEGIN(p) \
 	_EV_START; \
 	ev.type = PKG_EVENT_DEINSTALL_BEGIN; \
 	ev.e_deinstall_begin.pkg = p; \
 	_EV_EMIT; \
 	_EV_END
 #define EMIT_DEINSTALL_FINISHED(p) \
 	_EV_START; \
 	ev.type = PKG_EVENT_DEINSTALL_FINISHED; \
 	ev.e_install_finished.pkg = p; \
 	_EV_EMIT; \
 	_EV_END
 #define EMIT_UPGRADE_BEGIN(p) \
 	_EV_START; \
 	ev.type = PKG_EVENT_UPGRADE_BEGIN; \
 	ev.e_upgrade_begin.pkg = p; \
 	_EV_EMIT; \
 	_EV_END
 #define EMIT_UPGRADE_FINISHED(p) \
 	_EV_START; \
 	ev.type = PKG_EVENT_UPGRADE_FINISHED; \
 	ev.e_upgrade_finished.pkg = p; \
 	_EV_EMIT; \
 	_EV_END
 #define EMIT_MISSING_DEP(p, d) \
 	_EV_START; \
 	ev.type = PKG_EVENT_MISSING_DEP; \
 	ev.e_missing_dep.pkg = p; \
 	ev.e_missing_dep.dep = d;  \
 	_EV_EMIT; \
 	_EV_END
 #define EMIT_REQUIRED(p, f) \
 	_EV_START; \
 	ev.type = PKG_EVENT_REQUIRED; \
 	ev.e_required.pkg = p; \
 	ev.e_required.force = f; \
 	_EV_EMIT; \
 	_EV_END
 #define EMIT_FAILED_CKSUM(p) \
 	_EV_START; \
 	ev.type = PKG_EVENT_FAILED_CKSUM; \
 	ev.e_failed_cksum.pkg = p; \
 	_EV_EMIT; \
 	_EV_END
 void pkg_emit_event(struct pkg_event *, const char *, uint16_t);
 void pkg_emit_error(const char *fmt, ...);
 void pkg_emit_errno(const char *func, const char *arg);
 void pkg_emit_already_installed(struct pkg *p);
 void pkg_emit_fetching(const char *url, off_t total, off_t done, time_t elapsed);
 void pkg_emit_install_begin(struct pkg *p);
 void pkg_emit_install_finished(struct pkg *p);
 void pkg_emit_deinstall_begin(struct pkg *p);
 void pkg_emit_deinstall_finished(struct pkg *p);
 void pkg_emit_upgrade_begin(struct pkg *p);
 void pkg_emit_upgrade_finished(struct pkg *p);
 void pkg_emit_missing_dep(struct pkg *p, struct pkg_dep *d);
 void pkg_emit_required(struct pkg *p, int force);
 #endif

modified libpkg/pkg_jobs.c

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

 	assert(t != PKG_JOBS_INSTALL || db->type == PKGDB_REMOTE);
 	if((*j = calloc(1, sizeof(struct pkg_jobs))) == NULL) {
 		EMIT_ERRNO("calloc", "pkg_jobs");
 		pkg_emit_errno("calloc", "pkg_jobs");
 		return (EPKG_FATAL);
 	}

@@ -162,7 +162,7 @@ pkg_jobs_apply(struct pkg_jobs *j, int force)

 	if (j->type == PKG_JOBS_UPGRADE)
 		return (pkg_jobs_upgrade(j));
 	EMIT_PKG_ERROR("%s", "bad jobs argument");
 	pkg_emit_error("bad jobs argument");
 	return (EPKG_FATAL);
 }

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

 		if (ndep->pkg == NULL) {
 			ndep->pkg = pkgdb_query_remote(j->db, pkg_dep_origin(dep));
 			if (ndep->pkg == NULL)
 				EMIT_MISSING_DEP(n->pkg, dep);
 				pkg_emit_missing_dep(n->pkg, dep);
 			else {
 				pkg_setautomatic(ndep->pkg);
 				add_dep(j, ndep);

modified libpkg/pkg_manifest.c

@@ -105,7 +105,8 @@ pkg_set_flatsize_from_node(struct pkg *pkg, yaml_node_t *val, __unused yaml_docu

 	const char *errstr = NULL;
 	flatsize = strtonum(val->data.scalar.value, 0, INT64_MAX, &errstr);
 	if (errstr) {
 		EMIT_PKG_ERROR("Unable to convert %s to int64: %s", val->data.scalar.value, errstr);
 		pkg_emit_error("Unable to convert %s to int64: %s",
 					   val->data.scalar.value, errstr);
 		return (EPKG_FATAL);
 	}

@@ -121,7 +122,7 @@ pkg_set_licenselogic_from_node(struct pkg *pkg, yaml_node_t *val, __unused yaml_

 	else if ( !strcmp(val->data.scalar.value, "or") || !strcmp(val->data.scalar.value, "multi"))
 		pkg_set_licenselogic(pkg, LICENSE_OR);
 	else {
 		EMIT_PKG_ERROR("Unknown license logic: %s", val->data.scalar.value);
 		pkg_emit_error("Unknown license logic: %s", val->data.scalar.value);
 		return (EPKG_FATAL);
 	}
 	return (EPKG_OK);

@@ -139,31 +140,31 @@ parse_sequence(struct pkg * pkg, yaml_node_t *node, yaml_document_t *doc, int at

 		switch (attr) {
 			case PKG_CONFLICTS:
 				if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0)
 					EMIT_PKG_ERROR("Skipping malformed conflict", NULL);
 					pkg_emit_error("Skipping malformed conflict");
 				else
 					pkg_addconflict(pkg, val->data.scalar.value);
 				break;
 			case PKG_CATEGORIES:
 				if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0)
 					EMIT_PKG_ERROR("Skipping malformed category", NULL);
 					pkg_emit_error("Skipping malformed category");
 				else
 					pkg_addcategory(pkg, val->data.scalar.value);
 				break;
 			case PKG_LICENSES:
 				if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0)
 					EMIT_PKG_ERROR("Skipping malformed license", NULL);
 					pkg_emit_error("Skipping malformed license");
 				else
 					pkg_addlicense(pkg, val->data.scalar.value);
 				break;
 			case PKG_USERS:
 				if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0)
 					EMIT_PKG_ERROR("Skipping malformed license", NULL);
 					pkg_emit_error("Skipping malformed license");
 				else
 					pkg_adduser(pkg, val->data.scalar.value);
 				break;
 			case PKG_GROUPS:
 				if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0)
 					EMIT_PKG_ERROR("Skipping malformed license", NULL);
 					pkg_emit_error("Skipping malformed license");
 				else
 					pkg_addgroup(pkg, val->data.scalar.value);
 				break;

@@ -173,7 +174,7 @@ parse_sequence(struct pkg * pkg, yaml_node_t *node, yaml_document_t *doc, int at

 				else if (val->type == YAML_MAPPING_NODE)
 					parse_mapping(pkg, val, doc, attr);
 				else
 					EMIT_PKG_ERROR("Skipping malformed dirs", NULL);
 					pkg_emit_error("Skipping malformed dirs");
 		}
 		++item;
 	}

@@ -194,7 +195,7 @@ parse_mapping(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc, int attr

 		val = yaml_document_get_node(doc, pair->value);
 		if (key->data.scalar.length <= 0) {
 			EMIT_PKG_ERROR("Skipping empty dependency name", NULL);
 			pkg_emit_error("Skipping empty dependency name");
 			++pair;
 			continue;
 		}

@@ -202,13 +203,15 @@ parse_mapping(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc, int attr

 		switch (attr) {
 			case PKG_DEPS:
 				if (val->type != YAML_MAPPING_NODE)
 					EMIT_PKG_ERROR("Skipping malformed depencency %s", key->data.scalar.value);
 					pkg_emit_error("Skipping malformed depencency %s",
 								   key->data.scalar.value);
 				else
 					pkg_set_deps_from_node(pkg, val, doc, key->data.scalar.value);
 				break;
 			case PKG_DIRS:
 				if (val->type != YAML_MAPPING_NODE)
 					EMIT_PKG_ERROR("Skipping malformed dirs %s", key->data.scalar.value);
 					pkg_emit_error("Skipping malformed dirs %s",
 								   key->data.scalar.value);
 				else
 					pkg_set_dirs_from_node(pkg, val, doc, key->data.scalar.value);
 				break;

@@ -218,17 +221,20 @@ parse_mapping(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc, int attr

 				else if (val->type == YAML_MAPPING_NODE)
 					pkg_set_files_from_node(pkg, val, doc, key->data.scalar.value);
 				else
 					EMIT_PKG_ERROR("Skipping malformed files %s", key->data.scalar.value);
 					pkg_emit_error("Skipping malformed files %s",
 								   key->data.scalar.value);
 				break;
 			case PKG_OPTIONS:
 				if (val->type != YAML_SCALAR_NODE)
 					EMIT_PKG_ERROR("Skipping malformed option %s", key->data.scalar.value);
 					pkg_emit_error("Skipping malformed option %s",
 								   key->data.scalar.value);
 				else
 					pkg_addoption(pkg, key->data.scalar.value, val->data.scalar.value);
 				break;
 			case PKG_SCRIPTS:
 				if (val->type != YAML_SCALAR_NODE)
 					EMIT_PKG_ERROR("Skipping malformed scripts %s", key->data.scalar.value);
 					pkg_emit_error("Skipping malformed scripts %s",
 								   key->data.scalar.value);
 				if (strcmp(key->data.scalar.value, "pre-install") == 0) {
 					script_type = PKG_SCRIPT_PRE_INSTALL;
 				} else if (strcmp(key->data.scalar.value, "install") == 0) {

@@ -248,7 +254,8 @@ parse_mapping(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc, int attr

 				} else if (strcmp(key->data.scalar.value, "post-deinstall") == 0) {
 					script_type = PKG_SCRIPT_POST_DEINSTALL;
 				} else {
 					EMIT_PKG_ERROR("Skipping unknown script type: %s", key->data.scalar.value);
 					pkg_emit_error("Skipping unknown script type: %s",
 								   key->data.scalar.value);
 					break;
 				}

@@ -277,13 +284,13 @@ pkg_set_files_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc

 		key = yaml_document_get_node(doc, pair->key);
 		val = yaml_document_get_node(doc, pair->value);
 		if (key->data.scalar.length <= 0) {
 			EMIT_PKG_ERROR("Skipping malformed file entry for %s", filename);
 			pkg_emit_error("Skipping malformed file entry for %s", filename);
 			++pair;
 			continue;
 		}
 		if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0) {
 			EMIT_PKG_ERROR("Skipping malformed file entry for %s", filename);
 			pkg_emit_error("Skipping malformed file entry for %s", filename);
 			++pair;
 			continue;
 		}

@@ -296,11 +303,12 @@ pkg_set_files_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc

 			sum = val->data.scalar.value;
 		else if (!strcasecmp(key->data.scalar.value, "perm")) {
 			if ((set = setmode(val->data.scalar.value)) == NULL)
 				EMIT_PKG_ERROR("Not a valide mode: %s", val->data.scalar.value);
 				pkg_emit_error("Not a valide mode: %s", val->data.scalar.value);
 			else
 				perm = getmode(set, 0);
 		} else {
 			EMIT_PKG_ERROR("Skipping unknown key for file(%s): %s", filename, key->data.scalar.value);
 			pkg_emit_error("Skipping unknown key for file(%s): %s", filename,
 						   key->data.scalar.value);
 		}
 		++pair;

@@ -325,13 +333,13 @@ pkg_set_dirs_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc,

 		key = yaml_document_get_node(doc, pair->key);
 		val = yaml_document_get_node(doc, pair->value);
 		if (key->data.scalar.length <= 0) {
 			EMIT_PKG_ERROR("Skipping malformed file entry for %s", dirname);
 			pkg_emit_error("Skipping malformed file entry for %s", dirname);
 			++pair;
 			continue;
 		}
 		if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0) {
 			EMIT_PKG_ERROR("Skipping malformed file entry for %s", dirname);
 			pkg_emit_error("Skipping malformed file entry for %s", dirname);
 			++pair;
 			continue;
 		}

@@ -342,11 +350,12 @@ pkg_set_dirs_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc,

 			gname = val->data.scalar.value;
 		else if (!strcasecmp(key->data.scalar.value, "perm")) {
 			if ((set = setmode(val->data.scalar.value)) == NULL)
 				EMIT_PKG_ERROR("Not a valide mode: %s", val->data.scalar.value);
 				pkg_emit_error("Not a valide mode: %s", val->data.scalar.value);
 			else
 				perm = getmode(set, 0);
 		} else {
 			EMIT_PKG_ERROR("Skipping unknown key for dir(%s): %s", dirname, key->data.scalar.value);
 			pkg_emit_error("Skipping unknown key for dir(%s): %s", dirname,
 						   key->data.scalar.value);
 		}
 		++pair;

@@ -370,13 +379,15 @@ pkg_set_deps_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc,

 		key = yaml_document_get_node(doc, pair->key);
 		val = yaml_document_get_node(doc, pair->value);
 		if (key->data.scalar.length <= 0) {
 			EMIT_PKG_ERROR("Skipping malformed dependency entry for %s", depname);
 			pkg_emit_error("Skipping malformed dependency entry for %s",
 						   depname);
 			++pair;
 			continue;
 		}
 		if (val->type != YAML_SCALAR_NODE || val->data.scalar.length <= 0) {
 			EMIT_PKG_ERROR("Skipping malformed dependency entry for %s", depname);
 			pkg_emit_error("Skipping malformed dependency entry for %s",
 						   depname);
 			++pair;
 			continue;
 		}

@@ -393,7 +404,7 @@ pkg_set_deps_from_node(struct pkg *pkg, yaml_node_t *item, yaml_document_t *doc,

 	if (origin != NULL && version != NULL)
 		pkg_adddep(pkg, depname, origin, version);
 	else
 		EMIT_PKG_ERROR("Skipping malformed dependency %s", depname);
 		pkg_emit_error("Skipping malformed dependency %s", depname);
 	return (EPKG_OK);
 }

@@ -414,7 +425,7 @@ parse_root_node(struct pkg *pkg, yaml_node_t *node, yaml_document_t *doc) {

 		key = yaml_document_get_node(doc, pair->key);
 		val = yaml_document_get_node(doc, pair->value);
 		if (key->data.scalar.length <= 0) {
 			EMIT_PKG_ERROR("Skipping empty key", NULL);
 			pkg_emit_error("Skipping empty key");
 			++pair;
 			continue;
 		}

@@ -430,14 +441,16 @@ parse_root_node(struct pkg *pkg, yaml_node_t *node, yaml_document_t *doc) {

 				if (val->type == manifest_key[i].valid_type) {
 					retcode = manifest_key[i].parse_data(pkg, val, doc, manifest_key[i].type);
 				} else {
 					EMIT_PKG_ERROR("Unsupported format for key: %s", key->data.scalar.value);
 					pkg_emit_error("Unsupported format for key: %s",
 								   key->data.scalar.value);
 					retcode = EPKG_FATAL;
 				}
 				break;
 			}
 			if (manifest_key[i].key == NULL)
 				EMIT_PKG_ERROR("Skipping unknown manifest key: %s", key->data.scalar.value);
 				pkg_emit_error("Skipping unknown manifest key: %s",
 							   key->data.scalar.value);
 		}
 		++pair;
 	}

@@ -463,13 +476,13 @@ pkg_parse_manifest(struct pkg *pkg, char *buf)

 	node = yaml_document_get_root_node(&doc);
 	if (node != NULL) {
 		if (node->type != YAML_MAPPING_NODE) {
 			EMIT_PKG_ERROR("Invalid manifest format", NULL);
 			pkg_emit_error("Invalid manifest format");
 		} else {
 			parse_root_node(pkg, node, &doc);
 			retcode = EPKG_OK;
 		}
 	} else {
 		EMIT_PKG_ERROR("Invalid manifest format", NULL);
 		pkg_emit_error("Invalid manifest format");
 	}
 	yaml_document_delete(&doc);

modified libpkg/pkg_ports.c

@@ -155,7 +155,7 @@ ports_parse_plist(struct pkg *pkg, char *plist)

 				ret += pkg_adddir(pkg, path);
 			} else {
 				EMIT_PKG_ERROR("%s is deprecated, ignoring", plist_p);
 				pkg_emit_error("%s is deprecated, ignoring", plist_p);
 			}
 		} else if ((len = strlen(plist_p)) > 0){
 			filestarted = true;

@@ -184,7 +184,7 @@ ports_parse_plist(struct pkg *pkg, char *plist)

 				}
 				ret += pkg_addfile(pkg, path, p);
 			} else {
 				EMIT_ERRNO("lstat", path);
 				pkg_emit_errno("lstat", path);
 			}
 		}

modified libpkg/pkg_repo.c

@@ -41,7 +41,7 @@ pkg_repo_fetch(struct pkg *pkg)

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

@@ -60,7 +60,8 @@ pkg_repo_fetch(struct pkg *pkg)

 	retcode = sha256_file(dest, cksum);
 	if (retcode == EPKG_OK)
 		if (strcmp(cksum, pkg_get(pkg, PKG_CKSUM))) {
 			EMIT_FAILED_CKSUM(pkg);
 			pkg_emit_error("%s failed checksum from repo",
 						   pkg_get(pkg, PKG_NAME));
 			retcode = EPKG_FATAL;
 		}

@@ -102,12 +103,13 @@ load_rsa_public_key(const char *rsa_key_path)

 	char errbuf[1024];
 	if ((fp = fopen(rsa_key_path, "rb")) == 0) {
 		EMIT_ERRNO("Error reading public key(%s)", rsa_key_path);
 		pkg_emit_errno("fopen", rsa_key_path);
 		return (NULL);
 	}
 	if (!PEM_read_RSA_PUBKEY( fp, &rsa, NULL, NULL )) {
 		EMIT_PKG_ERROR("Error reading public key(%s): %s", rsa_key_path, ERR_error_string(ERR_get_error(), errbuf));
 		pkg_emit_error("error reading public key(%s): %s", rsa_key_path,
 					   ERR_error_string(ERR_get_error(), errbuf));
 		fclose(fp);
 		return (NULL);
 	}

@@ -134,7 +136,8 @@ pkg_repo_verify(const char *path, unsigned char *sig, unsigned int sig_len)

 		return(EPKG_FATAL);
 	if (RSA_verify(NID_sha1, sha256, sizeof(sha256), sig, sig_len, rsa) == 0) {
 		EMIT_PKG_ERROR("%s: %s", pkg_config("PUBKEY"), ERR_error_string(ERR_get_error(), errbuf));
 		pkg_emit_error("%s: %s", pkg_config("PUBKEY"),
 					   ERR_error_string(ERR_get_error(), errbuf));
 		return (EPKG_FATAL);
 	}

@@ -238,7 +241,7 @@ pkg_create_repo(char *path, void (progress)(struct pkg *pkg, void *data), void *

 		"VALUES (?1, (SELECT id FROM categories WHERE name = ?2));";
 	if (!is_dir(path)) {
 		EMIT_PKG_ERROR("%s is not a directory", path);
 		pkg_emit_error("%s is not a directory", path);
 		return EPKG_FATAL;
 	}

@@ -249,7 +252,7 @@ pkg_create_repo(char *path, void (progress)(struct pkg *pkg, void *data), void *

 	if (stat(repodb, &st) != -1)
 		if (unlink(repodb) != 0) {
 			EMIT_ERRNO("unlink", path);
 			pkg_emit_errno("unlink", path);
 			return EPKG_FATAL;
 		}

@@ -260,14 +263,14 @@ pkg_create_repo(char *path, void (progress)(struct pkg *pkg, void *data), void *

 	}
 	if (sqlite3_exec(sqlite, initsql, NULL, NULL, &errmsg) != SQLITE_OK) {
 		EMIT_PKG_ERROR("sqlite: %s", errmsg);
 		pkg_emit_error("sqlite: %s", errmsg);
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}
 	if (sqlite3_exec(sqlite, "BEGIN TRANSACTION;", NULL, NULL, &errmsg) !=
 		SQLITE_OK) {
 		EMIT_PKG_ERROR("sqlite: %s", errmsg);
 		pkg_emit_error("sqlite: %s", errmsg);
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}

@@ -297,7 +300,7 @@ pkg_create_repo(char *path, void (progress)(struct pkg *pkg, void *data), void *

 	}
 	if ((fts = fts_open(repopath, FTS_PHYSICAL, NULL)) == NULL) {
 		EMIT_ERRNO("fts_open", path);
 		pkg_emit_errno("fts_open", path);
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}

@@ -429,7 +432,7 @@ pkg_create_repo(char *path, void (progress)(struct pkg *pkg, void *data), void *

 	}
 	if (sqlite3_exec(sqlite, "COMMIT;", NULL, NULL, &errmsg) != SQLITE_OK) {
 		EMIT_PKG_ERROR("sqlite: %s", errmsg);
 		pkg_emit_error("sqlite: %s", errmsg);
 		retcode = EPKG_FATAL;
 	}

@@ -487,7 +490,7 @@ pkg_finish_repo(char *path, pem_password_cb *password_cb, char *rsa_key_path)

 	packing_init(&pack, repo_archive, TXZ);
 	if (rsa_key_path != NULL) {
 		if (access(rsa_key_path, R_OK) == -1) {
 			EMIT_ERRNO("access", rsa_key_path);
 			pkg_emit_errno("access", rsa_key_path);
 			return EPKG_FATAL;
 		}

@@ -505,7 +508,7 @@ pkg_finish_repo(char *path, pem_password_cb *password_cb, char *rsa_key_path)

 		if (RSA_sign(NID_sha1, sha256, sizeof(sha256), sigret, &siglen, rsa) == 0) {
 			/* XXX pass back RSA errors correctly */
 			EMIT_PKG_ERROR("%s: %lu", rsa_key_path, ERR_get_error());
 			pkg_emit_error("%s: %lu", rsa_key_path, ERR_get_error());
 			return EPKG_FATAL;
 		}

modified libpkg/pkg_util.c

@@ -70,7 +70,7 @@ mkdirs(const char *_path)

 		if (mkdir(path, S_IRWXU | S_IRWXG | S_IRWXO) < 0)
 			if (errno != EEXIST && errno != EISDIR) {
 				EMIT_ERRNO("mkdir", path);
 				pkg_emit_errno("mkdir", path);
 				return (EPKG_FATAL);
 			}

@@ -97,28 +97,28 @@ file_to_buffer(const char *path, char **buffer, off_t *sz)

 	assert(sz != NULL);
 	if ((fd = open(path, O_RDONLY)) == -1) {
 		EMIT_ERRNO("open", path);
 		pkg_emit_errno("open", path);
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}
 	if (fstat(fd, &st) == -1) {
 		close(fd);
 		EMIT_ERRNO("fstat", path);
 		pkg_emit_errno("fstat", path);
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}
 	if ((*buffer = malloc(st.st_size + 1)) == NULL) {
 		close(fd);
 		EMIT_ERRNO("malloc", "");
 		pkg_emit_errno("malloc", "");
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}
 	if (read(fd, *buffer, st.st_size) == -1) {
 		close(fd);
 		EMIT_ERRNO("read", path);
 		pkg_emit_errno("read", path);
 		retcode = EPKG_FATAL;
 		goto cleanup;
 	}

@@ -249,7 +249,7 @@ sha256_file(const char *path, char out[SHA256_DIGEST_LENGTH * 2 + 1])

 	SHA256_CTX sha256;
 	if ((fp = fopen(path, "rb")) == NULL) {
 		EMIT_ERRNO("fopen", path);
 		pkg_emit_errno("fopen", path);
 		return EPKG_FATAL;
 	}

@@ -261,7 +261,7 @@ sha256_file(const char *path, char out[SHA256_DIGEST_LENGTH * 2 + 1])

 	if (ferror(fp) != 0) {
 		fclose(fp);
 		out[0] = '\0';
 		EMIT_ERRNO("fread", path);
 		pkg_emit_errno("fread", path);
 		return EPKG_FATAL;
 	}

modified libpkg/pkg_util.h

@@ -10,7 +10,7 @@

 #define STARTS_WITH(string, needle) (strncasecmp(string, needle, strlen(needle)) == 0)
 #define ERROR_SQLITE(db) \
 	EMIT_PKG_ERROR("sqlite: %s", sqlite3_errmsg(db))
 	pkg_emit_error("sqlite: %s", sqlite3_errmsg(db))
 int sbuf_set(struct sbuf **, const char *);
 const char * sbuf_get(struct sbuf *);

modified libpkg/pkgdb.c

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

 					}
 				}
 				if (columns_text[i].name == NULL)
 					EMIT_PKG_ERROR("Unknown column %s", colname);
 					pkg_emit_error("Unknown column %s", colname);
 				break;
 			case SQLITE_INTEGER:
 				for (i = 0; columns_int[i].name != NULL; i++ ) {

@@ -124,11 +124,11 @@ populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {

 					}
 				}
 				if (columns_int[i].name == NULL)
 					EMIT_PKG_ERROR("Unknown column %s", colname);
 					pkg_emit_error("Unknown column %s", colname);
 				break;
 			case SQLITE_BLOB:
 			case SQLITE_FLOAT:
 				EMIT_PKG_ERROR("Wrong type for column: %s", colname);
 				pkg_emit_error("Wrong type for column: %s", colname);
 				/* just ignore currently */
 				break;
 			case SQLITE_NULL:

@@ -229,7 +229,7 @@ pkgdb_upgrade(sqlite3 *sdb)

 	if (db_version == DBVERSION)
 		return (EPKG_OK);
 	else if (db_version > DBVERSION) {
 		EMIT_PKG_ERROR("%s", "database version is newer than libpkg(3)");
 		pkg_emit_error("database version is newer than libpkg(3)");
 		return (EPKG_FATAL);
 	}

@@ -252,7 +252,7 @@ pkgdb_upgrade(sqlite3 *sdb)

 		 * been removed.
 		 */
 		if (sql_upgrade == NULL) {
 			EMIT_PKG_ERROR("can not upgrade to db version %" PRId64,
 			pkg_emit_error("can not upgrade to db version %" PRId64,
 						   db_version);
 			return (EPKG_FATAL);
 		}

@@ -426,7 +426,7 @@ pkgdb_open(struct pkgdb **db, pkgdb_t type)

 	dbdir = pkg_config("PKG_DBDIR");
 	if ((*db = calloc(1, sizeof(struct pkgdb))) == NULL) {
 		EMIT_ERRNO("malloc", "pkgdb");
 		pkg_emit_errno("malloc", "pkgdb");
 		return EPKG_FATAL;
 	}

@@ -436,13 +436,13 @@ pkgdb_open(struct pkgdb **db, pkgdb_t type)

 	retcode = access(localpath, R_OK);
 	if (retcode == -1) {
 		if (errno != ENOENT) {
 			EMIT_ERRNO("access", localpath);
 			pkg_emit_errno("access", localpath);
 			free(*db);
 			*db = NULL;
 			return (EPKG_FATAL);
 		}
 		else if (eaccess(dbdir, W_OK) != 0) {
 			EMIT_ERRNO("eaccess", dbdir);
 			pkg_emit_errno("eaccess", dbdir);
 			free(*db);
 			*db = NULL;
 			return (EPKG_FATAL);

@@ -461,7 +461,7 @@ pkgdb_open(struct pkgdb **db, pkgdb_t type)

 		snprintf(remotepath, sizeof(remotepath), "%s/repo.sqlite", dbdir);
 		if (access(remotepath, R_OK) != 0) {
 			EMIT_ERRNO("access", remotepath);
 			pkg_emit_errno("access", remotepath);
 			pkgdb_close(*db);
 			*db = NULL;
 			return (EPKG_FATAL);

@@ -527,7 +527,7 @@ pkgdb_it_new(struct pkgdb *db, sqlite3_stmt *s, int type)

 	struct pkgdb_it *it;
 	if ((it = malloc(sizeof(struct pkgdb_it))) == NULL) {
 		EMIT_ERRNO("malloc", "");
 		pkg_emit_errno("malloc", "pkgdb_it");
 		sqlite3_finalize(s);
 		return (NULL);
 	}

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

 		"VALUES (?1, (SELECT id FROM groups WHERE name = ?2));";
 	if (pkgdb_has_flag(db, PKGDB_FLAG_IN_FLIGHT)) {
 		EMIT_PKG_ERROR("%s", "tried to register a package with an in-flight SQL command");
 		pkg_emit_error("%s", "tried to register a package with an in-flight SQL command");
 		return (EPKG_FATAL);
 	}

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

 		if ((ret = sqlite3_step(stmt_file)) != SQLITE_DONE) {
 			if (ret == SQLITE_CONSTRAINT) {
 				    EMIT_PKG_ERROR("sqlite: constraint violation on files.path:"
 				    pkg_emit_error("sqlite: constraint violation on files.path:"
 								   " %s", pkg_file_path(file));
 			} else {
 				ERROR_SQLITE(s);

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

 		}
 		if ((ret = sqlite3_step(stmt_dir)) != SQLITE_DONE) {
 			if ( ret == SQLITE_CONSTRAINT) {
 				EMIT_PKG_ERROR("sqlite: constraint violation on dirs.path: %s",
 				pkg_emit_error("sqlite: constraint violation on dirs.path: %s",
 			 					pkg_dir_path(dir));
 			} else
 				ERROR_SQLITE(s);

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

 		if ((ret = sqlite3_step(stmt_cat)) != SQLITE_DONE) {
 			if (ret == SQLITE_CONSTRAINT) {
 				EMIT_PKG_ERROR("sqlite: constraint violation on categories.name: %s",
 				pkg_emit_error("sqlite: constraint violation on categories.name: %s",
 						pkg_category_name(category));
 			} else
 				ERROR_SQLITE(s);

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

 		if ((ret = sqlite3_step(stmt_lic)) != SQLITE_DONE) {
 			if (ret == SQLITE_CONSTRAINT) {
 				EMIT_PKG_ERROR("sqlite: constraint violation on licenses.name: %s",
 				pkg_emit_error("sqlite: constraint violation on licenses.name: %s",
 						pkg_license_name(license));
 			} else
 				ERROR_SQLITE(s);

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

 		if ((ret = sqlite3_step(stmt_user)) != SQLITE_DONE) {
 			if (ret == SQLITE_CONSTRAINT) {
 				EMIT_PKG_ERROR("sqlite: constraint violation on users.name: %s",
 				pkg_emit_error("sqlite: constraint violation on users.name: %s",
 						pkg_user_name(user));
 			} else
 				ERROR_SQLITE(s);

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

 		if ((ret = sqlite3_step(stmt_group)) != SQLITE_DONE) {
 			if (ret == SQLITE_CONSTRAINT) {
 				EMIT_PKG_ERROR("sqlite: constraint violation on groups.name: %s",
 				pkg_emit_error("sqlite: constraint violation on groups.name: %s",
 						pkg_group_name(group));
 			} else
 				ERROR_SQLITE(s);

@@ -1575,7 +1575,7 @@ pkgdb_register_finale(struct pkgdb *db, int retcode)

 	const char *command;
 	if (!pkgdb_has_flag(db, PKGDB_FLAG_IN_FLIGHT)) {
 		EMIT_PKG_ERROR("%s", "database command not in flight (misuse)");
 		pkg_emit_error("database command not in flight (misuse)");
 		return EPKG_FATAL;
 	}

@@ -1640,7 +1640,7 @@ sql_exec(sqlite3 *s, const char *sql)

 	char *errmsg;
 	if (sqlite3_exec(s, sql, NULL, NULL, &errmsg) != SQLITE_OK) {
 		EMIT_PKG_ERROR("sqlite: %s", errmsg);
 		pkg_emit_error("sqlite: %s", errmsg);
 		sqlite3_free(errmsg);
 		return (EPKG_FATAL);
 	}

@@ -1704,7 +1704,7 @@ pkgdb_query_upgrades(struct pkgdb *db)

 	sqlite3_stmt *stmt;
 	if (db->type != PKGDB_REMOTE) {
 		EMIT_PKG_ERROR("%s", "remote database not attached (misuse)");
 		pkg_emit_error("remote database not attached (misuse)");
 		return (NULL);
 	}

@@ -1732,7 +1732,7 @@ pkgdb_query_downgrades(struct pkgdb *db)

 	sqlite3_stmt *stmt;
 	if (db->type != PKGDB_REMOTE) {
 		EMIT_PKG_ERROR("%s", "remote database not attached (misuse)");
 		pkg_emit_error("remote database not attached (misuse)");
 		return (NULL);
 	}

@@ -1785,7 +1785,7 @@ pkgdb_rquery(struct pkgdb *db, const char *pattern, match_t match, pkgdb_field f

 	assert(pattern != NULL && pattern[0] != '\0');
 	if (db->type != PKGDB_REMOTE) {
 		EMIT_PKG_ERROR("%s", "remote database not attached (misuse)");
 		pkg_emit_error("remote database not attached (misuse)");
 		return (NULL);
 	}

modified pkg/event.c

@@ -11,6 +11,7 @@ event_callback(void *data, struct pkg_event *ev)

 	unsigned int percent;
 	const char *message;
 	int *debug = data;
 	(void)debug;
 	switch(ev->type) {
 	case PKG_EVENT_ERRNO:

@@ -73,8 +74,5 @@ event_callback(void *data, struct pkg_event *ev)

 		break;
 	}
 	if (*debug > 0)
 		printf("  at %s:%d\n", ev->file, ev->line);
 	return 0;
 }