From 7de0a9c21ecdb7becae761d7c9f2e723cb9ae0d3 Mon Sep 17 00:00:00 2001 From: root Date: Tue, 17 Jan 2012 23:14:55 +0000 Subject: Tue Jan 17 23:14:54 UTC 2012 --- community/packagekit/PKGBUILD | 16 +- community/packagekit/alpm.patch | 3056 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 3034 insertions(+), 38 deletions(-) (limited to 'community/packagekit') diff --git a/community/packagekit/PKGBUILD b/community/packagekit/PKGBUILD index 268d154f5..a66ae29ab 100644 --- a/community/packagekit/PKGBUILD +++ b/community/packagekit/PKGBUILD @@ -1,9 +1,9 @@ -# $Id: PKGBUILD 61985 2012-01-13 10:58:26Z jconder $ +# $Id: PKGBUILD 62160 2012-01-17 00:26:49Z jconder $ # Maintainer: Jonathan Conder pkgbase='packagekit' pkgname=('packagekit' 'packagekit-qt' 'packagekit-qt2' 'packagekit-python') -pkgver=0.6.19 -pkgrel=4 +pkgver=0.6.21 +pkgrel=1 pkgdesc="A system designed to make installation and updates of packages easier." arch=('i686' 'x86_64') url="http://www.packagekit.org" @@ -14,14 +14,12 @@ makedepends=('dbus-glib' 'gobject-introspection' 'gtk-doc' 'intltool' options=('!libtool') source=("http://www.packagekit.org/releases/PackageKit-$pkgver.tar.xz" 'alpm.patch') -sha256sums=('961c6408de08ebaf15c09e74afd06918d699be8974b5c35c2c9663e5b12b5223' - 'a0e23b5e666eb402cd3d1a7b6e9030af33be5c9ddcf40682ae9abba7018e177d') +sha256sums=('68e5d4d07adf50b1fae6cbc0963555345ba7fc12d86d3e3387874547a5448b8e' + 'fbe54a89c3495376a0b939b67fec5b2e57bed46e92b3f4816d797745882481e6') build() { cd "$srcdir/PackageKit-$pkgver" - # TODO: remove when this is fixed upstream - find -name '*.moc' -print0 | xargs -0 rm patch -Np1 -i "$srcdir/alpm.patch" sed -i 's@SUBDIRS = test@SUBDIRS =@' 'backends/Makefile.in' @@ -29,6 +27,8 @@ build() { sed -i 's@bin/python@bin/python2@' 'lib/python/packagekit/'*.py export PYTHON=/usr/bin/python2 + # TODO: remove when upstream is patched + autoreconf ./configure --prefix=/usr \ --sysconfdir=/etc \ --localstatedir=/var \ @@ -54,7 +54,7 @@ package_packagekit() { backup=('var/lib/PackageKit/transactions.db' 'etc/PackageKit/alpm.d/pacman.conf' 'etc/PackageKit/alpm.d/repos.list') - depends=('dbus-glib' 'pacman>=3.5.0' 'pacman<3.6.0' 'polkit' + depends=('dbus-glib' 'pacman>=4.0.0' 'pacman<4.1.0' 'polkit' 'shared-mime-info' 'sqlite3' 'udev') optdepends=('networkmanager') install='packagekit.install' diff --git a/community/packagekit/alpm.patch b/community/packagekit/alpm.patch index 5f576d3aa..d39ce14e1 100644 --- a/community/packagekit/alpm.patch +++ b/community/packagekit/alpm.patch @@ -1,8 +1,28 @@ +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..4cc9af2 100644 +index ba993f0..93f6d95 100644 --- a/backends/alpm/pk-backend-alpm.c +++ b/backends/alpm/pk-backend-alpm.c -@@ -22,8 +22,10 @@ +@@ -22,10 +22,13 @@ */ #include @@ -12,17 +32,80 @@ index ba993f0..4cc9af2 100644 +#include #include "pk-backend-alpm.h" ++#include "pk-backend-config.h" #include "pk-backend-databases.h" -@@ -194,6 +196,66 @@ pk_backend_logcb (pmloglevel_t level, const gchar *format, va_list args) + #include "pk-backend-error.h" + #include "pk-backend-groups.h" +@@ -35,7 +38,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 +166,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 +180,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; +@@ -194,44 +198,99 @@ pk_backend_logcb (pmloglevel_t level, const gchar *format, va_list args) g_free (output); } +-static gboolean +-pk_backend_initialize_alpm (PkBackend *self, GError **error) +static void -+pk_backend_initialize_environment (PkBackend *self) -+{ ++pk_backend_configure_environment (PkBackend *self) + { + struct utsname un; +- gchar *user_agent; + gchar *value; -+ + +- g_return_val_if_fail (self != NULL, FALSE); + g_return_if_fail (self != NULL); + + /* PATH might have been nuked by D-Bus */ + g_setenv ("PATH", PK_BACKEND_DEFAULT_PATH, FALSE); + + uname (&un); +- user_agent = g_strdup_printf ("%s/%s (%s %s) libalpm/%s", +- PACKAGE_TARNAME, PACKAGE_VERSION, +- un.sysname, un.machine, alpm_version ()); +- 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 ()); ++ value = g_strdup_printf ("%s/%s (%s %s) libalpm/%s", PACKAGE_TARNAME, ++ PACKAGE_VERSION, un.sysname, un.machine, ++ alpm_version ()); ++ g_setenv ("HTTP_USER_AGENT", value, FALSE); ++ g_free (value); + + value = pk_backend_get_locale (self); + if (value != NULL) { @@ -77,42 +160,2955 @@ index ba993f0..4cc9af2 100644 + } +} + ++static gboolean ++pk_backend_initialize_alpm (PkBackend *self, GError **error) ++{ ++ g_return_val_if_fail (self != NULL, FALSE); ++ ++ pk_backend_configure_environment (self); ++ ++ 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 +299,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_initialize_alpm (PkBackend *self, GError **error) ++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) { -@@ -260,6 +322,8 @@ pk_backend_initialize (PkBackend *self) +@@ -515,7 +637,7 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename, - g_return_if_fail (self != NULL); + 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); + } -+ pk_backend_initialize_environment (self); +- 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 (!pk_backend_initialize_alpm (self, &error) || - !pk_backend_initialize_databases (self, &error) || - !pk_backend_initialize_groups (self, &error)) { -@@ -380,3 +444,11 @@ pk_backend_finish (PkBackend *self, GError *error) - pk_backend_thread_finished (self); - return (error == NULL); ++ 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 + #include + +-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_transaction_start (PkBackend *self) ++pk_backend_configure_repos (alpm_list_t *repos, GHashTable *servers, ++ GHashTable *levels) +{ -+ g_return_if_fail (self != NULL); ++ 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); + -+ pk_backend_initialize_environment (self); ++ 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); ++ } +} -diff --git a/backends/alpm/pk-backend-transaction.c b/backends/alpm/pk-backend-transaction.c -index fdb840e..a4a712f 100644 ---- a/backends/alpm/pk-backend-transaction.c -+++ b/backends/alpm/pk-backend-transaction.c -@@ -280,8 +280,8 @@ pk_backend_install_ignorepkg (PkBackend *self, pmpkg_t *pkg, gint *result) ++ + 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 void --pk_backend_select_provider (PkBackend *self, pmdepend_t *dep, -- const alpm_list_t *providers) -+pk_backend_select_provider (PkBackend *self, const alpm_list_t *providers, -+ pmdepend_t *dep) + 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 + #include + ++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) { - gchar *output; + 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; +- +- case PM_ERR_BADPERMS: +- code = PK_ERROR_ENUM_NOT_AUTHORIZED; +- break; +- +- case PM_ERR_NOT_A_FILE: +- case PM_ERR_NOT_A_DIR: +- code = PK_ERROR_ENUM_FILE_NOT_FOUND; +- 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 PM_ERR_DISK_SPACE: +- code = PK_ERROR_ENUM_NO_SPACE_ON_DEVICE; +- 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 PM_ERR_HANDLE_LOCK: +- code = PK_ERROR_ENUM_CANNOT_GET_LOCK; +- 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 PM_ERR_DB_CREATE: +- code = PK_ERROR_ENUM_CANNOT_WRITE_REPO_CONFIG; +- break; +- +- case PM_ERR_DB_VERSION: +- case PM_ERR_DB_REMOVE: +- code = PK_ERROR_ENUM_REPO_CONFIGURATION_ERROR; +- break; +- +- case PM_ERR_DB_WRITE: +- code = PK_ERROR_ENUM_REPO_NOT_AVAILABLE; +- break; +- +- case PM_ERR_SERVER_BAD_URL: +- code = PK_ERROR_ENUM_REPO_CONFIGURATION_ERROR; +- break; +- +- case PM_ERR_SERVER_NONE: +- code = PK_ERROR_ENUM_NO_MORE_MIRRORS_TO_TRY; +- break; +- +- case PM_ERR_TRANS_DUP_TARGET: +- case PM_ERR_TRANS_ABORT: +- code = PK_ERROR_ENUM_TRANSACTION_ERROR; +- break; +- +- case PM_ERR_TRANS_TYPE: +- code = PK_ERROR_ENUM_CANNOT_CANCEL; +- break; +- +- case PM_ERR_PKG_NOT_FOUND: +- code = PK_ERROR_ENUM_PACKAGE_NOT_FOUND; +- break; +- +- case PM_ERR_PKG_IGNORED: +- code = PK_ERROR_ENUM_PACKAGE_INSTALL_BLOCKED; +- 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 PM_ERR_PKG_CANT_REMOVE: +- code = PK_ERROR_ENUM_PACKAGE_FAILED_TO_REMOVE; +- break; +- +- case PM_ERR_PKG_INVALID_ARCH: +- code = PK_ERROR_ENUM_INCOMPATIBLE_ARCHITECTURE; +- break; +- +- case PM_ERR_DLT_PATCHFAILED: +- code = PK_ERROR_ENUM_PACKAGE_FAILED_TO_BUILD; +- break; +- +- case PM_ERR_UNSATISFIED_DEPS: +- code = PK_ERROR_ENUM_DEP_RESOLUTION_FAILED; +- break; +- +- case PM_ERR_CONFLICTING_DEPS: +- code = PK_ERROR_ENUM_PACKAGE_CONFLICTS; +- break; +- +- case PM_ERR_FILE_CONFLICTS: +- code = PK_ERROR_ENUM_FILE_CONFLICTS; +- break; +- +- case PM_ERR_RETRIEVE: +- case PM_ERR_LIBFETCH: +- case PM_ERR_EXTERNAL_DOWNLOAD: +- code = PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED; +- break; +- +- case PM_ERR_LIBARCHIVE: +- code = PK_ERROR_ENUM_LOCAL_INSTALL_FAILED; +- break; +- +- case PM_ERR_CONFIG_INVALID: +- code = PK_ERROR_ENUM_CANNOT_REMOVE_SYSTEM_PACKAGE; +- break; +- +- case PM_ERR_PKG_HELD: +- code = PK_ERROR_ENUM_CANNOT_REMOVE_SYSTEM_PACKAGE; +- 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 ALPM_ERR_DISK_SPACE: ++ code = PK_ERROR_ENUM_NO_SPACE_ON_DEVICE; ++ 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 ALPM_ERR_HANDLE_LOCK: ++ code = PK_ERROR_ENUM_CANNOT_GET_LOCK; ++ 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 ALPM_ERR_DB_CREATE: ++ code = PK_ERROR_ENUM_CANNOT_WRITE_REPO_CONFIG; ++ 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 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 ALPM_ERR_DB_WRITE: ++ code = PK_ERROR_ENUM_REPO_NOT_AVAILABLE; ++ break; ++ ++ case ALPM_ERR_SERVER_NONE: ++ code = PK_ERROR_ENUM_NO_MORE_MIRRORS_TO_TRY; ++ break; ++ ++ case ALPM_ERR_TRANS_DUP_TARGET: ++ case ALPM_ERR_TRANS_ABORT: ++ code = PK_ERROR_ENUM_TRANSACTION_ERROR; ++ break; ++ ++ case ALPM_ERR_TRANS_TYPE: ++ code = PK_ERROR_ENUM_CANNOT_CANCEL; ++ break; ++ ++ case ALPM_ERR_PKG_NOT_FOUND: ++ code = PK_ERROR_ENUM_PACKAGE_NOT_FOUND; ++ break; ++ ++ case ALPM_ERR_PKG_IGNORED: ++ code = PK_ERROR_ENUM_PACKAGE_INSTALL_BLOCKED; ++ 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 ALPM_ERR_PKG_INVALID_CHECKSUM: ++ code = PK_ERROR_ENUM_PACKAGE_CORRUPT; ++ break; ++ ++ case ALPM_ERR_PKG_CANT_REMOVE: ++ code = PK_ERROR_ENUM_PACKAGE_FAILED_TO_REMOVE; ++ break; ++ ++ case ALPM_ERR_PKG_INVALID_ARCH: ++ code = PK_ERROR_ENUM_INCOMPATIBLE_ARCHITECTURE; ++ break; ++ ++ case ALPM_ERR_SIG_MISSING: ++ code = PK_ERROR_ENUM_MISSING_GPG_SIGNATURE; ++ break; ++ ++ case ALPM_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 ALPM_ERR_CONFLICTING_DEPS: ++ code = PK_ERROR_ENUM_PACKAGE_CONFLICTS; ++ break; ++ ++ case ALPM_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 ALPM_ERR_LIBARCHIVE: ++ code = PK_ERROR_ENUM_LOCAL_INSTALL_FAILED; ++ break; ++ ++ case ALPM_ERR_GPGME: ++ code = PK_ERROR_ENUM_GPG_FAILURE; ++ break; ++ ++ case ALPM_ERR_CONFIG_INVALID: ++ code = PK_ERROR_ENUM_FAILED_CONFIG_PARSING; ++ 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 + #include + +-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..76402f0 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, +- const alpm_list_t *providers) ++pk_backend_select_provider (PkBackend *self, const alpm_list_t *providers, ++ alpm_depend_t *depend) + { + 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); +- +- if (g_strcmp0 (first, reason) == 0 || +- g_strcmp0 (second, reason) == 0) { +- g_string_append_printf (list, "%s <-> %s, ", first, +- second); ++ alpm_conflict_t *conflict = (alpm_conflict_t *) i->data; ++ alpm_depend_t *depend = conflict->reason; ++ ++ 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 + + 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; -- cgit v1.2.3-54-g00ecf