Move all callbacks up to the handle level

This was just disgusting before, unnecessary to limit these to only
usage in a transaction. Still a lot of more room for cleanup but we'll
start by attaching them to the handle rather than the transaction we may
or may not even want to use these callbacks.

Signed-off-by: Dan McGee <dan@archlinux.org>

16 files changed, 161 insertions, 117 deletions

diff --git a/README b/README
index c14fd3c7..0e5a512d 100644
--- a/README
+++ b/README
@@ -395,6 +395,8 @@ API CHANGES BETWEEN 3.5 AND 4.0
 - alpm_pkg_load() now requires an extra parameter of an alpm_siglevel_t
 - alpm_db_setserver() replaced by alpm_db_set_servers(), alpm_db_add_server(),
     alpm_db_remove_server()
+- alpm_trans_init() no longer takes callbacks, set those using
+    alpm_option_set_*cb() functions
 - many functions now require a first parameter of an alpm_handle_t *:
   - alpm_option_get_*
   - alpm_option_set_*
@@ -425,10 +427,13 @@ API CHANGES BETWEEN 3.5 AND 4.0
   - alpm_pkg_reason_t
 
 [ADDED]
+- option functions:
+    alpm_{get,set}_eventcb(), alpm_option_{get,set}_convcb(),
+	alpm_option_{get,set}_progresscb()
 - package signing functions:
     alpm_option_get_default_siglevel(), alpm_option_set_default_siglevel(),
     alpm_option_get_gpgdir(), alpm_option_set_gpgdir(), alpm_db_get_siglevel(),
-    alpm_sigresult_cleanup(), alpm_db_check_pgp_signature(), alpm_pkg_check_pgp_signature(),
+    alpm_siglist_cleanup(), alpm_db_check_pgp_signature(), alpm_pkg_check_pgp_signature(),
     alpm_pkg_get_origin(), alpm_pkg_get_sha256sum(), alpm_pkg_get_base64_sig()
 - list functions:
     alpm_list_to_array(), alpm_list_previous()
diff --git a/lib/libalpm/add.c b/lib/libalpm/add.c
index cb8551e8..96272a25 100644
--- a/lib/libalpm/add.c
+++ b/lib/libalpm/add.c
@@ -473,7 +473,7 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 			goto cleanup;
 		}
 
-		EVENT(trans, ALPM_TRANS_EVT_UPGRADE_START, newpkg, local);
+		EVENT(handle, ALPM_TRANS_EVT_UPGRADE_START, newpkg, local);
 		_alpm_log(handle, ALPM_LOG_DEBUG, "upgrading package %s-%s\n",
 				newpkg->name, newpkg->version);
 
@@ -488,7 +488,7 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 	} else {
 		is_upgrade = 0;
 
-		EVENT(trans, ALPM_TRANS_EVT_ADD_START, newpkg, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_ADD_START, newpkg, NULL);
 		_alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s\n",
 				newpkg->name, newpkg->version);
 
@@ -567,10 +567,10 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 
 		/* call PROGRESS once with 0 percent, as we sort-of skip that here */
 		if(is_upgrade) {
-			PROGRESS(trans, ALPM_TRANS_PROGRESS_UPGRADE_START,
+			PROGRESS(handle, ALPM_TRANS_PROGRESS_UPGRADE_START,
 					newpkg->name, 0, pkg_count, pkg_current);
 		} else {
-			PROGRESS(trans, ALPM_TRANS_PROGRESS_ADD_START,
+			PROGRESS(handle, ALPM_TRANS_PROGRESS_ADD_START,
 					newpkg->name, 0, pkg_count, pkg_current);
 		}
 
@@ -594,10 +594,10 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 			}
 
 			if(is_upgrade) {
-				PROGRESS(trans, ALPM_TRANS_PROGRESS_UPGRADE_START,
+				PROGRESS(handle, ALPM_TRANS_PROGRESS_UPGRADE_START,
 						newpkg->name, percent, pkg_count, pkg_current);
 			} else {
-				PROGRESS(trans, ALPM_TRANS_PROGRESS_ADD_START,
+				PROGRESS(handle, ALPM_TRANS_PROGRESS_ADD_START,
 						newpkg->name, percent, pkg_count, pkg_current);
 			}
 
@@ -649,10 +649,10 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 	}
 
 	if(is_upgrade) {
-		PROGRESS(trans, ALPM_TRANS_PROGRESS_UPGRADE_START,
+		PROGRESS(handle, ALPM_TRANS_PROGRESS_UPGRADE_START,
 				newpkg->name, 100, pkg_count, pkg_current);
 	} else {
-		PROGRESS(trans, ALPM_TRANS_PROGRESS_ADD_START,
+		PROGRESS(handle, ALPM_TRANS_PROGRESS_ADD_START,
 				newpkg->name, 100, pkg_count, pkg_current);
 	}
 
@@ -669,9 +669,9 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 	}
 
 	if(is_upgrade) {
-		EVENT(trans, ALPM_TRANS_EVT_UPGRADE_DONE, newpkg, oldpkg);
+		EVENT(handle, ALPM_TRANS_EVT_UPGRADE_DONE, newpkg, oldpkg);
 	} else {
-		EVENT(trans, ALPM_TRANS_EVT_ADD_DONE, newpkg, oldpkg);
+		EVENT(handle, ALPM_TRANS_EVT_ADD_DONE, newpkg, oldpkg);
 	}
 
 cleanup:
diff --git a/lib/libalpm/alpm.h b/lib/libalpm/alpm.h
index cfc2a100..d2512ff2 100644
--- a/lib/libalpm/alpm.h
+++ b/lib/libalpm/alpm.h
@@ -863,7 +863,7 @@ typedef enum _alpm_transflag_t {
 	ALPM_TRANS_FLAG_NOLOCK = (1 << 17)
 } alpm_transflag_t;
 
-/** Transaction events.
+/** Events.
  * NULL parameters are passed to in all events unless specified otherwise.
  */
 typedef enum _alpm_transevt_t {
@@ -943,7 +943,7 @@ typedef enum _alpm_transevt_t {
 	ALPM_TRANS_EVT_DISKSPACE_DONE,
 } alpm_transevt_t;
 
-/** Transaction Conversations (ie, questions) */
+/** Conversations (ie, questions) */
 typedef enum _alpm_transconv_t {
 	ALPM_TRANS_CONV_INSTALL_IGNOREPKG = 1,
 	ALPM_TRANS_CONV_REPLACE_PKG = (1 << 1),
@@ -954,7 +954,7 @@ typedef enum _alpm_transconv_t {
 	ALPM_TRANS_CONV_SELECT_PROVIDER = (1 << 6),
 } alpm_transconv_t;
 
-/** Transaction Progress */
+/** Progress */
 typedef enum _alpm_transprog_t {
 	ALPM_TRANS_PROGRESS_ADD_START,
 	ALPM_TRANS_PROGRESS_UPGRADE_START,
@@ -964,15 +964,29 @@ typedef enum _alpm_transprog_t {
 	ALPM_TRANS_PROGRESS_INTEGRITY_START,
 } alpm_transprog_t;
 
-/** Transaction Event callback */
-typedef void (*alpm_trans_cb_event)(alpm_transevt_t, void *, void *);
+/** Event callback */
+typedef void (*alpm_cb_event)(alpm_transevt_t, void *, void *);
 
-/** Transaction Conversation callback */
-typedef void (*alpm_trans_cb_conv)(alpm_transconv_t, void *, void *,
-                                   void *, int *);
+/** Conversation callback */
+typedef void (*alpm_cb_conv)(alpm_transconv_t, void *, void *, void *, int *);
 
-/** Transaction Progress callback */
-typedef void (*alpm_trans_cb_progress)(alpm_transprog_t, const char *, int, size_t, size_t);
+/** Progress callback */
+typedef void (*alpm_cb_progress)(alpm_transprog_t, const char *, int, size_t, size_t);
+
+/** Returns the callback used for events. */
+alpm_cb_event alpm_option_get_eventcb(alpm_handle_t *handle);
+/** Sets the callback used for events. */
+int alpm_option_set_eventcb(alpm_handle_t *handle, alpm_cb_event cb);
+
+/** Returns the callback used for conversations (questions). */
+alpm_cb_conv alpm_option_get_convcb(alpm_handle_t *handle);
+/** Sets the callback used for conversations (questions). */
+int alpm_option_set_convcb(alpm_handle_t *handle, alpm_cb_conv cb);
+
+/** Returns the callback used for operation progress. */
+alpm_cb_progress alpm_option_get_progresscb(alpm_handle_t *handle);
+/** Sets the callback used for operation progress. */
+int alpm_option_set_progresscb(alpm_handle_t *handle, alpm_cb_progress cb);
 
 /** Returns the bitfield of flags for the current transaction.
  * @param handle the context handle
@@ -995,14 +1009,9 @@ alpm_list_t *alpm_trans_get_remove(alpm_handle_t *handle);
 /** Initialize the transaction.
  * @param handle the context handle
  * @param flags flags of the transaction (like nodeps, etc)
- * @param event event callback function pointer
- * @param conv question callback function pointer
- * @param progress progress callback function pointer
  * @return 0 on success, -1 on error (pm_errno is set accordingly)
  */
-int alpm_trans_init(alpm_handle_t *handle, alpm_transflag_t flags,
-                    alpm_trans_cb_event cb_event, alpm_trans_cb_conv conv,
-                    alpm_trans_cb_progress cb_progress);
+int alpm_trans_init(alpm_handle_t *handle, alpm_transflag_t flags);
 
 /** Prepare a transaction.
  * @param handle the context handle
diff --git a/lib/libalpm/conflict.c b/lib/libalpm/conflict.c
index 8417348a..4f96ad9a 100644
--- a/lib/libalpm/conflict.c
+++ b/lib/libalpm/conflict.c
@@ -384,7 +384,6 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 	alpm_list_t *i, *conflicts = NULL;
 	size_t numtargs = alpm_list_count(upgrade);
 	size_t current;
-	alpm_trans_t *trans = handle->trans;
 
 	if(!upgrade) {
 		return NULL;
@@ -402,7 +401,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 		size_t filenum;
 
 		int percent = (current * 100) / numtargs;
-		PROGRESS(trans, ALPM_TRANS_PROGRESS_CONFLICTS_START, "", percent,
+		PROGRESS(handle, ALPM_TRANS_PROGRESS_CONFLICTS_START, "", percent,
 		         numtargs, current);
 		/* CHECK 1: check every target against every target */
 		_alpm_log(handle, ALPM_LOG_DEBUG, "searching for file conflicts: %s\n",
@@ -585,7 +584,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
 			free(tmpfiles.files);
 		}
 	}
-	PROGRESS(trans, ALPM_TRANS_PROGRESS_CONFLICTS_START, "", 100,
+	PROGRESS(handle, ALPM_TRANS_PROGRESS_CONFLICTS_START, "", 100,
 			numtargs, current);
 
 	return conflicts;
diff --git a/lib/libalpm/deps.c b/lib/libalpm/deps.c
index 639f14ba..104c97ba 100644
--- a/lib/libalpm/deps.c
+++ b/lib/libalpm/deps.c
@@ -582,7 +582,7 @@ static alpm_pkg_t *resolvedep(alpm_handle_t *handle, alpm_depend_t *dep,
 			if(_alpm_pkg_should_ignore(handle, pkg)) {
 				int install = 0;
 				if(prompt) {
-					QUESTION(handle->trans, ALPM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
+					QUESTION(handle, ALPM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
 							 NULL, NULL, &install);
 				} else {
 					_alpm_log(handle, ALPM_LOG_WARNING, _("ignoring package %s-%s\n"),
@@ -607,7 +607,7 @@ static alpm_pkg_t *resolvedep(alpm_handle_t *handle, alpm_depend_t *dep,
 				if(_alpm_pkg_should_ignore(handle, pkg)) {
 					int install = 0;
 					if(prompt) {
-						QUESTION(handle->trans, ALPM_TRANS_CONV_INSTALL_IGNOREPKG,
+						QUESTION(handle, ALPM_TRANS_CONV_INSTALL_IGNOREPKG,
 									pkg, NULL, NULL, &install);
 					} else {
 						_alpm_log(handle, ALPM_LOG_WARNING, _("ignoring package %s-%s\n"),
@@ -640,7 +640,7 @@ static alpm_pkg_t *resolvedep(alpm_handle_t *handle, alpm_depend_t *dep,
 		int index = 0;
 		if(count > 1) {
 			/* if there is more than one provider, we ask the user */
-			QUESTION(handle->trans, ALPM_TRANS_CONV_SELECT_PROVIDER,
+			QUESTION(handle, ALPM_TRANS_CONV_SELECT_PROVIDER,
 					providers, dep, NULL, &index);
 		}
 		if(index >= 0 && index < count) {
diff --git a/lib/libalpm/diskspace.c b/lib/libalpm/diskspace.c
index ad80304b..f791c07b 100644
--- a/lib/libalpm/diskspace.c
+++ b/lib/libalpm/diskspace.c
@@ -260,7 +260,7 @@ int _alpm_check_diskspace(alpm_handle_t *handle)
 		for(targ = trans->remove; targ; targ = targ->next, current++) {
 			alpm_pkg_t *local_pkg;
 			int percent = (current * 100) / numtargs;
-			PROGRESS(trans, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
+			PROGRESS(handle, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
 					numtargs, current);
 
 			local_pkg = targ->data;
@@ -271,7 +271,7 @@ int _alpm_check_diskspace(alpm_handle_t *handle)
 	for(targ = trans->add; targ; targ = targ->next, current++) {
 		alpm_pkg_t *pkg, *local_pkg;
 		int percent = (current * 100) / numtargs;
-		PROGRESS(trans, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
+		PROGRESS(handle, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", percent,
 				numtargs, current);
 
 		pkg = targ->data;
@@ -290,7 +290,7 @@ int _alpm_check_diskspace(alpm_handle_t *handle)
 		}
 	}
 
-	PROGRESS(trans, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", 100,
+	PROGRESS(handle, ALPM_TRANS_PROGRESS_DISKSPACE_START, "", 100,
 			numtargs, current);
 
 	for(i = mount_points; i; i = i->next) {
diff --git a/lib/libalpm/handle.c b/lib/libalpm/handle.c
index b9d71db8..bc968c72 100644
--- a/lib/libalpm/handle.c
+++ b/lib/libalpm/handle.c
@@ -166,6 +166,24 @@ alpm_cb_totaldl SYMEXPORT alpm_option_get_totaldlcb(alpm_handle_t *handle)
 	return handle->totaldlcb;
 }
 
+alpm_cb_event SYMEXPORT alpm_option_get_eventcb(alpm_handle_t *handle)
+{
+	CHECK_HANDLE(handle, return NULL);
+	return handle->eventcb;
+}
+
+alpm_cb_conv SYMEXPORT alpm_option_get_convcb(alpm_handle_t *handle)
+{
+	CHECK_HANDLE(handle, return NULL);
+	return handle->convcb;
+}
+
+alpm_cb_progress SYMEXPORT alpm_option_get_progresscb(alpm_handle_t *handle)
+{
+	CHECK_HANDLE(handle, return NULL);
+	return handle->progresscb;
+}
+
 const char SYMEXPORT *alpm_option_get_root(alpm_handle_t *handle)
 {
 	CHECK_HANDLE(handle, return NULL);
@@ -290,6 +308,27 @@ int SYMEXPORT alpm_option_set_totaldlcb(alpm_handle_t *handle, alpm_cb_totaldl c
 	return 0;
 }
 
+int SYMEXPORT alpm_option_set_eventcb(alpm_handle_t *handle, alpm_cb_event cb)
+{
+	CHECK_HANDLE(handle, return -1);
+	handle->eventcb = cb;
+	return 0;
+}
+
+int SYMEXPORT alpm_option_set_convcb(alpm_handle_t *handle, alpm_cb_conv cb)
+{
+	CHECK_HANDLE(handle, return -1);
+	handle->convcb = cb;
+	return 0;
+}
+
+int SYMEXPORT alpm_option_set_progresscb(alpm_handle_t *handle, alpm_cb_progress cb)
+{
+	CHECK_HANDLE(handle, return -1);
+	handle->progresscb = cb;
+	return 0;
+}
+
 static char *canonicalize_path(const char *path) {
 	char *new_path;
 	size_t len;
diff --git a/lib/libalpm/handle.h b/lib/libalpm/handle.h
index 9e038581..8ceecd32 100644
--- a/lib/libalpm/handle.h
+++ b/lib/libalpm/handle.h
@@ -30,6 +30,25 @@
 #include <curl/curl.h>
 #endif
 
+#define EVENT(h, e, d1, d2) \
+do { \
+	if((h)->eventcb) { \
+		(h)->eventcb(e, d1, d2); \
+	} \
+} while(0)
+#define QUESTION(h, q, d1, d2, d3, r) \
+do { \
+	if((h)->convcb) { \
+		(h)->convcb(q, d1, d2, d3, r); \
+	} \
+} while(0)
+#define PROGRESS(h, e, p, per, n, r) \
+do { \
+	if((h)->progresscb) { \
+		(h)->progresscb(e, p, per, n, r); \
+	} \
+} while(0)
+
 struct __alpm_handle_t {
 	/* internal usage */
 	alpm_db_t *db_local;       /* local db pointer */
@@ -48,7 +67,10 @@ struct __alpm_handle_t {
 	alpm_cb_log logcb;      /* Log callback function */
 	alpm_cb_download dlcb;  /* Download callback function */
 	alpm_cb_totaldl totaldlcb;  /* Total download callback function */
-	alpm_cb_fetch fetchcb; /* Download file callback function */
+	alpm_cb_fetch fetchcb;  /* Download file callback function */
+	alpm_cb_event eventcb;
+	alpm_cb_conv convcb;
+	alpm_cb_progress progresscb;
 
 	/* filesystem paths */
 	char *root;              /* Root path, default '/' */
diff --git a/lib/libalpm/remove.c b/lib/libalpm/remove.c
index 7903a0f5..8867f651 100644
--- a/lib/libalpm/remove.c
+++ b/lib/libalpm/remove.c
@@ -161,7 +161,7 @@ int _alpm_remove_prepare(alpm_handle_t *handle, alpm_list_t **data)
 	}
 
 	if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
-		EVENT(trans, ALPM_TRANS_EVT_CHECKDEPS_START, NULL, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_CHECKDEPS_START, NULL, NULL);
 
 		_alpm_log(handle, ALPM_LOG_DEBUG, "looking for unsatisfied dependencies\n");
 		lp = alpm_checkdeps(handle, _alpm_db_get_pkgcache(db), trans->remove, NULL, 1);
@@ -205,7 +205,7 @@ int _alpm_remove_prepare(alpm_handle_t *handle, alpm_list_t **data)
 	}
 
 	if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
-		EVENT(trans, ALPM_TRANS_EVT_CHECKDEPS_DONE, NULL, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_CHECKDEPS_DONE, NULL, NULL);
 	}
 
 	return 0;
@@ -362,7 +362,7 @@ int _alpm_remove_single_package(alpm_handle_t *handle,
 		_alpm_log(handle, ALPM_LOG_DEBUG, "removing old package first (%s-%s)\n",
 				pkgname, pkgver);
 	} else {
-		EVENT(handle->trans, ALPM_TRANS_EVT_REMOVE_START, oldpkg, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_REMOVE_START, oldpkg, NULL);
 		_alpm_log(handle, ALPM_LOG_DEBUG, "removing package %s-%s\n",
 				pkgname, pkgver);
 
@@ -419,7 +419,7 @@ int _alpm_remove_single_package(alpm_handle_t *handle,
 
 	if(!newpkg) {
 		/* init progress bar, but only on true remove transactions */
-		PROGRESS(handle->trans, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname, 0,
+		PROGRESS(handle, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname, 0,
 				pkg_count, targ_count);
 	}
 
@@ -434,7 +434,7 @@ int _alpm_remove_single_package(alpm_handle_t *handle,
 		if(!newpkg) {
 			/* update progress bar after each file */
 			percent = (position * 100) / filenum;
-			PROGRESS(handle->trans, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname,
+			PROGRESS(handle, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname,
 					percent, pkg_count, targ_count);
 		}
 		position++;
@@ -443,7 +443,7 @@ int _alpm_remove_single_package(alpm_handle_t *handle,
 
 	if(!newpkg) {
 		/* set progress to 100% after we finish unlinking files */
-		PROGRESS(handle->trans, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname, 100,
+		PROGRESS(handle, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname, 100,
 				pkg_count, targ_count);
 
 		/* run the post-remove script if it exists  */
@@ -469,7 +469,7 @@ db:
 
 	if(!newpkg) {
 		/* TODO: awesome! we're passing invalid pointers. */
-		EVENT(handle->trans, ALPM_TRANS_EVT_REMOVE_DONE, oldpkg, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_REMOVE_DONE, oldpkg, NULL);
 	}
 
 	return 0;
diff --git a/lib/libalpm/sync.c b/lib/libalpm/sync.c
index f125b4a6..95b5f9dc 100644
--- a/lib/libalpm/sync.c
+++ b/lib/libalpm/sync.c
@@ -152,7 +152,7 @@ static alpm_list_t *check_replacers(alpm_handle_t *handle, alpm_pkg_t *lpkg,
 				continue;
 			}
 
-			QUESTION(handle->trans, ALPM_TRANS_CONV_REPLACE_PKG, lpkg, spkg,
+			QUESTION(handle, ALPM_TRANS_CONV_REPLACE_PKG, lpkg, spkg,
 					sdb->treename, &doreplace);
 			if(!doreplace) {
 				continue;
@@ -264,7 +264,7 @@ alpm_list_t SYMEXPORT *alpm_find_group_pkgs(alpm_list_t *dbs,
 			if(_alpm_pkg_should_ignore(db->handle, pkg)) {
 				ignorelist = alpm_list_add(ignorelist, pkg);
 				int install = 0;
-				QUESTION(db->handle->trans, ALPM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
+				QUESTION(db->handle, ALPM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
 						NULL, NULL, &install);
 				if(!install)
 					continue;
@@ -360,7 +360,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 
 		/* Build up list by repeatedly resolving each transaction package */
 		/* Resolve targets dependencies */
-		EVENT(trans, ALPM_TRANS_EVT_RESOLVEDEPS_START, NULL, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_RESOLVEDEPS_START, NULL, NULL);
 		_alpm_log(handle, ALPM_LOG_DEBUG, "resolving target's dependencies\n");
 
 		/* build remove list for resolvedeps */
@@ -393,7 +393,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 		   see if they'd like to ignore them rather than failing the sync */
 		if(unresolvable != NULL) {
 			int remove_unresolvable = 0;
-			QUESTION(trans, ALPM_TRANS_CONV_REMOVE_PKGS, unresolvable,
+			QUESTION(handle, ALPM_TRANS_CONV_REMOVE_PKGS, unresolvable,
 					NULL, NULL, &remove_unresolvable);
 			if(remove_unresolvable) {
 				/* User wants to remove the unresolvable packages from the
@@ -431,12 +431,12 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 		trans->add = _alpm_sortbydeps(handle, resolved, 0);
 		alpm_list_free(resolved);
 
-		EVENT(trans, ALPM_TRANS_EVT_RESOLVEDEPS_DONE, NULL, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_RESOLVEDEPS_DONE, NULL, NULL);
 	}
 
 	if(!(trans->flags & ALPM_TRANS_FLAG_NOCONFLICTS)) {
 		/* check for inter-conflicts and whatnot */
-		EVENT(trans, ALPM_TRANS_EVT_INTERCONFLICTS_START, NULL, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_INTERCONFLICTS_START, NULL, NULL);
 
 		_alpm_log(handle, ALPM_LOG_DEBUG, "looking for conflicts\n");
 
@@ -525,7 +525,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 			alpm_pkg_t *sync = _alpm_pkg_find(trans->add, conflict->package1);
 			alpm_pkg_t *local = _alpm_db_get_pkgfromcache(handle->db_local, conflict->package2);
 			int doremove = 0;
-			QUESTION(trans, ALPM_TRANS_CONV_CONFLICT_PKG, conflict->package1,
+			QUESTION(handle, ALPM_TRANS_CONV_CONFLICT_PKG, conflict->package1,
 							conflict->package2, conflict->reason->name, &doremove);
 			if(doremove) {
 				/* append to the removes list */
@@ -546,7 +546,7 @@ int _alpm_sync_prepare(alpm_handle_t *handle, alpm_list_t **data)
 				goto cleanup;
 			}
 		}
-		EVENT(trans, ALPM_TRANS_EVT_INTERCONFLICTS_DONE, NULL, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_INTERCONFLICTS_DONE, NULL, NULL);
 		alpm_list_free_inner(deps, (alpm_list_fn_free)_alpm_conflict_free);
 		alpm_list_free(deps);
 	}
@@ -646,7 +646,7 @@ static int apply_deltas(alpm_handle_t *handle)
 		if(!deltas_found) {
 			/* only show this if we actually have deltas to apply, and it is before
 			 * the very first one */
-			EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCHES_START, NULL, NULL);
+			EVENT(handle, ALPM_TRANS_EVT_DELTA_PATCHES_START, NULL, NULL);
 			deltas_found = 1;
 		}
 
@@ -680,11 +680,11 @@ static int apply_deltas(alpm_handle_t *handle)
 
 			_alpm_log(handle, ALPM_LOG_DEBUG, "command: %s\n", command);
 
-			EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCH_START, d->to, d->delta);
+			EVENT(handle, ALPM_TRANS_EVT_DELTA_PATCH_START, d->to, d->delta);
 
 			int retval = system(command);
 			if(retval == 0) {
-				EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCH_DONE, NULL, NULL);
+				EVENT(handle, ALPM_TRANS_EVT_DELTA_PATCH_DONE, NULL, NULL);
 
 				/* delete the delta file */
 				unlink(delta);
@@ -702,7 +702,7 @@ static int apply_deltas(alpm_handle_t *handle)
 
 			if(retval != 0) {
 				/* one delta failed for this package, cancel the remaining ones */
-				EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCH_FAILED, NULL, NULL);
+				EVENT(handle, ALPM_TRANS_EVT_DELTA_PATCH_FAILED, NULL, NULL);
 				handle->pm_errno = ALPM_ERR_DLT_PATCHFAILED;
 				ret = 1;
 				break;
@@ -710,28 +710,25 @@ static int apply_deltas(alpm_handle_t *handle)
 		}
 	}
 	if(deltas_found) {
-		EVENT(trans, ALPM_TRANS_EVT_DELTA_PATCHES_DONE, NULL, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_DELTA_PATCHES_DONE, NULL, NULL);
 	}
 
 	return ret;
 }
 
-/** Compares the md5sum of a file to the expected value.
- *
- * If the md5sum does not match, the user is asked whether the file
- * should be deleted.
- *
- * @param trans the transaction
+/**
+ * Prompts to delete the file now that we know it is invalid.
+ * @param handle the context handle
  * @param filename the absolute path of the file to test
  * @param reason an error code indicating the reason for package invalidity
  *
  * @return 1 if file was removed, 0 otherwise
  */
-static int prompt_to_delete(alpm_trans_t *trans, const char *filepath,
+static int prompt_to_delete(alpm_handle_t *handle, const char *filepath,
 		enum _alpm_errno_t reason)
 {
 	int doremove = 0;
-	QUESTION(trans, ALPM_TRANS_CONV_CORRUPTED_PKG, (char *)filepath,
+	QUESTION(handle, ALPM_TRANS_CONV_CORRUPTED_PKG, (char *)filepath,
 			&reason, NULL, &doremove);
 	if(doremove) {
 		unlink(filepath);
@@ -744,21 +741,20 @@ static int validate_deltas(alpm_handle_t *handle, alpm_list_t *deltas,
 {
 	int errors = 0;
 	alpm_list_t *i;
-	alpm_trans_t *trans = handle->trans;
 
 	if(!deltas) {
 		return 0;
 	}
 
 	/* Check integrity of deltas */
-	EVENT(trans, ALPM_TRANS_EVT_DELTA_INTEGRITY_START, NULL, NULL);
+	EVENT(handle, ALPM_TRANS_EVT_DELTA_INTEGRITY_START, NULL, NULL);
 
 	for(i = deltas; i; i = i->next) {
 		alpm_delta_t *d = alpm_list_getdata(i);
 		char *filepath = _alpm_filecache_find(handle, d->delta);
 
 		if(_alpm_test_checksum(filepath, d->delta_md5, ALPM_CSUM_MD5)) {
-			prompt_to_delete(trans, filepath, ALPM_ERR_DLT_INVALID);
+			prompt_to_delete(handle, filepath, ALPM_ERR_DLT_INVALID);
 			errors++;
 			*data = alpm_list_add(*data, strdup(d->delta));
 		}
@@ -844,7 +840,7 @@ static int download_files(alpm_handle_t *handle, alpm_list_t **deltas)
 		}
 
 		if(files) {
-			EVENT(handle->trans, ALPM_TRANS_EVT_RETRIEVE_START, current->treename, NULL);
+			EVENT(handle, ALPM_TRANS_EVT_RETRIEVE_START, current->treename, NULL);
 			for(j = files; j; j = j->next) {
 				struct dload_payload *payload = j->data;
 				alpm_list_t *server;
@@ -931,7 +927,7 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 
 	/* Check integrity of packages */
 	numtargs = alpm_list_count(trans->add);
-	EVENT(trans, ALPM_TRANS_EVT_INTEGRITY_START, NULL, NULL);
+	EVENT(handle, ALPM_TRANS_EVT_INTEGRITY_START, NULL, NULL);
 
 	current = current_bytes = 0;
 	errors = 0;
@@ -943,7 +939,7 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 		alpm_siglevel_t level;
 		int percent = (int)(((double)current_bytes / total_bytes) * 100);
 
-		PROGRESS(trans, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", percent,
+		PROGRESS(handle, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", percent,
 				numtargs, current);
 		if(spkg->origin == PKG_FROM_FILE) {
 			continue; /* pkg_load() has been already called, this package is valid */
@@ -962,7 +958,7 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 				spkg->name);
 		alpm_pkg_t *pkgfile =_alpm_pkg_load_internal(handle, filepath, spkg, 1, level);
 		if(!pkgfile) {
-			prompt_to_delete(trans, filepath, handle->pm_errno);
+			prompt_to_delete(handle, filepath, handle->pm_errno);
 			errors++;
 			*data = alpm_list_add(*data, strdup(filename));
 			FREE(filepath);
@@ -974,9 +970,9 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 		_alpm_pkg_free_trans(spkg); /* spkg has been removed from the target list */
 	}
 
-	PROGRESS(trans, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", 100,
+	PROGRESS(handle, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", 100,
 			numtargs, current);
-	EVENT(trans, ALPM_TRANS_EVT_INTEGRITY_DONE, NULL, NULL);
+	EVENT(handle, ALPM_TRANS_EVT_INTEGRITY_DONE, NULL, NULL);
 
 
 	if(errors) {
@@ -996,7 +992,7 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 
 	/* fileconflict check */
 	if(!(trans->flags & ALPM_TRANS_FLAG_FORCE)) {
-		EVENT(trans, ALPM_TRANS_EVT_FILECONFLICTS_START, NULL, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_FILECONFLICTS_START, NULL, NULL);
 
 		_alpm_log(handle, ALPM_LOG_DEBUG, "looking for file conflicts\n");
 		alpm_list_t *conflict = _alpm_db_find_fileconflicts(handle,
@@ -1011,12 +1007,12 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 			RET_ERR(handle, ALPM_ERR_FILE_CONFLICTS, -1);
 		}
 
-		EVENT(trans, ALPM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL);
 	}
 
 	/* check available disk space */
 	if(handle->checkspace) {
-		EVENT(trans, ALPM_TRANS_EVT_DISKSPACE_START, NULL, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_DISKSPACE_START, NULL, NULL);
 
 		_alpm_log(handle, ALPM_LOG_DEBUG, "checking available disk space\n");
 		if(_alpm_check_diskspace(handle) == -1) {
@@ -1024,7 +1020,7 @@ int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
 			return -1;
 		}
 
-		EVENT(trans, ALPM_TRANS_EVT_DISKSPACE_DONE, NULL, NULL);
+		EVENT(handle, ALPM_TRANS_EVT_DISKSPACE_DONE, NULL, NULL);
 	}
 
 	/* remove conflicting and to-be-replaced packages */
diff --git a/lib/libalpm/trans.c b/lib/libalpm/trans.c
index c594520d..47b9c98d 100644
--- a/lib/libalpm/trans.c
+++ b/lib/libalpm/trans.c
@@ -48,9 +48,7 @@
  */
 
 /** Initialize the transaction. */
-int SYMEXPORT alpm_trans_init(alpm_handle_t *handle, alpm_transflag_t flags,
-		alpm_trans_cb_event event, alpm_trans_cb_conv conv,
-		alpm_trans_cb_progress progress)
+int SYMEXPORT alpm_trans_init(alpm_handle_t *handle, alpm_transflag_t flags)
 {
 	alpm_trans_t *trans;
 
@@ -67,9 +65,6 @@ int SYMEXPORT alpm_trans_init(alpm_handle_t *handle, alpm_transflag_t flags,
 
 	CALLOC(trans, 1, sizeof(alpm_trans_t), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
 	trans->flags = flags;
-	trans->cb_event = event;
-	trans->cb_conv = conv;
-	trans->cb_progress = progress;
 	trans->state = STATE_INITIALIZED;
 
 	handle->trans = trans;
diff --git a/lib/libalpm/trans.h b/lib/libalpm/trans.h
index 6d5c08d1..a2be5a5c 100644
--- a/lib/libalpm/trans.h
+++ b/lib/libalpm/trans.h
@@ -42,34 +42,10 @@ struct __alpm_trans_t {
 	alpm_list_t *add;      /* list of (alpm_pkg_t *) */
 	alpm_list_t *remove;      /* list of (alpm_pkg_t *) */
 	alpm_list_t *skip_remove;   /* list of (char *) */
-	alpm_trans_cb_event cb_event;
-	alpm_trans_cb_conv cb_conv;
-	alpm_trans_cb_progress cb_progress;
 };
 
-#define EVENT(t, e, d1, d2) \
-do { \
-	if((t)->cb_event) { \
-		(t)->cb_event(e, d1, d2); \
-	} \
-} while(0)
-#define QUESTION(t, q, d1, d2, d3, r) \
-do { \
-	if((t)->cb_conv) { \
-		(t)->cb_conv(q, d1, d2, d3, r); \
-	} \
-} while(0)
-#define PROGRESS(t, e, p, per, h, r) \
-do { \
-	if((t)->cb_progress) { \
-		(t)->cb_progress(e, p, per, h, r); \
-	} \
-} while(0)
-
 void _alpm_trans_free(alpm_trans_t *trans);
-int _alpm_trans_init(alpm_trans_t *trans, alpm_transflag_t flags,
-                     alpm_trans_cb_event event, alpm_trans_cb_conv conv,
-                     alpm_trans_cb_progress progress);
+int _alpm_trans_init(alpm_trans_t *trans, alpm_transflag_t flags);
 int _alpm_runscriptlet(alpm_handle_t *handle, const char *installfn,
 		const char *script, const char *ver, const char *oldver);
 
diff --git a/lib/libalpm/util.c b/lib/libalpm/util.c
index 9bbac43b..161a35a9 100644
--- a/lib/libalpm/util.c
+++ b/lib/libalpm/util.c
@@ -569,7 +569,7 @@ int _alpm_run_chroot(alpm_handle_t *handle, const char *path, char *const argv[]
 				if(fgets(line, PATH_MAX, pipe_file) == NULL)
 					break;
 				alpm_logaction(handle, "%s", line);
-				EVENT(handle->trans, ALPM_TRANS_EVT_SCRIPTLET_INFO, line, NULL);
+				EVENT(handle, ALPM_TRANS_EVT_SCRIPTLET_INFO, line, NULL);
 			}
 			fclose(pipe_file);
 		}
diff --git a/src/pacman/callback.c b/src/pacman/callback.c
index c299564c..c6146a3c 100644
--- a/src/pacman/callback.c
+++ b/src/pacman/callback.c
@@ -153,6 +153,9 @@ static void fill_progress(const int bar_percent, const int disp_percent,
 /* callback to handle messages/notifications from libalpm transactions */
 void cb_trans_evt(alpm_transevt_t event, void *data1, void *data2)
 {
+	if(config->print) {
+		return;
+	}
 	switch(event) {
 		case ALPM_TRANS_EVT_CHECKDEPS_START:
 		  printf(_("checking dependencies...\n"));
@@ -252,6 +255,9 @@ void cb_trans_evt(alpm_transevt_t event, void *data1, void *data2)
 void cb_trans_conv(alpm_transconv_t event, void *data1, void *data2,
                    void *data3, int *response)
 {
+	if(config->print) {
+		return;
+	}
 	switch(event) {
 		case ALPM_TRANS_CONV_INSTALL_IGNOREPKG:
 			if(!config->op_s_downloadonly) {
diff --git a/src/pacman/conf.c b/src/pacman/conf.c
index fe858499..f87824c9 100644
--- a/src/pacman/conf.c
+++ b/src/pacman/conf.c
@@ -534,6 +534,9 @@ static int setup_libalpm(void)
 
 	alpm_option_set_logcb(handle, cb_log);
 	alpm_option_set_dlcb(handle, cb_dl_progress);
+	alpm_option_set_eventcb(handle, cb_trans_evt);
+	alpm_option_set_convcb(handle, cb_trans_conv);
+	alpm_option_set_progresscb(handle, cb_trans_progress);
 
 	config->logfile = config->logfile ? config->logfile : strdup(LOGFILE);
 	ret = alpm_option_set_logfile(handle, config->logfile);
diff --git a/src/pacman/util.c b/src/pacman/util.c
index 599c18c4..594186f6 100644
--- a/src/pacman/util.c
+++ b/src/pacman/util.c
@@ -55,13 +55,7 @@ int trans_init(alpm_transflag_t flags, int check_valid)
 
 	check_syncdbs(0, check_valid);
 
-	if(config->print) {
-		ret = alpm_trans_init(config->handle, flags, NULL, NULL, NULL);
-	} else {
-		ret = alpm_trans_init(config->handle, flags, cb_trans_evt, cb_trans_conv,
-				cb_trans_progress);
-	}
-
+	ret = alpm_trans_init(config->handle, flags);
 	if(ret == -1) {
 		trans_init_error();
 		return -1;