b091aa0 Rename _FAILED events to _ERROR and remove duplicate PKG_EVENT_DB_OPEN_ERROR. — HardenedBSD-pkg

modified libpkg/fetch.c

@@ -40,7 +40,7 @@ pkg_fetch_file(const char *url, const char *dest, void *data, fetch_cb cb)

 		if (remote == NULL) {
 			--retry;
 			if (retry == 0) {
 				pkg_emit_event(PKG_EVENT_FETCH_FAILED,
 				pkg_emit_event(PKG_EVENT_FETCH_ERROR,
 				    /*argc*/1, fetchLastErrString);
 				retcode = EPKG_FATAL;
 				goto cleanup;

@@ -71,7 +71,7 @@ pkg_fetch_file(const char *url, const char *dest, void *data, fetch_cb cb)

 	}
 	if (ferror(remote)) {
 		pkg_emit_event(PKG_EVENT_FETCH_FAILED, /*argc*/1,
 		pkg_emit_event(PKG_EVENT_FETCH_ERROR, /*argc*/1,
 		    fetchLastErrString);
 		retcode = EPKG_FATAL;
 		goto cleanup;

@@ -110,7 +110,7 @@ pkg_fetch_buffer(const char *url, char **buffer, void *data, fetch_cb cb)

 		if (remote == NULL) {
 			--retry;
 			if (retry == 0) {
 				pkg_emit_event(PKG_EVENT_FETCH_FAILED,
 				pkg_emit_event(PKG_EVENT_FETCH_ERROR,
 				    /*argc*/1, fetchLastErrString);
 				retcode = EPKG_FATAL;
 				goto cleanup;

@@ -138,7 +138,7 @@ pkg_fetch_buffer(const char *url, char **buffer, void *data, fetch_cb cb)

 	}
 	if (ferror(remote)) {
 		pkg_emit_event(PKG_EVENT_FETCH_FAILED, /*argc*/1,
 		pkg_emit_event(PKG_EVENT_FETCH_ERROR, /*argc*/1,
 		    fetchLastErrString);
 		goto cleanup;
 	}

modified libpkg/packing.c

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

 	const char *ext;
 	if ((*pack = calloc(1, sizeof(struct packing))) == NULL) {
 		pkg_emit_event(PKG_EVENT_MALLOC_FAILED, /*argc*/1,
 		pkg_emit_event(PKG_EVENT_MALLOC_ERROR, /*argc*/1,
 		    strerror(errno));
 	}

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) {
 		pkg_emit_event(PKG_EVENT_MALLOC_FAILED, /*argc*/1,
 		pkg_emit_event(PKG_EVENT_MALLOC_ERROR, /*argc*/1,
 		    strerror(errno));
 		return EPKG_FATAL;
 	}

modified libpkg/pkg.h

@@ -584,19 +584,18 @@ typedef enum {

 	PKG_EVENT_ARCHIVE_COMP_UNSUP = 65536,
 	PKG_EVENT_ARCHIVE_ERROR,
 	PKG_EVENT_ALREADY_INSTALLED,
 	PKG_EVENT_CKSUM_FAILED,
 	PKG_EVENT_CKSUM_ERROR,
 	PKG_EVENT_CONFIG_KEY_NOTFOUND,
 	PKG_EVENT_CREATEDB_FAILED,
 	PKG_EVENT_CREATEDB_FAILED_ERRNO,
 	PKG_EVENT_DB_OPEN_FAILED,
 	PKG_EVENT_CREATEDB_ERROR,
 	PKG_EVENT_CREATEDB_ERROR_ERRNO,
 	PKG_EVENT_DELETE_DEP_EXISTS,
 	PKG_EVENT_ERROR_INSTALLING_DEP,
 	PKG_EVENT_FETCH_FAILED,
 	PKG_EVENT_FETCH_ERROR,
 	PKG_EVENT_INVALID_DB_STATE,
 	PKG_EVENT_IO_ERROR,
 	PKG_EVENT_MALLOC_FAILED,
 	PKG_EVENT_MALLOC_ERROR,
 	PKG_EVENT_MISSING_DEP,
 	PKG_EVENT_OPEN_DB_FAILED,
 	PKG_EVENT_OPEN_DB_ERROR,
 	PKG_EVENT_PARSE_ERROR,
 	PKG_EVENT_REPO_KEY_UNAVAIL,
 	PKG_EVENT_REPO_KEY_UNUSABLE,

modified libpkg/pkg_create_repo.c

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

 		"VALUES (?1, ?2, ?3, ?4);";
 	if (!is_dir(path)) {
 		pkg_emit_event(PKG_EVENT_CREATEDB_FAILED, /*argc*/2,
 		pkg_emit_event(PKG_EVENT_CREATEDB_ERROR, /*argc*/2,
 		    path, "not a directory");
 		return EPKG_FATAL;
 	}

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

 	if (stat(repodb, &st) != -1)
 		if (unlink(repodb) != 0) {
 			pkg_emit_event(PKG_EVENT_CREATEDB_FAILED_ERRNO,
 			pkg_emit_event(PKG_EVENT_CREATEDB_ERROR_ERRNO,
 			    /*argc*/3, path, repodb, strerror(errno));
 			return EPKG_FATAL;
 		}

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

 	}
 	if ((fts = fts_open(repopath, FTS_PHYSICAL, NULL)) == NULL) {
 		pkg_emit_event(PKG_EVENT_OPEN_DB_FAILED, /*argc*/2,
 		pkg_emit_event(PKG_EVENT_OPEN_DB_ERROR, /*argc*/2,
 		    repopath, strerror(errno));
 		retcode = EPKG_FATAL;
 		goto cleanup;

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

 		if (pkg_open(&pkg, ent->fts_accpath) != EPKG_OK) {
 			if (progress != NULL) {
 				pkg_emit_event(PKG_EVENT_DB_OPEN_FAILED,
 				pkg_emit_event(PKG_EVENT_OPEN_DB_ERROR,
 				    /*argc*/2, ent->fts_name,
 				    pkg_error_string());
 				retcode = EPKG_WARN;

modified libpkg/pkg_event.c

@@ -10,30 +10,30 @@ pkg_event_argument_check(pkg_event_t ev, int argc)

 	switch(ev) {
 	case PKG_EVENT_ALREADY_INSTALLED:
 	case PKG_EVENT_CKSUM_FAILED:
 	case PKG_EVENT_CKSUM_ERROR:
 	case PKG_EVENT_CONFIG_KEY_NOTFOUND:
 	case PKG_EVENT_DELETE_DEP_EXISTS:
 	case PKG_EVENT_FETCH_FAILED:
 	case PKG_EVENT_FETCH_ERROR:
 	case PKG_EVENT_INSTALL_BEGIN:
 	case PKG_EVENT_INVALID_DB_STATE:
 	case PKG_EVENT_MALLOC_FAILED:
 	case PKG_EVENT_MALLOC_ERROR:
 	case PKG_EVENT_UNKNOWN_SCRIPT:
 	case PKG_EVENT_SQLITE_ERROR:
 		assert(argc == 1);
 		break;
 	case PKG_EVENT_ARCHIVE_COMP_UNSUP:
 	case PKG_EVENT_ARCHIVE_ERROR:
 	case PKG_EVENT_CREATEDB_FAILED:
 	case PKG_EVENT_CREATEDB_ERROR:
 	case PKG_EVENT_ERROR_INSTALLING_DEP:
 	case PKG_EVENT_MISSING_DEP:
 	case PKG_EVENT_OPEN_DB_FAILED:
 	case PKG_EVENT_OPEN_DB_ERROR:
 	case PKG_EVENT_PARSE_ERROR:
 	case PKG_EVENT_REPO_KEY_UNAVAIL:
 	case PKG_EVENT_REPO_KEY_UNUSABLE:
 	case PKG_EVENT_SQLITE_CONSTRAINT:
 		assert(argc == 2);
 		break;
 	case PKG_EVENT_CREATEDB_FAILED_ERRNO:
 	case PKG_EVENT_CREATEDB_ERROR_ERRNO:
 	case PKG_EVENT_IO_ERROR:
 		assert(argc == 3);
 		break;

@@ -59,17 +59,17 @@ libpkg_handle_event(pkg_event_t ev, void **argv)

 		pkg_error_set(EPKG_FATAL, "archive error at %s: %s",
 		    argv[0], archive_error_string(argv[1]));
 		break;
 	case PKG_EVENT_CKSUM_FAILED:
 	case PKG_EVENT_CKSUM_ERROR:
 		pkg_error_set(EPKG_FATAL, "package '%s' failed checksum",
 		    pkg_get(argv[0], PKG_NAME));
 		break;
 	case PKG_EVENT_CONFIG_KEY_NOTFOUND:
 		pkg_error_set(EPKG_FATAL, "unknown configuration key `%s'", argv[0]);
 		break;
 	case PKG_EVENT_CREATEDB_FAILED:
 	case PKG_EVENT_CREATEDB_ERROR:
 		pkg_error_set(EPKG_FATAL, "%s: %s", argv[0], argv[1]);
 		break;
 	case PKG_EVENT_CREATEDB_FAILED_ERRNO:
 	case PKG_EVENT_CREATEDB_ERROR_ERRNO:
 		pkg_error_set(EPKG_FATAL, "%s(%s): %s", argv[0], argv[1], argv[2]);
 		break;
 	case PKG_EVENT_DELETE_DEP_EXISTS:

@@ -79,7 +79,7 @@ libpkg_handle_event(pkg_event_t ev, void **argv)

 		pkg_error_set(EPKG_FATAL, "error while installing dependency %s: %s",
 		    argv[0], argv[1]);
 		break;
 	case PKG_EVENT_FETCH_FAILED:
 	case PKG_EVENT_FETCH_ERROR:
 		pkg_error_set(EPKG_FATAL, "%s", argv[0]);
 		break;
 	case PKG_EVENT_INVALID_DB_STATE:

@@ -89,14 +89,14 @@ libpkg_handle_event(pkg_event_t ev, void **argv)

 		pkg_error_set(EPKG_FATAL, "I/O error: %s(%s): %s",
 		    /*call*/argv[0], /*arg*/argv[1], /*strerror*/argv[2]);
 		break;
 	case PKG_EVENT_MALLOC_FAILED:
 	case PKG_EVENT_MALLOC_ERROR:
 		pkg_error_set(EPKG_FATAL, "allocation error: %s", argv[0]);
 		break;
 	case PKG_EVENT_MISSING_DEP:
 		pkg_error_set(EPKG_DEPENDENCY, "missing %s-%s dependency",
 		    argv[0], argv[1]);
 		break;
 	case PKG_EVENT_OPEN_DB_FAILED:
 	case PKG_EVENT_OPEN_DB_ERROR:
 		pkg_error_set(EPKG_FATAL, "db open(%s) failed: %s", argv[0], argv[1]);
 		break;
 	case PKG_EVENT_PARSE_ERROR:

modified libpkg/pkg_repo.c

@@ -32,7 +32,7 @@ pkg_repo_fetch(struct pkg *pkg, void *data, fetch_cb cb)

 	retcode = sha256_file(dest, cksum);
 	if (retcode == EPKG_OK)
 		if (strcmp(cksum, pkg_get(pkg, PKG_CKSUM))) {
 			pkg_emit_event(PKG_EVENT_CKSUM_FAILED, /*argc*/1, pkg);
 			pkg_emit_event(PKG_EVENT_CKSUM_ERROR, /*argc*/1, pkg);
 			retcode = EPKG_FATAL;
 		}

modified libpkg/pkg_util.c

@@ -84,7 +84,7 @@ file_to_buffer(const char *path, char **buffer, off_t *sz)

 	if ((*buffer = malloc(st.st_size + 1)) == NULL) {
 		close(fd);
 		pkg_emit_event(PKG_EVENT_MALLOC_FAILED, /*argc*/1,
 		pkg_emit_event(PKG_EVENT_MALLOC_ERROR, /*argc*/1,
 		    strerror(errno));
 		return EPKG_FATAL;
 	}

modified libpkg/pkgdb.c

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

 	dbdir = pkg_config("PKG_DBDIR");
 	if ((*db = calloc(1, sizeof(struct pkgdb))) == NULL) {
 		pkg_emit_event(PKG_EVENT_MALLOC_FAILED, /*argc*/1,
 		pkg_emit_event(PKG_EVENT_MALLOC_ERROR, /*argc*/1,
 		    strerror(errno));
 		return EPKG_FATAL;
 	}

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

 	struct pkgdb_it *it;
 	if ((it = malloc(sizeof(struct pkgdb_it))) == NULL) {
 		pkg_emit_event(PKG_EVENT_MALLOC_FAILED, /*argc*/1,
 		pkg_emit_event(PKG_EVENT_MALLOC_ERROR, /*argc*/1,
 		    strerror(errno));
 		sqlite3_finalize(s);
 		return (NULL);