f446c79 Get rid of sysexits — HardenedBSD-pkg

modified libpkg/pkg.h.in

@@ -86,10 +86,10 @@ extern "C" {

 #endif
 /* Special exit status for worker processes indicating that a restart
  * is desired -- eg. after a child has updated pkg(8) itself.  Don't
  * clash with any of the sysexits values */
  * is desired -- eg. after a child has updated pkg(8) itself.
  */
 #define EX_NEEDRESTART	(EX__MAX + 1)
 #define EX_NEEDRESTART	4
 struct pkg;
 struct pkg_dep;

modified libpkg/pkg_config.c

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

 #include <osreldate.h>
 #endif
 #include <ucl.h>
 #include <sysexits.h>
 #include "pkg.h"
 #include "private/pkg.h"

@@ -1408,7 +1407,7 @@ pkg_shutdown(void)

 {
 	if (!parsed) {
 		pkg_emit_error("pkg_shutdown() must be called after pkg_init()");
 		_exit(EX_SOFTWARE);
 		_exit(EXIT_FAILURE);
 		/* NOTREACHED */
 	}

modified libpkg/pkg_repo.c

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

 #define _WITH_GETLINE
 #include <stdio.h>
 #include <stdbool.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sys/mman.h>

modified libpkg/pkg_repo_create.c

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

 #include <string.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <errno.h>
 #include <fcntl.h>

modified src/add.c

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

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <getopt.h>
 #include <xstring.h>

@@ -111,7 +110,7 @@ exec_add(int argc, char **argv)

 			break;
 		default:
 			usage_add();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	argc -= optind;

@@ -119,7 +118,7 @@ exec_add(int argc, char **argv)

 	if (argc < 1) {
 		usage_add();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	retcode = pkgdb_access(PKGDB_MODE_READ  |

@@ -128,17 +127,17 @@ exec_add(int argc, char **argv)

 			       PKGDB_DB_LOCAL);
 	if (retcode == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to add packages");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (retcode != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an exclusive lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	failedpkgs = xstring_new();

@@ -200,6 +199,6 @@ exec_add(int argc, char **argv)

 		printf("%s", messages->buf);
 	}
 	return (retcode == EPKG_OK ? EX_OK : EX_SOFTWARE);
 	return (retcode == EPKG_OK ? EXIT_SUCCESS : EXIT_FAILURE);
 }

modified src/alias.c

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

 #include <libgen.h>
 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <getopt.h>

@@ -53,7 +52,7 @@ exec_alias(int argc, char **argv)

 	const pkg_object *alias;
 	pkg_iter it = NULL;
 	int ch;
 	int ret = EX_OK;
 	int ret = EXIT_SUCCESS;
 	bool list = false;
 	struct option longopts[] = {

@@ -72,7 +71,7 @@ exec_alias(int argc, char **argv)

 			break;
 		default:
 			usage_alias();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -108,7 +107,7 @@ exec_alias(int argc, char **argv)

 				printf("%-20s '%s'\n", argv[i], pkg_object_string(alias));
 		} else {
 			warnx("No such alias: '%s'", argv[i]);
 			ret = EX_UNAVAILABLE;
 			ret = EXIT_FAILURE;
 		}
 	}

modified src/annotate.c

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

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -176,7 +175,7 @@ read_input(void)

 			if (feof(stdin))
 				break;
 			if (ferror(stdin))
 				err(EX_NOINPUT, "Failed to read stdin");
 				err(EXIT_FAILURE, "Failed to read stdin");
 		}
 		fputc(ch, input->fp);
 	}

@@ -198,7 +197,7 @@ exec_annotate(int argc, char **argv)

 	int		 ch;
 	int		 match    = MATCH_EXACT;
 	int		 retcode;
 	int		 exitcode = EX_OK;
 	int		 exitcode = EXIT_SUCCESS;
 	int		 flags = 0;
 	int		 lock_type = PKGDB_LOCK_EXCLUSIVE;
 	int		 mode = PKGDB_MODE_READ;

@@ -263,7 +262,7 @@ exec_annotate(int argc, char **argv)

 			break;
 		default:
 			usage_annotate();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
         }
 	argc -= optind;

@@ -273,7 +272,7 @@ exec_annotate(int argc, char **argv)

 	    (match == MATCH_ALL && argc < 1) ||
 	    (match != MATCH_ALL && argc < 2)) {
 		usage_annotate();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (match == MATCH_ALL) {

@@ -296,37 +295,37 @@ exec_annotate(int argc, char **argv)

 	retcode = pkgdb_access(mode, PKGDB_DB_LOCAL);
 	if (retcode == EPKG_ENODB) {
 		if (match == MATCH_ALL) {
 			exitcode = EX_OK;
 			exitcode = EXIT_SUCCESS;
 			goto cleanup;
 		}
 		if (!quiet)
 			warnx("No packages installed.  Nothing to do!");
 		exitcode = EX_OK;
 		exitcode = EXIT_SUCCESS;
 		goto cleanup;
 	} else if (retcode == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to modify the package database");
 		exitcode = EX_NOPERM;
 		exitcode = EXIT_FAILURE;
 		goto cleanup;
 	} else if (retcode != EPKG_OK) {
 		warnx("Error accessing the package database");
 		exitcode = EX_SOFTWARE;
 		exitcode = EXIT_FAILURE;
 		goto cleanup;
 	}
 	retcode = pkgdb_open(&db, PKGDB_DEFAULT);
 	if (retcode != EPKG_OK) {
 		free(input);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_obtain_lock(db, lock_type) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an exclusive lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if ((it = pkgdb_query(db, pkgname, match)) == NULL) {
 		exitcode = EX_IOERR;
 		exitcode = EXIT_FAILURE;
 		goto cleanup;
 	}

@@ -335,7 +334,7 @@ exec_annotate(int argc, char **argv)

 		switch(action) {
 		case NONE:	/* Should never happen */
 			usage_annotate();
 			exitcode = EX_USAGE;
 			exitcode = EXIT_FAILURE;
 			break;
 		case ADD:
 			retcode = do_add(db, pkg, tag, value);

@@ -352,10 +351,10 @@ exec_annotate(int argc, char **argv)

 		}
 		if (retcode == EPKG_WARN)
 			exitcode = EX_DATAERR;
 			exitcode = EXIT_FAILURE;
 		if (retcode != EPKG_OK && retcode != EPKG_WARN) {
 			exitcode = EX_IOERR;
 			exitcode = EXIT_FAILURE;
 			goto cleanup;
 		}
 	}

modified src/audit.c

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

 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <sysexits.h>
 #include <khash.h>
 #include <xstring.h>

@@ -124,7 +123,7 @@ exec_audit(int argc, char **argv)

 	unsigned int		 affected = 0, vuln = 0;
 	bool			 fetch = false, recursive = false;
 	int			 ch, i;
 	int			 ret = EX_OK;
 	int			 ret = EXIT_SUCCESS;
 	xstring			*sb;
 	kh_pkgs_t		*check = NULL;

@@ -152,7 +151,7 @@ exec_audit(int argc, char **argv)

 			break;
 		default:
 			usage_audit();
 			return(EX_USAGE);
 			return(EXIT_FAILURE);
 		}
 	}
 	argc -= optind;

@@ -163,7 +162,7 @@ exec_audit(int argc, char **argv)

 	if (fetch == true) {
 		if (pkg_audit_fetch(NULL, audit_file) != EPKG_OK) {
 			pkg_audit_free(audit);
 			return (EX_IOERR);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -177,7 +176,7 @@ exec_audit(int argc, char **argv)

 					audit_file);
 		pkg_audit_free(audit);
 		return (EX_DATAERR);
 		return (EXIT_FAILURE);
 	}
 	check = kh_init_pkgs();

@@ -190,7 +189,7 @@ exec_audit(int argc, char **argv)

 				version++;
 			}
 			if (pkg_new(&pkg, PKG_FILE) != EPKG_OK)
 				err(EX_OSERR, "malloc");
 				err(EXIT_FAILURE, "malloc");
 			if (version != NULL)
 				pkg_set(pkg, PKG_NAME, name, PKG_VERSION, version);
 			else

@@ -212,23 +211,23 @@ exec_audit(int argc, char **argv)

 		if (ret == EPKG_ENODB) {
 			pkg_audit_free(audit);
 			kh_destroy_pkgs(check);
 			return (EX_OK);
 			return (EXIT_SUCCESS);
 		} else if (ret == EPKG_ENOACCESS) {
 			warnx("Insufficient privileges to read the package database");
 			pkg_audit_free(audit);
 			kh_destroy_pkgs(check);
 			return (EX_NOPERM);
 			return (EXIT_FAILURE);
 		} else if (ret != EPKG_OK) {
 			warnx("Error accessing the package database");
 			pkg_audit_free(audit);
 			kh_destroy_pkgs(check);
 			return (EX_IOERR);
 			return (EXIT_FAILURE);
 		}
 		if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
 			pkg_audit_free(audit);
 			kh_destroy_pkgs(check);
 			return (EX_IOERR);
 			return (EXIT_FAILURE);
 		}
 		if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {

@@ -236,12 +235,12 @@ exec_audit(int argc, char **argv)

 			pkg_audit_free(audit);
 			kh_destroy_pkgs(check);
 			warnx("Cannot get a read lock on a database, it is locked by another process");
 			return (EX_TEMPFAIL);
 			return (EXIT_FAILURE);
 		}
 		if ((it = pkgdb_query(db, NULL, MATCH_ALL)) == NULL) {
 			warnx("Error accessing the package database");
 			ret = EX_IOERR;
 			ret = EXIT_FAILURE;
 		}
 		else {
 			while ((ret = pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC|PKG_LOAD_RDEPS))

@@ -249,14 +248,14 @@ exec_audit(int argc, char **argv)

 				add_to_check(check, pkg);
 				pkg = NULL;
 			}
 			ret = EX_OK;
 			ret = EXIT_SUCCESS;
 		}
 		if (db != NULL) {
 			pkgdb_it_free(it);
 			pkgdb_release_lock(db, PKGDB_LOCK_READONLY);
 			pkgdb_close(db);
 		}
 		if (ret != EX_OK) {
 		if (ret != EXIT_SUCCESS) {
 			pkg_audit_free(audit);
 			kh_destroy_pkgs(check);
 			return (ret);

@@ -303,7 +302,7 @@ exec_audit(int argc, char **argv)

 		kh_destroy_pkgs(check);
 		if (ret == EPKG_END && vuln == 0)
 			ret = EX_OK;
 			ret = EXIT_SUCCESS;
 		if (!quiet)
 			printf("%u problem(s) in %u installed package(s) found.\n",

@@ -311,7 +310,7 @@ exec_audit(int argc, char **argv)

 	}
 	else {
 		warnx("cannot process vulnxml");
 		ret = EX_SOFTWARE;
 		ret = EXIT_FAILURE;
 		kh_destroy_pkgs(check);
 	}

modified src/autoremove.c

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

 #include <err.h>
 #include <getopt.h>
 #include <stdio.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -49,7 +48,7 @@ exec_autoremove(int argc, char **argv)

 {
 	struct pkgdb *db = NULL;
 	struct pkg_jobs *jobs = NULL;
 	int retcode = EX_OK;
 	int retcode = EXIT_SUCCESS;
 	int ch;
 	nbactions = nbdone = 0;
 	pkg_flags f = PKG_FLAG_FORCE;

@@ -84,7 +83,7 @@ exec_autoremove(int argc, char **argv)

 	if (argc != 0) {
 		usage_autoremove();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (dry_run)

@@ -95,34 +94,34 @@ exec_autoremove(int argc, char **argv)

 	if (retcode == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to autoremove packages");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (retcode == EPKG_ENODB) {
 		warnx("No packages installed.  Nothing to do!");
 		return (EX_OK);
 		return (EXIT_SUCCESS);
 	} else if (retcode != EPKG_OK) {
 		warnx("Error accessing the package database");
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_obtain_lock(db, lock_type) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an advisory lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	/* Always force packages to be removed */
 	if (pkg_jobs_new(&jobs, PKG_JOBS_AUTOREMOVE, db) != EPKG_OK) {
 		pkgdb_close(db);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	pkg_jobs_set_flags(jobs, f);
 	if ((retcode = pkg_jobs_solve(jobs)) != EPKG_OK) {
 		retcode = EX_SOFTWARE;
 		retcode = EXIT_FAILURE;
 		goto cleanup;
 	}

modified src/backup.c

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

 #include <pkg.h>
 #include <getopt.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include "pkgcli.h"

@@ -72,33 +71,33 @@ exec_backup(int argc, char **argv)

 			break;
 		default:
 			usage_backup();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	if ( dump == restore ) {
 		usage_backup();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (dump) {
 		if (!quiet)
 			printf("Dumping database:\n");
 		if (pkgdb_dump(db, backup_file) == EPKG_FATAL)
 			return (EX_IOERR);
 			return (EXIT_FAILURE);
 	}
 	if (restore) {
 		if (!quiet)
 			printf("Restoring database:\n");
 		if (pkgdb_load(db, backup_file) == EPKG_FATAL)
 			return (EX_IOERR);
 			return (EXIT_FAILURE);
 	}
 	pkgdb_close(db);
 	return (EX_OK);
 	return (EXIT_SUCCESS);
 }

modified src/check.c

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

 #include <err.h>
 #include <assert.h>
 #include <getopt.h>
 #include <sysexits.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>

@@ -279,7 +278,7 @@ exec_check(int argc, char **argv)

 	xstring *msg = NULL;
 	match_t match = MATCH_EXACT;
 	int flags = PKG_LOAD_BASIC;
 	int ret, rc = EX_OK;
 	int ret, rc = EXIT_SUCCESS;
 	int ch;
 	bool dcheck = false;
 	bool checksums = false;

@@ -358,7 +357,7 @@ exec_check(int argc, char **argv)

 			break;
 		default:
 			usage_check();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	argc -= optind;

@@ -369,7 +368,7 @@ exec_check(int argc, char **argv)

 		match = MATCH_ALL;
 	} else if ((argc == 0 && match != MATCH_ALL) || !(dcheck || checksums || recompute || reanalyse_shlibs)) {
 		usage_check();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (recompute || reanalyse_shlibs)

@@ -381,28 +380,28 @@ exec_check(int argc, char **argv)

 	if (ret == EPKG_ENODB) {
 		if (!quiet)
 			warnx("No packages installed.  Nothing to do!");
 		return (EX_OK);
 		return (EXIT_SUCCESS);
 	} else if (ret == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to access the package database");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (ret != EPKG_OK) {
 		warnx("Error accessing the package database");
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_access(PKGDB_MODE_WRITE, PKGDB_DB_LOCAL) == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	}
 	ret = pkgdb_open(&db, PKGDB_DEFAULT);
 	if (ret != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an advisory lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	i = 0;

@@ -411,7 +410,7 @@ exec_check(int argc, char **argv)

 		/* XXX: This is really quirky, it would be cleaner to pass
 		 * in multiple matches and only run this top-loop once. */
 		if ((it = pkgdb_query(db, argv[i], match)) == NULL) {
 			rc = EX_IOERR;
 			rc = EXIT_FAILURE;
 			goto cleanup;
 		}
 		nbactions = pkgdb_it_count(it);

@@ -459,14 +458,14 @@ exec_check(int argc, char **argv)

 					printf(" dependencies...");
 				nbpkgs += check_deps(db, pkg, &dh, noinstall, out);
 				if (noinstall && nbpkgs > 0) {
 					rc = EX_UNAVAILABLE;
 					rc = EXIT_FAILURE;
 				}
 			}
 			if (checksums) {
 				if (!quiet && verbose)
 					printf(" checksums...");
 				if (pkg_test_filesum(pkg) != EPKG_OK) {
 					rc = EX_DATAERR;
 					rc = EXIT_FAILURE;
 				}
 			}
 			if (recompute) {

@@ -475,14 +474,14 @@ exec_check(int argc, char **argv)

 					if (!quiet && verbose)
 						printf(" recomputing...");
 					if (pkg_recompute(db, pkg) != EPKG_OK) {
 						rc = EX_DATAERR;
 						rc = EXIT_FAILURE;
 					}
 					pkgdb_downgrade_lock(db,
 					    PKGDB_LOCK_EXCLUSIVE,
 					    PKGDB_LOCK_ADVISORY);
 				}
 				else {
 					rc = EX_TEMPFAIL;
 					rc = EXIT_FAILURE;
 				}
 			}
 			if (reanalyse_shlibs) {

@@ -494,14 +493,14 @@ exec_check(int argc, char **argv)

 						pkg_fprintf(stderr, "Failed to "
 						    "reanalyse for shlibs: "
 						    "%n-%v\n", pkg, pkg);
 						rc = EX_UNAVAILABLE;
 						rc = EXIT_FAILURE;
 					}
 					pkgdb_downgrade_lock(db,
 					    PKGDB_LOCK_EXCLUSIVE,
 					    PKGDB_LOCK_ADVISORY);
 				}
 				else {
 					rc = EX_TEMPFAIL;
 					rc = EXIT_FAILURE;
 				}
 			}

@@ -532,15 +531,15 @@ exec_check(int argc, char **argv)

 					check_summary(db, dh);
 				else if (ret == EPKG_ENODB) {
 					db = NULL;
 					rc = EX_IOERR;
 					rc = EXIT_FAILURE;
 				}
 				if (rc == EX_IOERR)
 				if (rc == EXIT_FAILURE)
 					goto cleanup;
 				pkgdb_downgrade_lock(db, PKGDB_LOCK_EXCLUSIVE,
 				    PKGDB_LOCK_ADVISORY);
 			}
 			else {
 				rc = EX_TEMPFAIL;
 				rc = EXIT_FAILURE;
 				goto cleanup;
 			}
 		}

modified src/clean.c

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

 #include <pkg.h>
 #include <stdbool.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <khash.h>
 #include <kvec.h>

@@ -113,7 +112,7 @@ static int

 delete_dellist(int fd, const char *cachedir,  dl_list *dl, int total)
 {
 	struct stat st;
 	int retcode = EX_OK;
 	int retcode = EXIT_SUCCESS;
 	int flag = 0;
 	size_t i;
 	unsigned int count = 0, processed = 0;

@@ -135,7 +134,7 @@ delete_dellist(int fd, const char *cachedir, dl_list *dl, int total)

 			flag = AT_REMOVEDIR;
 		if (unlinkat(fd, relpath, flag) == -1) {
 			warn("unlink(%s)", file);
 			retcode = EX_SOFTWARE;
 			retcode = EXIT_FAILURE;
 		}
 		free(file);
 		kv_A(*dl, i) = NULL;

@@ -145,7 +144,7 @@ delete_dellist(int fd, const char *cachedir, dl_list *dl, int total)

 	progressbar_tick(processed, total);
 	if (!quiet) {
 		if (retcode == EX_OK)
 		if (retcode == EXIT_SUCCESS)
 			printf("All done\n");
 		else
 			printf("%d package%s could not be deleted\n",

@@ -333,7 +332,7 @@ exec_clean(int argc, char **argv)

 			break;
 		default:
 			usage_clean();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -341,7 +340,7 @@ exec_clean(int argc, char **argv)

 	cachefd = pkg_get_cachedirfd();
 	if (cachefd == -1) {
 		warn("Impossible to open %s", cachedir);
 		return (errno == ENOENT ? EX_OK : EX_IOERR);
 		return (errno == ENOENT ? EXIT_SUCCESS : EXIT_FAILURE);
 	}
 	retcode = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_REPO);

@@ -349,22 +348,22 @@ exec_clean(int argc, char **argv)

 	if (retcode == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to clean old packages");
 		close(cachefd);
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (retcode == EPKG_ENODB) {
 		warnx("No package database installed.  Nothing to do!");
 		close(cachefd);
 		return (EX_OK);
 		return (EXIT_SUCCESS);
 	} else if (retcode != EPKG_OK) {
 		warnx("Error accessing the package database");
 		close(cachefd);
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 	retcode = EX_SOFTWARE;
 	retcode = EXIT_FAILURE;
 	if (pkgdb_open(&db, PKGDB_REMOTE) != EPKG_OK) {
 		close(cachefd);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {

@@ -372,7 +371,7 @@ exec_clean(int argc, char **argv)

 		close(cachefd);
 		warnx("Cannot get a read lock on a database, it is locked by "
 		    "another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 #ifdef HAVE_CAPSICUM

@@ -381,13 +380,13 @@ exec_clean(int argc, char **argv)

 		if (cap_rights_limit(cachefd, &rights) < 0 && errno != ENOSYS ) {
 			warn("cap_rights_limit() failed");
 			close(cachefd);
 			return (EX_SOFTWARE);
 			return (EXIT_FAILURE);
 		}
 		if (cap_enter() < 0 && errno != ENOSYS) {
 			warn("cap_enter() failed");
 			close(cachefd);
 			return (EX_SOFTWARE);
 			return (EXIT_FAILURE);
 		}
 #endif

@@ -406,7 +405,7 @@ exec_clean(int argc, char **argv)

 	if (kv_size(dl) == 0) {
 		if (!quiet)
 			printf("Nothing to do.\n");
 		retcode = EX_OK;
 		retcode = EXIT_SUCCESS;
 		goto cleanup;
 	}

@@ -421,7 +420,7 @@ exec_clean(int argc, char **argv)

 				retcode = delete_dellist(cachefd, cachedir, &dl, kv_size(dl));
 			}
 	} else {
 		retcode = EX_OK;
 		retcode = EXIT_SUCCESS;
 	}
 cleanup:

modified src/config.c

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

 #include <err.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <sysexits.h>
 #include <pkg.h>

@@ -55,7 +54,7 @@ exec_config(int argc, char **argv)

 	if (argc != 2) {
 		usage_config();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	key = argv[1];

@@ -65,7 +64,7 @@ exec_config(int argc, char **argv)

 	conf = pkg_config_get(key);
 	if (conf == NULL) {
 		warnx("No such configuration options: %s", key);
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 	switch (pkg_object_type(conf)) {

@@ -95,5 +94,5 @@ exec_config(int argc, char **argv)

 		break;
 	}
 	return (EX_OK);
 	return (EXIT_SUCCESS);
 }

modified src/create.c

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

 #include <strings.h>
 #include <unistd.h>
 #include <utlist.h>
 #include <sysexits.h>
 #include "pkgcli.h"

@@ -92,13 +91,13 @@ pkg_create_matches(int argc, char **argv, match_t match, struct pkg_create *pc)

 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
 		pkgdb_close(db);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	/* XXX: get rid of hardcoded timeouts */
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	for (i = 0; i < argc || match == MATCH_ALL; i++) {

@@ -241,7 +240,7 @@ exec_create(int argc, char **argv)

 				break;
 			}
 			warnx("Invalid compression level %s", optarg);
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 			}
 		case 'm':
 			metadatadir = optarg;

@@ -269,7 +268,7 @@ exec_create(int argc, char **argv)

 			ts = (time_t)strtoimax(optarg, &endptr, 10);
 			if (*endptr != '\0') {
 				warnx("Invalid timestamp %s", optarg);
 				return (EX_USAGE);
 				return (EXIT_FAILURE);
 			}
 			break;
 		case 'v':

@@ -280,7 +279,7 @@ exec_create(int argc, char **argv)

 			break;
 		default:
 			usage_create();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	argc -= optind;

@@ -289,14 +288,14 @@ exec_create(int argc, char **argv)

 	if (match != MATCH_ALL && metadatadir == NULL && manifest == NULL &&
 	    argc == 0) {
 		usage_create();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (metadatadir == NULL && manifest == NULL && rootdir != NULL) {
 		warnx("Do not specify a rootdir without also specifying "
 		    "either a metadatadir or manifest");
 		usage_create();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (outdir == NULL)

@@ -317,7 +316,7 @@ exec_create(int argc, char **argv)

 		pkg_create_set_timestamp(pc, ts);
 	if (metadatadir == NULL && manifest == NULL)
 		return (pkg_create_matches(argc, argv, match, pc) == EPKG_OK ? EX_OK : EX_SOFTWARE);
 		return (pkg_create_matches(argc, argv, match, pc) == EPKG_OK ? EXIT_SUCCESS : EXIT_FAILURE);
 	ret = pkg_create(pc, metadatadir != NULL ? metadatadir : manifest, plist,
 	    hash);
 	if (ret == EPKG_EXIST || ret == EPKG_OK)

modified src/delete.c

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

 #include <getopt.h>
 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -55,7 +54,7 @@ exec_delete(int argc, char **argv)

 	match_t		 match = MATCH_EXACT;
 	pkg_flags	 f = PKG_FLAG_NONE;
 	bool		 recursive_flag = false, rc = false;
 	int		 retcode = EX_SOFTWARE;
 	int		 retcode = EXIT_FAILURE;
 	int		 ch;
 	int		 i;
 	int		 lock_type = PKGDB_LOCK_ADVISORY;

@@ -118,7 +117,7 @@ exec_delete(int argc, char **argv)

 			break;
 		default:
 			usage_delete();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -127,7 +126,7 @@ exec_delete(int argc, char **argv)

 	if (argc < 1 && match != MATCH_ALL) {
 		usage_delete();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (dry_run)

@@ -138,28 +137,28 @@ exec_delete(int argc, char **argv)

 	if (retcode == EPKG_ENODB) {
 		warnx("No packages installed.  Nothing to do!");
 		return (EX_OK);
 		return (EXIT_SUCCESS);
 	} else if (retcode == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to delete packages");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (retcode != EPKG_OK) {
 		warnx("Error accessing the package database");
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (pkgdb_obtain_lock(db, lock_type) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an advisory lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if (pkg_jobs_new(&jobs, PKG_JOBS_DEINSTALL, db) != EPKG_OK) {
 		pkgdb_close(db);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	/*

@@ -187,7 +186,7 @@ exec_delete(int argc, char **argv)

 	if (pkg_jobs_solve(jobs) != EPKG_OK) {
 		fprintf(stderr, "Cannot perform request\n");
 		retcode = EX_NOPERM;
 		retcode = EXIT_FAILURE;
 		goto cleanup;
 	}

@@ -204,7 +203,7 @@ exec_delete(int argc, char **argv)

 			if (!quiet)
 				printf("Nothing to do.\n");
 			retcode = EX_OK;
 			retcode = EXIT_SUCCESS;
 			goto cleanup;
 		}
 		if (!quiet) {

@@ -215,7 +214,7 @@ exec_delete(int argc, char **argv)

 		if (locked_pkgs > 0) {
 			retcode = EPKG_LOCKED;
 		} else {
 			retcode = EX_DATAERR;
 			retcode = EXIT_FAILURE;
 		}
 		goto cleanup;
 	}

@@ -228,7 +227,7 @@ exec_delete(int argc, char **argv)

 				pkg_jobs_total(jobs));
 		}
 		if (dry_run) {
 			retcode = EX_OK;
 			retcode = EXIT_SUCCESS;
 			goto cleanup;
 		}
 		rc = query_yesno(false,

@@ -247,7 +246,7 @@ exec_delete(int argc, char **argv)

 	pkgdb_compact(db);
 	if (rc)
 		retcode = EX_OK;
 		retcode = EXIT_SUCCESS;
 	else
 		retcode = EXIT_FAILURE;

modified src/fetch.c

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

 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -60,7 +59,7 @@ exec_fetch(int argc, char **argv)

 	const char	*reponame = NULL;
 	const char *destdir = NULL;
 	int		 ch;
 	int		 retcode = EX_SOFTWARE;
 	int		 retcode = EXIT_FAILURE;
 	bool		 upgrades_for_installed = false, rc, csum_only = false;
 	unsigned	 mode;
 	match_t		 match = MATCH_EXACT;

@@ -124,7 +123,7 @@ exec_fetch(int argc, char **argv)

 			break;
 		default:
 			usage_fetch();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	argc -= optind;

@@ -132,12 +131,12 @@ exec_fetch(int argc, char **argv)

 	if (argc < 1 && match != MATCH_ALL && !upgrades_for_installed) {
 		usage_fetch();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
         if (match == MATCH_ALL && upgrades_for_installed) {
 		usage_fetch();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (auto_update)

@@ -149,18 +148,18 @@ exec_fetch(int argc, char **argv)

 	if (retcode == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to access repo catalogue");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (retcode != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (upgrades_for_installed) {
 		retcode = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL);
 		if (retcode == EPKG_ENOACCESS) {
 			warnx("Insufficient privileges to access the package database");
 			return (EX_NOPERM);
 			return (EXIT_FAILURE);
 		} else if (retcode != EPKG_OK)
 			return (EX_IOERR);
 			return (EXIT_FAILURE);
 	}
 	/* first update the remote repositories if needed */

@@ -169,12 +168,12 @@ exec_fetch(int argc, char **argv)

 		return (retcode);
 	if (pkgdb_open_all(&db, PKGDB_REMOTE, reponame) != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}

@@ -224,7 +223,7 @@ exec_fetch(int argc, char **argv)

 	if (csum_only && !quiet)
 		printf("Integrity check was successful.\n");
 	retcode = EX_OK;
 	retcode = EXIT_SUCCESS;
 cleanup:
 	pkg_jobs_free(jobs);

modified src/info.c

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

 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include "pkgcli.h"

@@ -215,13 +214,13 @@ exec_info(int argc, char **argv)

 			else if (strcasecmp(optarg, "ucl") == 0)
 				opt |= INFO_RAW_UCL;
 			else
 				errx(EX_USAGE, "Invalid format '%s' for the "
 				errx(EXIT_FAILURE, "Invalid format '%s' for the "
 				    "raw output, expecting json, json-compact "
 				    "or yaml", optarg);
 			break;
 		default:
 			usage_info();
 			return(EX_USAGE);
 			return(EXIT_FAILURE);
 		}
 	}

@@ -234,9 +233,9 @@ exec_info(int argc, char **argv)

 	if (argc == 0 && file == NULL && match != MATCH_ALL) {
 		/* which -O bsd.*.mk always execpt clean output */
 		if (origin_search)
 			return (EX_OK);
 			return (EXIT_SUCCESS);
 		usage_info();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	/* When no other data is requested, default is to print

@@ -266,7 +265,7 @@ exec_info(int argc, char **argv)

 	if (file != NULL) {
 		if ((fd = open(file, O_RDONLY)) == -1) {
 			warn("Unable to open %s", file);
 			return (EX_IOERR);
 			return (EXIT_FAILURE);
 		}
 		drop_privileges();

@@ -275,13 +274,13 @@ exec_info(int argc, char **argv)

 		if (cap_rights_limit(fd, &rights) < 0 && errno != ENOSYS ) {
 			warn("cap_rights_limit() failed");
 			close(fd);
 			return (EX_SOFTWARE);
 			return (EXIT_FAILURE);
 		}
 		if (cap_enter() < 0 && errno != ENOSYS) {
 			warn("cap_enter() failed");
 			close(fd);
 			return (EX_SOFTWARE);
 			return (EXIT_FAILURE);
 		}
 #endif
 		if (opt == INFO_TAG_NAMEVER)

@@ -300,32 +299,32 @@ exec_info(int argc, char **argv)

 		print_info(pkg, opt);
 		close(fd);
 		pkg_free(pkg);
 		return (EX_OK);
 		return (EXIT_SUCCESS);
 	}
 	ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL);
 	if (ret == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to query the package database");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (ret == EPKG_ENODB) {
 		if (match == MATCH_ALL)
 			return (EX_OK);
 			return (EXIT_SUCCESS);
 		if (origin_search)
 			return (EX_OK);
 			return (EXIT_SUCCESS);
 		if (!quiet)
 			warnx("No packages installed");
 		return (EX_UNAVAILABLE);
 		return (EXIT_FAILURE);
 	} else if (ret != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	ret = pkgdb_open(&db, PKGDB_DEFAULT);
 	if (ret != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	drop_privileges();
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	i = 0;

@@ -500,18 +499,18 @@ exec_info(int argc, char **argv)

 				}
 			}
 			if (pkg_exists)
 				retcode = EX_OK;
 				retcode = EXIT_SUCCESS;
 			else
 				print_info(pkg, opt);
 		}
 		if (ret != EPKG_END) {
 			retcode = EX_IOERR;
 			retcode = EXIT_FAILURE;
 		}
 		if (retcode == EX_OK && !gotone && match != MATCH_ALL) {
 		if (retcode == EXIT_SUCCESS && !gotone && match != MATCH_ALL) {
 			if (!quiet)
 				warnx("No package(s) matching %s", argv[i]);
 			retcode = EX_SOFTWARE;
 			retcode = EXIT_FAILURE;
 		}
 		pkgdb_it_free(it);

modified src/install.c

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

 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -154,7 +153,7 @@ exec_install(int argc, char **argv)

 			break;
 		default:
 			usage_install();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	argc -= optind;

@@ -162,7 +161,7 @@ exec_install(int argc, char **argv)

 	if (argc < 1) {
 		usage_install();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (dry_run && !auto_update)

@@ -186,11 +185,11 @@ exec_install(int argc, char **argv)

 	if (retcode == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to install packages");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (retcode != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	else
 		retcode = EX_SOFTWARE;
 		retcode = EXIT_FAILURE;
 	/* first update the remote repositories if needed */
 	if (auto_update && pkg_repos_total_count() > 0 &&

@@ -200,12 +199,12 @@ exec_install(int argc, char **argv)

 	if (pkgdb_open_all(&db,
 	    local_only ? PKGDB_DEFAULT : PKGDB_MAYBE_REMOTE,
 	    reponame) != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (pkgdb_obtain_lock(db, lock_type) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an advisory lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if (pkg_jobs_new(&jobs, PKG_JOBS_INSTALL, db) != EPKG_OK)

@@ -264,7 +263,7 @@ exec_install(int argc, char **argv)

 		printf("The most recent versions of packages are already installed\n");
 	if (rc)
 		retcode = EX_OK;
 		retcode = EXIT_SUCCESS;
 	else
 		retcode = EXIT_FAILURE;

modified src/lock.c

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

 #include <getopt.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -101,17 +100,17 @@ do_lock_unlock(struct pkgdb *db, int match, const char *pkgname,

 	struct pkgdb_it	*it = NULL;
 	struct pkg	*pkg = NULL;
 	int		 retcode;
 	int		 exitcode = EX_OK;
 	int		 exitcode = EXIT_SUCCESS;
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an exclusive lock on database. "
 		      "It is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if ((it = pkgdb_query(db, pkgname, match)) == NULL) {
 		exitcode = EX_IOERR;
 		exitcode = EXIT_FAILURE;
 		goto cleanup;
 	}

@@ -122,7 +121,7 @@ do_lock_unlock(struct pkgdb *db, int match, const char *pkgname,

 			retcode = do_unlock(db, pkg);
 		if (retcode != EPKG_OK) {
 			exitcode = EX_IOERR;
 			exitcode = EXIT_FAILURE;
 			goto cleanup;
 		}
 	}

@@ -157,7 +156,7 @@ list_locked(struct pkgdb *db, bool has_locked)

 	if ((it = pkgdb_query(db, " where locked=1", MATCH_CONDITION)) == NULL) {
 		pkgdb_close(db);
 		return (EX_UNAVAILABLE);
 		return (EXIT_FAILURE);
 	}
 	if (!quiet && !has_locked)

@@ -176,7 +175,7 @@ list_locked(struct pkgdb *db, bool has_locked)

 	if (has_locked)
 		return (gotone ? EXIT_SUCCESS : EXIT_FAILURE);
 	return (EX_OK);
 	return (EXIT_SUCCESS);
 }
 static int

@@ -185,7 +184,7 @@ exec_lock_unlock(int argc, char **argv, enum action action)

 	struct pkgdb	*db = NULL;
 	int		 match = MATCH_EXACT;
 	int		 retcode, i;
 	int		 exitcode = EX_OK;
 	int		 exitcode = EXIT_SUCCESS;
 	int		 ch;
 	bool		 show_locked = false;
 	bool		 read_only = false;

@@ -235,7 +234,7 @@ exec_lock_unlock(int argc, char **argv, enum action action)

 			break;
 		default:
 			usage_lock();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
         }
 	argc -= optind;

@@ -251,7 +250,7 @@ exec_lock_unlock(int argc, char **argv, enum action action)

 	if (!show_locked && match != MATCH_ALL && argc == 0) {
 		usage_lock();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (read_only)

@@ -261,21 +260,21 @@ exec_lock_unlock(int argc, char **argv, enum action action)

 			       PKGDB_DB_LOCAL);
 	if (retcode == EPKG_ENODB) {
 		if (match == MATCH_ALL)
 			return (EX_OK);
 			return (EXIT_SUCCESS);
 		if (!quiet)
 			warnx("No packages installed.  Nothing to do!");
 		return (EX_OK);
 		return (EXIT_SUCCESS);
 	} else if (retcode == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to modify the package database");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (retcode != EPKG_OK) {
 		warnx("Error accessing the package database");
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 	retcode = pkgdb_open(&db, PKGDB_DEFAULT);
 	if (retcode != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (!read_only) {
 		if (match == MATCH_ALL) {

@@ -283,7 +282,7 @@ exec_lock_unlock(int argc, char **argv, enum action action)

 		} else {
 			for (i = 0; i < argc; i++) {
 				retcode = do_lock_unlock(db, match, argv[i], action);
 				if (retcode != EX_OK)
 				if (retcode != EXIT_SUCCESS)
 					exitcode = retcode;
 			}
 		}

@@ -294,5 +293,5 @@ exec_lock_unlock(int argc, char **argv, enum action action)

 	pkgdb_close(db);
 	return (exitcode);
 	return (exitcode == EPKG_OK ? EXIT_SUCCESS : EXIT_FAILURE);
 }

modified src/main.c

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

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <utlist.h>
 #include <unistd.h>
 #ifdef HAVE_LIBJAIL

@@ -197,13 +196,13 @@ usage(const char *conffile, const char *reposdir, FILE *out, enum pkg_usage_reas

 			fprintf(out, "\t%-15s%s\n", cmd[i].name, cmd[i].desc);
 		if (!pkg_initialized() && pkg_ini(conffile, reposdir, 0) != EPKG_OK)
 			errx(EX_SOFTWARE, "Cannot parse configuration file!");
 			errx(EXIT_FAILURE, "Cannot parse configuration file!");
 		plugins_enabled = pkg_object_bool(pkg_config_get("PKG_ENABLE_PLUGINS"));
 		if (plugins_enabled) {
 			if (pkg_plugins_init() != EPKG_OK)
 				errx(EX_SOFTWARE, "Plugins cannot be loaded");
 				errx(EXIT_FAILURE, "Plugins cannot be loaded");
 			fprintf(out, "\nCommands provided by plugins:\n");

@@ -218,7 +217,7 @@ usage(const char *conffile, const char *reposdir, FILE *out, enum pkg_usage_reas

 out:
 	fprintf(out, "\nFor more information on available commands and options see 'pkg help'.\n");
 	exit(EX_USAGE);
 	exit(EXIT_FAILURE);
 }
 static void

@@ -240,13 +239,13 @@ exec_help(int argc, char **argv)

 	if ((argc != 2) || (strcmp("help", argv[1]) == 0)) {
 		usage_help();
 		return(EX_USAGE);
 		return(EXIT_FAILURE);
 	}
 	for (i = 0; i < cmd_len; i++) {
 		if (strcmp(cmd[i].name, argv[1]) == 0) {
 			if (asprintf(&manpage, "/usr/bin/man pkg-%s", cmd[i].name) == -1)
 				errx(EX_SOFTWARE, "cannot allocate memory");
 				errx(EXIT_FAILURE, "cannot allocate memory");
 			system(manpage);
 			free(manpage);

@@ -261,7 +260,7 @@ exec_help(int argc, char **argv)

 		DL_FOREACH(plugins, c) {
 			if (strcmp(c->name, argv[1]) == 0) {
 				if (asprintf(&manpage, "/usr/bin/man pkg-%s", c->name) == -1)
 					errx(EX_SOFTWARE, "cannot allocate memory");
 					errx(EXIT_FAILURE, "cannot allocate memory");
 				system(manpage);
 				free(manpage);

@@ -293,7 +292,7 @@ exec_help(int argc, char **argv)

 	fprintf(stderr, "See 'pkg help' for more information on the commands.\n");
 	return (EX_USAGE);
 	return (EXIT_FAILURE);
 }
 static void

@@ -383,13 +382,13 @@ show_version_info(int version)

 	printf(PKG_PORTVERSION""GITHASH"\n");
 	if (version == 1)
 		exit(EX_OK);
 		exit(EXIT_SUCCESS);
 	printf("%s\n", pkg_config_dump());
 	show_plugin_info();
 	show_repository_info();
 	exit(EX_OK);
 	exit(EXIT_SUCCESS);
 	/* NOTREACHED */
 }

@@ -406,19 +405,19 @@ do_activation_test(int argc)

 	switch (pkg_status(&count)) {
 	case PKG_STATUS_UNINSTALLED: /* This case shouldn't ever happen... */
 		errx(EX_UNAVAILABLE, "can't execute " PKG_EXEC_NAME
 		errx(EXIT_FAILURE, "can't execute " PKG_EXEC_NAME
 		    " or " PKG_STATIC_NAME "\n");
 		/* NOTREACHED */
 	case PKG_STATUS_NODB:
 		errx(EX_UNAVAILABLE, "package database non-existent");
 		errx(EXIT_FAILURE, "package database non-existent");
 		/* NOTREACHED */
 	case PKG_STATUS_NOPACKAGES:
 		errx(EX_UNAVAILABLE, "no packages registered");
 		errx(EXIT_FAILURE, "no packages registered");
 		/* NOTREACHED */
 	case PKG_STATUS_ACTIVE:
 		if (argc == 0) {
 			warnx("%d packages installed", count);
 			exit(EX_OK);
 			exit(EXIT_SUCCESS);
 		}
 		break;
 	}

@@ -450,7 +449,7 @@ export_arg_option (char *arg)

 static void
 start_process_worker(char *const *save_argv)
 {
 	int	ret = EX_OK;
 	int	ret = EXIT_SUCCESS;
 	int	status;
 	pid_t	child_pid;

@@ -471,11 +470,11 @@ start_process_worker(char *const *save_argv)

 			return;
 		} else {
 			if (child_pid == -1)
 				err(EX_OSERR, "Failed to fork worker process");
 				err(EXIT_FAILURE, "Failed to fork worker process");
 			while (waitpid(child_pid, &status, 0) == -1) {
 				if (errno != EINTR)
 					err(EX_OSERR, "Child process pid=%d", (int)child_pid);
 					err(EXIT_FAILURE, "Child process pid=%d", (int)child_pid);
 			}
 			ret = WEXITSTATUS(status);

@@ -537,7 +536,7 @@ expand_aliases(int argc, char ***argv)

 	veclen = sizeof(char *) * (spaces + argc + 1);
 	buf = malloc(veclen + arglen);
 	if (buf == NULL)
 		err(EX_OSERR, "expanding aliases");
 		err(EXIT_FAILURE, "expanding aliases");
 	newargv = (char **) buf;
 	args = (char *) (buf + veclen);

@@ -596,7 +595,7 @@ main(int argc, char **argv)

 	signed char	  ch;
 	int64_t		  debug = 0;
 	int		  version = 0;
 	int		  ret = EX_OK;
 	int		  ret = EXIT_SUCCESS;
 	bool		  plugins_enabled = false;
 	bool		  plugin_found = false;
 	bool		  show_commands = false;

@@ -642,7 +641,7 @@ main(int argc, char **argv)

 	 * line concept. */
 	if (setenv("POSIXLY_CORRECT", "1",  1) == -1)
 		err(EX_SOFTWARE, "setenv() failed");
 		err(EXIT_FAILURE, "setenv() failed");
 	save_argv = argv;

@@ -705,7 +704,7 @@ main(int argc, char **argv)

 	if (show_commands && version == 0) {
 		show_command_names();
 		exit(EX_OK);
 		exit(EXIT_SUCCESS);
 	}
 	if (argc == 0 && version == 0 && !activation_test)

@@ -735,7 +734,7 @@ main(int argc, char **argv)

 	if (chroot_path != NULL) {
 		if (chroot(chroot_path) == -1) {
 			err(EX_SOFTWARE, "chroot failed");
 			err(EXIT_FAILURE, "chroot failed");
 		}
 	}

@@ -751,26 +750,26 @@ main(int argc, char **argv)

 	if (jail_str != NULL || chroot_path != NULL)
 		if (chdir("/") == -1)
 			errx(EX_SOFTWARE, "chdir() failed");
 			errx(EXIT_FAILURE, "chdir() failed");
 #endif
 	if (rootdir != NULL) {
 		if (realpath(rootdir, realrootdir) == NULL)
 			err(EX_SOFTWARE, "Invalid rootdir");
 			err(EXIT_FAILURE, "Invalid rootdir");
 		if (chdir(rootdir) == -1)
 			errx(EX_SOFTWARE, "chdir() failed");
 			errx(EXIT_FAILURE, "chdir() failed");
 		if (pkg_set_rootdir(realrootdir) != EPKG_OK)
 			exit(EX_SOFTWARE);
 			exit(EXIT_FAILURE);
 	}
 	if (pkg_ini(conffile, reposdir, init_flags) != EPKG_OK)
 		errx(EX_SOFTWARE, "Cannot parse configuration file!");
 		errx(EXIT_FAILURE, "Cannot parse configuration file!");
 	if (debug > 0)
 		pkg_set_debug_level(debug);
 	if (atexit(&pkg_shutdown) != 0)
 		errx(EX_SOFTWARE, "register pkg_shutdown() to run at exit");
 		errx(EXIT_FAILURE, "register pkg_shutdown() to run at exit");
 	if (jail_str == NULL && !pkg_compiled_for_same_os_major())
 		warnx("Warning: Major OS version upgrade detected.  Running "

@@ -783,10 +782,10 @@ main(int argc, char **argv)

 		struct pkg_plugin	*p = NULL;
 		if (pkg_plugins_init() != EPKG_OK)
 			errx(EX_SOFTWARE, "Plugins cannot be loaded");
 			errx(EXIT_FAILURE, "Plugins cannot be loaded");
 		if (atexit(&pkg_plugins_shutdown) != 0)
 			errx(EX_SOFTWARE,
 			errx(EXIT_FAILURE,
                             "register pkg_plugins_shutdown() to run at exit");
 		/* load commands plugins */

@@ -891,7 +890,7 @@ main(int argc, char **argv)

 	if (save_argv != argv)
 		free(argv);
 	if (ret == EX_OK && newpkgversion)
 	if (ret == EXIT_SUCCESS && newpkgversion)
 		return (EX_NEEDRESTART);
 	return (ret);

modified src/plugins.c

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

 #include <getopt.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -61,7 +60,7 @@ exec_plugins(int argc, char **argv)

 			break;
 		default:
 			usage_plugins();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -77,5 +76,5 @@ exec_plugins(int argc, char **argv)

 		       pkg_plugin_get(p, PKG_PLUGIN_DESC),
 		       pkg_plugin_get(p, PKG_PLUGIN_VERSION));
 	return (EX_OK);
 	return (EXIT_SUCCESS);
 }

modified src/query.c

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

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -867,7 +866,7 @@ exec_query(int argc, char **argv)

 	match_t			 match = MATCH_EXACT;
 	int			 ch;
 	int			 ret;
 	int			 retcode = EX_OK;
 	int			 retcode = EXIT_SUCCESS;
 	int			 i;
 	char			 multiline = 0;
 	char			*condition = NULL;

@@ -911,7 +910,7 @@ exec_query(int argc, char **argv)

 			break;
 		default:
 			usage_query();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -920,7 +919,7 @@ exec_query(int argc, char **argv)

 	if (argc == 0) {
 		usage_query();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	/* Default to all packages if no pkg provided */

@@ -929,12 +928,12 @@ exec_query(int argc, char **argv)

 	} else if (((argc == 1) ^ (match == MATCH_ALL)) && pkgname == NULL
 			&& condition == NULL) {
 		usage_query();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (analyse_query_string(argv[0], accepted_query_flags, q_flags_len,
 			&query_flags, &multiline) != EPKG_OK)
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	if (pkgname != NULL) {
 		/* Use a manifest or compact manifest if possible. */

@@ -957,43 +956,43 @@ exec_query(int argc, char **argv)

 		}
 		pkg_manifest_keys_new(&keys);
 		if (pkg_open(&pkg, pkgname, keys, open_flags) != EPKG_OK) {
 			return (EX_IOERR);
 			return (EXIT_FAILURE);
 		}
 		pkg_manifest_keys_free(keys);
 		print_query(pkg, argv[0], multiline);
 		pkg_free(pkg);
 		return (EX_OK);
 		return (EXIT_SUCCESS);
 	}
 	if (condition != NULL) {
 		sqlcond = xstring_new();
 		if (format_sql_condition(condition, sqlcond, false) != EPKG_OK) {
 			xstring_free(sqlcond);
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL);
 	if (ret == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to query the package database");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (ret == EPKG_ENODB) {
 		if (!quiet)
 			warnx("No packages installed");
 		return (EX_OK);
 		return (EXIT_SUCCESS);
 	} else if (ret != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	ret = pkgdb_open(&db, PKGDB_DEFAULT);
 	if (ret != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	drop_privileges();
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if (match == MATCH_ALL || match == MATCH_CONDITION) {

@@ -1003,13 +1002,13 @@ exec_query(int argc, char **argv)

 			condition_sql = sqlcond->buf;
 		}
 		if ((it = pkgdb_query(db, condition_sql, match)) == NULL)
 			return (EX_IOERR);
 			return (EXIT_FAILURE);
 		while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK)
 			print_query(pkg, argv[0],  multiline);
 		if (ret != EPKG_END)
 			retcode = EX_SOFTWARE;
 			retcode = EXIT_FAILURE;
 		pkgdb_it_free(it);
 	} else {

@@ -1018,7 +1017,7 @@ exec_query(int argc, char **argv)

 			pkgname = argv[i];
 			if ((it = pkgdb_query(db, pkgname, match)) == NULL) {
 				retcode = EX_IOERR;
 				retcode = EXIT_FAILURE;
 				goto cleanup;
 			}

@@ -1028,16 +1027,16 @@ exec_query(int argc, char **argv)

 			}
 			if (ret != EPKG_END) {
 				retcode = EX_SOFTWARE;
 				retcode = EXIT_FAILURE;
 				break;
 			}
 			pkgdb_it_free(it);
 		}
 		if (nprinted == 0 && retcode == EX_OK) {
 		if (nprinted == 0 && retcode == EXIT_SUCCESS) {
 			/* ensure to return a non-zero status when no package
 			 were found. */
 			retcode = EX_UNAVAILABLE;
 			retcode = EXIT_FAILURE;
 		}
 	}

modified src/register.c

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

 #include <err.h>
 #include <stdio.h>
 #include <pkg.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdbool.h>

@@ -67,7 +66,7 @@ exec_register(int argc, char **argv)

 	int		 ch;
 	int		 ret     = EPKG_OK;
 	int		 retcode = EX_OK;
 	int		 retcode = EXIT_SUCCESS;
 	/* options descriptor */
 	struct option longopts[] = {

@@ -84,7 +83,7 @@ exec_register(int argc, char **argv)

 	};
 	if (pkg_new(&pkg, PKG_INSTALLED) != EPKG_OK)
 		err(EX_OSERR, "malloc");
 		err(EXIT_FAILURE, "malloc");
 	while ((ch = getopt_long(argc, argv, "+Adf:i:lM:m:t", longopts, NULL)) != -1) {
 		switch (ch) {

@@ -117,7 +116,7 @@ exec_register(int argc, char **argv)

 			warnx("Unrecognised option -%c\n", ch);
 			usage_register();
 			pkg_free(pkg);
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -128,10 +127,10 @@ exec_register(int argc, char **argv)

 	if (retcode == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to register packages");
 		pkg_free(pkg);
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (retcode != EPKG_OK) {
 		pkg_free(pkg);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	/*

@@ -155,7 +154,7 @@ exec_register(int argc, char **argv)

 		warnx("Cannot use both -m and -M together");
 		usage_register();
 		pkg_free(pkg);
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}

@@ -163,33 +162,33 @@ exec_register(int argc, char **argv)

 		warnx("One of either -m or -M flags is required");
 		usage_register();
 		pkg_free(pkg);
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (testing_mode && input_path != NULL) {
 		warnx("-i incompatible with -t option");
 		usage_register();
 		pkg_free(pkg);
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	ret = pkg_load_metadata(pkg, mfile, mdir, plist, input_path, testing_mode);
 	if (ret != EPKG_OK) {
 		pkg_free(pkg);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
 		pkg_free(pkg);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
 		pkgdb_close(db);
 		pkg_free(pkg);
 		warnx("Cannot get an exclusive lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	retcode = pkg_add_port(db, pkg, input_path, location, testing_mode);

@@ -202,5 +201,5 @@ exec_register(int argc, char **argv)

 	pkg_free(pkg);
 	pkgdb_release_lock(db, PKGDB_LOCK_EXCLUSIVE);
 	return (retcode != EPKG_OK ? EX_SOFTWARE : EX_OK);
 	return (retcode != EPKG_OK ? EXIT_FAILURE : EXIT_SUCCESS);
 }

modified src/repo.c

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

 #include <bsd_compat.h>
 #include <getopt.h>
 #include <signal.h>
 #include <sysexits.h>
 #include <stdio.h>
 #include <string.h>

@@ -134,7 +133,7 @@ exec_repo(int argc, char **argv)

 			break;
 		default:
 			usage_repo();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	argc -= optind;

@@ -142,12 +141,12 @@ exec_repo(int argc, char **argv)

 	if (argc < 1) {
 		usage_repo();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (argc > 2 && strcmp(argv[1], "signing_command:") != 0) {
 		usage_repo();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (output_dir == NULL)

@@ -158,12 +157,12 @@ exec_repo(int argc, char **argv)

 	if (ret != EPKG_OK) {
 		printf("Cannot create repository catalogue\n");
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	if (pkg_finish_repo(output_dir, password_cb, argv + 1, argc - 1,
 	    filelist) != EPKG_OK)
 		return (EX_DATAERR);
 		return (EXIT_FAILURE);
 	return (EX_OK);
 	return (EXIT_SUCCESS);
 }

modified src/rquery.c

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

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include "pkgcli.h"

@@ -111,7 +110,7 @@ exec_rquery(int argc, char **argv)

 	match_t			 match = MATCH_EXACT;
 	int			 ch;
 	int			 ret = EPKG_OK;
 	int			 retcode = EX_OK;
 	int			 retcode = EXIT_SUCCESS;
 	int			 i;
 	char			 multiline = 0;
 	char			*condition = NULL;

@@ -170,7 +169,7 @@ exec_rquery(int argc, char **argv)

 			break;
 		default:
 			usage_rquery();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -179,7 +178,7 @@ exec_rquery(int argc, char **argv)

 	if (argc == 0 && !index_output) {
 		usage_rquery();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	/* Default to all packages if no pkg provided */

@@ -188,7 +187,7 @@ exec_rquery(int argc, char **argv)

 			match = MATCH_ALL;
 		} else if (((argc == 1) ^ (match == MATCH_ALL )) && condition == NULL) {
 			usage_rquery();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	} else {
 		if (argc == 0)

@@ -196,13 +195,13 @@ exec_rquery(int argc, char **argv)

 	}
 	if (!index_output && analyse_query_string(argv[0], accepted_rquery_flags, q_flags_len, &query_flags, &multiline) != EPKG_OK)
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	if (condition != NULL) {
 		sqlcond = xstring_new();
 		if (format_sql_condition(condition, sqlcond, true) != EPKG_OK) {
 			xstring_free(sqlcond);
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -210,10 +209,10 @@ exec_rquery(int argc, char **argv)

 	if (ret == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to query the package database");
 		xstring_free(sqlcond);
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (ret != EPKG_OK) {
 		xstring_free(sqlcond);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	/* first update the remote repositories if needed */

@@ -228,7 +227,7 @@ exec_rquery(int argc, char **argv)

 	ret = pkgdb_open_all(&db, PKGDB_REMOTE, reponame);
 	if (ret != EPKG_OK) {
 		xstring_free(sqlcond);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	drop_privileges();

@@ -243,7 +242,7 @@ exec_rquery(int argc, char **argv)

 		}
 		if ((it = pkgdb_repo_query(db, condition_sql, match, reponame)) == NULL) {
 			xstring_free(sqlcond);
 			return (EX_IOERR);
 			return (EXIT_FAILURE);
 		}
 		while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {

@@ -254,7 +253,7 @@ exec_rquery(int argc, char **argv)

 		}
 		if (ret != EPKG_END)
 			retcode = EX_SOFTWARE;
 			retcode = EXIT_FAILURE;
 		pkgdb_it_free(it);
 	} else {

@@ -263,7 +262,7 @@ exec_rquery(int argc, char **argv)

 			if ((it = pkgdb_repo_query(db, pkgname, match, reponame)) == NULL) {
 				xstring_free(sqlcond);
 				return (EX_IOERR);
 				return (EXIT_FAILURE);
 			}
 			while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {

@@ -275,14 +274,14 @@ exec_rquery(int argc, char **argv)

 			}
 			if (ret != EPKG_END) {
 				retcode = EX_SOFTWARE;
 				retcode = EXIT_FAILURE;
 				break;
 			}
 			pkgdb_it_free(it);
 		}
 		if (!onematched && retcode == EX_OK)
 			retcode = EX_UNAVAILABLE;
 		if (!onematched && retcode == EXIT_SUCCESS)
 			retcode = EXIT_FAILURE;
 	}
 	xstring_free(sqlcond);

modified src/search.c

@@ -34,8 +34,6 @@

 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sysexits.h>
 #include <pkg.h>

@@ -131,7 +129,7 @@ search_label_opt(const char *optionarg)

 		break;
 	default:
 		usage_search();
 		errx(EX_USAGE, "Unknown search/label option: %s", optionarg);
 		errx(EXIT_FAILURE, "Unknown search/label option: %s", optionarg);
 		/* NOTREACHED */
 	}
 	return field;

@@ -209,7 +207,7 @@ modifier_opt(const char *optionarg)

 		break;
 	default:
 		usage_search();
 		errx(EX_USAGE, "Unkown modifier option %s", optionarg);
 		errx(EXIT_FAILURE, "Unkown modifier option %s", optionarg);
 		/* NOTREACHED */
 	}
 	return opt;

@@ -351,13 +349,13 @@ exec_search(int argc, char **argv)

 			else if (strcasecmp(optarg, "ucl") == 0)
 				opt |= INFO_RAW_UCL;
 			else
 				errx(EX_USAGE, "Invalid format '%s' for the "
 				errx(EXIT_FAILURE, "Invalid format '%s' for the "
 				    "raw output, expecting json, json-compact "
 				    "or yaml", optarg);
 			break;
 		default:
 			usage_search();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -366,13 +364,13 @@ exec_search(int argc, char **argv)

 	if (argc != 1) {
 		usage_search();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	pattern = argv[0];
 	if (pattern[0] == '\0') {
 		fprintf(stderr, "Pattern must not be empty.\n");
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (search == FIELD_NONE) {
 		if (strchr(pattern, '/') != NULL)

@@ -412,17 +410,17 @@ exec_search(int argc, char **argv)

 	switch(ret) {
 	case EPKG_ENOACCESS:
 		warnx("Insufficient privileges to query the package database");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	case EPKG_ENODB:
 		if (!auto_update) {
 			warnx("Unable to open remote repository catalogues. Try running '%s update' first.", getprogname());
 			return (EX_IOERR);
 			return (EXIT_FAILURE);
 		}
 		break;
 	case EPKG_OK:
 		break;
 	default:
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	/* first update the remote repositories if needed */

@@ -433,12 +431,12 @@ exec_search(int argc, char **argv)

 	quiet = old_quiet;
 	if (pkgdb_open_all(&db, PKGDB_REMOTE, reponame) != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if ((it = pkgdb_repo_search(db, pattern, match, search, search,
 	    reponame)) == NULL) {
 		pkgdb_close(db);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	if (opt & INFO_RAW) {

@@ -459,5 +457,5 @@ exec_search(int argc, char **argv)

 	if (!atleastone)
 		ret = EPKG_FATAL;
 	return ((ret == EPKG_OK || ret == EPKG_END) ? EX_OK : EX_SOFTWARE);
 	return ((ret == EPKG_OK || ret == EPKG_END) ? EXIT_SUCCESS : EXIT_FAILURE);
 }

modified src/set.c

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

 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -130,7 +129,7 @@ exec_set(int argc, char **argv)

 			sets |= AUTOMATIC;
 			newautomatic = optarg[0] - '0';
 			if (newautomatic != 0 && newautomatic != 1)
 				errx(EX_USAGE, "Wrong value for -A. "
 				errx(EXIT_FAILURE, "Wrong value for -A. "
 				    "Expecting 0 or 1, got: %s",
 				    optarg);
 			break;

@@ -152,7 +151,7 @@ exec_set(int argc, char **argv)

 			match = MATCH_ALL;
 			changed = "origin";
 			if (!check_change_values(optarg, &oldvalue, &newvalue, '/')) {
 				 errx(EX_USAGE, "Wrong format for -o. "
 				 errx(EXIT_FAILURE, "Wrong format for -o. "
 					 "Expecting oldorigin:neworigin, got: %s",
 					 optarg);
 			}

@@ -163,7 +162,7 @@ exec_set(int argc, char **argv)

 			match = MATCH_ALL;
 			changed = "name";
 			if (!check_change_values(optarg, &oldvalue, &newvalue, '\0')) {
 				 errx(EX_USAGE, "Wrong format for -n. "
 				 errx(EXIT_FAILURE, "Wrong format for -n. "
 					 "Expecting oldname:newname, got: %s",
 					 optarg);
 			}

@@ -175,7 +174,7 @@ exec_set(int argc, char **argv)

 			sets |= VITAL;
 			newvital = optarg[0] - '0';
 			if (newvital != 0 && newvital != 1)
 				errx(EX_USAGE, "Wrong value for -v. "
 				errx(EXIT_FAILURE, "Wrong value for -v. "
 				    "Expecting 0 or 1, got: %s",
 				    optarg);
 			break;

@@ -186,7 +185,7 @@ exec_set(int argc, char **argv)

 			free(oldvalue);
 			free(newvalue);
 			usage_set();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -198,7 +197,7 @@ exec_set(int argc, char **argv)

 		(sets & (NAME|ORIGIN)) == (NAME|ORIGIN)) {
 		free(newvalue);
 		usage_set();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (sets & NAME) {

@@ -215,44 +214,44 @@ exec_set(int argc, char **argv)

 	if (retcode == EPKG_ENODB) {
 		free(newvalue);
 		if (match == MATCH_ALL)
 			return (EX_OK);
 			return (EXIT_SUCCESS);
 		if (!quiet)
 			warnx("No packages installed.  Nothing to do!");
 		return (EX_OK);
 		return (EXIT_SUCCESS);
 	} else if (retcode == EPKG_ENOACCESS) {
 		free(newvalue);
 		warnx("Insufficient privileges to modify the package database");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (retcode != EPKG_OK) {
 		warnx("Error accessing package database");
 		free(newvalue);
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
 		free(newvalue);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
 		pkgdb_close(db);
 		free(newvalue);
 		warnx("Cannot get an exclusive lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_transaction_begin(db, NULL) != EPKG_OK) {
 		pkgdb_close(db);
 		free(newvalue);
 		warnx("Cannot start transaction for update");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if (oldvalue != NULL) {
 		match = MATCH_ALL;
 		if ((it = pkgdb_query(db, oldvalue, MATCH_EXACT)) == NULL) {
 			retcode = EX_IOERR;
 			retcode = EXIT_FAILURE;
 			goto cleanup;
 		}

@@ -262,7 +261,7 @@ exec_set(int argc, char **argv)

 			free(oldorigin);
 			pkgdb_it_free(it);
 			pkgdb_close(db);
 			return (EX_SOFTWARE);*/
 			return (EXIT_FAILURE);*/
 		}
 		rc = yes;

@@ -276,7 +275,7 @@ exec_set(int argc, char **argv)

 		}
 		if (pkg != NULL && rc) {
 			if (pkgdb_set(db, pkg, field, newvalue) != EPKG_OK) {
 				retcode = EX_IOERR;
 				retcode = EXIT_FAILURE;
 				goto cleanup;
 			}
 		}

@@ -287,7 +286,7 @@ exec_set(int argc, char **argv)

 		bool saved_rc = rc;
 		if ((it = pkgdb_query(db, argv[i], match)) == NULL) {
 			retcode = EX_IOERR;
 			retcode = EXIT_FAILURE;
 			goto cleanup;
 		}

@@ -336,7 +335,7 @@ exec_set(int argc, char **argv)

 					 * been queried.
 					 */
 					if (pkgdb_set(db, pkg, depfield, oldvalue, newvalue) != EPKG_OK) {
 						retcode = EX_IOERR;
 						retcode = EXIT_FAILURE;
 						goto cleanup;
 					}
 				}

modified src/shell.c

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

  */
 #include <stdio.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -44,5 +43,5 @@ exec_shell(int argc, char **argv)

 {
 	/* XXX: need exclusive lock here */
 	pkgdb_cmd(argc, argv);
 	return (EX_OK);
 	return (EXIT_SUCCESS);
 }

modified src/shlib.c

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

 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sysexits.h>
 #include <ctype.h>
 #include "pkgcli.h"

@@ -164,7 +163,7 @@ exec_shlib(int argc, char **argv)

 			break;
 		default:
 			usage_shlib();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	argc -= optind;

@@ -172,27 +171,27 @@ exec_shlib(int argc, char **argv)

 	if (argc < 1 || (provides_only && requires_only)) {
 		usage_shlib();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (argc >= 2) {
 		warnx("multiple libraries per run not allowed");
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (sanitize(libname, argv[0], sizeof(libname)) == NULL) {
 		usage_shlib();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	retcode = pkgdb_open(&db, PKGDB_DEFAULT);
 	if (retcode != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if (retcode == EPKG_OK && !requires_only)

@@ -202,7 +201,7 @@ exec_shlib(int argc, char **argv)

 		retcode = pkgs_requiring_lib(db, libname);
 	if (retcode != EPKG_OK)
 		retcode = (EX_IOERR);
 		retcode = (EXIT_FAILURE);
 	pkgdb_release_lock(db, PKGDB_LOCK_READONLY);
 	pkgdb_close(db);

modified src/ssh.c

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

 #include <sys/capsicum.h>
 #endif
 #include <sysexits.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <fcntl.h>

@@ -62,7 +61,7 @@ exec_ssh(int argc, char **argv __unused)

 	if (argc > 1) {
 		usage_ssh();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	restricted = pkg_object_string(pkg_config_get("SSH_RESTRICT_DIR"));

@@ -71,7 +70,7 @@ exec_ssh(int argc, char **argv __unused)

 	if ((fd = open(restricted, O_DIRECTORY|O_RDONLY|O_CLOEXEC)) < 0) {
 		warn("Impossible to open the restricted directory");
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 #ifdef HAVE_CAPSICUM

@@ -79,21 +78,21 @@ exec_ssh(int argc, char **argv __unused)

 	if (cap_rights_limit(fd, &rights) < 0 && errno != ENOSYS ) {
 		warn("cap_rights_limit() failed");
 		close(fd);
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 	if (cap_enter() < 0 && errno != ENOSYS) {
 		warn("cap_enter() failed");
 		close(fd);
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 #endif
 	if (pkg_sshserve(fd) != EPKG_OK) {
 		close(fd);
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 	close(fd);
 	return (EX_OK);
 	return (EXIT_SUCCESS);
 }

modified src/stats.c

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

 #include <libutil.h>
 #endif
 #include <stdio.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -86,7 +85,7 @@ exec_stats(int argc, char **argv)

 			break;
 		default:
 			usage_stats();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	argv += optind;

@@ -96,13 +95,13 @@ exec_stats(int argc, char **argv)

 		opt |= (STATS_LOCAL | STATS_REMOTE);
 	if (pkgdb_open(&db, PKGDB_REMOTE) != EPKG_OK) {
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if (opt & STATS_LOCAL) {

@@ -140,5 +139,5 @@ exec_stats(int argc, char **argv)

 	pkgdb_release_lock(db, PKGDB_LOCK_READONLY);
 	pkgdb_close(db);
 	return (EX_OK);
 	return (EXIT_SUCCESS);
 }

modified src/update.c

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

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <pkg.h>

@@ -156,14 +155,14 @@ exec_update(int argc, char **argv)

 			break;
 		default:
 			usage_update();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	argc -= optind;
 	if (argc != 0) {
 		usage_update();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	ret = pkgdb_access(PKGDB_MODE_WRITE|PKGDB_MODE_CREATE,

@@ -171,12 +170,12 @@ exec_update(int argc, char **argv)

 	if (ret == EPKG_ENOACCESS) {
 		warnx("Insufficient privileges to update the repository "
 		      "catalogue.");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (ret != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	/* For pkg-update update op is strict */
 	ret = pkgcli_update(force, true, reponame);
 	return ((ret == EPKG_OK) ? EX_OK : EX_SOFTWARE);
 	return ((ret == EPKG_OK) ? EXIT_SUCCESS : EXIT_FAILURE);
 }

modified src/updating.c

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

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <ctype.h>
 #include <regex.h>

@@ -275,7 +274,7 @@ exec_updating(int argc, char **argv)

 			break;
 		default:
 			usage_updating();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	argc -= optind;

@@ -284,21 +283,21 @@ exec_updating(int argc, char **argv)

 	/* checking date format */
 	if (date != NULL)
 		if (strlen(date) != 8 || strspn(date, "0123456789") != 8)
 			err(EX_DATAERR, "Invalid date format");
 			err(EXIT_FAILURE, "Invalid date format");
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if (updatingfile == NULL) {
 		const char *portsdir = pkg_object_string(pkg_config_get("PORTSDIR"));
 		if (portsdir == NULL) {
 			retcode = EX_CONFIG;
 			retcode = EXIT_FAILURE;
 			goto cleanup;
 		}
 		asprintf(&updatingfile, "%s/UPDATING", portsdir);

@@ -315,20 +314,20 @@ exec_updating(int argc, char **argv)

 	if (cap_rights_limit(fileno(fd), &rights) < 0 && errno != ENOSYS ) {
 		warn("cap_rights_limit() failed");
 		fclose(fd);
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 	if (cap_enter() < 0 && errno != ENOSYS) {
 		warn("cap_enter() failed");
 		fclose(fd);
 		return (EX_SOFTWARE);
 		return (EXIT_FAILURE);
 	}
 #endif
 	SLIST_INIT(&origins);
 	if (argc == 0) {
 		if ((it = pkgdb_query(db, NULL, MATCH_ALL)) == NULL) {
 			retcode = EX_UNAVAILABLE;
 			retcode = EXIT_FAILURE;
 			fclose(fd);
 			goto cleanup;
 		}

modified src/upgrade.c

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

 #include <err.h>
 #include <getopt.h>
 #include <stdio.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <errno.h>
 #include <signal.h>

@@ -111,7 +110,7 @@ check_vulnerable(struct pkg_audit *audit, struct pkgdb *db, int sock)

 			}
 		}
 		ret = EX_OK;
 		ret = EXIT_SUCCESS;
 	}
 	if (db != NULL) {

@@ -119,7 +118,7 @@ check_vulnerable(struct pkg_audit *audit, struct pkgdb *db, int sock)

 		pkgdb_close(db);
 	}
 	if (ret != EX_OK) {
 	if (ret != EXIT_SUCCESS) {
 		pkg_audit_free(audit);
 		kh_destroy_pkgs(check);
 		fclose(out);

@@ -188,7 +187,7 @@ add_vulnerable_upgrades(struct pkg_jobs *jobs, struct pkgdb *db)

 	if (pkg_audit_fetch(NULL, NULL) != EPKG_OK) {
 		pkg_audit_free(audit);
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	/* Create socketpair to execute audit check in a detached mode */

@@ -341,7 +340,7 @@ exec_upgrade(int argc, char **argv)

 			break;
 		default:
 			usage_upgrade();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 			/* NOTREACHED */
 		}
 	}

@@ -364,11 +363,11 @@ exec_upgrade(int argc, char **argv)

 	if (retcode == EPKG_ENOACCESS) {
 		warnx("Insufficient privilege to upgrade packages");
 		return (EX_NOPERM);
 		return (EXIT_FAILURE);
 	} else if (retcode != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	else
 		retcode = EX_SOFTWARE;
 		retcode = EXIT_FAILURE;
 	/* first update the remote repositories if needed */
 	if (auto_update &&

@@ -376,12 +375,12 @@ exec_upgrade(int argc, char **argv)

 		return (updcode);
 	if (pkgdb_open_all(&db, PKGDB_REMOTE, reponame) != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (pkgdb_obtain_lock(db, lock_type) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an advisory lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if (pkg_jobs_new(&jobs, PKG_JOBS_UPGRADE, db) != EPKG_OK)

@@ -446,7 +445,7 @@ exec_upgrade(int argc, char **argv)

 		printf("Your packages are up to date.\n");
 	if (rc)
 		retcode = EX_OK;
 		retcode = EXIT_SUCCESS;
 	else
 		retcode = EXIT_FAILURE;

modified src/version.c

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

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <fnmatch.h>
 #include <spawn.h>

@@ -156,7 +155,7 @@ do_testversion(unsigned int opt, int argc, char ** restrict argv)

 	/* -t must be unique and takes two arguments */
 	if ( opt != VERSION_TESTVERSION || argc < 2 ) {
 		usage_version();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	switch (pkg_version_cmp(argv[0], argv[1])) {

@@ -171,7 +170,7 @@ do_testversion(unsigned int opt, int argc, char ** restrict argv)

 		break;
 	}
 	return (EX_OK);
 	return (EXIT_SUCCESS);
 }
 static int

@@ -187,7 +186,7 @@ do_testpattern(unsigned int opt, int argc, char ** restrict argv)

 	/* -T must be unique and takes two arguments */
 	if ( opt != VERSION_TESTPATTERN || argc < 2 ) {
 		usage_version();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (strncmp(argv[0], "-", 1) == 0)

@@ -198,7 +197,7 @@ do_testpattern(unsigned int opt, int argc, char ** restrict argv)

 	if (pattern_from_stdin && pkgname_from_stdin) {
 		usage_version();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (!pattern_from_stdin && !pkgname_from_stdin)

@@ -261,13 +260,13 @@ indexfilename(char *filebuf, size_t filebuflen)

 		indexdir = pkg_object_string(pkg_config_get("PORTSDIR"));
 		if (indexdir == NULL)
 			err(EX_SOFTWARE, "Cannot get either INDEXDIR or "
 			err(EXIT_FAILURE, "Cannot get either INDEXDIR or "
 			    "PORTSDIR config entry!");
 	}
 	indexfile = pkg_object_string(pkg_config_get("INDEXFILE"));
 	if (indexfile == NULL)
 		err(EX_SOFTWARE, "Cannot get INDEXFILE config entry!");
 		err(EXIT_FAILURE, "Cannot get INDEXFILE config entry!");
 	strlcpy(filebuf, indexdir, filebuflen);

@@ -297,7 +296,7 @@ hash_indexfile(const char *indexfilename)

 	indexfile = fopen(indexfilename, "re");
 	if (!indexfile)
 		err(EX_NOINPUT, "Unable to open %s", indexfilename);
 		err(EXIT_FAILURE, "Unable to open %s", indexfilename);
 	while (getline(&line, &linecap, indexfile) > 0) {
 		/* line is pkgname|portdir|... */

@@ -308,7 +307,7 @@ hash_indexfile(const char *indexfilename)

 		name = version;
 		version = strrchr(version, '-');
 		if (version == NULL)
 			errx(EX_IOERR, "Invalid INDEX file format: %s",
 			errx(EXIT_FAILURE, "Invalid INDEX file format: %s",
 			    indexfilename);
 		version[0] = '\0';
 		version++;

@@ -321,7 +320,7 @@ hash_indexfile(const char *indexfilename)

 		if (entry == NULL || entry->version == NULL ||
 		    entry->name == NULL)
 			err(EX_SOFTWARE, "Out of memory while reading %s",
 			err(EXIT_FAILURE, "Out of memory while reading %s",
 			    indexfilename);
 		if (index == NULL)

@@ -340,7 +339,7 @@ hash_indexfile(const char *indexfilename)

 	fclose(indexfile);
 	if (index == NULL)
 		errx(EX_DATAERR, "No valid entries found in '%s'",
 		errx(EXIT_FAILURE, "No valid entries found in '%s'",
 		    indexfilename);
 	return (index);

@@ -419,11 +418,11 @@ do_source_index(unsigned int opt, char limchar, char *pattern, match_t match,

 	if ( (opt & VERSION_SOURCES) != VERSION_SOURCE_INDEX) {
 		usage_version();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	index = hash_indexfile(indexfile);

@@ -432,7 +431,7 @@ do_source_index(unsigned int opt, char limchar, char *pattern, match_t match,

 		free_index(index);
 		warnx("Cannot get a read lock on the database. "
 		      "It is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	it = pkgdb_query(db, pattern, match);

@@ -486,7 +485,7 @@ do_source_remote(unsigned int opt, char limchar, char *pattern, match_t match,

 	if ( (opt & VERSION_SOURCES) != VERSION_SOURCE_REMOTE ) {
 		usage_version();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	/* Only force remote mode if looking up remote, otherwise

@@ -499,18 +498,18 @@ do_source_remote(unsigned int opt, char limchar, char *pattern, match_t match,

 	}
 	if (pkgdb_open_all(&db, PKGDB_REMOTE, reponame) != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database. "
 		      "It is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	it = pkgdb_query(db, pattern, match);
 	if (it == NULL) {
 		retcode = EX_IOERR;
 		retcode = EXIT_FAILURE;
 		goto cleanup;
 	}

@@ -533,7 +532,7 @@ do_source_remote(unsigned int opt, char limchar, char *pattern, match_t match,

 		it_remote = pkgdb_repo_query(db, is_origin ? origin : name, MATCH_EXACT, reponame);
 		if (it_remote == NULL) {
 			retcode = EX_IOERR;
 			retcode = EXIT_FAILURE;
 			goto cleanup;
 		}

@@ -761,20 +760,20 @@ do_source_ports(unsigned int opt, char limchar, char *pattern, match_t match,

 	if ( (opt & VERSION_SOURCES) != VERSION_SOURCE_PORTS ) {
 		usage_version();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (chdir(portsdir) != 0)
 		err(EX_SOFTWARE, "Cannot chdir to %s\n", portsdir);
 		err(EXIT_FAILURE, "Cannot chdir to %s\n", portsdir);
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database. "
 		      "It is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if ((it = pkgdb_query(db, pattern, match)) == NULL)

@@ -869,7 +868,7 @@ exec_version(int argc, char **argv)

 			break;
 		case 'h':
 			usage_version();
 			return (EX_OK);
 			return (EXIT_SUCCESS);
 		case 'I':
 			opt |= VERSION_SOURCE_INDEX;
 			break;

@@ -926,7 +925,7 @@ exec_version(int argc, char **argv)

 			break;
 		default:
 			usage_version();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}
 	argc -= optind;

@@ -941,7 +940,7 @@ exec_version(int argc, char **argv)

 	if (matchorigin != NULL && matchname != NULL) {
 		usage_version();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if ( (opt & VERSION_TESTVERSION) == VERSION_TESTVERSION )

@@ -957,7 +956,7 @@ exec_version(int argc, char **argv)

 		    limchar != '?' &&
 		    limchar != '!') {
 			usage_version();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -966,7 +965,7 @@ exec_version(int argc, char **argv)

 	if (argc > 1) {
 		usage_version();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if ( !(opt & VERSION_SOURCES ) ) {

@@ -993,7 +992,7 @@ exec_version(int argc, char **argv)

 	if ( (opt & VERSION_SOURCE_INDEX) == VERSION_SOURCE_INDEX ) {
 		if (!have_indexfile(&indexfile, filebuf, sizeof(filebuf),
 		     argc, argv, true))
 			return (EX_SOFTWARE);
 			return (EXIT_FAILURE);
 		else
 			return (do_source_index(opt, limchar, pattern, match,
 				    matchorigin, matchname, indexfile));

@@ -1005,7 +1004,7 @@ exec_version(int argc, char **argv)

 	if ( (opt & VERSION_SOURCE_PORTS) == VERSION_SOURCE_PORTS ) {
 		if (!have_ports(&portsdir, true))
 			return (EX_SOFTWARE);
 			return (EXIT_FAILURE);
 		else
 			return (do_source_ports(opt, limchar, pattern,
 				    match, matchorigin, matchname, portsdir));

@@ -1031,7 +1030,7 @@ exec_version(int argc, char **argv)

 	}
 	/* NOTREACHED */
 	return (EX_SOFTWARE);
 	return (EXIT_FAILURE);
 }
 /*
  * That's All Folks!

modified src/which.c

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

 #include <getopt.h>
 #include <stdio.h>
 #include <string.h>
 #include <sysexits.h>
 #include <unistd.h>
 #include <kvec.h>
 #include <fnmatch.h>

@@ -75,7 +74,7 @@ exec_which(int argc, char **argv)

 	struct pkg_file *file = NULL;
 	char		 pathabs[MAXPATHLEN];
 	char		*p, *path, *match, *savedpath;
 	int		 ret = EPKG_OK, retcode = EX_SOFTWARE;
 	int		 ret = EPKG_OK, retcode = EXIT_FAILURE;
 	int		 ch, res, pathlen = 0;
 	size_t		 i;
 	bool		 orig = false;

@@ -115,7 +114,7 @@ exec_which(int argc, char **argv)

 			break;
 		default:
 			usage_which();
 			return (EX_USAGE);
 			return (EXIT_FAILURE);
 		}
 	}

@@ -124,17 +123,17 @@ exec_which(int argc, char **argv)

 	if (argc < 1) {
 		usage_which();
 		return (EX_USAGE);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
 		return (EX_IOERR);
 		return (EXIT_FAILURE);
 	}
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);
 		return (EXIT_FAILURE);
 	}
 	if (search_s) {

@@ -148,7 +147,7 @@ exec_which(int argc, char **argv)

 	while (argc >= 1) {
 		kv_init(patterns);
 		retcode = EX_SOFTWARE;
 		retcode = EXIT_FAILURE;
 		if (search_s) {
 			if ((argv[0][0] == '.') || (argv[0][0] == '/')) {
 				search = false;

@@ -156,13 +155,13 @@ exec_which(int argc, char **argv)

 				search = true;
 				if (strlen(argv[0]) >= FILENAME_MAX) {
 					retcode = EX_USAGE;
 					retcode = EXIT_FAILURE;
 					goto cleanup;
 				}
 				p = malloc(pathlen);
 				if (p == NULL) {
 					retcode = EX_OSERR;
 					retcode = EXIT_FAILURE;
 					goto cleanup;
 				}
 				strlcpy(p, path, pathlen);

@@ -174,11 +173,11 @@ exec_which(int argc, char **argv)

 					if (p == NULL)
 						break;
 					if (res == (EX_USAGE)) {
 					if (res == (EXIT_FAILURE)) {
 						printf("%s was not found in PATH, falling back to non-search behaviour\n", argv[0]);
 						search = false;
 					} else if (res == (EX_OSERR)) {
 						retcode = EX_OSERR;
 					} else if (res == (EXIT_FAILURE)) {
 						retcode = EXIT_FAILURE;
 						free(savedpath);
 						goto cleanup;
 					} else {

@@ -199,7 +198,7 @@ exec_which(int argc, char **argv)

 			kv_push(char *, patterns, strdup(pathabs));
 		} else if (!search) {
 			if (strlcpy(pathabs, argv[0], sizeof(pathabs)) >= sizeof(pathabs)) {
 				retcode = EX_USAGE;
 				retcode = EXIT_FAILURE;
 				goto cleanup;
                         }
 			kv_push(char *, patterns, strdup(pathabs));

@@ -208,13 +207,13 @@ exec_which(int argc, char **argv)

 		for (i = 0; i < kv_size(patterns); i++) {
 			if ((it = pkgdb_query_which(db, kv_A(patterns, i), glob)) == NULL) {
 				retcode = EX_IOERR;
 				retcode = EXIT_FAILURE;
 				goto cleanup;
 			}
 			pkg = NULL;
 			while ((ret = pkgdb_it_next(it, &pkg, PKG_LOAD_FILES)) == EPKG_OK) {
 				retcode = EX_OK;
 				retcode = EXIT_SUCCESS;
 				if (quiet && orig && !show_match)
 					pkg_printf("%o\n", pkg);
 				else if (quiet && !orig && !show_match)

@@ -229,14 +228,14 @@ exec_which(int argc, char **argv)

 					while(pkg_files(pkg, &file) == EPKG_OK) {
 						pkg_asprintf(&match, "%Fn", file);
 						if (match == NULL)
 							err(EX_DATAERR, "pkg_asprintf");
 							err(EXIT_FAILURE, "pkg_asprintf");
 						if(!fnmatch(kv_A(patterns, i), match, 0))
 							printf("%s\n", match);
 						free(match);
 					}
 				}
 			}
 			if (retcode != EX_OK && !quiet)
 			if (retcode != EXIT_SUCCESS && !quiet)
 				printf("%s was not found in the database\n", kv_A(patterns, i));
 			pkg_free(pkg);

@@ -279,10 +278,10 @@ get_match(char **pathabs, char **path, char *filename)

 			len = strlen(candidate) + 1;
 			*pathabs = malloc(len);
 			if (*pathabs == NULL)
 				return (EX_OSERR);
 				return (EXIT_FAILURE);
 			strlcpy(*pathabs, candidate, len);
 			return (EX_OK);
 			return (EXIT_SUCCESS);
 		}
 	}
 	return (EX_USAGE);
 	return (EXIT_FAILURE);
 }

modified tests/frontend/add.sh

@@ -126,7 +126,7 @@ EOF

 	atf_check \
 		-o inline:"${JAILED}Installing test-1...\n\nFailed to install the following 1 package(s): test-1.txz\n" \
 		-e inline:"${PROGNAME}: Missing dependency 'b'\n" \
 		-s exit:70 \
 		-s exit:1 \
 		pkg add test-1.txz
 OUTPUT="${JAILED}Installing test-1...

@@ -196,7 +196,7 @@ EOF

 	cat test-1.txz | atf_check \
 		-o inline:"${JAILED}Installing test-1...\n\nFailed to install the following 1 package(s): -\n" \
 		-e inline:"${PROGNAME}: Missing dependency 'b'\n" \
 		-s exit:70 \
 		-s exit:1 \
 		pkg add -
 OUTPUT="${JAILED}Installing test-1...

modified tests/frontend/alias.sh

@@ -25,7 +25,7 @@ alias_body() {

 	atf_check \
 		-o empty \
 		-e inline:"${PROGNAME}: No such alias: 'nonexistent'\n" \
 		-s exit:69 \
 		-s exit:1 \
 		pkg -C "" alias nonexistent
 }

@@ -57,7 +57,7 @@ list 'info -q'

 	atf_check \
 		-o empty \
 		-e inline:"${PROGNAME}: No such alias: 'nonexistent'\n" \
 		-s exit:69 \
 		-s exit:1 \
 		pkg -C "" alias nonexistent
 }

@@ -96,6 +96,6 @@ list 'info -q'

 	atf_check \
 		-o empty \
 		-e inline:"${PROGNAME}: No such alias: 'nonexistent'\n" \
 		-s exit:69 \
 		-s exit:1 \
 		pkg -C config alias nonexistent
 }

modified tests/frontend/config.sh

@@ -46,7 +46,7 @@ duplicate_pkgs_notallowed_body() {

 	atf_check \
 		-e empty \
 		-s exit:70 \
 		-s exit:1 \
 		pkg register -M test1.ucl
 	atf_check \

modified tests/frontend/create.sh

@@ -599,7 +599,7 @@ EOF

 	atf_check \
 		-o match:"0 Jan +2 +1970.*/a" \
 		tar tvf test-1.txz
 	atf_check -e match:"Invalid" -s exit:64 pkg create -t meh -M test.ucl
 	atf_check -e match:"Invalid" -s exit:1 pkg create -t meh -M test.ucl
 	atf_check pkg create -t 172800 -M test.ucl
 	atf_check \
 		-o match:"0 Jan +3 +1970.*/a" \

modified tests/frontend/pkg.sh

@@ -14,7 +14,7 @@ pkg_no_database_body() {

 	atf_check \
 	    -o empty \
 	    -e inline:"${PROGNAME}: package database non-existent\n" \
 	    -s exit:69 \
 	    -s exit:1 \
 	    env -i PATH="${PATH}" DYLD_LIBRARY_PATH="${DYLD_LIBRARY_PATH}" LD_LIBRARY_PATH="${LD_LIBRARY_PATH}" pkg -o PKG_DBDIR=/dev/null -N
 }

modified tests/frontend/register.sh

@@ -36,7 +36,7 @@ EOF

 	atf_check \
 	    -o match:".*Installing.*" \
 	    -e match:".*conflicts.*" \
 	    -s exit:70 \
 	    -s exit:1 \
 	    pkg register -i teststage -M test.ucl
 	nsum=$(openssl dgst -sha256 -binary plop | hexdump -v -e '/1 "%x"')
 	atf_check_equal ${sum} ${nsum}

@@ -120,6 +120,6 @@ file_not_found_body()

 	mkdir -p ${TMPDIR}/target
 	atf_check \
 		-e match:"Unable to access file ${TMPDIR}/prefix/foo" \
 		-s exit:74 \
 		-s exit:1 \
 		pkg -r ${TMPDIR}/target register -M ${TMPDIR}/test.ucl -f ${TMPDIR}/plist -i ${TMPDIR}
 }

modified tests/frontend/update.sh

@@ -18,6 +18,6 @@ EOF

 	atf_check \
 		-o match:"Unable to update repository test" \
 		-e match:"pkg: file://empty//packagesite.txz: No such file or directory" \
 		-s exit:70 \
 		-s exit:1 \
 		pkg -R repos update
 }

modified tests/frontend/version.sh

@@ -25,7 +25,7 @@ compare_body() {

 	atf_check \
 		-o ignore \
 		-e ignore \
 		-s exit:70 \
 		-s exit:1 \
 		pkg info "test<5"
 	atf_check \
 		-o ignore \

@@ -33,11 +33,11 @@ compare_body() {

 	atf_check \
 		-o ignore \
 		-e ignore \
 		-s exit:70 \
 		-s exit:1 \
 		pkg info "test>5<5.20"
 	atf_check \
 		-o ignore \
 		-e ignore \
 		-s exit:70 \
 		-s exit:1 \
 		pkg info "test>5.20_3<6"
 }