Tue Nov 1 23:15:01 UTC 2011

3 files changed, 3107 insertions, 0 deletions

diff --git a/community-testing/packagekit/PKGBUILD b/community-testing/packagekit/PKGBUILD
new file mode 100644
index 000000000..107d17c51
--- /dev/null
+++ b/community-testing/packagekit/PKGBUILD
@@ -0,0 +1,105 @@
+# $Id: PKGBUILD 57602 2011-10-31 12:13:15Z jconder $
+# Maintainer: Jonathan Conder <jonno.conder@gmail.com>
+pkgbase='packagekit'
+pkgname=('packagekit' 'packagekit-qt' 'packagekit-qt2' 'packagekit-python')
+pkgver=0.6.19
+pkgrel=2
+pkgdesc="A system designed to make installation and updates of packages easier."
+arch=('i686' 'x86_64')
+url="http://www.packagekit.org"
+license=('GPL')
+makedepends=('dbus-glib' 'gobject-introspection' 'gtk-doc' 'intltool'
+             'networkmanager' 'pacman'  'pm-utils' 'polkit' 'python2' 'qt'
+	     'shared-mime-info' 'sqlite3' 'udev')
+options=('!libtool')
+source=("http://www.packagekit.org/releases/PackageKit-$pkgver.tar.xz"
+        'alpm.patch')
+sha256sums=('961c6408de08ebaf15c09e74afd06918d699be8974b5c35c2c9663e5b12b5223'
+            '5ae3330f28d98c2369fad2a1fb6f8c1edd95c096b8fb4f1b170de6e8b2b134d8')
+
+build() {
+  cd "$srcdir/PackageKit-$pkgver"
+
+  patch -Np1 -i "$srcdir/alpm.patch"
+
+  # TODO: remove when this is fixed upstream
+  find -name '*.moc' -print0 | xargs -0 rm
+
+  sed -i 's@SUBDIRS = test@SUBDIRS =@' 'backends/Makefile.in'
+  sed -i 's@python @python2 @' 'lib/python/packagekit/Makefile.in'
+  sed -i 's@bin/python@bin/python2@' 'lib/python/packagekit/'*.py
+
+  export PYTHON=/usr/bin/python2
+  ./configure --prefix=/usr \
+	      --sysconfdir=/etc \
+	      --localstatedir=/var \
+	      --libexecdir=/usr/lib/PackageKit \
+	      --disable-static \
+	      --disable-gtk-doc \
+	      --disable-tests \
+	      --disable-local \
+	      --disable-browser-plugin \
+	      --disable-gstreamer-plugin \
+	      --disable-gtk-module \
+	      --disable-command-not-found \
+	      --disable-cron \
+	      --disable-debuginfo-install \
+	      --enable-pm-utils \
+	      --disable-dummy \
+	      --enable-alpm \
+	      --with-default-backend=alpm
+  make -s
+}
+
+package_packagekit() {
+  backup=('var/lib/PackageKit/transactions.db'
+          'etc/PackageKit/alpm.d/pacman.conf'
+          'etc/PackageKit/alpm.d/repos.list')
+  depends=('dbus-glib' 'pacman>=4.0.0' 'pacman<4.1.0' 'polkit'
+           'shared-mime-info' 'sqlite3' 'udev')
+  optdepends=('networkmanager')
+  install='packagekit.install'
+
+  cd "$srcdir/PackageKit-$pkgver"
+
+  make DESTDIR="$pkgdir" install
+
+  rm -rf "$pkgdir/usr/include/PackageKit/packagekit-qt"*
+  rm -rf "$pkgdir/usr/lib/libpackagekit-qt"*
+  rm -rf "$pkgdir/usr/lib/pkgconfig/packagekit-qt"*
+  rm -rf "$pkgdir/usr/share/cmake"
+
+  rm -rf "$pkgdir/usr/lib/python"*
+  rm -rf "$pkgdir/usr/share/PackageKit/website"
+
+  mv "$pkgdir/etc/bash_completion.d/pk-completion.bash" \
+     "$pkgdir/etc/bash_completion.d/pkcon"
+  touch "$pkgdir/var/log/PackageKit"
+}
+
+package_packagekit-qt() {
+  depends=('packagekit' 'qt')
+  pkgdesc=('Qt bindings for PackageKit')
+
+  cd "$srcdir/PackageKit-$pkgver/lib/packagekit-qt"
+
+  make DESTDIR="$pkgdir" install
+}
+
+package_packagekit-qt2() {
+  depends=('packagekit' 'qt')
+  pkgdesc=('Qt bindings for PackageKit')
+
+  cd "$srcdir/PackageKit-$pkgver/lib/packagekit-qt2"
+
+  make DESTDIR="$pkgdir" install
+}
+
+package_packagekit-python() {
+  depends=('packagekit' 'python2')
+  pkgdesc=('Python bindings for PackageKit')
+
+  cd "$srcdir/PackageKit-$pkgver/lib/python"
+
+  make DESTDIR="$pkgdir" install
+}
diff --git a/community-testing/packagekit/alpm.patch b/community-testing/packagekit/alpm.patch
new file mode 100644
index 000000000..a6a6fcc0a
--- /dev/null
+++ b/community-testing/packagekit/alpm.patch
@@ -0,0 +1,2991 @@
+diff --git a/backends/alpm/Makefile.am b/backends/alpm/Makefile.am
+index 5a5468a..d8c3dfc 100644
+--- a/backends/alpm/Makefile.am
++++ b/backends/alpm/Makefile.am
+@@ -5,6 +5,7 @@ PK_BACKEND_REPO_FILE = $(confdir)/repos.list
+ PK_BACKEND_DEFAULT_PATH = "/bin:/usr/bin:/sbin:/usr/sbin"
+ PK_BACKEND_DEFAULT_ROOT = "/"
+ PK_BACKEND_DEFAULT_DBPATH = $(localstatedir)/lib/pacman/
++PK_BACKEND_DEFAULT_GPGDIR = $(sysconfdir)/pacman.d/gnupg/
+ PK_BACKEND_DEFAULT_CACHEDIR = $(localstatedir)/cache/pacman/pkg/
+ PK_BACKEND_DEFAULT_LOGFILE = $(localstatedir)/log/pacman.log
+ 
+@@ -17,6 +18,7 @@ DEFS = -DPK_BACKEND_CONFIG_FILE=\"$(PK_BACKEND_CONFIG_FILE)\" \
+        -DPK_BACKEND_DEFAULT_PATH=\"$(PK_BACKEND_DEFAULT_PATH)\" \
+        -DPK_BACKEND_DEFAULT_ROOT=\"$(PK_BACKEND_DEFAULT_ROOT)\" \
+        -DPK_BACKEND_DEFAULT_DBPATH=\"$(PK_BACKEND_DEFAULT_DBPATH)\" \
++       -DPK_BACKEND_DEFAULT_GPGDIR=\"$(PK_BACKEND_DEFAULT_GPGDIR)\" \
+        -DPK_BACKEND_DEFAULT_CACHEDIR=\"$(PK_BACKEND_DEFAULT_CACHEDIR)\" \
+        -DPK_BACKEND_DEFAULT_LOGFILE=\"$(PK_BACKEND_DEFAULT_LOGFILE)\" \
+        -DALPM_CACHE_PATH=\"$(ALPM_CACHE_PATH)\" \
+diff --git a/backends/alpm/pk-backend-alpm.c b/backends/alpm/pk-backend-alpm.c
+index ba993f0..417714c 100644
+--- a/backends/alpm/pk-backend-alpm.c
++++ b/backends/alpm/pk-backend-alpm.c
+@@ -26,6 +26,7 @@
+ #include <sys/utsname.h>
+ 
+ #include "pk-backend-alpm.h"
++#include "pk-backend-config.h"
+ #include "pk-backend-databases.h"
+ #include "pk-backend-error.h"
+ #include "pk-backend-groups.h"
+@@ -35,7 +36,8 @@ PkBackend *backend = NULL;
+ GCancellable *cancellable = NULL;
+ static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+ 
+-pmdb_t *localdb = NULL;
++alpm_handle_t *alpm = NULL;
++alpm_db_t *localdb = NULL;
+ 
+ gchar *xfercmd = NULL;
+ alpm_list_t *holdpkgs = NULL;
+@@ -162,7 +164,7 @@ out:
+ }
+ 
+ static void
+-pk_backend_logcb (pmloglevel_t level, const gchar *format, va_list args)
++pk_backend_logcb (alpm_loglevel_t level, const gchar *format, va_list args)
+ {
+ 	gchar *output;
+ 
+@@ -176,12 +178,12 @@ pk_backend_logcb (pmloglevel_t level, const gchar *format, va_list args)
+ 
+ 	/* report important output to PackageKit */
+ 	switch (level) {
+-		case PM_LOG_DEBUG:
+-		case PM_LOG_FUNCTION:
++		case ALPM_LOG_DEBUG:
++		case ALPM_LOG_FUNCTION:
+ 			g_debug ("%s", output);
+ 			break;
+ 
+-		case PM_LOG_WARNING:
++		case ALPM_LOG_WARNING:
+ 			g_warning ("%s", output);
+ 			pk_backend_output (backend, output);
+ 			break;
+@@ -212,26 +214,21 @@ pk_backend_initialize_alpm (PkBackend *self, GError **error)
+ 	g_setenv ("HTTP_USER_AGENT", user_agent, FALSE);
+ 	g_free (user_agent);
+ 
+-	g_debug ("initializing");
+-	if (alpm_initialize () < 0) {
+-		g_set_error_literal (error, ALPM_ERROR, pm_errno,
+-				     alpm_strerrorlast ());
++	alpm = pk_backend_configure (PK_BACKEND_CONFIG_FILE, error);
++	if (alpm == NULL) {
+ 		return FALSE;
+ 	}
+ 
+ 	backend = self;
+-	localdb = alpm_option_get_localdb ();
++	alpm_option_set_logcb (alpm, pk_backend_logcb);
++
++	localdb = alpm_option_get_localdb (alpm);
+ 	if (localdb == NULL) {
+-		g_set_error (error, ALPM_ERROR, pm_errno, "[%s]: %s", "local",
+-			     alpm_strerrorlast ());
++		enum _alpm_errno_t errno = alpm_errno (alpm);
++		g_set_error (error, ALPM_ERROR, errno, "[%s]: %s", "local",
++			     alpm_strerror (errno));
+ 	}
+ 
+-	/* set some sane defaults */
+-	alpm_option_set_logcb (pk_backend_logcb);
+-	alpm_option_set_root (PK_BACKEND_DEFAULT_ROOT);
+-	alpm_option_set_dbpath (PK_BACKEND_DEFAULT_DBPATH);
+-	alpm_option_set_logfile (PK_BACKEND_DEFAULT_LOGFILE);
+-
+ 	return TRUE;
+ }
+ 
+@@ -240,17 +237,20 @@ pk_backend_destroy_alpm (PkBackend *self)
+ {
+ 	g_return_if_fail (self != NULL);
+ 
+-	if (backend != NULL) {
+-		if (alpm_trans_get_flags () != -1) {
+-			alpm_trans_release ();
++	if (alpm != NULL) {
++		if (alpm_trans_get_flags (alpm) < 0) {
++			alpm_trans_release (alpm);
+ 		}
+-		alpm_release ();
++		alpm_release (alpm);
++
++		alpm = NULL;
+ 		backend = NULL;
+ 	}
+ 
+ 	FREELIST (syncfirsts);
+ 	FREELIST (holdpkgs);
+ 	g_free (xfercmd);
++	xfercmd = NULL;
+ }
+ 
+ void
+diff --git a/backends/alpm/pk-backend-alpm.h b/backends/alpm/pk-backend-alpm.h
+index 23a2724..ecd6d0f 100644
+--- a/backends/alpm/pk-backend-alpm.h
++++ b/backends/alpm/pk-backend-alpm.h
+@@ -28,7 +28,8 @@
+ extern PkBackend *backend;
+ extern GCancellable *cancellable;
+ 
+-extern pmdb_t *localdb;
++extern alpm_handle_t *alpm;
++extern alpm_db_t *localdb;
+ 
+ extern gchar *xfercmd;
+ extern alpm_list_t *holdpkgs;
+diff --git a/backends/alpm/pk-backend-config.c b/backends/alpm/pk-backend-config.c
+index 21a4c54..a51a984 100644
+--- a/backends/alpm/pk-backend-config.c
++++ b/backends/alpm/pk-backend-config.c
+@@ -28,29 +28,44 @@
+ 
+ #include "pk-backend-alpm.h"
+ #include "pk-backend-config.h"
++#include "pk-backend-databases.h"
+ #include "pk-backend-error.h"
+ 
+-typedef struct {
+-	gboolean checkspace, ilovecandy, showsize, totaldl, usedelta, usesyslog;
++typedef struct
++{
++	 gboolean	 checkspace, ilovecandy, totaldl, usedelta, usesyslog,
++			 verbosepkglists;
+ 
+-	gchar *arch, *cleanmethod, *dbpath, *logfile, *root, *xfercmd;
++	 gchar		*arch, *cleanmethod, *dbpath, *gpgdir, *logfile, *root,
++			*xfercmd;
+ 
+-	alpm_list_t *cachedirs, *holdpkgs, *ignoregrps, *ignorepkgs,
+-		    *noextracts, *noupgrades, *syncfirsts;
++	 alpm_list_t	*cachedirs, *holdpkgs, *ignoregroups, *ignorepkgs,
++			*noextracts, *noupgrades, *syncfirsts;
+ 
+-	alpm_list_t *repos;
+-	GHashTable *servers;
+-	GRegex *xrepo, *xarch;
++	 alpm_list_t	*repos;
++	 GHashTable	*servers;
++	 GHashTable	*levels;
++	 GRegex		*xrepo, *xarch;
+ } PkBackendConfig;
+ 
+ static PkBackendConfig *
+ pk_backend_config_new (void)
+ {
+ 	PkBackendConfig *config = g_new0 (PkBackendConfig, 1);
++	alpm_siglevel_t *level = g_new0 (alpm_siglevel_t, 1);
++
+ 	config->servers = g_hash_table_new_full (g_str_hash, g_str_equal,
+ 						 g_free, NULL);
++	config->levels = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
++						g_free);
++
++	*level |= ALPM_SIG_PACKAGE | ALPM_SIG_PACKAGE_OPTIONAL;
++	*level |= ALPM_SIG_DATABASE | ALPM_SIG_DATABASE_OPTIONAL;
++	g_hash_table_insert (config->levels, g_strdup ("options"), level);
++
+ 	config->xrepo = g_regex_new ("\\$repo", 0, 0, NULL);
+ 	config->xarch = g_regex_new ("\\$arch", 0, 0, NULL);
++
+ 	return config;
+ }
+ 
+@@ -76,13 +91,14 @@ pk_backend_config_free (PkBackendConfig *config)
+ 	g_free (config->arch);
+ 	g_free (config->cleanmethod);
+ 	g_free (config->dbpath);
++	g_free (config->gpgdir);
+ 	g_free (config->logfile);
+ 	g_free (config->root);
+ 	g_free (config->xfercmd);
+ 
+ 	FREELIST (config->cachedirs);
+ 	FREELIST (config->holdpkgs);
+-	FREELIST (config->ignoregrps);
++	FREELIST (config->ignoregroups);
+ 	FREELIST (config->ignorepkgs);
+ 	FREELIST (config->noextracts);
+ 	FREELIST (config->noupgrades);
+@@ -92,6 +108,8 @@ pk_backend_config_free (PkBackendConfig *config)
+ 	g_hash_table_foreach_remove (config->servers,
+ 				     pk_backend_config_servers_free, NULL);
+ 	g_hash_table_unref (config->servers);
++	g_hash_table_unref (config->levels);
++
+ 	g_regex_unref (config->xrepo);
+ 	g_regex_unref (config->xarch);
+ }
+@@ -113,14 +131,6 @@ pk_backend_config_set_ilovecandy (PkBackendConfig *config)
+ }
+ 
+ static void
+-pk_backend_config_set_showsize (PkBackendConfig *config)
+-{
+-	g_return_if_fail (config != NULL);
+-
+-	config->showsize = TRUE;
+-}
+-
+-static void
+ pk_backend_config_set_totaldl (PkBackendConfig *config)
+ {
+ 	g_return_if_fail (config != NULL);
+@@ -144,19 +154,28 @@ pk_backend_config_set_usesyslog (PkBackendConfig *config)
+ 	config->usesyslog = TRUE;
+ }
+ 
+-typedef struct {
+-	const gchar *name;
+-	void (*func) (PkBackendConfig *config);
++static void
++pk_backend_config_set_verbosepkglists (PkBackendConfig *config)
++{
++	g_return_if_fail (config != NULL);
++
++	config->verbosepkglists = TRUE;
++}
++
++typedef struct
++{
++	 const gchar	*name;
++	 void		(*func) (PkBackendConfig *config);
+ } PkBackendConfigBoolean;
+ 
+ /* keep this in alphabetical order */
+ static const PkBackendConfigBoolean pk_backend_config_boolean_options[] = {
+ 	{ "CheckSpace", pk_backend_config_set_checkspace },
+ 	{ "ILoveCandy", pk_backend_config_set_ilovecandy },
+-	{ "ShowSize", pk_backend_config_set_showsize },
+ 	{ "TotalDownload", pk_backend_config_set_totaldl },
+ 	{ "UseDelta", pk_backend_config_set_usedelta },
+ 	{ "UseSyslog", pk_backend_config_set_usesyslog },
++	{ "VerbosePkgLists", pk_backend_config_set_verbosepkglists },
+ 	{ NULL, NULL }
+ };
+ 
+@@ -234,6 +253,17 @@ pk_backend_config_set_dbpath (PkBackendConfig *config, const gchar *path)
+ }
+ 
+ static void
++pk_backend_config_set_gpgdir (PkBackendConfig *config, const gchar *path)
++{
++	g_return_if_fail (config != NULL);
++	g_return_if_fail (path != NULL);
++
++	g_free (config->gpgdir);
++	config->gpgdir = g_strdup (path);
++}
++
++
++static void
+ pk_backend_config_set_logfile (PkBackendConfig *config, const gchar *filename)
+ {
+ 	g_return_if_fail (config != NULL);
+@@ -263,9 +293,10 @@ pk_backend_config_set_xfercmd (PkBackendConfig *config, const gchar *command)
+ 	config->xfercmd = g_strdup (command);
+ }
+ 
+-typedef struct {
+-	const gchar *name;
+-	void (*func) (PkBackendConfig *config, const gchar *s);
++typedef struct
++{
++	 const gchar	*name;
++	 void		(*func) (PkBackendConfig *config, const gchar *s);
+ } PkBackendConfigString;
+ 
+ /* keep this in alphabetical order */
+@@ -274,6 +305,7 @@ static const PkBackendConfigString pk_backend_config_string_options[] = {
+ 	{ "CacheDir", pk_backend_config_add_cachedir },
+ 	{ "CleanMethod", pk_backend_config_set_cleanmethod },
+ 	{ "DBPath", pk_backend_config_set_dbpath },
++	{ "GPGDir", pk_backend_config_set_gpgdir },
+ 	{ "LogFile", pk_backend_config_set_logfile },
+ 	{ "RootDir", pk_backend_config_set_root },
+ 	{ "XferCommand", pk_backend_config_set_xfercmd },
+@@ -313,12 +345,12 @@ pk_backend_config_add_holdpkg (PkBackendConfig *config, gchar *package)
+ }
+ 
+ static void
+-pk_backend_config_add_ignoregrp (PkBackendConfig *config, gchar *group)
++pk_backend_config_add_ignoregroup (PkBackendConfig *config, gchar *group)
+ {
+ 	g_return_if_fail (config != NULL);
+ 	g_return_if_fail (group != NULL);
+ 
+-	config->ignoregrps = alpm_list_add (config->ignoregrps, group);
++	config->ignoregroups = alpm_list_add (config->ignoregroups, group);
+ }
+ 
+ static void
+@@ -357,15 +389,16 @@ pk_backend_config_add_syncfirst (PkBackendConfig *config, gchar *package)
+ 	config->syncfirsts = alpm_list_add (config->syncfirsts, package);
+ }
+ 
+-typedef struct {
+-	const gchar *name;
+-	void (*func) (PkBackendConfig *config, gchar *value);
++typedef struct
++{
++	const gchar	*name;
++	void		(*func) (PkBackendConfig *config, gchar *value);
+ } PkBackendConfigList;
+ 
+ /* keep this in alphabetical order */
+ static const PkBackendConfigList pk_backend_config_list_options[] = {
+ 	{ "HoldPkg", pk_backend_config_add_holdpkg },
+-	{ "IgnoreGroup", pk_backend_config_add_ignoregrp },
++	{ "IgnoreGroup", pk_backend_config_add_ignoregroup },
+ 	{ "IgnorePkg", pk_backend_config_add_ignorepkg },
+ 	{ "NoExtract", pk_backend_config_add_noextract },
+ 	{ "NoUpgrade", pk_backend_config_add_noupgrade },
+@@ -451,7 +484,7 @@ pk_backend_config_repo_add_server (PkBackendConfig *config, const gchar *repo,
+ 			return FALSE;
+ 		}
+ 	} else if (strstr (url, "$arch") != NULL) {
+-		g_set_error (e, ALPM_ERROR, PM_ERR_CONFIG_INVALID,
++		g_set_error (e, ALPM_ERROR, ALPM_ERR_CONFIG_INVALID,
+ 			     "url contained $arch, which is not set");
+ 	}
+ 
+@@ -463,6 +496,95 @@ pk_backend_config_repo_add_server (PkBackendConfig *config, const gchar *repo,
+ }
+ 
+ static gboolean
++pk_backend_config_set_siglevel (PkBackendConfig *config, const gchar *section,
++				const gchar *list, GError **error)
++{
++	alpm_siglevel_t *level;
++
++	g_return_val_if_fail (config != NULL, FALSE);
++	g_return_val_if_fail (section != NULL, FALSE);
++	g_return_val_if_fail (list != NULL, FALSE);
++
++	level = g_hash_table_lookup (config->levels, section);
++	if (level == NULL) {
++		level = g_hash_table_lookup (config->levels, "options");
++		level = g_memdup (level, sizeof (alpm_siglevel_t));
++		g_hash_table_insert (config->levels, g_strdup (section), level);
++	}
++
++	while (TRUE) {
++		gboolean package = TRUE, database = TRUE;
++
++		if (g_str_has_prefix (list, "Package")) {
++			database = FALSE;
++			list += 7;
++		} else if (g_str_has_prefix (list, "Database")) {
++			package = FALSE;
++			list += 8;
++		}
++
++		/* this also allows e.g. NeverEver, so put prefixes last */
++		if (g_str_has_prefix (list, "Never") == 0) {
++			if (package) {
++				*level &= ~ALPM_SIG_PACKAGE;
++			}
++			if (database) {
++				*level &= ~ALPM_SIG_DATABASE;
++			}
++		} else if (g_str_has_prefix (list, "Optional") == 0) {
++			if (package) {
++				*level |= ALPM_SIG_PACKAGE;
++				*level |= ALPM_SIG_PACKAGE_OPTIONAL;
++			}
++			if (database) {
++				*level |= ALPM_SIG_DATABASE;
++				*level |= ALPM_SIG_DATABASE_OPTIONAL;
++			}
++		} else if (g_str_has_prefix (list, "Required") == 0) {
++			if (package) {
++				*level |= ALPM_SIG_PACKAGE;
++				*level &= ~ALPM_SIG_PACKAGE_OPTIONAL;
++			}
++			if (database) {
++				*level |= ALPM_SIG_DATABASE;
++				*level &= ~ALPM_SIG_DATABASE_OPTIONAL;
++			}
++		} else if (g_str_has_prefix (list, "TrustedOnly") == 0) {
++			if (package) {
++				*level &= ~ALPM_SIG_PACKAGE_MARGINAL_OK;
++				*level &= ~ALPM_SIG_PACKAGE_UNKNOWN_OK;
++			}
++			if (database) {
++				*level &= ~ALPM_SIG_DATABASE_MARGINAL_OK;
++				*level &= ~ALPM_SIG_DATABASE_UNKNOWN_OK;
++			}
++		} else if (g_str_has_prefix (list, "TrustAll") == 0) {
++			if (package) {
++				*level |= ALPM_SIG_PACKAGE_MARGINAL_OK;
++				*level |= ALPM_SIG_PACKAGE_UNKNOWN_OK;
++			}
++			if (database) {
++				*level |= ALPM_SIG_DATABASE_MARGINAL_OK;
++				*level |= ALPM_SIG_DATABASE_UNKNOWN_OK;
++			}
++		} else {
++			g_set_error (error, ALPM_ERROR, ALPM_ERR_CONFIG_INVALID,
++				     "invalid SigLevel value: %s", list);
++			return FALSE;
++		}
++
++		list = strchr (list, ' ');
++		if (list == NULL) {
++			break;
++		} else {
++			++list;
++		}
++	}
++
++	return TRUE;
++}
++
++static gboolean
+ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename,
+ 			 gchar *section, GError **error)
+ {
+@@ -515,7 +637,7 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename,
+ 
+ 			if (*str == '\0') {
+ 				g_set_error (&e, ALPM_ERROR,
+-					     PM_ERR_CONFIG_INVALID,
++					     ALPM_ERR_CONFIG_INVALID,
+ 					     "empty section name");
+ 				break;
+ 			}
+@@ -532,7 +654,7 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename,
+ 
+ 		/* parse a directive */
+ 		if (section == NULL) {
+-			g_set_error (&e, ALPM_ERROR, PM_ERR_CONFIG_INVALID,
++			g_set_error (&e, ALPM_ERROR, ALPM_ERR_CONFIG_INVALID,
+ 				     "directive must belong to a section");
+ 			break;
+ 		}
+@@ -590,9 +712,18 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename,
+ 				continue;
+ 			}
+ 		}
++	
++		if (g_strcmp0 (key, "SigLevel") == 0 && str != NULL) {
++			if (!pk_backend_config_set_siglevel (config, section,
++							     str, &e)) {
++				break;
++			} else {
++				continue;
++			}
++		}
+ 
+ 		/* report errors from above */
+-		g_set_error (&e, ALPM_ERROR, PM_ERR_CONFIG_INVALID,
++		g_set_error (&e, ALPM_ERROR, ALPM_ERR_CONFIG_INVALID,
+ 			     "unrecognised directive '%s'", key);
+ 		break;
+ 	}
+@@ -611,107 +742,100 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename,
+ 	}
+ }
+ 
+-static gboolean
+-pk_backend_config_configure_paths (PkBackendConfig *config, GError **error)
++static alpm_handle_t *
++pk_backend_config_initialize_alpm (PkBackendConfig *config, GError **error)
+ {
++	alpm_handle_t *handle;
++	enum _alpm_errno_t errno;
++	gsize dir = 1;
++
+ 	g_return_val_if_fail (config != NULL, FALSE);
+ 
+-	if (config->root == NULL) {
++	if (config->root == NULL || *config->root == '\0') {
+ 		config->root = g_strdup (PK_BACKEND_DEFAULT_ROOT);
++	} else if (!g_str_has_suffix (config->root, G_DIR_SEPARATOR_S)) {
++		dir = 0;
+ 	}
+ 
+-	if (alpm_option_set_root (config->root) < 0) {
+-		g_set_error (error, ALPM_ERROR, pm_errno, "RootDir: %s",
+-			     alpm_strerrorlast ());
+-		return FALSE;
++	if (config->dbpath == NULL) {
++		config->dbpath = g_strconcat (config->root,
++					      PK_BACKEND_DEFAULT_DBPATH + dir,
++					      NULL);
+ 	}
+ 
+-	if (config->dbpath == NULL) {
+-		config->dbpath = g_strconcat (alpm_option_get_root (),
+-					      PK_BACKEND_DEFAULT_DBPATH + 1,
++	g_debug ("initializing alpm");
++	handle = alpm_initialize (config->root, config->dbpath, &errno);
++	if (handle == NULL) {
++		g_set_error_literal (error, ALPM_ERROR, errno,
++				     alpm_strerror (errno));
++		return handle;
++	}
++
++	if (config->gpgdir == NULL) {
++		config->gpgdir = g_strconcat (config->root,
++					      PK_BACKEND_DEFAULT_GPGDIR + dir,
+ 					      NULL);
+ 	}
+ 
+-	if (alpm_option_set_dbpath (config->dbpath) < 0) {
+-		g_set_error (error, ALPM_ERROR, pm_errno, "DBPath: %s",
+-			     alpm_strerrorlast ());
+-		return FALSE;
++	if (alpm_option_set_gpgdir (handle, config->gpgdir) < 0) {
++		errno = alpm_errno (handle);
++		g_set_error (error, ALPM_ERROR, errno, "GPGDir: %s",
++			     alpm_strerror (errno));
++		return handle;
+ 	}
+ 
+ 	if (config->logfile == NULL) {
+-		config->logfile = g_strconcat (alpm_option_get_root (),
+-					       PK_BACKEND_DEFAULT_LOGFILE + 1,
++		config->logfile = g_strconcat (config->root,
++					       PK_BACKEND_DEFAULT_LOGFILE + dir,
+ 					       NULL);
+ 	}
+ 
+-	alpm_option_set_logfile (config->logfile);
++	if (alpm_option_set_logfile (handle, config->logfile) < 0) {
++		errno = alpm_errno (handle);
++		g_set_error (error, ALPM_ERROR, errno, "LogFile: %s",
++			     alpm_strerror (errno));
++		return handle;
++	}
+ 
+ 	if (config->cachedirs == NULL) {
+-		gchar *path = g_strconcat (alpm_option_get_root (),
+-					   PK_BACKEND_DEFAULT_CACHEDIR + 1,
++		gchar *path = g_strconcat (config->root,
++					   PK_BACKEND_DEFAULT_CACHEDIR + dir,
+ 					   NULL);
+ 		config->cachedirs = alpm_list_add (NULL, path);
+ 	}
+ 
+ 	/* alpm takes ownership */
+-	alpm_option_set_cachedirs (config->cachedirs);
++	if (alpm_option_set_cachedirs (handle, config->cachedirs) < 0) {
++		errno = alpm_errno (handle);
++		g_set_error (error, ALPM_ERROR, errno, "CacheDir: %s",
++			     alpm_strerror (errno));
++		return handle;
++	}
+ 	config->cachedirs = NULL;
+ 
+-	return TRUE;
++	return handle;
+ }
+ 
+-static gboolean
+-pk_backend_config_configure_repos (PkBackendConfig *config, GError **error)
++static alpm_handle_t *
++pk_backend_config_configure_alpm (PkBackendConfig *config, GError **error)
+ {
+-	const alpm_list_t *i;
++	alpm_handle_t *handle;
++	alpm_siglevel_t *level;
+ 
+ 	g_return_val_if_fail (config != NULL, FALSE);
+ 
+-	for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) {
+-		if (alpm_db_unregister (i->data) < 0) {
+-			g_set_error_literal (error, ALPM_ERROR, pm_errno,
+-					     alpm_strerrorlast ());
+-			return FALSE;
+-		}
+-	}
+-
+-	for (i = config->repos; i != NULL; i = i->next) {
+-		const gchar *key;
+-		gpointer value;
+-		pmdb_t *db;
+-		alpm_list_t *j;
+-
+-		key = (const gchar *) i->data;
+-		value = g_hash_table_lookup (config->servers, key);
+-
+-		db = alpm_db_register_sync (key);
+-		if (db == NULL) {
+-			g_set_error (error, ALPM_ERROR, pm_errno, "[%s]: %s",
+-				     key, alpm_strerrorlast ());
+-			return FALSE;
+-		}
+-
+-		for (j = (alpm_list_t *) value; j != NULL; j = j->next) {
+-			alpm_db_setserver (db, (const gchar *) j->data);
+-		}
++	handle = pk_backend_config_initialize_alpm (config, error);
++	if (handle == NULL) {
++		return NULL;
+ 	}
+ 
+-	return TRUE;
+-}
+-
+-static gboolean
+-pk_backend_config_configure_alpm (PkBackendConfig *config, GError **error)
+-{
+-	g_return_val_if_fail (config != NULL, FALSE);
+-
+-	if (!pk_backend_config_configure_paths (config, error)) {
+-		return FALSE;
+-	}
++	alpm_option_set_checkspace (handle, config->checkspace);
++	alpm_option_set_usedelta (handle, config->usedelta);
++	alpm_option_set_usesyslog (handle, config->usesyslog);
++	alpm_option_set_arch (handle, config->arch);
+ 
+-	alpm_option_set_checkspace (config->checkspace);
+-	alpm_option_set_usedelta (config->usedelta);
+-	alpm_option_set_usesyslog (config->usesyslog);
+-	alpm_option_set_arch (config->arch);
++	level = g_hash_table_lookup (config->levels, "options");
++	alpm_option_set_default_siglevel (handle, *level);
+ 
+ 	/* backend takes ownership */
+ 	g_free (xfercmd);
+@@ -719,9 +843,9 @@ pk_backend_config_configure_alpm (PkBackendConfig *config, GError **error)
+ 	config->xfercmd = NULL;
+ 
+ 	if (xfercmd != NULL) {
+-		alpm_option_set_fetchcb (pk_backend_fetchcb);
++		alpm_option_set_fetchcb (handle, pk_backend_fetchcb);
+ 	} else {
+-		alpm_option_set_fetchcb (NULL);
++		alpm_option_set_fetchcb (handle, NULL);
+ 	}
+ 
+ 	/* backend takes ownership */
+@@ -735,41 +859,53 @@ pk_backend_config_configure_alpm (PkBackendConfig *config, GError **error)
+ 	config->syncfirsts = NULL;
+ 
+ 	/* alpm takes ownership */
+-	alpm_option_set_ignoregrps (config->ignoregrps);
+-	config->ignoregrps = NULL;
++	alpm_option_set_ignoregroups (handle, config->ignoregroups);
++	config->ignoregroups = NULL;
+ 
+ 	/* alpm takes ownership */
+-	alpm_option_set_ignorepkgs (config->ignorepkgs);
++	alpm_option_set_ignorepkgs (handle, config->ignorepkgs);
+ 	config->ignorepkgs = NULL;
+ 
+ 	/* alpm takes ownership */
+-	alpm_option_set_noextracts (config->noextracts);
++	alpm_option_set_noextracts (handle, config->noextracts);
+ 	config->noextracts = NULL;
+ 
+ 	/* alpm takes ownership */
+-	alpm_option_set_noupgrades (config->noupgrades);
++	alpm_option_set_noupgrades (handle, config->noupgrades);
+ 	config->noupgrades = NULL;
+ 
+-	if (!pk_backend_config_configure_repos (config, error)) {
+-		return FALSE;
+-	}
++	pk_backend_configure_repos (config->repos, config->servers,
++				    config->levels);
+ 
+-	return TRUE;
++	return handle;
+ }
+ 
+-gboolean
++alpm_handle_t *
+ pk_backend_configure (const gchar *filename, GError **error)
+ {
+ 	PkBackendConfig *config;
+-	gboolean result;
++	alpm_handle_t *handle;
++	GError *e = NULL;
+ 
+ 	g_return_val_if_fail (filename != NULL, FALSE);
+ 
++	g_debug ("reading config from %s", filename);
+ 	config = pk_backend_config_new ();
+ 
+-	result = pk_backend_config_parse (config, filename, NULL, error) &&
+-		 pk_backend_config_configure_alpm (config, error);
++	if (pk_backend_config_parse (config, filename, NULL, &e)) {
++		handle = pk_backend_config_configure_alpm (config, &e);
++	} else {
++		handle = NULL;
++	}
+ 
+ 	pk_backend_config_free (config);
+-	return result;
++	if (e != NULL) {
++		g_propagate_error (error, e);
++		if (handle != NULL) {
++			alpm_release (handle);
++		}
++		return NULL;
++	} else {
++		return handle;
++	}
+ }
+diff --git a/backends/alpm/pk-backend-config.h b/backends/alpm/pk-backend-config.h
+index cb8b8dc..412f59c 100644
+--- a/backends/alpm/pk-backend-config.h
++++ b/backends/alpm/pk-backend-config.h
+@@ -21,6 +21,7 @@
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+  */
+ 
++#include <alpm.h>
+ #include <glib.h>
+ 
+-gboolean	 pk_backend_configure	(const gchar *filename, GError **error);
++alpm_handle_t	*pk_backend_configure	(const gchar *filename, GError **error);
+diff --git a/backends/alpm/pk-backend-databases.c b/backends/alpm/pk-backend-databases.c
+index f6ab06e..ac530c7 100644
+--- a/backends/alpm/pk-backend-databases.c
++++ b/backends/alpm/pk-backend-databases.c
+@@ -26,7 +26,15 @@
+ #include "pk-backend-databases.h"
+ #include "pk-backend-error.h"
+ 
++typedef struct
++{
++	gchar *name;
++	alpm_list_t *servers;
++	alpm_siglevel_t level;
++} PkBackendRepo;
++
+ static GHashTable *disabled = NULL;
++static alpm_list_t *configured = NULL;
+ 
+ static GHashTable *
+ disabled_repos_new (GError **error)
+@@ -113,8 +121,8 @@ disabled_repos_free (GHashTable *table)
+ 
+ 	/* write all disabled repos line by line */
+ 	while (g_hash_table_iter_next (&iter, (gpointer *) &line, NULL) &&
+-		g_data_output_stream_put_string (output, line, NULL, NULL) &&
+-		g_data_output_stream_put_byte (output, '\n', NULL, NULL));
++	       g_data_output_stream_put_string (output, line, NULL, NULL) &&
++	       g_data_output_stream_put_byte (output, '\n', NULL, NULL));
+ 
+ 	g_object_unref (output);
+ 	g_object_unref (os);
+@@ -128,37 +136,65 @@ disabled_repos_configure (GHashTable *table, GError **error)
+ {
+ 	const alpm_list_t *i;
+ 
+-	g_debug ("reading config from %s", PK_BACKEND_CONFIG_FILE);
++	g_return_val_if_fail (table != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 
+-	/* read configuration from pacman.conf file */
+-	if (!pk_backend_configure (PK_BACKEND_CONFIG_FILE, error)) {
++	if (alpm_db_unregister_all (alpm) < 0) {
++		enum _alpm_errno_t errno = alpm_errno (alpm);
++		g_set_error_literal (error, ALPM_ERROR, errno,
++				     alpm_strerror (errno));
+ 		return FALSE;
+ 	}
+ 
+-	/* disable disabled repos */
+-	for (i = alpm_option_get_syncdbs (); i != NULL;) {
+-		pmdb_t *db = (pmdb_t *) i->data;
+-		const gchar *repo = alpm_db_get_name (db);
++	for (i = configured; i != NULL; i = i->next) {
++		PkBackendRepo *repo = (PkBackendRepo *) i->data;
++		alpm_db_t *db;
+ 
+-		if (g_hash_table_lookup (table, repo) == NULL) {
+-			/* repo is not disabled */
+-			i = i->next;
++		if (g_hash_table_lookup (table, repo->name) != NULL) {
++			/* repo is disabled */
+ 			continue;
+ 		}
+ 
+-		if (alpm_db_unregister (db) < 0) {
+-			g_set_error (error, ALPM_ERROR, pm_errno, "[%s]: %s",
+-				     repo, alpm_strerrorlast ());
++		db = alpm_db_register_sync (alpm, repo->name, repo->level);
++		if (db == NULL) {
++			enum _alpm_errno_t errno = alpm_errno (alpm);
++			g_set_error (error, ALPM_ERROR, errno, "[%s]: %s",
++				     repo->name, alpm_strerror (errno));
+ 			return FALSE;
+ 		}
+ 
+-		/* start again because the list gets invalidated */
+-		i = alpm_option_get_syncdbs ();
++		alpm_db_set_servers (db, alpm_list_strdup (repo->servers));
+ 	}
+ 
+ 	return TRUE;
+ }
+ 
++void
++pk_backend_configure_repos (alpm_list_t *repos, GHashTable *servers,
++			    GHashTable *levels)
++{
++	alpm_list_t *i;
++
++	g_return_if_fail (servers != NULL);
++
++	for (i = repos; i != NULL; i = i->next) {
++		PkBackendRepo *repo = g_new (PkBackendRepo, 1);
++		gpointer value = g_hash_table_lookup (servers, i->data);
++
++		repo->name = g_strdup ((const gchar *) i->data);
++		repo->servers = alpm_list_strdup ((alpm_list_t *) value);
++
++		value = g_hash_table_lookup (levels, i->data);
++		if (value != NULL) {
++			repo->level = *(alpm_siglevel_t *)value;
++		} else {
++			repo->level = ALPM_SIG_USE_DEFAULT;
++		}
++
++		configured = alpm_list_add (configured, repo);
++	}
++}
++
+ gboolean
+ pk_backend_initialize_databases (PkBackend *self, GError **error)
+ {
+@@ -179,11 +215,21 @@ pk_backend_initialize_databases (PkBackend *self, GError **error)
+ void
+ pk_backend_destroy_databases (PkBackend *self)
+ {
++	alpm_list_t *i;
++
+ 	g_return_if_fail (self != NULL);
+ 
+ 	if (disabled != NULL) {
+ 		disabled_repos_free (disabled);
+ 	}
++
++	for (i = configured; i != NULL; i = i->next) {
++		PkBackendRepo *repo = (PkBackendRepo *) i->data;
++		g_free (repo->name);
++		FREELIST (repo->servers);
++		g_free (repo);
++	}
++	alpm_list_free (configured);
+ }
+ 
+ static gboolean
+@@ -210,11 +256,12 @@ pk_backend_get_repo_list_thread (PkBackend *self)
+ 	gpointer key, value;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 	g_return_val_if_fail (disabled != NULL, FALSE);
+ 
+ 	/* emit enabled repos */
+-	for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) {
+-		pmdb_t *db = (pmdb_t *) i->data;
++	for (i = alpm_option_get_syncdbs (alpm); i != NULL; i = i->next) {
++		alpm_db_t *db = (alpm_db_t *) i->data;
+ 		const gchar *repo = alpm_db_get_name (db);
+ 
+ 		if (pk_backend_cancelled (self)) {
+@@ -269,7 +316,7 @@ pk_backend_repo_enable_thread (PkBackend *self)
+ 			pk_backend_repo_list_changed (self);
+ 		}
+ 	} else {
+-		int code = PM_ERR_DB_NOT_NULL;
++		int code = ALPM_ERR_DB_NOT_NULL;
+ 		g_set_error (&error, ALPM_ERROR, code, "[%s]: %s",
+ 			     repo, alpm_strerror (code));
+ 	}
+@@ -292,21 +339,23 @@ pk_backend_repo_disable_thread (PkBackend *self)
+ 	GError *error = NULL;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 	g_return_val_if_fail (disabled != NULL, FALSE);
+ 
+ 	repo = pk_backend_get_string (self, "repo_id");
+ 
+ 	g_return_val_if_fail (repo != NULL, FALSE);
+ 
+-	for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) {
+-		pmdb_t *db = (pmdb_t *) i->data;
++	for (i = alpm_option_get_syncdbs (alpm); i != NULL; i = i->next) {
++		alpm_db_t *db = (alpm_db_t *) i->data;
+ 		const gchar *name = alpm_db_get_name (db);
+ 
+ 		if (g_strcmp0 (repo, name) == 0) {
+ 			if (alpm_db_unregister (db) < 0) {
+-				g_set_error (&error, ALPM_ERROR, pm_errno,
++				enum _alpm_errno_t errno = alpm_errno (alpm);
++				g_set_error (&error, ALPM_ERROR, errno,
+ 					     "[%s]: %s", repo,
+-					     alpm_strerrorlast ());
++					     alpm_strerror (errno));
+ 			} else {
+ 				g_hash_table_insert (disabled, g_strdup (repo),
+ 						     GINT_TO_POINTER (1));
+@@ -316,7 +365,7 @@ pk_backend_repo_disable_thread (PkBackend *self)
+ 	}
+ 
+ 	if (i == NULL) {
+-		int code = PM_ERR_DB_NULL;
++		int code = ALPM_ERR_DB_NULL;
+ 		g_set_error (&error, ALPM_ERROR, code, "[%s]: %s", repo,
+ 			     alpm_strerror (code));
+ 	}
+diff --git a/backends/alpm/pk-backend-databases.h b/backends/alpm/pk-backend-databases.h
+index f9eb2f9..2636cae 100644
+--- a/backends/alpm/pk-backend-databases.h
++++ b/backends/alpm/pk-backend-databases.h
+@@ -24,6 +24,10 @@
+ #include <alpm.h>
+ #include <pk-backend.h>
+ 
++void		 pk_backend_configure_repos		(alpm_list_t *repos,
++							 GHashTable *servers,
++							 GHashTable *levels);
++
+ gboolean	 pk_backend_initialize_databases	(PkBackend *self,
+ 							 GError **error);
+ 
+diff --git a/backends/alpm/pk-backend-depends.c b/backends/alpm/pk-backend-depends.c
+index 8bb8567..7c7b45a 100644
+--- a/backends/alpm/pk-backend-depends.c
++++ b/backends/alpm/pk-backend-depends.c
+@@ -29,7 +29,7 @@
+ #include "pk-backend-error.h"
+ #include "pk-backend-packages.h"
+ 
+-static pmpkg_t *
++static alpm_pkg_t *
+ alpm_list_find_pkg (const alpm_list_t *pkgs, const gchar *name)
+ {
+ 	g_return_val_if_fail (name != NULL, NULL);
+@@ -50,11 +50,12 @@ pk_backend_find_provider (PkBackend *self, alpm_list_t *pkgs,
+ 	PkBitfield filters;
+ 	gboolean recursive, skip_local, skip_remote;
+ 
+-	pmpkg_t *provider;
++	alpm_pkg_t *provider;
+ 	alpm_list_t *pkgcache, *syncdbs;
+ 
+ 	g_return_val_if_fail (self != NULL, pkgs);
+ 	g_return_val_if_fail (depend != NULL, pkgs);
++	g_return_val_if_fail (alpm != NULL, pkgs);
+ 	g_return_val_if_fail (localdb != NULL, pkgs);
+ 
+ 	recursive = pk_backend_get_bool (self, "recursive");
+@@ -84,8 +85,8 @@ pk_backend_find_provider (PkBackend *self, alpm_list_t *pkgs,
+ 	}
+ 
+ 	/* look for remote dependencies */
+-	syncdbs = alpm_option_get_syncdbs ();
+-	provider = alpm_find_dbs_satisfier (syncdbs, depend);
++	syncdbs = alpm_option_get_syncdbs (alpm);
++	provider = alpm_find_dbs_satisfier (alpm, syncdbs, depend);
+ 
+ 	if (provider != NULL) {
+ 		if (!skip_remote) {
+@@ -96,7 +97,7 @@ pk_backend_find_provider (PkBackend *self, alpm_list_t *pkgs,
+ 			pkgs = alpm_list_add (pkgs, provider);
+ 		}
+ 	} else {
+-		int code = PM_ERR_UNSATISFIED_DEPS;
++		int code = ALPM_ERR_UNSATISFIED_DEPS;
+ 		g_set_error (error, ALPM_ERROR, code, "%s: %s", depend,
+ 			     alpm_strerror (code));
+ 	}
+@@ -108,7 +109,7 @@ static alpm_list_t *
+ pk_backend_find_requirer (PkBackend *self, alpm_list_t *pkgs, const gchar *name,
+ 			  GError **error)
+ {
+-	pmpkg_t *requirer;
++	alpm_pkg_t *requirer;
+ 
+ 	g_return_val_if_fail (self != NULL, pkgs);
+ 	g_return_val_if_fail (name != NULL, pkgs);
+@@ -127,7 +128,7 @@ pk_backend_find_requirer (PkBackend *self, alpm_list_t *pkgs, const gchar *name,
+ 			pkgs = alpm_list_add (pkgs, requirer);
+ 		}
+ 	} else {
+-		int code = PM_ERR_PKG_NOT_FOUND;
++		int code = ALPM_ERR_PKG_NOT_FOUND;
+ 		g_set_error (error, ALPM_ERROR, code, "%s: %s", name,
+ 			     alpm_strerror (code));
+ 	}
+@@ -150,7 +151,7 @@ pk_backend_get_depends_thread (PkBackend *self)
+ 
+ 	/* construct an initial package list */
+ 	for (; *packages != NULL; ++packages) {
+-		pmpkg_t *pkg;
++		alpm_pkg_t *pkg;
+ 
+ 		if (pk_backend_cancelled (self)) {
+ 			break;
+@@ -206,7 +207,7 @@ pk_backend_get_requires_thread (PkBackend *self)
+ 
+ 	/* construct an initial package list */
+ 	for (; *packages != NULL; ++packages) {
+-		pmpkg_t *pkg;
++		alpm_pkg_t *pkg;
+ 
+ 		if (pk_backend_cancelled (self)) {
+ 			break;
+diff --git a/backends/alpm/pk-backend-error.c b/backends/alpm/pk-backend-error.c
+index 255f1fb..57c4b4b 100644
+--- a/backends/alpm/pk-backend-error.c
++++ b/backends/alpm/pk-backend-error.c
+@@ -33,140 +33,159 @@ pk_backend_error (PkBackend *self, GError *error)
+ 	g_return_if_fail (self != NULL);
+ 	g_return_if_fail (error != NULL);
+ 
+-	if (error->domain == ALPM_ERROR) {
+-		switch (error->code) {
+-			case PM_ERR_MEMORY:
+-			case PM_ERR_SYSTEM:
+-				code = PK_ERROR_ENUM_OOM;
+-				break;
++	if (error->domain != ALPM_ERROR) {
++		pk_backend_error_code (self, code, "%s", error->message);
++		return;
++	}
++
++	switch (error->code) {
++		case ALPM_ERR_MEMORY:
++		case ALPM_ERR_SYSTEM:
++			code = PK_ERROR_ENUM_OOM;
++			break;
++
++		case ALPM_ERR_BADPERMS:
++			code = PK_ERROR_ENUM_NOT_AUTHORIZED;
++			break;
++
++		case ALPM_ERR_NOT_A_FILE:
++		case ALPM_ERR_NOT_A_DIR:
++			code = PK_ERROR_ENUM_FILE_NOT_FOUND;
++			break;
++
++		case ALPM_ERR_WRONG_ARGS:
++		case ALPM_ERR_HANDLE_NULL:
++		case ALPM_ERR_DB_NULL:
++		case ALPM_ERR_TRANS_NULL:
++		case ALPM_ERR_TRANS_NOT_INITIALIZED:
++		case ALPM_ERR_TRANS_NOT_PREPARED:
++		case ALPM_ERR_TRANS_NOT_LOCKED:
++		case ALPM_ERR_INVALID_REGEX:
++			code = PK_ERROR_ENUM_INTERNAL_ERROR;
++			break;
+ 
+-			case PM_ERR_BADPERMS:
+-				code = PK_ERROR_ENUM_NOT_AUTHORIZED;
+-				break;
++		case ALPM_ERR_DISK_SPACE:
++			code = PK_ERROR_ENUM_NO_SPACE_ON_DEVICE;
++			break;
+ 
+-			case PM_ERR_NOT_A_FILE:
+-			case PM_ERR_NOT_A_DIR:
+-				code = PK_ERROR_ENUM_FILE_NOT_FOUND;
+-				break;
++		case ALPM_ERR_HANDLE_NOT_NULL:
++		case ALPM_ERR_DB_NOT_NULL:
++		case ALPM_ERR_TRANS_NOT_NULL:
++			code = PK_ERROR_ENUM_FAILED_INITIALIZATION;
++			break;
+ 
+-			case PM_ERR_WRONG_ARGS:
+-			case PM_ERR_HANDLE_NULL:
+-			case PM_ERR_DB_NULL:
+-			case PM_ERR_TRANS_NULL:
+-			case PM_ERR_TRANS_NOT_INITIALIZED:
+-			case PM_ERR_TRANS_NOT_PREPARED:
+-			case PM_ERR_TRANS_NOT_LOCKED:
+-			case PM_ERR_INVALID_REGEX:
+-				code = PK_ERROR_ENUM_INTERNAL_ERROR;
+-				break;
++		case ALPM_ERR_HANDLE_LOCK:
++			code = PK_ERROR_ENUM_CANNOT_GET_LOCK;
++			break;
+ 
+-			case PM_ERR_DISK_SPACE:
+-				code = PK_ERROR_ENUM_NO_SPACE_ON_DEVICE;
+-				break;
++		case ALPM_ERR_DB_OPEN:
++		case ALPM_ERR_DB_NOT_FOUND:
++		case ALPM_ERR_PKG_REPO_NOT_FOUND:
++			code = PK_ERROR_ENUM_REPO_NOT_FOUND;
++			break;
+ 
+-			case PM_ERR_HANDLE_NOT_NULL:
+-			case PM_ERR_DB_NOT_NULL:
+-			case PM_ERR_TRANS_NOT_NULL:
+-				code = PK_ERROR_ENUM_FAILED_INITIALIZATION;
+-				break;
++		case ALPM_ERR_DB_CREATE:
++			code = PK_ERROR_ENUM_CANNOT_WRITE_REPO_CONFIG;
++			break;
+ 
+-			case PM_ERR_HANDLE_LOCK:
+-				code = PK_ERROR_ENUM_CANNOT_GET_LOCK;
+-				break;
++		case ALPM_ERR_DB_INVALID:
++		case ALPM_ERR_DB_VERSION:
++		case ALPM_ERR_DB_REMOVE:
++		case ALPM_ERR_SERVER_BAD_URL:
++			code = PK_ERROR_ENUM_REPO_CONFIGURATION_ERROR;
++			break;
+ 
+-			case PM_ERR_DB_OPEN:
+-			case PM_ERR_DB_NOT_FOUND:
+-			case PM_ERR_PKG_REPO_NOT_FOUND:
+-				code = PK_ERROR_ENUM_REPO_NOT_FOUND;
+-				break;
++		case ALPM_ERR_DB_INVALID_SIG:
++		case ALPM_ERR_PKG_INVALID_SIG:
++		case ALPM_ERR_SIG_INVALID:
++			code = PK_ERROR_ENUM_BAD_GPG_SIGNATURE;
++			break;
+ 
+-			case PM_ERR_DB_CREATE:
+-				code = PK_ERROR_ENUM_CANNOT_WRITE_REPO_CONFIG;
+-				break;
++		case ALPM_ERR_DB_WRITE:
++			code = PK_ERROR_ENUM_REPO_NOT_AVAILABLE;
++			break;
+ 
+-			case PM_ERR_DB_VERSION:
+-			case PM_ERR_DB_REMOVE:
+-				code = PK_ERROR_ENUM_REPO_CONFIGURATION_ERROR;
+-				break;
++		case ALPM_ERR_SERVER_NONE:
++			code = PK_ERROR_ENUM_NO_MORE_MIRRORS_TO_TRY;
++			break;
+ 
+-			case PM_ERR_DB_WRITE:
+-				code = PK_ERROR_ENUM_REPO_NOT_AVAILABLE;
+-				break;
++		case ALPM_ERR_TRANS_DUP_TARGET:
++		case ALPM_ERR_TRANS_ABORT:
++			code = PK_ERROR_ENUM_TRANSACTION_ERROR;
++			break;
+ 
+-			case PM_ERR_SERVER_BAD_URL:
+-				code = PK_ERROR_ENUM_REPO_CONFIGURATION_ERROR;
+-				break;
++		case ALPM_ERR_TRANS_TYPE:
++			code = PK_ERROR_ENUM_CANNOT_CANCEL;
++			break;
+ 
+-			case PM_ERR_SERVER_NONE:
+-				code = PK_ERROR_ENUM_NO_MORE_MIRRORS_TO_TRY;
+-				break;
++		case ALPM_ERR_PKG_NOT_FOUND:
++			code = PK_ERROR_ENUM_PACKAGE_NOT_FOUND;
++			break;
+ 
+-			case PM_ERR_TRANS_DUP_TARGET:
+-			case PM_ERR_TRANS_ABORT:
+-				code = PK_ERROR_ENUM_TRANSACTION_ERROR;
+-				break;
++		case ALPM_ERR_PKG_IGNORED:
++			code = PK_ERROR_ENUM_PACKAGE_INSTALL_BLOCKED;
++			break;
+ 
+-			case PM_ERR_TRANS_TYPE:
+-				code = PK_ERROR_ENUM_CANNOT_CANCEL;
+-				break;
++		case ALPM_ERR_PKG_INVALID:
++		case ALPM_ERR_PKG_OPEN:
++		case ALPM_ERR_PKG_INVALID_NAME:
++		case ALPM_ERR_DLT_INVALID:
++			code = PK_ERROR_ENUM_INVALID_PACKAGE_FILE;
++			break;
+ 
+-			case PM_ERR_PKG_NOT_FOUND:
+-				code = PK_ERROR_ENUM_PACKAGE_NOT_FOUND;
+-				break;
++		case ALPM_ERR_PKG_INVALID_CHECKSUM:
++			code = PK_ERROR_ENUM_PACKAGE_CORRUPT;
++			break;
+ 
+-			case PM_ERR_PKG_IGNORED:
+-				code = PK_ERROR_ENUM_PACKAGE_INSTALL_BLOCKED;
+-				break;
++		case ALPM_ERR_PKG_CANT_REMOVE:
++			code = PK_ERROR_ENUM_PACKAGE_FAILED_TO_REMOVE;
++			break;
+ 
+-			case PM_ERR_PKG_INVALID:
+-			case PM_ERR_PKG_OPEN:
+-			case PM_ERR_PKG_INVALID_NAME:
+-			case PM_ERR_DLT_INVALID:
+-				code = PK_ERROR_ENUM_INVALID_PACKAGE_FILE;
+-				break;
++		case ALPM_ERR_PKG_INVALID_ARCH:
++			code = PK_ERROR_ENUM_INCOMPATIBLE_ARCHITECTURE;
++			break;
+ 
+-			case PM_ERR_PKG_CANT_REMOVE:
+-				code = PK_ERROR_ENUM_PACKAGE_FAILED_TO_REMOVE;
+-				break;
++		case ALPM_ERR_SIG_MISSING:
++			code = PK_ERROR_ENUM_MISSING_GPG_SIGNATURE;
++			break;
+ 
+-			case PM_ERR_PKG_INVALID_ARCH:
+-				code = PK_ERROR_ENUM_INCOMPATIBLE_ARCHITECTURE;
+-				break;
++		case ALPM_ERR_DLT_PATCHFAILED:
++			code = PK_ERROR_ENUM_PACKAGE_FAILED_TO_BUILD;
++			break;
+ 
+-			case PM_ERR_DLT_PATCHFAILED:
+-				code = PK_ERROR_ENUM_PACKAGE_FAILED_TO_BUILD;
+-				break;
++		case ALPM_ERR_UNSATISFIED_DEPS:
++			code = PK_ERROR_ENUM_DEP_RESOLUTION_FAILED;
++			break;
+ 
+-			case PM_ERR_UNSATISFIED_DEPS:
+-				code = PK_ERROR_ENUM_DEP_RESOLUTION_FAILED;
+-				break;
++		case ALPM_ERR_CONFLICTING_DEPS:
++			code = PK_ERROR_ENUM_PACKAGE_CONFLICTS;
++			break;
+ 
+-			case PM_ERR_CONFLICTING_DEPS:
+-				code = PK_ERROR_ENUM_PACKAGE_CONFLICTS;
+-				break;
++		case ALPM_ERR_FILE_CONFLICTS:
++			code = PK_ERROR_ENUM_FILE_CONFLICTS;
++			break;
+ 
+-			case PM_ERR_FILE_CONFLICTS:
+-				code = PK_ERROR_ENUM_FILE_CONFLICTS;
+-				break;
++		case ALPM_ERR_RETRIEVE:
++		case ALPM_ERR_LIBCURL:
++		case ALPM_ERR_EXTERNAL_DOWNLOAD:
++			code = PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED;
++			break;
+ 
+-			case PM_ERR_RETRIEVE:
+-			case PM_ERR_LIBFETCH:
+-			case PM_ERR_EXTERNAL_DOWNLOAD:
+-				code = PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED;
+-				break;
++		case ALPM_ERR_LIBARCHIVE:
++			code = PK_ERROR_ENUM_LOCAL_INSTALL_FAILED;
++			break;
+ 
+-			case PM_ERR_LIBARCHIVE:
+-				code = PK_ERROR_ENUM_LOCAL_INSTALL_FAILED;
+-				break;
++		case ALPM_ERR_GPGME:
++			code = PK_ERROR_ENUM_GPG_FAILURE;
++			break;
+ 
+-			case PM_ERR_CONFIG_INVALID:
+-				code = PK_ERROR_ENUM_CANNOT_REMOVE_SYSTEM_PACKAGE;
+-				break;
++		case ALPM_ERR_CONFIG_INVALID:
++			code = PK_ERROR_ENUM_FAILED_CONFIG_PARSING;
++			break;
+ 
+-			case PM_ERR_PKG_HELD:
+-				code = PK_ERROR_ENUM_CANNOT_REMOVE_SYSTEM_PACKAGE;
+-				break;
+-		}
++		case ALPM_ERR_PKG_HELD:
++			code = PK_ERROR_ENUM_CANNOT_REMOVE_SYSTEM_PACKAGE;
++			break;
+ 	}
+ 
+ 	pk_backend_error_code (self, code, "%s", error->message);
+diff --git a/backends/alpm/pk-backend-error.h b/backends/alpm/pk-backend-error.h
+index 83fe4a5..0a029e4 100644
+--- a/backends/alpm/pk-backend-error.h
++++ b/backends/alpm/pk-backend-error.h
+@@ -26,8 +26,8 @@
+ #define	 ALPM_ERROR		(alpm_error_quark ())
+ 
+ enum {
+-	PM_ERR_CONFIG_INVALID = 0x10000,
+-	PM_ERR_PKG_HELD
++	ALPM_ERR_CONFIG_INVALID = 0x10000,
++	ALPM_ERR_PKG_HELD
+ };
+ 
+ void	 pk_backend_error	(PkBackend *self, GError *error);
+diff --git a/backends/alpm/pk-backend-groups.c b/backends/alpm/pk-backend-groups.c
+index 59e304d..6056c54 100644
+--- a/backends/alpm/pk-backend-groups.c
++++ b/backends/alpm/pk-backend-groups.c
+@@ -125,7 +125,7 @@ pk_backend_destroy_groups (PkBackend *self)
+ }
+ 
+ const gchar *
+-alpm_pkg_get_group (pmpkg_t *pkg)
++alpm_pkg_get_group (alpm_pkg_t *pkg)
+ {
+ 	const alpm_list_t *i;
+ 
+diff --git a/backends/alpm/pk-backend-groups.h b/backends/alpm/pk-backend-groups.h
+index 28dcf65..d736e37 100644
+--- a/backends/alpm/pk-backend-groups.h
++++ b/backends/alpm/pk-backend-groups.h
+@@ -29,4 +29,4 @@ gboolean	 pk_backend_initialize_groups	(PkBackend *self,
+ 
+ void		 pk_backend_destroy_groups	(PkBackend *self);
+ 
+-const gchar	*alpm_pkg_get_group		(pmpkg_t *pkg);
++const gchar	*alpm_pkg_get_group		(alpm_pkg_t *pkg);
+diff --git a/backends/alpm/pk-backend-install.c b/backends/alpm/pk-backend-install.c
+index 65a6c11..5b5e2b2 100644
+--- a/backends/alpm/pk-backend-install.c
++++ b/backends/alpm/pk-backend-install.c
+@@ -32,15 +32,19 @@
+ static gint
+ alpm_add_file (const gchar *filename)
+ {
+-	pmpkg_t *pkg;
++	alpm_pkg_t *pkg;
++	alpm_siglevel_t level;
+ 
+ 	g_return_val_if_fail (filename != NULL, -1);
++	g_return_val_if_fail (alpm != NULL, -1);
+ 
+-	if (alpm_pkg_load (filename, 1, &pkg) < 0) {
++	level = alpm_option_get_default_siglevel (alpm);
++
++	if (alpm_pkg_load (alpm, filename, 1, level, &pkg) < 0) {
+ 		return -1;
+ 	}
+ 
+-	if (alpm_add_pkg (pkg) < 0) {
++	if (alpm_add_pkg (alpm, pkg) < 0) {
+ 		alpm_pkg_free (pkg);
+ 		return -1;
+ 	}
+@@ -61,8 +65,9 @@ pk_backend_transaction_add_targets (PkBackend *self, GError **error)
+ 
+ 	for (; *paths != NULL; ++paths) {
+ 		if (alpm_add_file (*paths) < 0) {
+-			g_set_error (error, ALPM_ERROR, pm_errno, "%s: %s",
+-				     *paths, alpm_strerrorlast ());
++			enum _alpm_errno_t errno = alpm_errno (alpm);
++			g_set_error (error, ALPM_ERROR, errno, "%s: %s",
++				     *paths, alpm_strerror (errno));
+ 			return FALSE;
+ 		}
+ 	}
+diff --git a/backends/alpm/pk-backend-packages.c b/backends/alpm/pk-backend-packages.c
+index e9a7c94..2d057aa 100644
+--- a/backends/alpm/pk-backend-packages.c
++++ b/backends/alpm/pk-backend-packages.c
+@@ -27,13 +27,11 @@
+ #include "pk-backend-packages.h"
+ 
+ gchar *
+-alpm_pkg_build_id (pmpkg_t *pkg)
++alpm_pkg_build_id (alpm_pkg_t *pkg)
+ {
+ 	const gchar *name, *version, *arch, *repo;
+-	pmdb_t *db;
+ 
+ 	g_return_val_if_fail (pkg != NULL, NULL);
+-	g_return_val_if_fail (localdb != NULL, NULL);
+ 
+ 	name = alpm_pkg_get_name (pkg);
+ 	version = alpm_pkg_get_version (pkg);
+@@ -43,19 +41,18 @@ alpm_pkg_build_id (pmpkg_t *pkg)
+ 		arch = "any";
+ 	}
+ 
+-	db = alpm_pkg_get_db (pkg);
+-	/* TODO: check */
+-	if (db == NULL || db == localdb) {
+-		repo = "installed";
++	/* TODO: check correctness */
++	if (alpm_pkg_get_origin (pkg) == PKG_FROM_SYNCDB) {
++		repo = alpm_db_get_name (alpm_pkg_get_db (pkg));
+ 	} else {
+-		repo = alpm_db_get_name (db);
++		repo = "installed";
+ 	}
+ 
+ 	return pk_package_id_build (name, version, arch, repo);
+ }
+ 
+ void
+-pk_backend_pkg (PkBackend *self, pmpkg_t *pkg, PkInfoEnum info)
++pk_backend_pkg (PkBackend *self, alpm_pkg_t *pkg, PkInfoEnum info)
+ {
+ 	gchar *package;
+ 
+@@ -67,16 +64,17 @@ pk_backend_pkg (PkBackend *self, pmpkg_t *pkg, PkInfoEnum info)
+ 	g_free (package);
+ }
+ 
+-pmpkg_t *
++alpm_pkg_t *
+ pk_backend_find_pkg (PkBackend *self, const gchar *package_id, GError **error)
+ {
+ 	gchar **package;
+ 	const gchar *repo_id;
+-	pmdb_t *db = NULL;
+-	pmpkg_t *pkg;
++	alpm_db_t *db = NULL;
++	alpm_pkg_t *pkg;
+ 
+ 	g_return_val_if_fail (self != NULL, NULL);
+ 	g_return_val_if_fail (package_id != NULL, NULL);
++	g_return_val_if_fail (alpm != NULL, NULL);
+ 	g_return_val_if_fail (localdb != NULL, NULL);
+ 
+ 	package = pk_package_id_split (package_id);
+@@ -86,8 +84,8 @@ pk_backend_find_pkg (PkBackend *self, const gchar *package_id, GError **error)
+ 	if (g_strcmp0 (repo_id, "installed") == 0) {
+ 		db = localdb;
+ 	} else {
+-		const alpm_list_t *i;
+-		for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) {
++		const alpm_list_t *i = alpm_option_get_syncdbs (alpm);
++		for (; i != NULL; i = i->next) {
+ 			const gchar *repo = alpm_db_get_name (i->data);
+ 
+ 			if (g_strcmp0 (repo, repo_id) == 0) {
+@@ -111,7 +109,7 @@ pk_backend_find_pkg (PkBackend *self, const gchar *package_id, GError **error)
+ 	}
+ 
+ 	if (pkg == NULL) {
+-		int code = PM_ERR_PKG_NOT_FOUND;
++		int code = ALPM_ERR_PKG_NOT_FOUND;
+ 		g_set_error (error, ALPM_ERROR, code, "%s: %s", package_id,
+ 			     alpm_strerror (code));
+ 	}
+@@ -123,7 +121,7 @@ static gboolean
+ pk_backend_resolve_package (PkBackend *self, const gchar *package,
+ 			    GError **error)
+ {
+-	pmpkg_t *pkg;
++	alpm_pkg_t *pkg;
+ 	
+ 	PkBitfield filters;
+ 	gboolean skip_local, skip_remote;
+@@ -142,7 +140,7 @@ pk_backend_resolve_package (PkBackend *self, const gchar *package,
+ 					  PK_FILTER_ENUM_NOT_INSTALLED);
+ 	skip_remote = pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED);
+ 
+-	if (alpm_pkg_get_db (pkg) == localdb) {
++	if (alpm_pkg_get_origin (pkg) == PKG_FROM_LOCALDB) {
+ 		if (!skip_local) {
+ 			pk_backend_pkg (self, pkg, PK_INFO_ENUM_INSTALLED);
+ 		}
+@@ -158,7 +156,7 @@ pk_backend_resolve_package (PkBackend *self, const gchar *package,
+ static gboolean
+ pk_backend_resolve_name (PkBackend *self, const gchar *name, GError **error)
+ {
+-	pmpkg_t *pkg;
++	alpm_pkg_t *pkg;
+ 	int code;
+ 	
+ 	PkBitfield filters;
+@@ -166,6 +164,7 @@ pk_backend_resolve_name (PkBackend *self, const gchar *name, GError **error)
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
+ 	g_return_val_if_fail (name != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 	g_return_val_if_fail (localdb != NULL, FALSE);
+ 
+ 	filters = pk_backend_get_uint (self, "filters");
+@@ -180,8 +179,8 @@ pk_backend_resolve_name (PkBackend *self, const gchar *name, GError **error)
+ 			return TRUE;
+ 		}
+ 	} else if (!skip_remote) {
+-		const alpm_list_t *i;
+-		for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) {
++		const alpm_list_t *i = alpm_option_get_syncdbs (alpm);
++		for (; i != NULL; i = i->next) {
+ 			pkg = alpm_db_get_pkg (i->data, name);
+ 			if (pkg != NULL) {
+ 				pk_backend_pkg (self, pkg,
+@@ -191,7 +190,7 @@ pk_backend_resolve_name (PkBackend *self, const gchar *name, GError **error)
+ 		}
+ 	}
+ 
+-	code = PM_ERR_PKG_NOT_FOUND;
++	code = ALPM_ERR_PKG_NOT_FOUND;
+ 	g_set_error (error, ALPM_ERROR, code, "%s: %s", name,
+ 		     alpm_strerror (code));
+ 	return FALSE;
+@@ -254,7 +253,7 @@ pk_backend_get_details_thread (PkBackend *self)
+ 	g_return_val_if_fail (packages != NULL, FALSE);
+ 
+ 	for (; *packages != NULL; ++packages) {
+-		pmpkg_t *pkg;
++		alpm_pkg_t *pkg;
+ 		const alpm_list_t *i;
+ 
+ 		GString *licenses;
+@@ -286,7 +285,7 @@ pk_backend_get_details_thread (PkBackend *self)
+ 		desc = alpm_pkg_get_desc (pkg);
+ 		url = alpm_pkg_get_url (pkg);
+ 
+-		if (alpm_pkg_get_db (pkg) == localdb) {
++		if (alpm_pkg_get_origin (pkg) == PKG_FROM_LOCALDB) {
+ 			size = alpm_pkg_get_isize (pkg);
+ 		} else {
+ 			size = alpm_pkg_download_size (pkg);
+@@ -317,17 +316,19 @@ pk_backend_get_files_thread (PkBackend *self)
+ 	GError *error = NULL;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 
+ 	packages = pk_backend_get_strv (self, "package_ids");
+ 
+ 	g_return_val_if_fail (packages != NULL, FALSE);
+ 
+ 	for (; *packages != NULL; ++packages) {
+-		pmpkg_t *pkg;
+-		const alpm_list_t *i;
++		alpm_pkg_t *pkg;
++		const gchar *root;
+ 
+ 		GString *files;
+-		const gchar *root;
++		alpm_filelist_t *filelist;
++		gsize i;
+ 
+ 		if (pk_backend_cancelled (self)) {
+ 			break;
+@@ -338,11 +339,13 @@ pk_backend_get_files_thread (PkBackend *self)
+ 			break;
+ 		}
+ 
++		root = alpm_option_get_root (alpm);
+ 		files = g_string_new ("");
+-		root = alpm_option_get_root ();
+-		for (i = alpm_pkg_get_files (pkg); i != NULL; i = i->next) {
+-			g_string_append_printf (files, ";%s%s", root,
+-						(const gchar *) i->data);
++
++		filelist = alpm_pkg_get_files (pkg);
++		for (i = 0; i < filelist->count; ++i) {
++			const gchar *file = filelist->files[i].name;
++			g_string_append_printf (files, ";%s%s", root, file);
+ 		}
+ 
+ 		pk_backend_files (self, *packages, files->str + 1);
+diff --git a/backends/alpm/pk-backend-packages.h b/backends/alpm/pk-backend-packages.h
+index 4b2d7f8..2d54684 100644
+--- a/backends/alpm/pk-backend-packages.h
++++ b/backends/alpm/pk-backend-packages.h
+@@ -24,10 +24,11 @@
+ #include <alpm.h>
+ #include <pk-backend.h>
+ 
+-gchar	*alpm_pkg_build_id	(pmpkg_t *pkg);
++gchar		*alpm_pkg_build_id	(alpm_pkg_t *pkg);
+ 
+-void	 pk_backend_pkg		(PkBackend *self, pmpkg_t *pkg,
+-				 PkInfoEnum info);
++void		 pk_backend_pkg		(PkBackend *self, alpm_pkg_t *pkg,
++					 PkInfoEnum info);
+ 
+-pmpkg_t	*pk_backend_find_pkg	(PkBackend *self, const gchar *package_id,
+-				 GError **error);
++alpm_pkg_t	*pk_backend_find_pkg	(PkBackend *self,
++					 const gchar *package_id,
++					 GError **error);
+diff --git a/backends/alpm/pk-backend-remove.c b/backends/alpm/pk-backend-remove.c
+index 03329b1..1993061 100644
+--- a/backends/alpm/pk-backend-remove.c
++++ b/backends/alpm/pk-backend-remove.c
+@@ -29,29 +29,14 @@
+ #include "pk-backend-remove.h"
+ #include "pk-backend-transaction.h"
+ 
+-static gint
+-alpm_remove_local (const gchar *name)
+-{
+-	pmpkg_t *pkg;
+-
+-	g_return_val_if_fail (name != NULL, -1);
+-	g_return_val_if_fail (localdb != NULL, -1);
+-
+-	pkg = alpm_db_get_pkg (localdb, name);
+-	if (pkg == NULL) {
+-		pm_errno = PM_ERR_PKG_NOT_FOUND;
+-		return -1;
+-	}
+-
+-	return alpm_remove_pkg (pkg);
+-}
+-
+ static gboolean
+ pk_backend_transaction_remove_targets (PkBackend *self, GError **error)
+ {
+ 	gchar **packages;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
++	g_return_val_if_fail (localdb != NULL, FALSE);
+ 
+ 	packages = pk_backend_get_strv (self, "package_ids");
+ 
+@@ -61,9 +46,11 @@ pk_backend_transaction_remove_targets (PkBackend *self, GError **error)
+ 		gchar **package = pk_package_id_split (*packages);
+ 		gchar *name = package[PK_PACKAGE_ID_NAME];
+ 
+-		if (alpm_remove_local (name) < 0) {
+-			g_set_error (error, ALPM_ERROR, pm_errno, "%s: %s",
+-				     name, alpm_strerrorlast ());
++		alpm_pkg_t *pkg = alpm_db_get_pkg (localdb, name);
++		if (pkg == NULL || alpm_remove_pkg (alpm, pkg) < 0) {
++			enum _alpm_errno_t errno = alpm_errno (alpm);
++			g_set_error (error, ALPM_ERROR, errno, "%s: %s", name,
++				     alpm_strerror (errno));
+ 			g_strfreev (package);
+ 			return FALSE;
+ 		}
+@@ -79,14 +66,17 @@ pk_backend_transaction_remove_simulate (PkBackend *self, GError **error)
+ {
+ 	const alpm_list_t *i;
+ 
++	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
++
+ 	if (!pk_backend_transaction_simulate (self, error)) {
+ 		return FALSE;
+ 	}
+ 
+-	for (i = alpm_trans_get_remove (); i != NULL; i = i->next) {
++	for (i = alpm_trans_get_remove (alpm); i != NULL; i = i->next) {
+ 		const gchar *name = alpm_pkg_get_name (i->data);
+ 		if (alpm_list_find_str (holdpkgs, name)) {
+-			g_set_error (error, ALPM_ERROR, PM_ERR_PKG_HELD,
++			g_set_error (error, ALPM_ERROR, ALPM_ERR_PKG_HELD,
+ 				     "%s: %s", name,
+ 				     "could not remove HoldPkg");
+ 			return FALSE;
+@@ -99,14 +89,14 @@ pk_backend_transaction_remove_simulate (PkBackend *self, GError **error)
+ static gboolean
+ pk_backend_simulate_remove_packages_thread (PkBackend *self)
+ {
+-	pmtransflag_t flags = PM_TRANS_FLAG_CASCADE;
++	alpm_transflag_t flags = ALPM_TRANS_FLAG_CASCADE;
+ 	GError *error = NULL;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
+ 
+ 	/* remove unneeded packages that were required by those to be removed */
+ 	if (pk_backend_get_bool (self, "autoremove")) {
+-		flags |= PM_TRANS_FLAG_RECURSE;
++		flags |= ALPM_TRANS_FLAG_RECURSE;
+ 	}
+ 
+ 	if (pk_backend_transaction_initialize (self, flags, &error) &&
+@@ -121,18 +111,18 @@ pk_backend_simulate_remove_packages_thread (PkBackend *self)
+ static gboolean
+ pk_backend_remove_packages_thread (PkBackend *self)
+ {
+-	pmtransflag_t flags = 0;
++	alpm_transflag_t flags = 0;
+ 	GError *error = NULL;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
+ 
+ 	/* remove packages that depend on those to be removed */
+ 	if (pk_backend_get_bool (self, "allow_deps")) {
+-		flags |= PM_TRANS_FLAG_CASCADE;
++		flags |= ALPM_TRANS_FLAG_CASCADE;
+ 	}
+ 	/* remove unneeded packages that were required by those to be removed */
+ 	if (pk_backend_get_bool (self, "autoremove")) {
+-		flags |= PM_TRANS_FLAG_RECURSE;
++		flags |= ALPM_TRANS_FLAG_RECURSE;
+ 	}
+ 
+ 	if (pk_backend_transaction_initialize (self, flags, &error) &&
+diff --git a/backends/alpm/pk-backend-search.c b/backends/alpm/pk-backend-search.c
+index 592472d..c4e80ae 100644
+--- a/backends/alpm/pk-backend-search.c
++++ b/backends/alpm/pk-backend-search.c
+@@ -55,9 +55,10 @@ static gpointer
+ pk_backend_pattern_chroot (const gchar *needle, GError **error)
+ {
+ 	g_return_val_if_fail (needle != NULL, NULL);
++	g_return_val_if_fail (alpm != NULL, NULL);
+ 
+ 	if (G_IS_DIR_SEPARATOR (*needle)) {
+-		const gchar *file = needle, *root = alpm_option_get_root ();
++		const gchar *file = needle, *root = alpm_option_get_root (alpm);
+ 
+ 		/* adjust needle to the correct prefix */
+ 		for (; *file == *root; ++file, ++root) {
+@@ -74,7 +75,7 @@ pk_backend_pattern_chroot (const gchar *needle, GError **error)
+ }
+ 
+ static gboolean
+-pk_backend_match_all (pmpkg_t *pkg, gpointer pattern)
++pk_backend_match_all (alpm_pkg_t *pkg, gpointer pattern)
+ {
+ 	g_return_val_if_fail (pkg != NULL, FALSE);
+ 	g_return_val_if_fail (pattern != NULL, FALSE);
+@@ -84,10 +85,10 @@ pk_backend_match_all (pmpkg_t *pkg, gpointer pattern)
+ }
+ 
+ static gboolean
+-pk_backend_match_details (pmpkg_t *pkg, GRegex *regex)
++pk_backend_match_details (alpm_pkg_t *pkg, GRegex *regex)
+ {
+ 	const gchar *desc;
+-	pmdb_t *db;
++	alpm_db_t *db;
+ 	const alpm_list_t *i;
+ 
+ 	g_return_val_if_fail (pkg != NULL, FALSE);
+@@ -123,32 +124,38 @@ pk_backend_match_details (pmpkg_t *pkg, GRegex *regex)
+ }
+ 
+ static gboolean
+-pk_backend_match_file (pmpkg_t *pkg, const gchar *needle)
++pk_backend_match_file (alpm_pkg_t *pkg, const gchar *needle)
+ {
+-	const alpm_list_t *i;
++	alpm_filelist_t *files;
++	gsize i;
+ 
+ 	g_return_val_if_fail (pkg != NULL, FALSE);
+ 	g_return_val_if_fail (needle != NULL, FALSE);
+ 
++	files = alpm_pkg_get_files (pkg);
++
+ 	/* match any file the package contains */
+ 	if (G_IS_DIR_SEPARATOR (*needle)) {
+-		for (i = alpm_pkg_get_files (pkg); i != NULL; i = i->next) {
++		for (i = 0; i < files->count; ++i) {
++			const gchar *file = files->files[i].name;
+ 			/* match the full path of file */
+-			if (g_strcmp0 (i->data, needle + 1) == 0) {
++			if (g_strcmp0 (file, needle + 1) == 0) {
+ 				return TRUE;
+ 			}
+ 		}
+ 	} else {
+-		for (i = alpm_pkg_get_files (pkg); i != NULL; i = i->next) {
+-			const gchar *file = strrchr (i->data, G_DIR_SEPARATOR);
+-			if (file == NULL) {
+-				file = i->data;
++		for (i = 0; i < files->count; ++i) {
++			const gchar *file = files->files[i].name;
++			const gchar *name = strrchr (file, G_DIR_SEPARATOR);
++
++			if (name == NULL) {
++				name = file;
+ 			} else {
+-				++file;
++				++name;
+ 			}
+ 
+ 			/* match the basename of file */
+-			if (g_strcmp0 (file, needle) == 0) {
++			if (g_strcmp0 (name, needle) == 0) {
+ 				return TRUE;
+ 			}
+ 		}
+@@ -158,7 +165,7 @@ pk_backend_match_file (pmpkg_t *pkg, const gchar *needle)
+ }
+ 
+ static gboolean
+-pk_backend_match_group (pmpkg_t *pkg, const gchar *needle)
++pk_backend_match_group (alpm_pkg_t *pkg, const gchar *needle)
+ {
+ 	g_return_val_if_fail (pkg != NULL, FALSE);
+ 	g_return_val_if_fail (needle != NULL, FALSE);
+@@ -168,7 +175,7 @@ pk_backend_match_group (pmpkg_t *pkg, const gchar *needle)
+ }
+ 
+ static gboolean
+-pk_backend_match_name (pmpkg_t *pkg, GRegex *regex)
++pk_backend_match_name (alpm_pkg_t *pkg, GRegex *regex)
+ {
+ 	g_return_val_if_fail (pkg != NULL, FALSE);
+ 	g_return_val_if_fail (regex != NULL, FALSE);
+@@ -178,7 +185,7 @@ pk_backend_match_name (pmpkg_t *pkg, GRegex *regex)
+ }
+ 
+ static gboolean
+-pk_backend_match_provides (pmpkg_t *pkg, gpointer pattern)
++pk_backend_match_provides (alpm_pkg_t *pkg, gpointer pattern)
+ {
+ 	/* TODO: implement GStreamer codecs, Pango fonts, etc. */
+ 	const alpm_list_t *i;
+@@ -215,7 +222,7 @@ typedef enum {
+ } SearchType;
+ 
+ typedef gpointer (*PatternFunc) (const gchar *needle, GError **error);
+-typedef gboolean (*MatchFunc) (pmpkg_t *pkg, gpointer pattern);
++typedef gboolean (*MatchFunc) (alpm_pkg_t *pkg, gpointer pattern);
+ 
+ static PatternFunc pattern_funcs[] = {
+ 	pk_backend_pattern_needle,
+@@ -245,9 +252,9 @@ static MatchFunc match_funcs[] = {
+ };
+ 
+ static gboolean
+-alpm_pkg_is_local (pmpkg_t *pkg)
++alpm_pkg_is_local (alpm_pkg_t *pkg)
+ {
+-	pmpkg_t *local;
++	alpm_pkg_t *local;
+ 
+ 	g_return_val_if_fail (pkg != NULL, FALSE);
+ 	g_return_val_if_fail (localdb != NULL, FALSE);
+@@ -274,7 +281,7 @@ alpm_pkg_is_local (pmpkg_t *pkg)
+ }
+ 
+ static void
+-pk_backend_search_db (PkBackend *self, pmdb_t *db, MatchFunc match,
++pk_backend_search_db (PkBackend *self, alpm_db_t *db, MatchFunc match,
+ 		      const alpm_list_t *patterns)
+ {
+ 	const alpm_list_t *i, *j;
+@@ -326,6 +333,7 @@ pk_backend_search_thread (PkBackend *self)
+ 	GError *error = NULL;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 	g_return_val_if_fail (localdb != NULL, FALSE);
+ 
+ 	needles = pk_backend_get_strv (self, "search");
+@@ -366,7 +374,7 @@ pk_backend_search_thread (PkBackend *self)
+ 		goto out;
+ 	}
+ 
+-	for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) {
++	for (i = alpm_option_get_syncdbs (alpm); i != NULL; i = i->next) {
+ 		if (pk_backend_cancelled (self)) {
+ 			break;
+ 		}
+diff --git a/backends/alpm/pk-backend-sync.c b/backends/alpm/pk-backend-sync.c
+index 9e1e02b..c770159 100644
+--- a/backends/alpm/pk-backend-sync.c
++++ b/backends/alpm/pk-backend-sync.c
+@@ -30,41 +30,13 @@
+ #include "pk-backend-sync.h"
+ #include "pk-backend-transaction.h"
+ 
+-static gint
+-alpm_add_dbtarget (const gchar *repo, const gchar *name)
+-{
+-	const alpm_list_t *i;
+-	pmpkg_t *pkg;
+-
+-	g_return_val_if_fail (repo != NULL, -1);
+-	g_return_val_if_fail (name != NULL, -1);
+-
+-	for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) {
+-		if (g_strcmp0 (alpm_db_get_name (i->data), repo) == 0) {
+-			break;
+-		}
+-	}
+-
+-	if (i == NULL) {
+-		pm_errno = PM_ERR_DB_NOT_FOUND;
+-		return -1;
+-	}
+-
+-	pkg = alpm_db_get_pkg (i->data, name);
+-	if (pkg == NULL) {
+-		pm_errno = PM_ERR_PKG_NOT_FOUND;
+-		return -1;
+-	}
+-
+-	return alpm_add_pkg (pkg);
+-}
+-
+ static gboolean
+ pk_backend_transaction_sync_targets (PkBackend *self, GError **error)
+ {
+ 	gchar **packages;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 
+ 	packages = pk_backend_get_strv (self, "package_ids");
+ 
+@@ -75,9 +47,28 @@ pk_backend_transaction_sync_targets (PkBackend *self, GError **error)
+ 		gchar *repo = package[PK_PACKAGE_ID_DATA];
+ 		gchar *name = package[PK_PACKAGE_ID_NAME];
+ 
+-		if (alpm_add_dbtarget (repo, name) < 0) {
+-			g_set_error (error, ALPM_ERROR, pm_errno, "%s/%s: %s",
+-				     repo, name, alpm_strerrorlast ());
++		const alpm_list_t *i = alpm_option_get_syncdbs (alpm);
++		alpm_pkg_t *pkg;
++
++		for (; i != NULL; i = i->next) {
++			if (g_strcmp0 (alpm_db_get_name (i->data), repo) == 0) {
++				break;
++			}
++		}
++
++		if (i == NULL) {
++			enum _alpm_errno_t errno = ALPM_ERR_DB_NOT_FOUND;
++			g_set_error (error, ALPM_ERROR, errno, "%s/%s: %s",
++				     repo, name, alpm_strerror (errno));
++			g_strfreev (package);
++			return FALSE;
++		}
++
++		pkg = alpm_db_get_pkg (i->data, name);
++		if (pkg == NULL || alpm_add_pkg (alpm, pkg) < 0) {
++			enum _alpm_errno_t errno = alpm_errno (alpm);
++			g_set_error (error, ALPM_ERROR, errno, "%s/%s: %s",
++				     repo, name, alpm_strerror (errno));
+ 			g_strfreev (package);
+ 			return FALSE;
+ 		}
+@@ -93,23 +84,27 @@ pk_backend_download_packages_thread (PkBackend *self)
+ {
+ 	alpm_list_t *cachedirs;
+ 	const gchar *directory;
+-	pmtransflag_t flags = 0;
++	alpm_transflag_t flags = 0;
+ 	GError *error = NULL;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 
+ 	directory = pk_backend_get_string (self, "directory");
+ 
+ 	if (directory != NULL) {
+ 		/* download files to a PackageKit directory */
+ 		gchar *cachedir = strdup (directory);
+-		cachedirs = alpm_list_strdup (alpm_option_get_cachedirs ());
+-		alpm_option_set_cachedirs (alpm_list_add (NULL, cachedir));
++		const alpm_list_t *old = alpm_option_get_cachedirs (alpm);
++		alpm_list_t *new = alpm_list_add (NULL, cachedir);
++
++		cachedirs = alpm_list_strdup (old);
++		alpm_option_set_cachedirs (alpm, new);
+ 	}
+ 
+-	flags |= PM_TRANS_FLAG_NODEPS;
+-	flags |= PM_TRANS_FLAG_NOCONFLICTS;
+-	flags |= PM_TRANS_FLAG_DOWNLOADONLY;
++	flags |= ALPM_TRANS_FLAG_NODEPS;
++	flags |= ALPM_TRANS_FLAG_NOCONFLICTS;
++	flags |= ALPM_TRANS_FLAG_DOWNLOADONLY;
+ 
+ 	if (pk_backend_transaction_initialize (self, flags, &error) &&
+ 	    pk_backend_transaction_sync_targets (self, &error) &&
+@@ -118,7 +113,7 @@ pk_backend_download_packages_thread (PkBackend *self)
+ 	}
+ 
+ 	if (directory != NULL) {
+-		alpm_option_set_cachedirs (cachedirs);
++		alpm_option_set_cachedirs (alpm, cachedirs);
+ 	}
+ 
+ 	return pk_backend_transaction_finish (self, error);
+@@ -190,16 +185,17 @@ pk_backend_install_packages (PkBackend *self, gboolean only_trusted,
+ }
+ 
+ static gboolean
+-pk_backend_replaces_dependencies (PkBackend *self, pmpkg_t *pkg)
++pk_backend_replaces_dependencies (PkBackend *self, alpm_pkg_t *pkg)
+ {
+ 	const alpm_list_t *i, *replaces;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
+ 	g_return_val_if_fail (pkg != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 
+ 	replaces = alpm_pkg_get_replaces (pkg);
+-	for (i = alpm_trans_get_remove (); i != NULL; i = i->next) {
+-		pmpkg_t *rpkg = (pmpkg_t *) i->data;
++	for (i = alpm_trans_get_remove (alpm); i != NULL; i = i->next) {
++		alpm_pkg_t *rpkg = (alpm_pkg_t *) i->data;
+ 		const gchar *rname = alpm_pkg_get_name (rpkg);
+ 
+ 		if (pk_backend_cancelled (self)) {
+@@ -208,7 +204,7 @@ pk_backend_replaces_dependencies (PkBackend *self, pmpkg_t *pkg)
+ 			continue;
+ 		}
+ 
+-		if (alpm_pkg_get_reason (rpkg) == PM_PKG_REASON_EXPLICIT) {
++		if (alpm_pkg_get_reason (rpkg) == ALPM_PKG_REASON_EXPLICIT) {
+ 			return FALSE;
+ 		}
+ 	}
+@@ -224,6 +220,7 @@ pk_backend_update_packages_thread (PkBackend *self)
+ 	GError *error = NULL;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 	g_return_val_if_fail (localdb != NULL, FALSE);
+ 
+ 	if (!pk_backend_transaction_initialize (self, 0, &error) ||
+@@ -233,8 +230,8 @@ pk_backend_update_packages_thread (PkBackend *self)
+ 	}
+ 
+ 	/* change the install reason of packages that replace dependencies */
+-	for (i = alpm_trans_get_add (); i != NULL; i = i->next) {
+-		pmpkg_t *pkg = (pmpkg_t *) i->data;
++	for (i = alpm_trans_get_add (alpm); i != NULL; i = i->next) {
++		alpm_pkg_t *pkg = (alpm_pkg_t *) i->data;
+ 		const gchar *name = alpm_pkg_get_name (pkg);
+ 
+ 		if (pk_backend_cancelled (self)) {
+@@ -254,7 +251,8 @@ pk_backend_update_packages_thread (PkBackend *self)
+ 
+ 	for (i = asdeps; i != NULL; i = i->next) {
+ 		const gchar *name = (const gchar *) i->data;
+-		alpm_db_set_pkgreason (localdb, name, PM_PKG_REASON_DEPEND);
++		alpm_pkg_t *pkg = alpm_db_get_pkg (localdb, name);
++		alpm_db_set_pkgreason (alpm, pkg, ALPM_PKG_REASON_DEPEND);
+ 	}
+ 
+ out:
+diff --git a/backends/alpm/pk-backend-transaction.c b/backends/alpm/pk-backend-transaction.c
+index fdb840e..f812766 100644
+--- a/backends/alpm/pk-backend-transaction.c
++++ b/backends/alpm/pk-backend-transaction.c
+@@ -29,10 +29,10 @@
+ static off_t dcomplete = 0;
+ static off_t dtotal = 0;
+ 
+-static pmpkg_t *dpkg = NULL;
++static alpm_pkg_t *dpkg = NULL;
+ static GString *dfiles = NULL;
+ 
+-static pmpkg_t *tpkg = NULL;
++static alpm_pkg_t *tpkg = NULL;
+ static GString *toutput = NULL;
+ 
+ static gchar *
+@@ -51,25 +51,26 @@ pk_backend_resolve_path (PkBackend *self, const gchar *basename)
+ }
+ 
+ static gboolean
+-alpm_pkg_has_basename (pmpkg_t *pkg, const gchar *basename)
++alpm_pkg_has_basename (alpm_pkg_t *pkg, const gchar *basename)
+ {
+ 	const alpm_list_t *i;
+ 
+ 	g_return_val_if_fail (pkg != NULL, FALSE);
+ 	g_return_val_if_fail (basename != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 
+ 	if (g_strcmp0 (alpm_pkg_get_filename (pkg), basename) == 0) {
+ 		return TRUE;
+ 	}
+ 
+-	if (alpm_option_get_usedelta () == 0) {
++	if (alpm_option_get_usedelta (alpm) == 0) {
+ 		return FALSE;
+ 	}
+ 
+ 	for (i = alpm_pkg_get_deltas (pkg); i != NULL; i = i->next) {
+-		const gchar *patch = alpm_delta_get_filename (i->data);
++		alpm_delta_t *delta = (alpm_delta_t *) i->data;
+ 
+-		if (g_strcmp0 (patch, basename) == 0) {
++		if (g_strcmp0 (delta->delta, basename) == 0) {
+ 			return TRUE;
+ 		}
+ 	}
+@@ -109,6 +110,7 @@ pk_backend_transaction_download_start (PkBackend *self, const gchar *basename)
+ 
+ 	g_return_if_fail (self != NULL);
+ 	g_return_if_fail (basename != NULL);
++	g_return_if_fail (alpm != NULL);
+ 
+ 	/* continue or finish downloading the current package */
+ 	if (dpkg != NULL) {
+@@ -127,8 +129,8 @@ pk_backend_transaction_download_start (PkBackend *self, const gchar *basename)
+ 	}
+ 
+ 	/* figure out what the next package is */
+-	for (i = alpm_trans_get_add (); i != NULL; i = i->next) {
+-		pmpkg_t *pkg = (pmpkg_t *) i->data;
++	for (i = alpm_trans_get_add (alpm); i != NULL; i = i->next) {
++		alpm_pkg_t *pkg = (alpm_pkg_t *) i->data;
+ 
+ 		if (alpm_pkg_has_basename (pkg, basename)) {
+ 			dpkg = pkg;
+@@ -202,16 +204,17 @@ pk_backend_transaction_dlcb (const gchar *basename, off_t complete, off_t total)
+ }
+ 
+ static void
+-pk_backend_transaction_progress_cb (pmtransprog_t type, const gchar *target,
++pk_backend_transaction_progress_cb (alpm_progress_t type, const gchar *target,
+ 				    gint percent, gsize targets, gsize current)
+ {
+ 	static gint recent = 101;
+ 	gsize overall = percent + (current - 1) * 100;
+ 
+ 	/* TODO: revert when fixed upstream */
+-	if (type == PM_TRANS_PROGRESS_CONFLICTS_START ||
+-	    type == PM_TRANS_PROGRESS_DISKSPACE_START ||
+-	    type == PM_TRANS_PROGRESS_INTEGRITY_START) {
++	if (type == ALPM_PROGRESS_CONFLICTS_START ||
++	    type == ALPM_PROGRESS_DISKSPACE_START ||
++	    type == ALPM_PROGRESS_INTEGRITY_START ||
++	    type == ALPM_PROGRESS_LOAD_START) {
+ 		if (current < targets) {
+ 			overall = percent + current++ * 100;
+ 		}
+@@ -228,12 +231,13 @@ pk_backend_transaction_progress_cb (pmtransprog_t type, const gchar *target,
+ 
+ 	/* update transaction progress */
+ 	switch (type) {
+-		case PM_TRANS_PROGRESS_ADD_START:
+-		case PM_TRANS_PROGRESS_UPGRADE_START:
+-		case PM_TRANS_PROGRESS_REMOVE_START:
+-		case PM_TRANS_PROGRESS_CONFLICTS_START:
+-		case PM_TRANS_PROGRESS_DISKSPACE_START:
+-		case PM_TRANS_PROGRESS_INTEGRITY_START:
++		case ALPM_PROGRESS_ADD_START:
++		case ALPM_PROGRESS_UPGRADE_START:
++		case ALPM_PROGRESS_REMOVE_START:
++		case ALPM_PROGRESS_CONFLICTS_START:
++		case ALPM_PROGRESS_DISKSPACE_START:
++		case ALPM_PROGRESS_INTEGRITY_START:
++		case ALPM_PROGRESS_LOAD_START:
+ 			if (percent == recent) {
+ 				break;
+ 			}
+@@ -253,7 +257,7 @@ pk_backend_transaction_progress_cb (pmtransprog_t type, const gchar *target,
+ }
+ 
+ static void
+-pk_backend_install_ignorepkg (PkBackend *self, pmpkg_t *pkg, gint *result)
++pk_backend_install_ignorepkg (PkBackend *self, alpm_pkg_t *pkg, gint *result)
+ {
+ 	gchar *output;
+ 
+@@ -280,50 +284,52 @@ pk_backend_install_ignorepkg (PkBackend *self, pmpkg_t *pkg, gint *result)
+ }
+ 
+ static void
+-pk_backend_select_provider (PkBackend *self, pmdepend_t *dep,
++pk_backend_select_provider (PkBackend *self, alpm_depend_t *depend,
+ 			    const alpm_list_t *providers)
+ {
+ 	gchar *output;
+ 
+ 	g_return_if_fail (self != NULL);
+-	g_return_if_fail (dep != NULL);
++	g_return_if_fail (depend != NULL);
+ 	g_return_if_fail (providers != NULL);
+ 
+ 	output = g_strdup_printf ("provider package was selected "
+ 				  "(%s provides %s)\n",
+ 				  alpm_pkg_get_name (providers->data),
+-				  alpm_dep_get_name (dep));
++				  depend->name);
+ 	pk_backend_output (self, output);
+ 	g_free (output);
+ }
+ 
+ static void
+-pk_backend_transaction_conv_cb (pmtransconv_t question, gpointer data1,
++pk_backend_transaction_conv_cb (alpm_question_t question, gpointer data1,
+ 				gpointer data2, gpointer data3, gint *result)
+ {
+ 	g_return_if_fail (result != NULL);
+ 	g_return_if_fail (backend != NULL);
+ 
+ 	switch (question) {
+-		case PM_TRANS_CONV_INSTALL_IGNOREPKG:
++		case ALPM_QUESTION_INSTALL_IGNOREPKG:
+ 			pk_backend_install_ignorepkg (backend, data1, result);
+ 			break;
+ 
+-		case PM_TRANS_CONV_REPLACE_PKG:
+-		case PM_TRANS_CONV_CONFLICT_PKG:
+-		case PM_TRANS_CONV_CORRUPTED_PKG:
+-		case PM_TRANS_CONV_LOCAL_NEWER:
++		case ALPM_QUESTION_REPLACE_PKG:
++		case ALPM_QUESTION_CONFLICT_PKG:
++		case ALPM_QUESTION_CORRUPTED_PKG:
++		case ALPM_QUESTION_LOCAL_NEWER:
+ 			/* these actions are mostly harmless */
+ 			g_debug ("safe question %d", question);
+ 			*result = 1;
+ 			break;
+ 
+-		case PM_TRANS_CONV_REMOVE_PKGS:
++		case ALPM_QUESTION_REMOVE_PKGS:
++		/* TODO: handle keys better */
++		case ALPM_QUESTION_IMPORT_KEY:
+ 			g_debug ("unsafe question %d", question);
+ 			*result = 0;
+ 			break;
+ 
+-		case PM_TRANS_CONV_SELECT_PROVIDER:
++		case ALPM_QUESTION_SELECT_PROVIDER:
+ 			pk_backend_select_provider (backend, data1, data2);
+ 			*result = 0;
+ 			break;
+@@ -349,7 +355,7 @@ pk_backend_output_end (PkBackend *self)
+ }
+ 
+ static void
+-pk_backend_output_start (PkBackend *self, pmpkg_t *pkg)
++pk_backend_output_start (PkBackend *self, alpm_pkg_t *pkg)
+ {
+ 	g_return_if_fail (self != NULL);
+ 	g_return_if_fail (pkg != NULL);
+@@ -398,7 +404,7 @@ pk_backend_transaction_test_commit (PkBackend *self)
+ }
+ 
+ static void
+-pk_backend_transaction_add_start (PkBackend *self, pmpkg_t *pkg)
++pk_backend_transaction_add_start (PkBackend *self, alpm_pkg_t *pkg)
+ {
+ 	g_return_if_fail (self != NULL);
+ 	g_return_if_fail (pkg != NULL);
+@@ -409,18 +415,19 @@ pk_backend_transaction_add_start (PkBackend *self, pmpkg_t *pkg)
+ }
+ 
+ static void
+-pk_backend_transaction_add_done (PkBackend *self, pmpkg_t *pkg)
++pk_backend_transaction_add_done (PkBackend *self, alpm_pkg_t *pkg)
+ {
+ 	const gchar *name, *version;
+ 	const alpm_list_t *i, *optdepends;
+ 
+ 	g_return_if_fail (self != NULL);
+ 	g_return_if_fail (pkg != NULL);
++	g_return_if_fail (alpm != NULL);
+ 
+ 	name = alpm_pkg_get_name (pkg);
+ 	version = alpm_pkg_get_version (pkg);
+ 
+-	alpm_logaction ("installed %s (%s)\n", name, version);
++	alpm_logaction (alpm, "installed %s (%s)\n", name, version);
+ 	pk_backend_pkg (self, pkg, PK_INFO_ENUM_FINISHED);
+ 
+ 	optdepends = alpm_pkg_get_optdepends (pkg);
+@@ -438,7 +445,7 @@ pk_backend_transaction_add_done (PkBackend *self, pmpkg_t *pkg)
+ }
+ 
+ static void
+-pk_backend_transaction_remove_start (PkBackend *self, pmpkg_t *pkg)
++pk_backend_transaction_remove_start (PkBackend *self, alpm_pkg_t *pkg)
+ {
+ 	g_return_if_fail (self != NULL);
+ 	g_return_if_fail (pkg != NULL);
+@@ -449,24 +456,25 @@ pk_backend_transaction_remove_start (PkBackend *self, pmpkg_t *pkg)
+ }
+ 
+ static void
+-pk_backend_transaction_remove_done (PkBackend *self, pmpkg_t *pkg)
++pk_backend_transaction_remove_done (PkBackend *self, alpm_pkg_t *pkg)
+ {
+ 	const gchar *name, *version;
+ 
+ 	g_return_if_fail (self != NULL);
+ 	g_return_if_fail (pkg != NULL);
++	g_return_if_fail (alpm != NULL);
+ 
+ 	name = alpm_pkg_get_name (pkg);
+ 	version = alpm_pkg_get_version (pkg);
+ 
+-	alpm_logaction ("removed %s (%s)\n", name, version);
++	alpm_logaction (alpm, "removed %s (%s)\n", name, version);
+ 	pk_backend_pkg (self, pkg, PK_INFO_ENUM_FINISHED);
+ 	pk_backend_output_end (self);
+ }
+ 
+ static void
+-pk_backend_transaction_upgrade_start (PkBackend *self, pmpkg_t *pkg,
+-				      pmpkg_t *old)
++pk_backend_transaction_upgrade_start (PkBackend *self, alpm_pkg_t *pkg,
++				      alpm_pkg_t *old)
+ {
+ 	PkRoleEnum role;
+ 	PkStatusEnum state;
+@@ -491,8 +499,8 @@ pk_backend_transaction_upgrade_start (PkBackend *self, pmpkg_t *pkg,
+ }
+ 
+ static void
+-pk_backend_transaction_upgrade_done (PkBackend *self, pmpkg_t *pkg,
+-				     pmpkg_t *old)
++pk_backend_transaction_upgrade_done (PkBackend *self, alpm_pkg_t *pkg,
++				     alpm_pkg_t *old)
+ {
+ 	const gchar *name, *pre, *post;
+ 	const alpm_list_t *i;
+@@ -501,12 +509,13 @@ pk_backend_transaction_upgrade_done (PkBackend *self, pmpkg_t *pkg,
+ 	g_return_if_fail (self != NULL);
+ 	g_return_if_fail (pkg != NULL);
+ 	g_return_if_fail (old != NULL);
++	g_return_if_fail (alpm != NULL);
+ 
+ 	name = alpm_pkg_get_name (pkg);
+ 	pre = alpm_pkg_get_version (old);
+ 	post = alpm_pkg_get_version (pkg);
+ 
+-	alpm_logaction ("upgraded %s (%s -> %s)\n", name, pre, post);
++	alpm_logaction (alpm, "upgraded %s (%s -> %s)\n", name, pre, post);
+ 	pk_backend_pkg (self, pkg, PK_INFO_ENUM_FINISHED);
+ 
+ 	optdepends = alpm_list_diff (alpm_pkg_get_optdepends (pkg),
+@@ -528,53 +537,65 @@ pk_backend_transaction_upgrade_done (PkBackend *self, pmpkg_t *pkg,
+ }
+ 
+ static void
+-pk_backend_transaction_event_cb (pmtransevt_t event, gpointer data,
++pk_backend_transaction_setup (PkBackend *self)
++{
++	g_return_if_fail (self != NULL);
++
++	pk_backend_set_status (self, PK_STATUS_ENUM_SETUP);
++}
++
++static void
++pk_backend_transaction_event_cb (alpm_event_t event, gpointer data,
+ 				 gpointer old)
+ {
+ 	g_return_if_fail (backend != NULL);
+ 
+ 	/* figure out the backend status and package info */
+ 	switch (event) {
+-		case PM_TRANS_EVT_CHECKDEPS_START:
+-		case PM_TRANS_EVT_RESOLVEDEPS_START:
++		case ALPM_EVENT_CHECKDEPS_START:
++		case ALPM_EVENT_RESOLVEDEPS_START:
+ 			pk_backend_transaction_dep_resolve (backend);
+ 			break;
+ 
+-		case PM_TRANS_EVT_FILECONFLICTS_START:
+-		case PM_TRANS_EVT_INTERCONFLICTS_START:
+-		case PM_TRANS_EVT_INTEGRITY_START:
+-		case PM_TRANS_EVT_DELTA_INTEGRITY_START:
+-		case PM_TRANS_EVT_DISKSPACE_START:
++		case ALPM_EVENT_FILECONFLICTS_START:
++		case ALPM_EVENT_INTERCONFLICTS_START:
++		case ALPM_EVENT_INTEGRITY_START:
++		case ALPM_EVENT_DELTA_INTEGRITY_START:
++		case ALPM_EVENT_DISKSPACE_START:
+ 			pk_backend_transaction_test_commit (backend);
+ 			break;
+ 
+-		case PM_TRANS_EVT_ADD_START:
++		case ALPM_EVENT_ADD_START:
+ 			pk_backend_transaction_add_start (backend, data);
+ 			break;
+ 
+-		case PM_TRANS_EVT_ADD_DONE:
++		case ALPM_EVENT_ADD_DONE:
+ 			pk_backend_transaction_add_done (backend, data);
+ 			break;
+ 
+-		case PM_TRANS_EVT_REMOVE_START:
++		case ALPM_EVENT_REMOVE_START:
+ 			pk_backend_transaction_remove_start (backend, data);
+ 			break;
+ 
+-		case PM_TRANS_EVT_REMOVE_DONE:
++		case ALPM_EVENT_REMOVE_DONE:
+ 			pk_backend_transaction_remove_done (backend, data);
+ 			break;
+ 
+-		case PM_TRANS_EVT_UPGRADE_START:
++		case ALPM_EVENT_UPGRADE_START:
+ 			pk_backend_transaction_upgrade_start (backend, data,
+ 							      old);
+ 			break;
+ 
+-		case PM_TRANS_EVT_UPGRADE_DONE:
++		case ALPM_EVENT_UPGRADE_DONE:
+ 			pk_backend_transaction_upgrade_done (backend, data,
+ 							     old);
+ 			break;
+ 
+-		case PM_TRANS_EVT_SCRIPTLET_INFO:
++		case ALPM_EVENT_LOAD_START:
++			pk_backend_transaction_setup (backend);
++			break;
++
++		case ALPM_EVENT_SCRIPTLET_INFO:
+ 			pk_backend_output (backend, data);
+ 			break;
+ 
+@@ -588,27 +609,32 @@ static void
+ transaction_cancelled_cb (GCancellable *object, gpointer data)
+ {
+ 	g_return_if_fail (data != NULL);
++	g_return_if_fail (alpm != NULL);
+ 
+-	alpm_trans_interrupt ();
++	alpm_trans_interrupt (alpm);
+ }
+ 
+ gboolean
+-pk_backend_transaction_initialize (PkBackend *self, pmtransflag_t flags,
++pk_backend_transaction_initialize (PkBackend *self, alpm_transflag_t flags,
+ 				   GError **error)
+ {
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 	g_return_val_if_fail (cancellable != NULL, FALSE);
+ 
+-	if (alpm_trans_init (flags, pk_backend_transaction_event_cb,
+-			     pk_backend_transaction_conv_cb,
+-			     pk_backend_transaction_progress_cb) < 0) {
+-		g_set_error_literal (error, ALPM_ERROR, pm_errno,
+-				     alpm_strerrorlast ());
++	if (alpm_trans_init (alpm, flags) < 0) {
++		enum _alpm_errno_t errno = alpm_errno (alpm);
++		g_set_error_literal (error, ALPM_ERROR, errno,
++				     alpm_strerror (errno));
+ 		return FALSE;
+ 	}
+ 
+-	alpm_option_set_dlcb (pk_backend_transaction_dlcb);
+-	alpm_option_set_totaldlcb (pk_backend_transaction_totaldlcb);
++	alpm_option_set_eventcb (alpm, pk_backend_transaction_event_cb);
++	alpm_option_set_questioncb (alpm, pk_backend_transaction_conv_cb);
++	alpm_option_set_progresscb (alpm, pk_backend_transaction_progress_cb);
++
++	alpm_option_set_dlcb (alpm, pk_backend_transaction_dlcb);
++	alpm_option_set_totaldlcb (alpm, pk_backend_transaction_totaldlcb);
+ 
+ 	g_cancellable_connect (cancellable,
+ 			       G_CALLBACK (transaction_cancelled_cb),
+@@ -649,10 +675,11 @@ alpm_miss_build_list (const alpm_list_t *i)
+ 	}
+ 
+ 	for (; i != NULL; i = i->next) {
+-		pmdepend_t *dep = alpm_miss_get_dep (i->data);
+-		gchar *depend = alpm_dep_compute_string (dep);
++		alpm_depmissing_t *miss = (alpm_depmissing_t *) i->data;
++		gchar *depend = alpm_dep_compute_string (miss->depend);
++
+ 		g_string_append_printf (list, "%s <- %s, ", depend,
+-					alpm_miss_get_target (i->data));
++					miss->target);
+ 		free (depend);
+ 	}
+ 
+@@ -661,25 +688,21 @@ alpm_miss_build_list (const alpm_list_t *i)
+ }
+ 
+ static void
+-alpm_dep_free (gpointer dep)
++alpm_depend_free (alpm_depend_t *depend)
+ {
+-	/* TODO: remove when implemented in libalpm */
+-	free ((gpointer) alpm_dep_get_name (dep));
+-	free ((gpointer) alpm_dep_get_version (dep));
+-	free (dep);
++	free (depend->name);
++	free (depend->version);
++	free (depend);
+ }
+ 
+ static void
+-alpm_miss_free (gpointer miss)
++alpm_depmissing_free (gpointer miss)
+ {
+-	/* TODO: remove when implemented in libalpm */
+-	const gchar *temp = alpm_miss_get_causingpkg (miss);
+-	if (temp != NULL) {
+-		free ((gpointer) temp);
+-	}
++	alpm_depmissing_t *self = (alpm_depmissing_t *) miss;
+ 
+-	free ((gpointer) alpm_miss_get_target (miss));
+-	alpm_dep_free (alpm_miss_get_dep (miss));
++	free (self->target);
++	alpm_depend_free (self->depend);
++	free (self->causingpkg);
+ 	free (miss);
+ }
+ 
+@@ -695,17 +718,20 @@ alpm_conflict_build_list (const alpm_list_t *i)
+ 	}
+ 
+ 	for (; i != NULL; i = i->next) {
+-		const gchar *first = alpm_conflict_get_package1 (i->data);
+-		const gchar *second = alpm_conflict_get_package2 (i->data);
+-		const gchar *reason = alpm_conflict_get_reason (i->data);
++		alpm_conflict_t *conflict = (alpm_conflict_t *) i->data;
++		alpm_depend_t *depend = conflict->reason;
+ 
+-		if (g_strcmp0 (first, reason) == 0 ||
+-		    g_strcmp0 (second, reason) == 0) {
+-			g_string_append_printf (list, "%s <-> %s, ", first,
+-						second);
++		if (g_strcmp0 (conflict->package1, depend->name) == 0 ||
++		    g_strcmp0 (conflict->package2, depend->name) == 0) {
++			g_string_append_printf (list, "%s <-> %s, ",
++						conflict->package1,
++						conflict->package2);
+ 		} else {
+-			g_string_append_printf (list, "%s <-> %s (%s), ", first,
+-						second, reason);
++			gchar *reason = alpm_dep_compute_string (depend);
++			g_string_append_printf (list, "%s <-> %s (%s), ",
++						conflict->package1,
++						conflict->package2, reason);
++			g_free (reason);
+ 		}
+ 	}
+ 
+@@ -716,10 +742,10 @@ alpm_conflict_build_list (const alpm_list_t *i)
+ static void
+ alpm_conflict_free (gpointer conflict)
+ {
+-	/* TODO: remove when implemented in libalpm */
+-	free ((gpointer) alpm_conflict_get_package1 (conflict));
+-	free ((gpointer) alpm_conflict_get_package2 (conflict));
+-	free ((gpointer) alpm_conflict_get_reason (conflict));
++	alpm_conflict_t *self = (alpm_conflict_t *) conflict;
++
++	free (self->package1);
++	free (self->package2);
+ 	free (conflict);
+ }
+ 
+@@ -735,15 +761,17 @@ alpm_fileconflict_build_list (const alpm_list_t *i)
+ 	}
+ 
+ 	for (; i != NULL; i = i->next) {
+-		const gchar *target = alpm_fileconflict_get_target (i->data);
+-		const gchar *file = alpm_fileconflict_get_file (i->data);
+-		const gchar *ctarget = alpm_fileconflict_get_ctarget (i->data);
+-		if (*ctarget != '\0') {
++		alpm_fileconflict_t *conflict = (alpm_fileconflict_t *) i->data;
++
++		if (*conflict->ctarget != '\0') {
+ 			g_string_append_printf (list, "%s <-> %s (%s), ",
+-						target, ctarget, file);
++						conflict->target,
++						conflict->ctarget,
++						conflict->file);
+ 		} else {
+-			g_string_append_printf (list, "%s (%s), ", target,
+-						file);
++			g_string_append_printf (list, "%s (%s), ",
++						conflict->target,
++						conflict->file);
+ 		}
+ 	}
+ 
+@@ -754,14 +782,11 @@ alpm_fileconflict_build_list (const alpm_list_t *i)
+ static void
+ alpm_fileconflict_free (gpointer conflict)
+ {
+-	/* TODO: remove when implemented in libalpm */
+-	const gchar *temp = alpm_fileconflict_get_ctarget (conflict);
+-	if (*temp != '\0') {
+-		free ((gpointer) temp);
+-	}
++	alpm_fileconflict_t *self = (alpm_fileconflict_t *) conflict;
+ 
+-	free ((gpointer) alpm_fileconflict_get_target (conflict));
+-	free ((gpointer) alpm_fileconflict_get_file (conflict));
++	free (self->target);
++	free (self->file);
++	free (self->ctarget);
+ 	free (conflict);
+ }
+ 
+@@ -771,29 +796,32 @@ pk_backend_transaction_simulate (PkBackend *self, GError **error)
+ 	alpm_list_t *data = NULL;
+ 	gchar *prefix;
+ 
+-	if (alpm_trans_prepare (&data) >= 0) {
++	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
++
++	if (alpm_trans_prepare (alpm, &data) >= 0) {
+ 		return TRUE;
+ 	}
+ 
+-	switch (pm_errno) {
+-		case PM_ERR_PKG_INVALID_ARCH:
++	switch (alpm_errno (alpm)) {
++		case ALPM_ERR_PKG_INVALID_ARCH:
+ 			prefix = alpm_pkg_build_list (data);
+ 			alpm_list_free (data);
+ 			break;
+ 
+-		case PM_ERR_UNSATISFIED_DEPS:
++		case ALPM_ERR_UNSATISFIED_DEPS:
+ 			prefix = alpm_miss_build_list (data);
+-			alpm_list_free_inner (data, alpm_miss_free);
++			alpm_list_free_inner (data, alpm_depmissing_free);
+ 			alpm_list_free (data);
+ 			break;
+ 
+-		case PM_ERR_CONFLICTING_DEPS:
++		case ALPM_ERR_CONFLICTING_DEPS:
+ 			prefix = alpm_conflict_build_list (data);
+ 			alpm_list_free_inner (data, alpm_conflict_free);
+ 			alpm_list_free (data);
+ 			break;
+ 
+-		case PM_ERR_FILE_CONFLICTS:
++		case ALPM_ERR_FILE_CONFLICTS:
+ 			prefix = alpm_fileconflict_build_list (data);
+ 			alpm_list_free_inner (data, alpm_fileconflict_free);
+ 			alpm_list_free (data);
+@@ -802,18 +830,21 @@ pk_backend_transaction_simulate (PkBackend *self, GError **error)
+ 		default:
+ 			prefix = NULL;
+ 			if (data != NULL) {
+-				g_warning ("unhandled error %d", pm_errno);
++				g_warning ("unhandled error %d",
++					   alpm_errno (alpm));
+ 			}
+ 			break;
+ 	}
+ 
+ 	if (prefix != NULL) {
+-		g_set_error (error, ALPM_ERROR, pm_errno, "%s: %s", prefix,
+-			     alpm_strerrorlast ());
++		enum _alpm_errno_t errno = alpm_errno (alpm);
++		g_set_error (error, ALPM_ERROR, errno, "%s: %s", prefix,
++			     alpm_strerror (errno));
+ 		g_free (prefix);
+ 	} else {
+-		g_set_error_literal (error, ALPM_ERROR, pm_errno,
+-				     alpm_strerrorlast ());
++		enum _alpm_errno_t errno = alpm_errno (alpm);
++		g_set_error_literal (error, ALPM_ERROR, errno,
++				     alpm_strerror (errno));
+ 	}
+ 
+ 	return FALSE;
+@@ -826,10 +857,11 @@ pk_backend_transaction_packages (PkBackend *self)
+ 	PkInfoEnum info;
+ 
+ 	g_return_if_fail (self != NULL);
++	g_return_if_fail (alpm != NULL);
+ 	g_return_if_fail (localdb != NULL);
+ 
+ 	/* emit packages that would have been installed */
+-	for (i = alpm_trans_get_add (); i != NULL; i = i->next) {
++	for (i = alpm_trans_get_add (alpm); i != NULL; i = i->next) {
+ 		if (pk_backend_cancelled (self)) {
+ 			break;
+ 		} else {
+@@ -856,7 +888,7 @@ pk_backend_transaction_packages (PkBackend *self)
+ 	}
+ 
+ 	/* emit packages that would have been removed */
+-	for (i = alpm_trans_get_remove (); i != NULL; i = i->next) {
++	for (i = alpm_trans_get_remove (alpm); i != NULL; i = i->next) {
+ 		if (pk_backend_cancelled (self)) {
+ 			break;
+ 		} else {
+@@ -890,6 +922,9 @@ pk_backend_transaction_commit (PkBackend *self, GError **error)
+ 	alpm_list_t *data = NULL;
+ 	gchar *prefix;
+ 
++	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
++
+ 	if (pk_backend_cancelled (self)) {
+ 		return TRUE;
+ 	}
+@@ -897,19 +932,19 @@ pk_backend_transaction_commit (PkBackend *self, GError **error)
+ 	pk_backend_set_allow_cancel (self, FALSE);
+ 	pk_backend_set_status (self, PK_STATUS_ENUM_RUNNING);
+ 
+-	if (alpm_trans_commit (&data) >= 0) {
++	if (alpm_trans_commit (alpm, &data) >= 0) {
+ 		return TRUE;
+ 	}
+ 
+-	switch (pm_errno) {
+-		case PM_ERR_FILE_CONFLICTS:
++	switch (alpm_errno (alpm)) {
++		case ALPM_ERR_FILE_CONFLICTS:
+ 			prefix = alpm_fileconflict_build_list (data);
+ 			alpm_list_free_inner (data, alpm_fileconflict_free);
+ 			alpm_list_free (data);
+ 			break;
+ 
+-		case PM_ERR_PKG_INVALID:
+-		case PM_ERR_DLT_INVALID:
++		case ALPM_ERR_PKG_INVALID:
++		case ALPM_ERR_DLT_INVALID:
+ 			prefix = alpm_string_build_list (data);
+ 			alpm_list_free (data);
+ 			break;
+@@ -917,18 +952,21 @@ pk_backend_transaction_commit (PkBackend *self, GError **error)
+ 		default:
+ 			prefix = NULL;
+ 			if (data != NULL) {
+-				g_warning ("unhandled error %d", pm_errno);
++				g_warning ("unhandled error %d",
++					   alpm_errno (alpm));
+ 			}
+ 			break;
+ 	}
+ 
+ 	if (prefix != NULL) {
+-		g_set_error (error, ALPM_ERROR, pm_errno, "%s: %s", prefix,
+-			     alpm_strerrorlast ());
++		enum _alpm_errno_t errno = alpm_errno (alpm);
++		g_set_error (error, ALPM_ERROR, errno, "%s: %s", prefix,
++			     alpm_strerror (errno));
+ 		g_free (prefix);
+ 	} else {
+-		g_set_error_literal (error, ALPM_ERROR, pm_errno,
+-				     alpm_strerrorlast ());
++		enum _alpm_errno_t errno = alpm_errno (alpm);
++		g_set_error_literal (error, ALPM_ERROR, errno,
++				     alpm_strerror (errno));
+ 	}
+ 
+ 	return FALSE;
+@@ -938,9 +976,14 @@ gboolean
+ pk_backend_transaction_end (PkBackend *self, GError **error)
+ {
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
++
++	alpm_option_set_eventcb (alpm, NULL);
++	alpm_option_set_questioncb (alpm, NULL);
++	alpm_option_set_progresscb (alpm, NULL);
+ 
+-	alpm_option_set_dlcb (NULL);
+-	alpm_option_set_totaldlcb (NULL);
++	alpm_option_set_dlcb (alpm, NULL);
++	alpm_option_set_totaldlcb (alpm, NULL);
+ 
+ 	if (dpkg != NULL) {
+ 		pk_backend_transaction_download_end (self);
+@@ -949,9 +992,10 @@ pk_backend_transaction_end (PkBackend *self, GError **error)
+ 		pk_backend_output_end (self);
+ 	}
+ 
+-	if (alpm_trans_release () < 0) {
+-		g_set_error_literal (error, ALPM_ERROR, pm_errno,
+-				     alpm_strerrorlast ());
++	if (alpm_trans_release (alpm) < 0) {
++		enum _alpm_errno_t errno = alpm_errno (alpm);
++		g_set_error_literal (error, ALPM_ERROR, errno,
++				     alpm_strerror (errno));
+ 		return FALSE;
+ 	}
+ 
+diff --git a/backends/alpm/pk-backend-transaction.h b/backends/alpm/pk-backend-transaction.h
+index 6bb1d69..e3733d6 100644
+--- a/backends/alpm/pk-backend-transaction.h
++++ b/backends/alpm/pk-backend-transaction.h
+@@ -25,7 +25,7 @@
+ #include <pk-backend.h>
+ 
+ gboolean	 pk_backend_transaction_initialize	(PkBackend *self,
+-							 pmtransflag_t flags,
++							 alpm_transflag_t flags,
+ 							 GError **error);
+ 
+ gboolean	 pk_backend_transaction_simulate	(PkBackend *self,
+diff --git a/backends/alpm/pk-backend-update.c b/backends/alpm/pk-backend-update.c
+index a281953..37ade1e 100644
+--- a/backends/alpm/pk-backend-update.c
++++ b/backends/alpm/pk-backend-update.c
+@@ -34,7 +34,7 @@
+ #include "pk-backend-update.h"
+ 
+ static gchar *
+-alpm_pkg_build_replaces (pmpkg_t *pkg)
++alpm_pkg_build_replaces (alpm_pkg_t *pkg)
+ {
+ 	const alpm_list_t *i;
+ 	GString *string = NULL;
+@@ -44,7 +44,7 @@ alpm_pkg_build_replaces (pmpkg_t *pkg)
+ 
+ 	/* make a list of the packages that package replaces */
+ 	for (i = alpm_pkg_get_replaces (pkg); i != NULL; i = i->next) {
+-		pmpkg_t *replaces = alpm_db_get_pkg (localdb, i->data);
++		alpm_pkg_t *replaces = alpm_db_get_pkg (localdb, i->data);
+ 
+ 		if (replaces != NULL) {
+ 			gchar *package = alpm_pkg_build_id (replaces);
+@@ -65,7 +65,7 @@ alpm_pkg_build_replaces (pmpkg_t *pkg)
+ }
+ 
+ static gchar *
+-alpm_pkg_build_urls (pmpkg_t *pkg)
++alpm_pkg_build_urls (alpm_pkg_t *pkg)
+ {
+ 	GString *string = g_string_new ("");
+ #ifdef ALPM_PACKAGE_URL
+@@ -97,7 +97,7 @@ alpm_pkg_build_urls (pmpkg_t *pkg)
+ }
+ 
+ static gboolean
+-alpm_pkg_same_pkgver (pmpkg_t *a, pmpkg_t *b)
++alpm_pkg_same_pkgver (alpm_pkg_t *a, alpm_pkg_t *b)
+ {
+ 	const gchar *version_a, *version_b, *last_a, *last_b;
+ 	gsize length_a, length_b;
+@@ -145,8 +145,8 @@ pk_backend_get_update_detail_thread (PkBackend *self)
+ 
+ 	/* collect details about updates */
+ 	for (; *packages != NULL; ++packages) {
+-		pmpkg_t *pkg, *old;
+-		pmdb_t *db;
++		alpm_pkg_t *pkg, *old;
++		alpm_db_t *db;
+ 
+ 		gchar *upgrades, *replaces, *urls;
+ 		const gchar *reason;
+@@ -245,18 +245,19 @@ pk_backend_update_databases (PkBackend *self, gint force, GError **error) {
+ 	const alpm_list_t *i;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 
+ 	if (!pk_backend_transaction_initialize (self, 0, error)) {
+ 		return FALSE;
+ 	}
+ 
+-	alpm_logaction ("synchronizing package lists\n");
++	alpm_logaction (alpm, "synchronizing package lists\n");
+ 
+-	dlcb = alpm_option_get_dlcb ();
+-	totaldlcb = alpm_option_get_totaldlcb ();
++	dlcb = alpm_option_get_dlcb (alpm);
++	totaldlcb = alpm_option_get_totaldlcb (alpm);
+ 
+ 	/* set total size to minus the number of databases */
+-	i = alpm_option_get_syncdbs ();
++	i = alpm_option_get_syncdbs (alpm);
+ 	totaldlcb (-alpm_list_count (i));
+ 
+ 	for (; i != NULL; i = i->next) {
+@@ -274,9 +275,10 @@ pk_backend_update_databases (PkBackend *self, gint force, GError **error) {
+ 			/* fake the download when already up to date */
+ 			dlcb ("", 1, 1);
+ 		} else if (result < 0) {
+-			g_set_error (error, ALPM_ERROR, pm_errno, "[%s]: %s",
++			enum _alpm_errno_t errno = alpm_errno (alpm);
++			g_set_error (error, ALPM_ERROR, errno, "[%s]: %s",
+ 				     alpm_db_get_name (i->data),
+-				     alpm_strerrorlast ());
++				     alpm_strerror (errno));
+ 			break;
+ 		}
+ 	}
+@@ -292,20 +294,21 @@ pk_backend_update_databases (PkBackend *self, gint force, GError **error) {
+ }
+ 
+ static gboolean
+-alpm_pkg_is_ignorepkg (pmpkg_t *pkg)
++alpm_pkg_is_ignorepkg (alpm_pkg_t *pkg)
+ {
+-	const alpm_list_t *ignorepkgs, *ignoregrps, *i;
++	const alpm_list_t *ignorepkgs, *ignoregroups, *i;
+ 
+ 	g_return_val_if_fail (pkg != NULL, TRUE);
++	g_return_val_if_fail (alpm != NULL, TRUE);
+ 
+-	ignorepkgs = alpm_option_get_ignorepkgs ();
++	ignorepkgs = alpm_option_get_ignorepkgs (alpm);
+ 	if (alpm_list_find_str (ignorepkgs, alpm_pkg_get_name (pkg)) != NULL) {
+ 		return TRUE;
+ 	}
+ 
+-	ignoregrps = alpm_option_get_ignoregrps ();
++	ignoregroups = alpm_option_get_ignoregroups (alpm);
+ 	for (i = alpm_pkg_get_groups (pkg); i != NULL; i = i->next) {
+-		if (alpm_list_find_str (ignoregrps, i->data) != NULL) {
++		if (alpm_list_find_str (ignoregroups, i->data) != NULL) {
+ 			return TRUE;
+ 		}
+ 	}
+@@ -314,7 +317,7 @@ alpm_pkg_is_ignorepkg (pmpkg_t *pkg)
+ }
+ 
+ static gboolean
+-alpm_pkg_is_syncfirst (pmpkg_t *pkg)
++alpm_pkg_is_syncfirst (alpm_pkg_t *pkg)
+ {
+ 	g_return_val_if_fail (pkg != NULL, FALSE);
+ 
+@@ -325,8 +328,18 @@ alpm_pkg_is_syncfirst (pmpkg_t *pkg)
+ 	return FALSE;
+ }
+ 
+-static pmpkg_t *
+-alpm_pkg_find_update (pmpkg_t *pkg, const alpm_list_t *dbs)
++static gboolean
++alpm_pkg_replaces (alpm_pkg_t *pkg, const gchar *name)
++{
++	g_return_val_if_fail (pkg != NULL, FALSE);
++	g_return_val_if_fail (name != NULL, FALSE);
++
++	return alpm_list_find_str (alpm_pkg_get_replaces (pkg), name) != NULL;
++}
++
++
++static alpm_pkg_t *
++alpm_pkg_find_update (alpm_pkg_t *pkg, const alpm_list_t *dbs)
+ {
+ 	const gchar *name;
+ 	const alpm_list_t *i;
+@@ -336,7 +349,7 @@ alpm_pkg_find_update (pmpkg_t *pkg, const alpm_list_t *dbs)
+ 	name = alpm_pkg_get_name (pkg);
+ 
+ 	for (; dbs != NULL; dbs = dbs->next) {
+-		pmpkg_t *update = alpm_db_get_pkg (dbs->data, name);
++		alpm_pkg_t *update = alpm_db_get_pkg (dbs->data, name);
+ 
+ 		if (update != NULL) {
+ 			if (alpm_pkg_vercmp (alpm_pkg_get_version (update),
+@@ -349,8 +362,7 @@ alpm_pkg_find_update (pmpkg_t *pkg, const alpm_list_t *dbs)
+ 
+ 		i = alpm_db_get_pkgcache (dbs->data);
+ 		for (; i != NULL; i = i->next) {
+-			if (alpm_list_find_str (alpm_pkg_get_replaces (i->data),
+-						name) != NULL) {
++			if (alpm_pkg_replaces (i->data, name)) {
+ 				return i->data;
+ 			}
+ 		}
+@@ -367,6 +379,7 @@ pk_backend_get_updates_thread (PkBackend *self)
+ 	const alpm_list_t *i, *syncdbs;
+ 
+ 	g_return_val_if_fail (self != NULL, FALSE);
++	g_return_val_if_fail (alpm != NULL, FALSE);
+ 	g_return_val_if_fail (localdb != NULL, FALSE);
+ 
+ 	time (&one_hour_ago);
+@@ -385,9 +398,9 @@ pk_backend_get_updates_thread (PkBackend *self)
+ 	}
+ 
+ 	/* find outdated and replacement packages */
+-	syncdbs = alpm_option_get_syncdbs ();
++	syncdbs = alpm_option_get_syncdbs (alpm);
+ 	for (i = alpm_db_get_pkgcache (localdb); i != NULL; i = i->next) {
+-		pmpkg_t *upgrade = alpm_pkg_find_update (i->data, syncdbs);
++		alpm_pkg_t *upgrade = alpm_pkg_find_update (i->data, syncdbs);
+ 
+ 		if (pk_backend_cancelled (self)) {
+ 			break;
diff --git a/community-testing/packagekit/packagekit.install b/community-testing/packagekit/packagekit.install
new file mode 100644
index 000000000..7c8a8bd2b
--- /dev/null
+++ b/community-testing/packagekit/packagekit.install
@@ -0,0 +1,11 @@
+post_install() {
+	update-mime-database usr/share/mime &> /dev/null
+}
+
+post_upgrade() {
+	post_install
+}
+
+post_remove() {
+	post_install
+}