1 files changed, 284 insertions, 280 deletions

diff --git a/lib/libalpm/handle.c b/lib/libalpm/handle.c
index 586aad1e..acd35409 100644
--- a/lib/libalpm/handle.c
+++ b/lib/libalpm/handle.c
@@ -22,14 +22,14 @@
 
 #include "config.h"
 
+#include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <limits.h>
 #include <sys/types.h>
 #include <syslog.h>
-#include <time.h>
 #include <sys/stat.h>
-#include <errno.h>
+#include <fcntl.h>
 
 /* libalpm */
 #include "handle.h"
@@ -39,22 +39,19 @@
 #include "trans.h"
 #include "alpm.h"
 
-/* global var for handle (private to libalpm) */
-pmhandle_t *handle = NULL;
-
 pmhandle_t *_alpm_handle_new()
 {
 	pmhandle_t *handle;
 
-	CALLOC(handle, 1, sizeof(pmhandle_t), RET_ERR(PM_ERR_MEMORY, NULL));
+	CALLOC(handle, 1, sizeof(pmhandle_t), return NULL);
 
-	return(handle);
+	handle->sigverify = PM_PGP_VERIFY_OPTIONAL;
+
+	return handle;
 }
 
 void _alpm_handle_free(pmhandle_t *handle)
 {
-	ALPM_LOG_FUNC;
-
 	if(handle == NULL) {
 		return;
 	}
@@ -69,6 +66,11 @@ void _alpm_handle_free(pmhandle_t *handle)
 		closelog();
 	}
 
+#ifdef HAVE_LIBCURL
+	/* release curl handle */
+	curl_easy_cleanup(handle->curl);
+#endif
+
 	/* free memory */
 	_alpm_trans_free(handle->trans);
 	FREE(handle->root);
@@ -77,6 +79,7 @@ void _alpm_handle_free(pmhandle_t *handle)
 	FREE(handle->logfile);
 	FREE(handle->lockfile);
 	FREE(handle->arch);
+	FREE(handle->gpgdir);
 	FREELIST(handle->dbs_sync);
 	FREELIST(handle->noupgrade);
 	FREELIST(handle->noextract);
@@ -85,363 +88,317 @@ void _alpm_handle_free(pmhandle_t *handle)
 	FREE(handle);
 }
 
-alpm_cb_log SYMEXPORT alpm_option_get_logcb()
+/** Lock the database */
+int _alpm_handle_lock(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
+	int fd;
+	char *dir, *ptr;
+
+	ASSERT(handle->lockfile != NULL, return -1);
+	ASSERT(handle->lckstream == NULL, return 0);
+
+	/* create the dir of the lockfile first */
+	dir = strdup(handle->lockfile);
+	ptr = strrchr(dir, '/');
+	if(ptr) {
+		*ptr = '\0';
 	}
-	return handle->logcb;
+	if(_alpm_makepath(dir)) {
+		FREE(dir);
+		return -1;
+	}
+	FREE(dir);
+
+	do {
+		fd = open(handle->lockfile, O_WRONLY | O_CREAT | O_EXCL, 0000);
+	} while(fd == -1 && errno == EINTR);
+	if(fd > 0) {
+		FILE *f = fdopen(fd, "w");
+		fprintf(f, "%ld\n", (long)getpid());
+		fflush(f);
+		fsync(fd);
+		handle->lckstream = f;
+		return 0;
+	}
+	return -1;
 }
 
-alpm_cb_download SYMEXPORT alpm_option_get_dlcb()
+/** Remove a lock file */
+int _alpm_handle_unlock(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
+	ASSERT(handle->lockfile != NULL, return -1);
+	ASSERT(handle->lckstream != NULL, return 0);
+
+	if(handle->lckstream != NULL) {
+		fclose(handle->lckstream);
+		handle->lckstream = NULL;
+	}
+	if(unlink(handle->lockfile) && errno != ENOENT) {
+		return -1;
 	}
+	return 0;
+}
+
+
+alpm_cb_log SYMEXPORT alpm_option_get_logcb(pmhandle_t *handle)
+{
+	CHECK_HANDLE(handle, return NULL);
+	return handle->logcb;
+}
+
+alpm_cb_download SYMEXPORT alpm_option_get_dlcb(pmhandle_t *handle)
+{
+	CHECK_HANDLE(handle, return NULL);
 	return handle->dlcb;
 }
 
-alpm_cb_fetch SYMEXPORT alpm_option_get_fetchcb()
+alpm_cb_fetch SYMEXPORT alpm_option_get_fetchcb(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->fetchcb;
 }
 
-alpm_cb_totaldl SYMEXPORT alpm_option_get_totaldlcb()
+alpm_cb_totaldl SYMEXPORT alpm_option_get_totaldlcb(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->totaldlcb;
 }
 
-const char SYMEXPORT *alpm_option_get_root()
+const char SYMEXPORT *alpm_option_get_root(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->root;
 }
 
-const char SYMEXPORT *alpm_option_get_dbpath()
+const char SYMEXPORT *alpm_option_get_dbpath(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->dbpath;
 }
 
-alpm_list_t SYMEXPORT *alpm_option_get_cachedirs()
+alpm_list_t SYMEXPORT *alpm_option_get_cachedirs(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->cachedirs;
 }
 
-const char SYMEXPORT *alpm_option_get_logfile()
+const char SYMEXPORT *alpm_option_get_logfile(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->logfile;
 }
 
-const char SYMEXPORT *alpm_option_get_lockfile()
+const char SYMEXPORT *alpm_option_get_lockfile(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->lockfile;
 }
 
-int SYMEXPORT alpm_option_get_usesyslog()
+const char SYMEXPORT *alpm_option_get_gpgdir(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return -1;
-	}
+	CHECK_HANDLE(handle, return NULL);
+	return handle->gpgdir;
+}
+
+int SYMEXPORT alpm_option_get_usesyslog(pmhandle_t *handle)
+{
+	CHECK_HANDLE(handle, return -1);
 	return handle->usesyslog;
 }
 
-alpm_list_t SYMEXPORT *alpm_option_get_noupgrades()
+alpm_list_t SYMEXPORT *alpm_option_get_noupgrades(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->noupgrade;
 }
 
-alpm_list_t SYMEXPORT *alpm_option_get_noextracts()
+alpm_list_t SYMEXPORT *alpm_option_get_noextracts(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->noextract;
 }
 
-alpm_list_t SYMEXPORT *alpm_option_get_ignorepkgs()
+alpm_list_t SYMEXPORT *alpm_option_get_ignorepkgs(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->ignorepkg;
 }
 
-alpm_list_t SYMEXPORT *alpm_option_get_ignoregrps()
+alpm_list_t SYMEXPORT *alpm_option_get_ignoregrps(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->ignoregrp;
 }
 
-const char SYMEXPORT *alpm_option_get_arch()
+const char SYMEXPORT *alpm_option_get_arch(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->arch;
 }
 
-int SYMEXPORT alpm_option_get_usedelta()
+int SYMEXPORT alpm_option_get_usedelta(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return -1;
-	}
+	CHECK_HANDLE(handle, return -1);
 	return handle->usedelta;
 }
 
-int SYMEXPORT alpm_option_get_checkspace()
+int SYMEXPORT alpm_option_get_checkspace(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return -1;
-	}
+	CHECK_HANDLE(handle, return -1);
 	return handle->checkspace;
 }
 
-pmdb_t SYMEXPORT *alpm_option_get_localdb()
+pmdb_t SYMEXPORT *alpm_option_get_localdb(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->db_local;
 }
 
-alpm_list_t SYMEXPORT *alpm_option_get_syncdbs()
+alpm_list_t SYMEXPORT *alpm_option_get_syncdbs(pmhandle_t *handle)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return NULL;
-	}
+	CHECK_HANDLE(handle, return NULL);
 	return handle->dbs_sync;
 }
 
-void SYMEXPORT alpm_option_set_logcb(alpm_cb_log cb)
+int SYMEXPORT alpm_option_set_logcb(pmhandle_t *handle, alpm_cb_log cb)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return;
-	}
+	CHECK_HANDLE(handle, return -1);
 	handle->logcb = cb;
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_dlcb(alpm_cb_download cb)
+int SYMEXPORT alpm_option_set_dlcb(pmhandle_t *handle, alpm_cb_download cb)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return;
-	}
+	CHECK_HANDLE(handle, return -1);
 	handle->dlcb = cb;
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_fetchcb(alpm_cb_fetch cb)
+int SYMEXPORT alpm_option_set_fetchcb(pmhandle_t *handle, alpm_cb_fetch cb)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return;
-	}
+	CHECK_HANDLE(handle, return -1);
 	handle->fetchcb = cb;
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_totaldlcb(alpm_cb_totaldl cb)
+int SYMEXPORT alpm_option_set_totaldlcb(pmhandle_t *handle, alpm_cb_totaldl cb)
 {
-	if (handle == NULL) {
-		pm_errno = PM_ERR_HANDLE_NULL;
-		return;
-	}
+	CHECK_HANDLE(handle, return -1);
 	handle->totaldlcb = cb;
+	return 0;
 }
 
-int SYMEXPORT alpm_option_set_root(const char *root)
-{
-	struct stat st;
-	char *realroot;
-	size_t rootlen;
-
-	ALPM_LOG_FUNC;
+static char *canonicalize_path(const char *path) {
+	char *new_path;
+	size_t len;
 
-	ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
-
-	if(!root) {
-		pm_errno = PM_ERR_WRONG_ARGS;
-		return(-1);
-	}
-	if(stat(root, &st) == -1 || !S_ISDIR(st.st_mode)) {
-		pm_errno = PM_ERR_NOT_A_DIR;
-		return(-1);
-	}
-
-	realroot = calloc(PATH_MAX+1, sizeof(char));
-	if(!realpath(root, realroot)) {
-		FREE(realroot);
-		pm_errno = PM_ERR_NOT_A_DIR;
-		return(-1);
-	}
-
-	/* verify root ends in a '/' */
-	rootlen = strlen(realroot);
-	if(realroot[rootlen-1] != '/') {
-		rootlen += 1;
+	/* verify path ends in a '/' */
+	len = strlen(path);
+	if(path[len - 1] != '/') {
+		len += 1;
 	}
-	if(handle->root) {
-		FREE(handle->root);
-	}
-	handle->root = calloc(rootlen + 1, sizeof(char));
-	strncpy(handle->root, realroot, rootlen);
-	handle->root[rootlen-1] = '/';
-	FREE(realroot);
-	_alpm_log(PM_LOG_DEBUG, "option 'root' = %s\n", handle->root);
-	return(0);
+	CALLOC(new_path, len + 1, sizeof(char), return NULL);
+	strncpy(new_path, path, len);
+	new_path[len - 1] = '/';
+	return new_path;
 }
 
-int SYMEXPORT alpm_option_set_dbpath(const char *dbpath)
-{
+enum _pmerrno_t _alpm_set_directory_option(const char *value,
+		char **storage, int must_exist)
+ {
 	struct stat st;
-	size_t dbpathlen, lockfilelen;
-	const char *lf = "db.lck";
-
-	ALPM_LOG_FUNC;
+	char *real = NULL;
+	const char *path;
 
-	ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
-	if(!dbpath) {
-		pm_errno = PM_ERR_WRONG_ARGS;
-		return(-1);
-	}
-	if(stat(dbpath, &st) == -1 || !S_ISDIR(st.st_mode)) {
-		pm_errno = PM_ERR_NOT_A_DIR;
-		return(-1);
-	}
-	/* verify dbpath ends in a '/' */
-	dbpathlen = strlen(dbpath);
-	if(dbpath[dbpathlen-1] != '/') {
-		dbpathlen += 1;
+	path = value;
+	if(!path) {
+		return PM_ERR_WRONG_ARGS;
 	}
-	if(handle->dbpath) {
-		FREE(handle->dbpath);
+	if(must_exist) {
+		if(stat(path, &st) == -1 || !S_ISDIR(st.st_mode)) {
+			return PM_ERR_NOT_A_DIR;
+		}
+		CALLOC(real, PATH_MAX, sizeof(char), return PM_ERR_MEMORY);
+		if(!realpath(path, real)) {
+			free(real);
+			return PM_ERR_NOT_A_DIR;
+		}
+		path = real;
 	}
-	handle->dbpath = calloc(dbpathlen+1, sizeof(char));
-	strncpy(handle->dbpath, dbpath, dbpathlen);
-	handle->dbpath[dbpathlen-1] = '/';
-	_alpm_log(PM_LOG_DEBUG, "option 'dbpath' = %s\n", handle->dbpath);
 
-	if(handle->lockfile) {
-		FREE(handle->lockfile);
+	if(*storage) {
+		FREE(*storage);
 	}
-	lockfilelen = strlen(handle->dbpath) + strlen(lf) + 1;
-	handle->lockfile = calloc(lockfilelen, sizeof(char));
-	snprintf(handle->lockfile, lockfilelen, "%s%s", handle->dbpath, lf);
-	_alpm_log(PM_LOG_DEBUG, "option 'lockfile' = %s\n", handle->lockfile);
-	return(0);
+	*storage = canonicalize_path(path);
+	if(!*storage) {
+		return PM_ERR_MEMORY;
+	}
+	free(real);
+	return 0;
 }
 
-int SYMEXPORT alpm_option_add_cachedir(const char *cachedir)
+int SYMEXPORT alpm_option_add_cachedir(pmhandle_t *handle, const char *cachedir)
 {
 	char *newcachedir;
-	size_t cachedirlen;
-
-	ALPM_LOG_FUNC;
 
-	ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
-	if(!cachedir) {
-		pm_errno = PM_ERR_WRONG_ARGS;
-		return(-1);
-	}
+	CHECK_HANDLE(handle, return -1);
+	ASSERT(cachedir != NULL, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
 	/* don't stat the cachedir yet, as it may not even be needed. we can
 	 * fail later if it is needed and the path is invalid. */
 
-	/* verify cachedir ends in a '/' */
-	cachedirlen = strlen(cachedir);
-	if(cachedir[cachedirlen-1] != '/') {
-		cachedirlen += 1;
+	newcachedir = canonicalize_path(cachedir);
+	if(!newcachedir) {
+		RET_ERR(handle, PM_ERR_MEMORY, -1);
 	}
-	newcachedir = calloc(cachedirlen + 1, sizeof(char));
-	strncpy(newcachedir, cachedir, cachedirlen);
-	newcachedir[cachedirlen-1] = '/';
 	handle->cachedirs = alpm_list_add(handle->cachedirs, newcachedir);
-	_alpm_log(PM_LOG_DEBUG, "option 'cachedir' = %s\n", newcachedir);
-	return(0);
+	_alpm_log(handle, PM_LOG_DEBUG, "option 'cachedir' = %s\n", newcachedir);
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_cachedirs(alpm_list_t *cachedirs)
+int SYMEXPORT alpm_option_set_cachedirs(pmhandle_t *handle, alpm_list_t *cachedirs)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
-	if(handle->cachedirs) FREELIST(handle->cachedirs);
-	if(cachedirs) handle->cachedirs = cachedirs;
+	alpm_list_t *i;
+	CHECK_HANDLE(handle, return -1);
+	if(handle->cachedirs) {
+		FREELIST(handle->cachedirs);
+	}
+	for(i = cachedirs; i; i = i->next) {
+		int ret = alpm_option_add_cachedir(handle, i->data);
+		if(ret) {
+			return ret;
+		}
+	}
+	return 0;
 }
 
-int SYMEXPORT alpm_option_remove_cachedir(const char *cachedir)
+int SYMEXPORT alpm_option_remove_cachedir(pmhandle_t *handle, const char *cachedir)
 {
 	char *vdata = NULL;
 	char *newcachedir;
-	size_t cachedirlen;
-	ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
-	/* verify cachedir ends in a '/' */
-	cachedirlen = strlen(cachedir);
-	if(cachedir[cachedirlen-1] != '/') {
-		cachedirlen += 1;
+	CHECK_HANDLE(handle, return -1);
+	ASSERT(cachedir != NULL, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
+
+	newcachedir = canonicalize_path(cachedir);
+	if(!newcachedir) {
+		RET_ERR(handle, PM_ERR_MEMORY, -1);
 	}
-	newcachedir = calloc(cachedirlen + 1, sizeof(char));
-	strncpy(newcachedir, cachedir, cachedirlen);
-	newcachedir[cachedirlen-1] = '/';
 	handle->cachedirs = alpm_list_remove_str(handle->cachedirs, newcachedir, &vdata);
 	FREE(newcachedir);
 	if(vdata != NULL) {
 		FREE(vdata);
-		return(1);
+		return 1;
 	}
-	return(0);
+	return 0;
 }
 
-int SYMEXPORT alpm_option_set_logfile(const char *logfile)
+int SYMEXPORT alpm_option_set_logfile(pmhandle_t *handle, const char *logfile)
 {
 	char *oldlogfile = handle->logfile;
 
-	ALPM_LOG_FUNC;
-
-	ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+	CHECK_HANDLE(handle, return -1);
 	if(!logfile) {
-		pm_errno = PM_ERR_WRONG_ARGS;
-		return(-1);
+		handle->pm_errno = PM_ERR_WRONG_ARGS;
+		return -1;
 	}
 
 	handle->logfile = strdup(logfile);
@@ -455,133 +412,180 @@ int SYMEXPORT alpm_option_set_logfile(const char *logfile)
 		fclose(handle->logstream);
 		handle->logstream = NULL;
 	}
-	_alpm_log(PM_LOG_DEBUG, "option 'logfile' = %s\n", handle->logfile);
-	return(0);
+	_alpm_log(handle, PM_LOG_DEBUG, "option 'logfile' = %s\n", handle->logfile);
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_usesyslog(int usesyslog)
+int SYMEXPORT alpm_option_set_gpgdir(pmhandle_t *handle, const char *gpgdir)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
+	if(!gpgdir) {
+		handle->pm_errno = PM_ERR_WRONG_ARGS;
+		return -1;
+	}
+
+	if(handle->gpgdir) {
+		FREE(handle->gpgdir);
+	}
+	handle->gpgdir = strdup(gpgdir);
+
+	_alpm_log(handle, PM_LOG_DEBUG, "option 'gpgdir' = %s\n", handle->gpgdir);
+	return 0;
+}
+
+int SYMEXPORT alpm_option_set_usesyslog(pmhandle_t *handle, int usesyslog)
+{
+	CHECK_HANDLE(handle, return -1);
 	handle->usesyslog = usesyslog;
+	return 0;
 }
 
-void SYMEXPORT alpm_option_add_noupgrade(const char *pkg)
+int SYMEXPORT alpm_option_add_noupgrade(pmhandle_t *handle, const char *pkg)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
 	handle->noupgrade = alpm_list_add(handle->noupgrade, strdup(pkg));
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_noupgrades(alpm_list_t *noupgrade)
+int SYMEXPORT alpm_option_set_noupgrades(pmhandle_t *handle, alpm_list_t *noupgrade)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
 	if(handle->noupgrade) FREELIST(handle->noupgrade);
-	if(noupgrade) handle->noupgrade = noupgrade;
+	handle->noupgrade = alpm_list_strdup(noupgrade);
+	return 0;
 }
 
-int SYMEXPORT alpm_option_remove_noupgrade(const char *pkg)
+int SYMEXPORT alpm_option_remove_noupgrade(pmhandle_t *handle, const char *pkg)
 {
 	char *vdata = NULL;
-	ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+	CHECK_HANDLE(handle, return -1);
 	handle->noupgrade = alpm_list_remove_str(handle->noupgrade, pkg, &vdata);
 	if(vdata != NULL) {
 		FREE(vdata);
-		return(1);
+		return 1;
 	}
-	return(0);
+	return 0;
 }
 
-void SYMEXPORT alpm_option_add_noextract(const char *pkg)
+int SYMEXPORT alpm_option_add_noextract(pmhandle_t *handle, const char *pkg)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
 	handle->noextract = alpm_list_add(handle->noextract, strdup(pkg));
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_noextracts(alpm_list_t *noextract)
+int SYMEXPORT alpm_option_set_noextracts(pmhandle_t *handle, alpm_list_t *noextract)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
 	if(handle->noextract) FREELIST(handle->noextract);
-	if(noextract) handle->noextract = noextract;
+	handle->noextract = alpm_list_strdup(noextract);
+	return 0;
 }
 
-int SYMEXPORT alpm_option_remove_noextract(const char *pkg)
+int SYMEXPORT alpm_option_remove_noextract(pmhandle_t *handle, const char *pkg)
 {
 	char *vdata = NULL;
-	ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+	CHECK_HANDLE(handle, return -1);
 	handle->noextract = alpm_list_remove_str(handle->noextract, pkg, &vdata);
 	if(vdata != NULL) {
 		FREE(vdata);
-		return(1);
+		return 1;
 	}
-	return(0);
+	return 0;
 }
 
-void SYMEXPORT alpm_option_add_ignorepkg(const char *pkg)
+int SYMEXPORT alpm_option_add_ignorepkg(pmhandle_t *handle, const char *pkg)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
 	handle->ignorepkg = alpm_list_add(handle->ignorepkg, strdup(pkg));
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_ignorepkgs(alpm_list_t *ignorepkgs)
+int SYMEXPORT alpm_option_set_ignorepkgs(pmhandle_t *handle, alpm_list_t *ignorepkgs)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
 	if(handle->ignorepkg) FREELIST(handle->ignorepkg);
-	if(ignorepkgs) handle->ignorepkg = ignorepkgs;
+	handle->ignorepkg = alpm_list_strdup(ignorepkgs);
+	return 0;
 }
 
-int SYMEXPORT alpm_option_remove_ignorepkg(const char *pkg)
+int SYMEXPORT alpm_option_remove_ignorepkg(pmhandle_t *handle, const char *pkg)
 {
 	char *vdata = NULL;
-	ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+	CHECK_HANDLE(handle, return -1);
 	handle->ignorepkg = alpm_list_remove_str(handle->ignorepkg, pkg, &vdata);
 	if(vdata != NULL) {
 		FREE(vdata);
-		return(1);
+		return 1;
 	}
-	return(0);
+	return 0;
 }
 
-void SYMEXPORT alpm_option_add_ignoregrp(const char *grp)
+int SYMEXPORT alpm_option_add_ignoregrp(pmhandle_t *handle, const char *grp)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
 	handle->ignoregrp = alpm_list_add(handle->ignoregrp, strdup(grp));
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_ignoregrps(alpm_list_t *ignoregrps)
+int SYMEXPORT alpm_option_set_ignoregrps(pmhandle_t *handle, alpm_list_t *ignoregrps)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
 	if(handle->ignoregrp) FREELIST(handle->ignoregrp);
-	if(ignoregrps) handle->ignoregrp = ignoregrps;
+	handle->ignoregrp = alpm_list_strdup(ignoregrps);
+	return 0;
 }
 
-int SYMEXPORT alpm_option_remove_ignoregrp(const char *grp)
+int SYMEXPORT alpm_option_remove_ignoregrp(pmhandle_t *handle, const char *grp)
 {
 	char *vdata = NULL;
-	ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+	CHECK_HANDLE(handle, return -1);
 	handle->ignoregrp = alpm_list_remove_str(handle->ignoregrp, grp, &vdata);
 	if(vdata != NULL) {
 		FREE(vdata);
-		return(1);
+		return 1;
 	}
-	return(0);
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_arch(const char *arch)
+int SYMEXPORT alpm_option_set_arch(pmhandle_t *handle, const char *arch)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
 	if(handle->arch) FREE(handle->arch);
-	if(arch) handle->arch = strdup(arch);
+	if(arch) {
+		handle->arch = strdup(arch);
+	} else {
+		handle->arch = NULL;
+	}
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_usedelta(int usedelta)
+int SYMEXPORT alpm_option_set_usedelta(pmhandle_t *handle, int usedelta)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
 	handle->usedelta = usedelta;
+	return 0;
 }
 
-void SYMEXPORT alpm_option_set_checkspace(int checkspace)
+int SYMEXPORT alpm_option_set_checkspace(pmhandle_t *handle, int checkspace)
 {
-	ASSERT(handle != NULL, RET_ERR_VOID(PM_ERR_HANDLE_NULL));
+	CHECK_HANDLE(handle, return -1);
 	handle->checkspace = checkspace;
+	return 0;
+}
+
+int SYMEXPORT alpm_option_set_default_sigverify(pmhandle_t *handle, pgp_verify_t level)
+{
+	CHECK_HANDLE(handle, return -1);
+	ASSERT(level != PM_PGP_VERIFY_UNKNOWN, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
+	handle->sigverify = level;
+	return 0;
+}
+
+pgp_verify_t SYMEXPORT alpm_option_get_default_sigverify(pmhandle_t *handle)
+{
+	CHECK_HANDLE(handle, return PM_PGP_VERIFY_UNKNOWN);
+	return handle->sigverify;
 }
 
 /* vim: set ts=2 sw=2 noet: */