1 files changed, 132 insertions, 145 deletions

diff --git a/lib/libalpm/add.c b/lib/libalpm/add.c
index ad6ef17e..6f93c61d 100644
--- a/lib/libalpm/add.c
+++ b/lib/libalpm/add.c
@@ -37,50 +37,44 @@
 
 /* libalpm */
 #include "add.h"
+#include "alpm.h"
 #include "alpm_list.h"
+#include "handle.h"
 #include "trans.h"
 #include "util.h"
 #include "log.h"
 #include "backup.h"
 #include "package.h"
 #include "db.h"
-#include "conflict.h"
-#include "deps.h"
 #include "remove.h"
 #include "handle.h"
 
-/** Add a package to the transaction.
- * @param pkg the package to add
- * @return 0 on success, -1 on error (pm_errno is set accordingly)
- */
-int SYMEXPORT alpm_add_pkg(pmpkg_t *pkg)
+/** Add a package to the transaction. */
+int SYMEXPORT alpm_add_pkg(pmhandle_t *handle, pmpkg_t *pkg)
 {
 	const char *pkgname, *pkgver;
 	pmtrans_t *trans;
-	pmdb_t *db_local;
 	pmpkg_t *local;
 
-	ALPM_LOG_FUNC;
-
 	/* Sanity checks */
-	ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
-	ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+	ASSERT(handle != NULL, return -1);
+	ASSERT(pkg != NULL, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
+	ASSERT(handle == pkg->handle, RET_ERR(handle, PM_ERR_WRONG_ARGS, -1));
 	trans = handle->trans;
-	ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
-	ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(PM_ERR_TRANS_NOT_INITIALIZED, -1));
-	ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
-	db_local = handle->db_local;
+	ASSERT(trans != NULL, RET_ERR(handle, PM_ERR_TRANS_NULL, -1));
+	ASSERT(trans->state == STATE_INITIALIZED,
+			RET_ERR(handle, PM_ERR_TRANS_NOT_INITIALIZED, -1));
 
-	pkgname = alpm_pkg_get_name(pkg);
-	pkgver = alpm_pkg_get_version(pkg);
+	pkgname = pkg->name;
+	pkgver = pkg->version;
 
-	_alpm_log(PM_LOG_DEBUG, "adding package '%s'\n", pkgname);
+	_alpm_log(handle, PM_LOG_DEBUG, "adding package '%s'\n", pkgname);
 
 	if(_alpm_pkg_find(trans->add, pkgname)) {
-		RET_ERR(PM_ERR_TRANS_DUP_TARGET, -1);
+		RET_ERR(handle, PM_ERR_TRANS_DUP_TARGET, -1);
 	}
 
-	local = _alpm_db_get_pkgfromcache(db_local, pkgname);
+	local = _alpm_db_get_pkgfromcache(handle->db_local, pkgname);
 	if(local) {
 		const char *localpkgname = alpm_pkg_get_name(local);
 		const char *localpkgver = alpm_pkg_get_version(local);
@@ -89,30 +83,30 @@ int SYMEXPORT alpm_add_pkg(pmpkg_t *pkg)
 		if(cmp == 0) {
 			if(trans->flags & PM_TRANS_FLAG_NEEDED) {
 				/* with the NEEDED flag, packages up to date are not reinstalled */
-				_alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- skipping\n"),
+				_alpm_log(handle, PM_LOG_WARNING, _("%s-%s is up to date -- skipping\n"),
 						localpkgname, localpkgver);
-				return(0);
+				return 0;
 			} else if(!(trans->flags & PM_TRANS_FLAG_DOWNLOADONLY)) {
-				_alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- reinstalling\n"),
+				_alpm_log(handle, PM_LOG_WARNING, _("%s-%s is up to date -- reinstalling\n"),
 						localpkgname, localpkgver);
 			}
 		} else if(cmp < 0) {
 			/* local version is newer */
-			_alpm_log(PM_LOG_WARNING, _("downgrading package %s (%s => %s)\n"),
+			_alpm_log(handle, PM_LOG_WARNING, _("downgrading package %s (%s => %s)\n"),
 					localpkgname, localpkgver, pkgver);
 		}
 	}
 
 	/* add the package to the transaction */
 	pkg->reason = PM_PKG_REASON_EXPLICIT;
-	_alpm_log(PM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
+	_alpm_log(handle, PM_LOG_DEBUG, "adding package %s-%s to the transaction add list\n",
 						pkgname, pkgver);
 	trans->add = alpm_list_add(trans->add, pkg);
 
-	return(0);
+	return 0;
 }
 
-static int perform_extraction(struct archive *archive,
+static int perform_extraction(pmhandle_t *handle, struct archive *archive,
 		struct archive_entry *entry, const char *filename, const char *origname)
 {
 	int ret;
@@ -125,21 +119,20 @@ static int perform_extraction(struct archive *archive,
 	ret = archive_read_extract(archive, entry, archive_flags);
 	if(ret == ARCHIVE_WARN && archive_errno(archive) != ENOSPC) {
 		/* operation succeeded but a "non-critical" error was encountered */
-		_alpm_log(PM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
+		_alpm_log(handle, PM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
 				origname, archive_error_string(archive));
 	} else if(ret != ARCHIVE_OK) {
-		_alpm_log(PM_LOG_ERROR, _("could not extract %s (%s)\n"),
+		_alpm_log(handle, PM_LOG_ERROR, _("could not extract %s (%s)\n"),
 				origname, archive_error_string(archive));
-		alpm_logaction("error: could not extract %s (%s)\n",
+		alpm_logaction(handle, "error: could not extract %s (%s)\n",
 				origname, archive_error_string(archive));
-		return(1);
+		return 1;
 	}
-	return(0);
+	return 0;
 }
 
-static int extract_single_file(struct archive *archive,
-		struct archive_entry *entry, pmpkg_t *newpkg, pmpkg_t *oldpkg,
-		pmtrans_t *trans, pmdb_t *db)
+static int extract_single_file(pmhandle_t *handle, struct archive *archive,
+		struct archive_entry *entry, pmpkg_t *newpkg, pmpkg_t *oldpkg)
 {
 	const char *entryname;
 	mode_t entrymode;
@@ -157,19 +150,19 @@ static int extract_single_file(struct archive *archive,
 	if(strcmp(entryname, ".INSTALL") == 0) {
 		/* the install script goes inside the db */
 		snprintf(filename, PATH_MAX, "%s%s-%s/install",
-				_alpm_db_path(db), newpkg->name, newpkg->version);
+				_alpm_db_path(handle->db_local), newpkg->name, newpkg->version);
 		archive_entry_set_perm(entry, 0644);
 	} else if(strcmp(entryname, ".CHANGELOG") == 0) {
 		/* the changelog goes inside the db */
 		snprintf(filename, PATH_MAX, "%s%s-%s/changelog",
-				_alpm_db_path(db), newpkg->name, newpkg->version);
+				_alpm_db_path(handle->db_local), newpkg->name, newpkg->version);
 		archive_entry_set_perm(entry, 0644);
 	} else if(*entryname == '.') {
 		/* for now, ignore all files starting with '.' that haven't
 		 * already been handled (for future possibilities) */
-		_alpm_log(PM_LOG_DEBUG, "skipping extraction of '%s'\n", entryname);
+		_alpm_log(handle, PM_LOG_DEBUG, "skipping extraction of '%s'\n", entryname);
 		archive_read_data_skip(archive);
-		return(0);
+		return 0;
 	} else {
 		/* build the new entryname relative to handle->root */
 		snprintf(filename, PATH_MAX, "%s%s", handle->root, entryname);
@@ -177,12 +170,12 @@ static int extract_single_file(struct archive *archive,
 
 	/* if a file is in NoExtract then we never extract it */
 	if(alpm_list_find_str(handle->noextract, entryname)) {
-		_alpm_log(PM_LOG_DEBUG, "%s is in NoExtract, skipping extraction\n",
+		_alpm_log(handle, PM_LOG_DEBUG, "%s is in NoExtract, skipping extraction\n",
 				entryname);
-		alpm_logaction("note: %s is in NoExtract, skipping extraction\n",
+		alpm_logaction(handle, "note: %s is in NoExtract, skipping extraction\n",
 				entryname);
 		archive_read_data_skip(archive);
-		return(0);
+		return 0;
 	}
 
 	/* Check for file existence. This is one of the more crucial parts
@@ -216,42 +209,42 @@ static int extract_single_file(struct archive *archive,
 				if(lsbuf.st_mode != entrymode) {
 					/* if filesystem perms are different than pkg perms, warn user */
 					mode_t mask = 07777;
-					_alpm_log(PM_LOG_WARNING, _("directory permissions differ on %s\n"
+					_alpm_log(handle, PM_LOG_WARNING, _("directory permissions differ on %s\n"
 								"filesystem: %o  package: %o\n"), entryname, lsbuf.st_mode & mask,
 							entrymode & mask);
-					alpm_logaction("warning: directory permissions differ on %s\n"
+					alpm_logaction(handle, "warning: directory permissions differ on %s\n"
 							"filesystem: %o  package: %o\n", entryname, lsbuf.st_mode & mask,
 							entrymode & mask);
 				}
-				_alpm_log(PM_LOG_DEBUG, "extract: skipping dir extraction of %s\n",
+				_alpm_log(handle, PM_LOG_DEBUG, "extract: skipping dir extraction of %s\n",
 						entryname);
 				archive_read_data_skip(archive);
-				return(0);
+				return 0;
 			} else {
 				/* case 10/11: trying to overwrite dir with file/symlink, don't allow it */
-				_alpm_log(PM_LOG_ERROR, _("extract: not overwriting dir with file %s\n"),
+				_alpm_log(handle, PM_LOG_ERROR, _("extract: not overwriting dir with file %s\n"),
 						entryname);
 				archive_read_data_skip(archive);
-				return(1);
+				return 1;
 			}
 		} else if(S_ISLNK(lsbuf.st_mode) && S_ISDIR(entrymode)) {
 			/* case 9: existing symlink, dir in package */
 			if(S_ISDIR(sbuf.st_mode)) {
 				/* the symlink on FS is to a directory, so we'll use it */
-				_alpm_log(PM_LOG_DEBUG, "extract: skipping symlink overwrite of %s\n",
+				_alpm_log(handle, PM_LOG_DEBUG, "extract: skipping symlink overwrite of %s\n",
 						entryname);
 				archive_read_data_skip(archive);
-				return(0);
+				return 0;
 			} else {
 				/* this is BAD. symlink was not to a directory */
-				_alpm_log(PM_LOG_ERROR, _("extract: symlink %s does not point to dir\n"),
+				_alpm_log(handle, PM_LOG_ERROR, _("extract: symlink %s does not point to dir\n"),
 						entryname);
 				archive_read_data_skip(archive);
-				return(1);
+				return 1;
 			}
 		} else if(S_ISREG(lsbuf.st_mode) && S_ISDIR(entrymode)) {
 			/* case 6: trying to overwrite file with dir */
-			_alpm_log(PM_LOG_DEBUG, "extract: overwriting file with dir %s\n",
+			_alpm_log(handle, PM_LOG_DEBUG, "extract: overwriting file with dir %s\n",
 					entryname);
 		} else if(S_ISREG(entrymode)) {
 			/* case 4,7: */
@@ -275,7 +268,7 @@ static int extract_single_file(struct archive *archive,
 
 				/* if we force hash_orig to be non-NULL retroactive backup works */
 				if(needbackup && !hash_orig) {
-					STRDUP(hash_orig, "", RET_ERR(PM_ERR_MEMORY, -1));
+					STRDUP(hash_orig, "", RET_ERR(handle, PM_ERR_MEMORY, -1));
 				}
 			}
 		}
@@ -285,7 +278,7 @@ static int extract_single_file(struct archive *archive,
 
 	/* we need access to the original entryname later after calls to
 	 * archive_entry_set_pathname(), so we need to dupe it and free() later */
-	STRDUP(entryname_orig, entryname, RET_ERR(PM_ERR_MEMORY, -1));
+	STRDUP(entryname_orig, entryname, RET_ERR(handle, PM_ERR_MEMORY, -1));
 
 	if(needbackup) {
 		char checkfile[PATH_MAX];
@@ -294,12 +287,12 @@ static int extract_single_file(struct archive *archive,
 
 		snprintf(checkfile, PATH_MAX, "%s.paccheck", filename);
 
-		ret = perform_extraction(archive, entry, checkfile, entryname_orig);
+		ret = perform_extraction(handle, archive, entry, checkfile, entryname_orig);
 		if(ret == 1) {
 			/* error */
 			FREE(hash_orig);
 			FREE(entryname_orig);
-			return(1);
+			return 1;
 		}
 
 		hash_local = alpm_compute_md5sum(filename);
@@ -317,7 +310,7 @@ static int extract_single_file(struct archive *archive,
 			char *backup = NULL;
 			/* length is tab char, null byte and MD5 (32 char) */
 			size_t backup_len = strlen(oldbackup) + 34;
-			MALLOC(backup, backup_len, RET_ERR(PM_ERR_MEMORY, -1));
+			MALLOC(backup, backup_len, RET_ERR(handle, PM_ERR_MEMORY, -1));
 
 			sprintf(backup, "%s\t%s", oldbackup, hash_pkg);
 			backup[backup_len-1] = '\0';
@@ -325,10 +318,10 @@ static int extract_single_file(struct archive *archive,
 			backups->data = backup;
 		}
 
-		_alpm_log(PM_LOG_DEBUG, "checking hashes for %s\n", entryname_orig);
-		_alpm_log(PM_LOG_DEBUG, "current:  %s\n", hash_local);
-		_alpm_log(PM_LOG_DEBUG, "new:      %s\n", hash_pkg);
-		_alpm_log(PM_LOG_DEBUG, "original: %s\n", hash_orig);
+		_alpm_log(handle, PM_LOG_DEBUG, "checking hashes for %s\n", entryname_orig);
+		_alpm_log(handle, PM_LOG_DEBUG, "current:  %s\n", hash_local);
+		_alpm_log(handle, PM_LOG_DEBUG, "new:      %s\n", hash_pkg);
+		_alpm_log(handle, PM_LOG_DEBUG, "original: %s\n", hash_orig);
 
 		if(!oldpkg) {
 			if(strcmp(hash_local, hash_pkg) != 0) {
@@ -339,22 +332,22 @@ static int extract_single_file(struct archive *archive,
 
 				/* move the existing file to the "pacorig" */
 				if(rename(filename, newpath)) {
-					_alpm_log(PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+					_alpm_log(handle, PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
 							filename, newpath, strerror(errno));
-					alpm_logaction("error: could not rename %s to %s (%s)\n",
+					alpm_logaction(handle, "error: could not rename %s to %s (%s)\n",
 							filename, newpath, strerror(errno));
 					errors++;
 				} else {
 					/* rename the file we extracted to the real name */
 					if(rename(checkfile, filename)) {
-						_alpm_log(PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+						_alpm_log(handle, PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
 								checkfile, filename, strerror(errno));
-						alpm_logaction("error: could not rename %s to %s (%s)\n",
+						alpm_logaction(handle, "error: could not rename %s to %s (%s)\n",
 								checkfile, filename, strerror(errno));
 						errors++;
 					} else {
-						_alpm_log(PM_LOG_WARNING, _("%s saved as %s\n"), filename, newpath);
-						alpm_logaction("warning: %s saved as %s\n", filename, newpath);
+						_alpm_log(handle, PM_LOG_WARNING, _("%s saved as %s\n"), filename, newpath);
+						alpm_logaction(handle, "warning: %s saved as %s\n", filename, newpath);
 					}
 				}
 			} else {
@@ -367,48 +360,48 @@ static int extract_single_file(struct archive *archive,
 			if(strcmp(hash_orig, hash_local) == 0) {
 				/* installed file has NOT been changed by user */
 				if(strcmp(hash_orig, hash_pkg) != 0) {
-					_alpm_log(PM_LOG_DEBUG, "action: installing new file: %s\n",
+					_alpm_log(handle, PM_LOG_DEBUG, "action: installing new file: %s\n",
 							entryname_orig);
 
 					if(rename(checkfile, filename)) {
-						_alpm_log(PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+						_alpm_log(handle, PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
 								checkfile, filename, strerror(errno));
-						alpm_logaction("error: could not rename %s to %s (%s)\n",
+						alpm_logaction(handle, "error: could not rename %s to %s (%s)\n",
 								checkfile, filename, strerror(errno));
 						errors++;
 					}
 				} else {
 					/* there's no sense in installing the same file twice, install
 					 * ONLY is the original and package hashes differ */
-					_alpm_log(PM_LOG_DEBUG, "action: leaving existing file in place\n");
+					_alpm_log(handle, PM_LOG_DEBUG, "action: leaving existing file in place\n");
 					unlink(checkfile);
 				}
 			} else if(strcmp(hash_orig, hash_pkg) == 0) {
 				/* originally installed file and new file are the same - this
 				 * implies the case above failed - i.e. the file was changed by a
 				 * user */
-				_alpm_log(PM_LOG_DEBUG, "action: leaving existing file in place\n");
+				_alpm_log(handle, PM_LOG_DEBUG, "action: leaving existing file in place\n");
 				unlink(checkfile);
 			} else if(strcmp(hash_local, hash_pkg) == 0) {
 				/* this would be magical.  The above two cases failed, but the
 				 * user changes just so happened to make the new file exactly the
 				 * same as the one in the package... skip it */
-				_alpm_log(PM_LOG_DEBUG, "action: leaving existing file in place\n");
+				_alpm_log(handle, PM_LOG_DEBUG, "action: leaving existing file in place\n");
 				unlink(checkfile);
 			} else {
 				char newpath[PATH_MAX];
-				_alpm_log(PM_LOG_DEBUG, "action: keeping current file and installing"
+				_alpm_log(handle, PM_LOG_DEBUG, "action: keeping current file and installing"
 						" new one with .pacnew ending\n");
 				snprintf(newpath, PATH_MAX, "%s.pacnew", filename);
 				if(rename(checkfile, newpath)) {
-					_alpm_log(PM_LOG_ERROR, _("could not install %s as %s (%s)\n"),
+					_alpm_log(handle, PM_LOG_ERROR, _("could not install %s as %s (%s)\n"),
 							filename, newpath, strerror(errno));
-					alpm_logaction("error: could not install %s as %s (%s)\n",
+					alpm_logaction(handle, "error: could not install %s as %s (%s)\n",
 							filename, newpath, strerror(errno));
 				} else {
-					_alpm_log(PM_LOG_WARNING, _("%s installed as %s\n"),
+					_alpm_log(handle, PM_LOG_WARNING, _("%s installed as %s\n"),
 							filename, newpath);
-					alpm_logaction("warning: %s installed as %s\n",
+					alpm_logaction(handle, "warning: %s installed as %s\n",
 							filename, newpath);
 				}
 			}
@@ -423,26 +416,26 @@ static int extract_single_file(struct archive *archive,
 		/* we didn't need a backup */
 		if(notouch) {
 			/* change the path to a .pacnew extension */
-			_alpm_log(PM_LOG_DEBUG, "%s is in NoUpgrade -- skipping\n", filename);
-			_alpm_log(PM_LOG_WARNING, _("extracting %s as %s.pacnew\n"), filename, filename);
-			alpm_logaction("warning: extracting %s as %s.pacnew\n", filename, filename);
+			_alpm_log(handle, PM_LOG_DEBUG, "%s is in NoUpgrade -- skipping\n", filename);
+			_alpm_log(handle, PM_LOG_WARNING, _("extracting %s as %s.pacnew\n"), filename, filename);
+			alpm_logaction(handle, "warning: extracting %s as %s.pacnew\n", filename, filename);
 			strncat(filename, ".pacnew", PATH_MAX - strlen(filename));
 		} else {
-			_alpm_log(PM_LOG_DEBUG, "extracting %s\n", filename);
+			_alpm_log(handle, PM_LOG_DEBUG, "extracting %s\n", filename);
 		}
 
-		if(trans->flags & PM_TRANS_FLAG_FORCE) {
+		if(handle->trans->flags & PM_TRANS_FLAG_FORCE) {
 			/* if FORCE was used, unlink() each file (whether it's there
 			 * or not) before extracting. This prevents the old "Text file busy"
 			 * error that crops up if forcing a glibc or pacman upgrade. */
 			unlink(filename);
 		}
 
-		ret = perform_extraction(archive, entry, filename, entryname_orig);
+		ret = perform_extraction(handle, archive, entry, filename, entryname_orig);
 		if(ret == 1) {
 			/* error */
 			FREE(entryname_orig);
-			return(1);
+			return 1;
 		}
 
 		/* calculate an hash if this is in newpkg's backup */
@@ -456,10 +449,10 @@ static int extract_single_file(struct archive *archive,
 			if(!oldbackup || strcmp(oldbackup, entryname_orig) != 0) {
 				continue;
 			}
-			_alpm_log(PM_LOG_DEBUG, "appending backup entry for %s\n", filename);
+			_alpm_log(handle, PM_LOG_DEBUG, "appending backup entry for %s\n", filename);
 
 			hash = alpm_compute_md5sum(filename);
-			MALLOC(backup, backup_len, RET_ERR(PM_ERR_MEMORY, -1));
+			MALLOC(backup, backup_len, RET_ERR(handle, PM_ERR_MEMORY, -1));
 
 			sprintf(backup, "%s\t%s", oldbackup, hash);
 			backup[backup_len-1] = '\0';
@@ -469,20 +462,18 @@ static int extract_single_file(struct archive *archive,
 		}
 	}
 	FREE(entryname_orig);
-	return(errors);
+	return errors;
 }
 
-static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
-		size_t pkg_count, pmtrans_t *trans, pmdb_t *db)
+static int commit_single_pkg(pmhandle_t *handle, pmpkg_t *newpkg,
+		size_t pkg_current, size_t pkg_count)
 {
 	int i, ret = 0, errors = 0;
-	char scriptlet[PATH_MAX+1];
+	char scriptlet[PATH_MAX];
 	int is_upgrade = 0;
 	pmpkg_t *oldpkg = NULL;
-
-	ALPM_LOG_FUNC;
-
-	ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+	pmdb_t *db = handle->db_local;
+	pmtrans_t *trans = handle->trans;
 
 	snprintf(scriptlet, PATH_MAX, "%s%s-%s/install",
 			_alpm_db_path(db), alpm_pkg_get_name(newpkg),
@@ -500,7 +491,7 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
 		_alpm_local_db_read(oldpkg->origin_data.db, oldpkg, INFRQ_ALL);
 
 		EVENT(trans, PM_TRANS_EVT_UPGRADE_START, newpkg, oldpkg);
-		_alpm_log(PM_LOG_DEBUG, "upgrading package %s-%s\n",
+		_alpm_log(handle, PM_LOG_DEBUG, "upgrading package %s-%s\n",
 				newpkg->name, newpkg->version);
 
 		/* copy over the install reason */
@@ -508,20 +499,20 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
 
 		/* pre_upgrade scriptlet */
 		if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
-			_alpm_runscriptlet(handle->root, newpkg->origin_data.file,
-					"pre_upgrade", newpkg->version, oldpkg->version, trans);
+			_alpm_runscriptlet(handle, newpkg->origin_data.file,
+					"pre_upgrade", newpkg->version, oldpkg->version);
 		}
 	} else {
 		is_upgrade = 0;
 
 		EVENT(trans, PM_TRANS_EVT_ADD_START, newpkg, NULL);
-		_alpm_log(PM_LOG_DEBUG, "adding package %s-%s\n",
+		_alpm_log(handle, PM_LOG_DEBUG, "adding package %s-%s\n",
 				newpkg->name, newpkg->version);
 
 		/* pre_install scriptlet */
 		if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
-			_alpm_runscriptlet(handle->root, newpkg->origin_data.file,
-					"pre_install", newpkg->version, NULL, trans);
+			_alpm_runscriptlet(handle, newpkg->origin_data.file,
+					"pre_install", newpkg->version, NULL);
 		}
 	}
 
@@ -534,8 +525,8 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
 
 	if(oldpkg) {
 		/* set up fake remove transaction */
-		if(_alpm_upgraderemove_package(oldpkg, newpkg, trans) == -1) {
-			pm_errno = PM_ERR_TRANS_ABORT;
+		if(_alpm_upgraderemove_package(handle, oldpkg, newpkg) == -1) {
+			handle->pm_errno = PM_ERR_TRANS_ABORT;
 			ret = -1;
 			goto cleanup;
 		}
@@ -544,9 +535,9 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
 	/* prepare directory for database entries so permission are correct after
 	   changelog/install script installation (FS#12263) */
 	if(_alpm_local_db_prepare(db, newpkg)) {
-		alpm_logaction("error: could not create database entry %s-%s\n",
+		alpm_logaction(handle, "error: could not create database entry %s-%s\n",
 				alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
-		pm_errno = PM_ERR_DB_WRITE;
+		handle->pm_errno = PM_ERR_DB_WRITE;
 		ret = -1;
 		goto cleanup;
 	}
@@ -557,10 +548,10 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
 		char cwd[PATH_MAX] = "";
 		int restore_cwd = 0;
 
-		_alpm_log(PM_LOG_DEBUG, "extracting files\n");
+		_alpm_log(handle, PM_LOG_DEBUG, "extracting files\n");
 
-		if ((archive = archive_read_new()) == NULL) {
-			pm_errno = PM_ERR_LIBARCHIVE;
+		if((archive = archive_read_new()) == NULL) {
+			handle->pm_errno = PM_ERR_LIBARCHIVE;
 			ret = -1;
 			goto cleanup;
 		}
@@ -568,24 +559,25 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
 		archive_read_support_compression_all(archive);
 		archive_read_support_format_all(archive);
 
-		_alpm_log(PM_LOG_DEBUG, "archive: %s\n", newpkg->origin_data.file);
+		_alpm_log(handle, PM_LOG_DEBUG, "archive: %s\n", newpkg->origin_data.file);
 		if(archive_read_open_filename(archive, newpkg->origin_data.file,
 					ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
-			pm_errno = PM_ERR_PKG_OPEN;
+			handle->pm_errno = PM_ERR_PKG_OPEN;
 			ret = -1;
 			goto cleanup;
 		}
 
 		/* save the cwd so we can restore it later */
 		if(getcwd(cwd, PATH_MAX) == NULL) {
-			_alpm_log(PM_LOG_ERROR, _("could not get current working directory\n"));
+			_alpm_log(handle, PM_LOG_ERROR, _("could not get current working directory\n"));
 		} else {
 			restore_cwd = 1;
 		}
 
 		/* libarchive requires this for extracting hard links */
 		if(chdir(handle->root) != 0) {
-			_alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), handle->root, strerror(errno));
+			_alpm_log(handle, PM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
+					handle->root, strerror(errno));
 			ret = -1;
 			goto cleanup;
 		}
@@ -608,7 +600,7 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
 				 * (missing metadata sizes) */
 				int64_t pos = archive_position_compressed(archive);
 				percent = (pos * 100) / newpkg->size;
-				_alpm_log(PM_LOG_DEBUG, "decompression progress: "
+				_alpm_log(handle, PM_LOG_DEBUG, "decompression progress: "
 						"%d%% (%"PRId64" / %jd)\n",
 						percent, pos, (intmax_t)newpkg->size);
 				if(percent >= 100) {
@@ -629,27 +621,26 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
 			}
 
 			/* extract the next file from the archive */
-			errors += extract_single_file(archive, entry, newpkg, oldpkg,
-					trans, db);
+			errors += extract_single_file(handle, archive, entry, newpkg, oldpkg);
 		}
 		archive_read_finish(archive);
 
 		/* restore the old cwd if we have it */
 		if(restore_cwd && chdir(cwd) != 0) {
-			_alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
+			_alpm_log(handle, PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
 		}
 
 		if(errors) {
 			ret = -1;
 			if(is_upgrade) {
-				_alpm_log(PM_LOG_ERROR, _("problem occurred while upgrading %s\n"),
+				_alpm_log(handle, PM_LOG_ERROR, _("problem occurred while upgrading %s\n"),
 						newpkg->name);
-				alpm_logaction("error: problem occurred while upgrading %s\n",
+				alpm_logaction(handle, "error: problem occurred while upgrading %s\n",
 						newpkg->name);
 			} else {
-				_alpm_log(PM_LOG_ERROR, _("problem occurred while installing %s\n"),
+				_alpm_log(handle, PM_LOG_ERROR, _("problem occurred while installing %s\n"),
 						newpkg->name);
-				alpm_logaction("error: problem occurred while installing %s\n",
+				alpm_logaction(handle, "error: problem occurred while installing %s\n",
 						newpkg->name);
 			}
 		}
@@ -658,21 +649,21 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
 	/* make an install date (in UTC) */
 	newpkg->installdate = time(NULL);
 
-	_alpm_log(PM_LOG_DEBUG, "updating database\n");
-	_alpm_log(PM_LOG_DEBUG, "adding database entry '%s'\n", newpkg->name);
+	_alpm_log(handle, PM_LOG_DEBUG, "updating database\n");
+	_alpm_log(handle, PM_LOG_DEBUG, "adding database entry '%s'\n", newpkg->name);
 
 	if(_alpm_local_db_write(db, newpkg, INFRQ_ALL)) {
-		_alpm_log(PM_LOG_ERROR, _("could not update database entry %s-%s\n"),
+		_alpm_log(handle, PM_LOG_ERROR, _("could not update database entry %s-%s\n"),
 				alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
-		alpm_logaction("error: could not update database entry %s-%s\n",
+		alpm_logaction(handle, "error: could not update database entry %s-%s\n",
 				alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
-		pm_errno = PM_ERR_DB_WRITE;
+		handle->pm_errno = PM_ERR_DB_WRITE;
 		ret = -1;
 		goto cleanup;
 	}
 
 	if(_alpm_db_add_pkgincache(db, newpkg) == -1) {
-		_alpm_log(PM_LOG_ERROR, _("could not add entry '%s' in cache\n"),
+		_alpm_log(handle, PM_LOG_ERROR, _("could not add entry '%s' in cache\n"),
 				alpm_pkg_get_name(newpkg));
 	}
 
@@ -688,12 +679,12 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
 	if(alpm_pkg_has_scriptlet(newpkg)
 			&& !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
 		if(is_upgrade) {
-			_alpm_runscriptlet(handle->root, scriptlet, "post_upgrade",
+			_alpm_runscriptlet(handle, scriptlet, "post_upgrade",
 					alpm_pkg_get_version(newpkg),
-					oldpkg ? alpm_pkg_get_version(oldpkg) : NULL, trans);
+					oldpkg ? alpm_pkg_get_version(oldpkg) : NULL);
 		} else {
-			_alpm_runscriptlet(handle->root, scriptlet, "post_install",
-					alpm_pkg_get_version(newpkg), NULL, trans);
+			_alpm_runscriptlet(handle, scriptlet, "post_install",
+					alpm_pkg_get_version(newpkg), NULL);
 		}
 	}
 
@@ -705,22 +696,18 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
 
 cleanup:
 	_alpm_pkg_free(oldpkg);
-	return(ret);
+	return ret;
 }
 
-int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
+int _alpm_upgrade_packages(pmhandle_t *handle)
 {
 	size_t pkg_count, pkg_current;
 	int skip_ldconfig = 0, ret = 0;
 	alpm_list_t *targ;
-
-	ALPM_LOG_FUNC;
-
-	ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
-	ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
+	pmtrans_t *trans = handle->trans;
 
 	if(trans->add == NULL) {
-		return(0);
+		return 0;
 	}
 
 	pkg_count = alpm_list_count(trans->add);
@@ -729,14 +716,14 @@ int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
 	/* loop through our package list adding/upgrading one at a time */
 	for(targ = trans->add; targ; targ = targ->next) {
 		if(handle->trans->state == STATE_INTERRUPTED) {
-			return(ret);
+			return ret;
 		}
 
 		pmpkg_t *newpkg = (pmpkg_t *)targ->data;
-		if(commit_single_pkg(newpkg, pkg_current, pkg_count, trans, db)) {
+		if(commit_single_pkg(handle, newpkg, pkg_current, pkg_count)) {
 			/* something screwed up on the commit, abort the trans */
 			trans->state = STATE_INTERRUPTED;
-			pm_errno = PM_ERR_TRANS_ABORT;
+			handle->pm_errno = PM_ERR_TRANS_ABORT;
 			/* running ldconfig at this point could possibly screw system */
 			skip_ldconfig = 1;
 			ret = -1;
@@ -747,10 +734,10 @@ int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
 
 	if(!skip_ldconfig) {
 		/* run ldconfig if it exists */
-		_alpm_ldconfig(handle->root);
+		_alpm_ldconfig(handle);
 	}
 
-	return(ret);
+	return ret;
 }
 
 /* vim: set ts=2 sw=2 noet: */