From fd8249d016683ade99a23251d6ffdf5d5a3e76a4 Mon Sep 17 00:00:00 2001 From: root Date: Sat, 6 Apr 2013 00:05:46 -0700 Subject: Sat Apr 6 00:05:46 PDT 2013 --- community/packagekit/PKGBUILD | 19 +- community/packagekit/alpm.patch | 1611 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 1623 insertions(+), 7 deletions(-) create mode 100644 community/packagekit/alpm.patch (limited to 'community/packagekit') diff --git a/community/packagekit/PKGBUILD b/community/packagekit/PKGBUILD index 65e8fb431..3e2c73040 100644 --- a/community/packagekit/PKGBUILD +++ b/community/packagekit/PKGBUILD @@ -1,9 +1,9 @@ -# $Id: PKGBUILD 85588 2013-03-03 17:28:55Z dreisner $ +# $Id: PKGBUILD 87649 2013-04-05 01:44:23Z allan $ # Maintainer: Jonathan Conder pkgbase='packagekit' -pkgname=('packagekit' 'packagekit-qt2' 'packagekit-python') +pkgname=('packagekit' 'packagekit-qt2' 'python2-packagekit') pkgver=0.7.6 -pkgrel=5 +pkgrel=6 pkgdesc="A system designed to make installation and updates of packages easier." arch=('i686' 'x86_64') url="http://www.packagekit.org" @@ -14,9 +14,11 @@ makedepends=('dbus-glib' 'gobject-introspection' 'gtk-doc' 'intltool' options=('!libtool') source=("http://www.packagekit.org/releases/PackageKit-$pkgver.tar.xz" 'adopt.patch' + 'alpm.patch' 'libarchive.patch') sha256sums=('82c0a553075d49add3c4f58e6e93f7f3613938809a4b8e36f46476e86981b45d' 'd0ee8580202a878571dddd470017731299c63e5c5120afe881bb41b9544322b8' + '067f39917f5442b8146c793b62f86f66fc8a4c7e391c0f3219d13f98d45ba630' '0d3798c8992afdc0930aa271b3e44deb55c046ab4adee25b4ec4c33bcdd950e2') build() { @@ -27,10 +29,11 @@ build() { sed -i 's@bin/python@bin/python2@' 'lib/python/packagekit/'*.py patch -Np1 -i "$srcdir/adopt.patch" + patch -Np1 -i "$srcdir/alpm.patch" patch -Np1 -i "$srcdir/libarchive.patch" export PYTHON=/usr/bin/python2 - ./configure --prefix=/usr \ + ./autogen.sh --prefix=/usr \ --sysconfdir=/etc \ --localstatedir=/var \ --libexecdir=/usr/lib/PackageKit \ @@ -49,14 +52,14 @@ build() { --disable-dummy \ --enable-alpm \ --with-default-backend=alpm - make -s CFLAGS='-D_FILE_OFFSET_BITS=64' + make -s CFLAGS='-D_FILE_OFFSET_BITS=64 -O2 -Wno-unused-local-typedefs' } package_packagekit() { backup=('var/lib/PackageKit/transactions.db' 'etc/PackageKit/alpm.d/pacman.conf' 'etc/PackageKit/alpm.d/repos.list') - depends=('dbus-glib' 'pacman>=4.0.0' 'pacman<4.1.0' 'polkit' + depends=('dbus-glib' 'pacman>=4.1.0' 'pacman<4.2.0' 'polkit' 'shared-mime-info' 'sqlite' 'udev') optdepends=('networkmanager') install='packagekit.install' @@ -89,9 +92,11 @@ package_packagekit-qt2() { make DESTDIR="$pkgdir" install } -package_packagekit-python() { +package_python2-packagekit() { depends=('packagekit' 'python2') pkgdesc=('Python bindings for PackageKit') + conflicts=('packagekit-python') + replaces=('packagekit-python') cd "$srcdir/PackageKit-$pkgver/lib/python" diff --git a/community/packagekit/alpm.patch b/community/packagekit/alpm.patch new file mode 100644 index 000000000..aeba9c347 --- /dev/null +++ b/community/packagekit/alpm.patch @@ -0,0 +1,1611 @@ +diff --git a/backends/alpm/Makefile.am b/backends/alpm/Makefile.am +index d8c3dfc..8e14790 100644 +--- a/backends/alpm/Makefile.am ++++ b/backends/alpm/Makefile.am +@@ -23,6 +23,7 @@ DEFS = -DPK_BACKEND_CONFIG_FILE=\"$(PK_BACKEND_CONFIG_FILE)\" \ + -DPK_BACKEND_DEFAULT_LOGFILE=\"$(PK_BACKEND_DEFAULT_LOGFILE)\" \ + -DALPM_CACHE_PATH=\"$(ALPM_CACHE_PATH)\" \ + -DALPM_PACKAGE_URL=\"$(ALPM_PACKAGE_URL)\" \ ++ -DPK_LOG_PREFIX=\"PACKAGEKIT\" \ + -DG_LOG_DOMAIN=\"PackageKit-alpm\" + + confdir = $(PK_CONF_DIR)/alpm.d +@@ -47,10 +48,11 @@ libpk_backend_alpm_la_SOURCES = pk-backend-alpm.c \ + pk-backend-transaction.c \ + pk-backend-update.c + libpk_backend_alpm_la_LIBADD = $(PK_PLUGIN_LIBS) \ +- -lalpm ++ $(ALPM_LIBS) + libpk_backend_alpm_la_LDFLAGS = -module \ + -avoid-version + libpk_backend_alpm_la_CFLAGS = $(PK_PLUGIN_CFLAGS) \ ++ $(ALPM_CFLAGS) \ + $(WARNINGFLAGS_C) + + EXTRA_DIST = $(conf_DATA) $(libpk_backend_alpm_la_SOURCES:.c=.h) +diff --git a/backends/alpm/pk-backend-alpm.c b/backends/alpm/pk-backend-alpm.c +index 5c6b629..a4cd197 100644 +--- a/backends/alpm/pk-backend-alpm.c ++++ b/backends/alpm/pk-backend-alpm.c +@@ -284,9 +284,9 @@ pk_backend_initialize_alpm (PkBackend *self, GError **error) + backend = self; + alpm_option_set_logcb (alpm, pk_backend_logcb); + +- localdb = alpm_option_get_localdb (alpm); ++ localdb = alpm_get_localdb (alpm); + if (localdb == NULL) { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ alpm_errno_t errno = alpm_errno (alpm); + g_set_error (error, ALPM_ERROR, errno, "[%s]: %s", "local", + alpm_strerror (errno)); + } +diff --git a/backends/alpm/pk-backend-config.c b/backends/alpm/pk-backend-config.c +index c8fd13b..1a82637 100644 +--- a/backends/alpm/pk-backend-config.c ++++ b/backends/alpm/pk-backend-config.c +@@ -33,35 +33,32 @@ + + typedef struct + { +- gboolean checkspace, ilovecandy, totaldl, usedelta, usesyslog, +- verbosepkglists; ++ gboolean checkspace, color, ilovecandy, totaldl, ++ usesyslog, verbosepkglists; ++ gdouble deltaratio; + +- gchar *arch, *cleanmethod, *dbpath, *gpgdir, *logfile, *root, +- *xfercmd; ++ gchar *arch, *cleanmethod, *dbpath, *gpgdir, *logfile, ++ *root, *xfercmd; + +- alpm_list_t *cachedirs, *holdpkgs, *ignoregroups, *ignorepkgs, +- *noextracts, *noupgrades, *syncfirsts; ++ alpm_list_t *cachedirs, *holdpkgs, *ignoregroups, ++ *ignorepkgs, *localfilesiglevels, *noextracts, ++ *noupgrades, *remotefilesiglevels; + +- alpm_list_t *repos; +- GHashTable *servers; +- GHashTable *levels; +- GRegex *xrepo, *xarch; ++ alpm_list_t *sections; ++ GRegex *xrepo, *xarch; + } PkBackendConfig; + ++typedef struct ++{ ++ gchar *name; ++ alpm_list_t *servers, *siglevels; ++} PkBackendConfigSection; ++ + 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->deltaratio = 0.0; + + config->xrepo = g_regex_new ("\\$repo", 0, 0, NULL); + config->xarch = g_regex_new ("\\$arch", 0, 0, NULL); +@@ -70,17 +67,17 @@ pk_backend_config_new (void) + } + + static void +-pk_backend_config_list_free (alpm_list_t *list) ++pk_backend_config_section_free (gpointer data) + { +- alpm_list_free_inner (list, g_free); +- alpm_list_free (list); +-} ++ PkBackendConfigSection *section = data; + +-static gboolean +-pk_backend_config_servers_free (gpointer repo, gpointer list, gpointer data) +-{ +- pk_backend_config_list_free ((alpm_list_t *) list); +- return TRUE; ++ if (section != NULL) { ++ g_free (section->name); ++ alpm_list_free_inner (section->servers, g_free); ++ alpm_list_free (section->servers); ++ FREELIST (section->siglevels); ++ g_free (section); ++ } + } + + static void +@@ -100,15 +97,13 @@ pk_backend_config_free (PkBackendConfig *config) + FREELIST (config->holdpkgs); + FREELIST (config->ignoregroups); + FREELIST (config->ignorepkgs); ++ FREELIST (config->localfilesiglevels); + FREELIST (config->noextracts); + FREELIST (config->noupgrades); +- FREELIST (config->syncfirsts); ++ FREELIST (config->remotefilesiglevels); + +- pk_backend_config_list_free (config->repos); +- 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); ++ alpm_list_free_inner (config->sections, pk_backend_config_section_free); ++ alpm_list_free (config->sections); + + g_regex_unref (config->xrepo); + g_regex_unref (config->xarch); +@@ -123,6 +118,14 @@ pk_backend_config_set_checkspace (PkBackendConfig *config) + } + + static void ++pk_backend_config_set_color (PkBackendConfig *config) ++{ ++ g_return_if_fail (config != NULL); ++ ++ config->color = TRUE; ++} ++ ++static void + pk_backend_config_set_ilovecandy (PkBackendConfig *config) + { + g_return_if_fail (config != NULL); +@@ -143,7 +146,7 @@ pk_backend_config_set_usedelta (PkBackendConfig *config) + { + g_return_if_fail (config != NULL); + +- config->usedelta = TRUE; ++ config->deltaratio = 0.7; + } + + static void +@@ -171,6 +174,7 @@ typedef struct + /* keep this in alphabetical order */ + static const PkBackendConfigBoolean pk_backend_config_boolean_options[] = { + { "CheckSpace", pk_backend_config_set_checkspace }, ++ { "Color", pk_backend_config_set_color }, + { "ILoveCandy", pk_backend_config_set_ilovecandy }, + { "TotalDownload", pk_backend_config_set_totaldl }, + { "UseDelta", pk_backend_config_set_usedelta }, +@@ -284,6 +288,22 @@ pk_backend_config_set_root (PkBackendConfig *config, const gchar *path) + } + + static void ++pk_backend_config_set_deltaratio (PkBackendConfig *config, const gchar *number) ++{ ++ gdouble ratio; ++ gchar *endptr; ++ ++ g_return_if_fail (config != NULL); ++ g_return_if_fail (number != NULL); ++ ++ ratio = g_ascii_strtod (number, &endptr); ++ /* this ignores invalid values whereas pacman reports an error */ ++ if (*endptr == '\0' && 0.0 <= ratio && ratio <= 2.0) { ++ config->deltaratio = ratio; ++ } ++} ++ ++static void + pk_backend_config_set_xfercmd (PkBackendConfig *config, const gchar *command) + { + g_return_if_fail (config != NULL); +@@ -308,6 +328,7 @@ static const PkBackendConfigString pk_backend_config_string_options[] = { + { "GPGDir", pk_backend_config_set_gpgdir }, + { "LogFile", pk_backend_config_set_logfile }, + { "RootDir", pk_backend_config_set_root }, ++ { "UseDelta", pk_backend_config_set_deltaratio }, + { "XferCommand", pk_backend_config_set_xfercmd }, + { NULL, NULL } + }; +@@ -335,102 +356,51 @@ pk_backend_config_set_string (PkBackendConfig *config, const gchar *option, + } + } + +-static void +-pk_backend_config_add_holdpkg (PkBackendConfig *config, gchar *package) +-{ +- g_return_if_fail (config != NULL); +- g_return_if_fail (package != NULL); +- +- config->holdpkgs = alpm_list_add (config->holdpkgs, package); +-} +- +-static void +-pk_backend_config_add_ignoregroup (PkBackendConfig *config, gchar *group) +-{ +- g_return_if_fail (config != NULL); +- g_return_if_fail (group != NULL); +- +- config->ignoregroups = alpm_list_add (config->ignoregroups, group); +-} +- +-static void +-pk_backend_config_add_ignorepkg (PkBackendConfig *config, gchar *package) +-{ +- g_return_if_fail (config != NULL); +- g_return_if_fail (package != NULL); +- +- config->ignorepkgs = alpm_list_add (config->ignorepkgs, package); +-} +- +-static void +-pk_backend_config_add_noextract (PkBackendConfig *config, gchar *filename) +-{ +- g_return_if_fail (config != NULL); +- g_return_if_fail (filename != NULL); +- +- config->noextracts = alpm_list_add (config->noextracts, filename); +-} +- +-static void +-pk_backend_config_add_noupgrade (PkBackendConfig *config, gchar *filename) +-{ +- g_return_if_fail (config != NULL); +- g_return_if_fail (filename != NULL); +- +- config->noupgrades = alpm_list_add (config->noupgrades, filename); +-} +- +-static void +-pk_backend_config_add_syncfirst (PkBackendConfig *config, gchar *package) +-{ +- g_return_if_fail (config != NULL); +- g_return_if_fail (package != NULL); +- +- config->syncfirsts = alpm_list_add (config->syncfirsts, package); +-} +- + typedef struct + { + const gchar *name; +- void (*func) (PkBackendConfig *config, gchar *value); ++ glong offset; + } 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_ignoregroup }, +- { "IgnorePkg", pk_backend_config_add_ignorepkg }, +- { "NoExtract", pk_backend_config_add_noextract }, +- { "NoUpgrade", pk_backend_config_add_noupgrade }, +- { "SyncFirst", pk_backend_config_add_syncfirst }, +- { NULL, NULL } ++ { "HoldPkg", G_STRUCT_OFFSET (PkBackendConfig, holdpkgs) }, ++ { "IgnoreGroup", G_STRUCT_OFFSET (PkBackendConfig, ignoregroups) }, ++ { "IgnorePkg", G_STRUCT_OFFSET (PkBackendConfig, ignorepkgs) }, ++ { "LocalFileSigLevel", G_STRUCT_OFFSET (PkBackendConfig, ++ localfilesiglevels) }, ++ { "NoExtract", G_STRUCT_OFFSET (PkBackendConfig, noextracts) }, ++ { "NoUpgrade", G_STRUCT_OFFSET (PkBackendConfig, noupgrades) }, ++ { "RemoteFileSigLevel", G_STRUCT_OFFSET (PkBackendConfig, ++ remotefilesiglevels) }, ++ { NULL, 0 } + }; + +-static void +-pk_backend_config_list_add (PkBackendConfig *config, gsize option, +- const gchar *list) ++static alpm_list_t * ++alpm_list_add_words (alpm_list_t *list, const gchar *words) + { + gchar *str; + +- for (str = strchr (list, ' '); str != NULL; str = strchr (list, ' ')) { ++ while ((str = strchr (words, ' ')) != NULL) { + /* allocate normally */ +- gchar *value = malloc ((++str - list) * sizeof (gchar)); +- g_strlcpy (value, list, str - list); +- pk_backend_config_list_options[option].func (config, value); +- list = str; ++ gchar *word = malloc ((++str - words) * sizeof (gchar)); ++ g_strlcpy (word, words, str - words); ++ list = alpm_list_add (list, word); ++ words = str; + } +- pk_backend_config_list_options[option].func (config, strdup (list)); ++ ++ return alpm_list_add (list, strdup (words)); + } + + static gboolean + pk_backend_config_set_list (PkBackendConfig *config, const gchar *option, +- const gchar *list) ++ const gchar *words) + { + gsize i; + + g_return_val_if_fail (config != NULL, FALSE); + g_return_val_if_fail (option != NULL, FALSE); +- g_return_val_if_fail (list != NULL, FALSE); ++ g_return_val_if_fail (words != NULL, FALSE); + + for (i = 0;; ++i) { + const gchar *name = pk_backend_config_list_options[i].name; +@@ -439,37 +409,57 @@ pk_backend_config_set_list (PkBackendConfig *config, const gchar *option, + if (name == NULL || cmp < 0) { + return FALSE; + } else if (cmp == 0) { +- pk_backend_config_list_add (config, i, list); ++ glong offset = pk_backend_config_list_options[i].offset; ++ alpm_list_t **list = G_STRUCT_MEMBER_P (config, offset); ++ *list = alpm_list_add_words (*list, words); + return TRUE; + } + } + } + +-static void +-pk_backend_config_add_repo (PkBackendConfig *config, const gchar *repo) ++static gint ++pk_backend_config_section_match (gconstpointer element, gconstpointer name) + { +- g_return_if_fail (config != NULL); +- g_return_if_fail (repo != NULL); ++ const PkBackendConfigSection *section = element; ++ ++ g_return_val_if_fail (section != NULL, -1); ++ ++ return g_strcmp0 (section->name, name); ++} ++ ++static PkBackendConfigSection * ++pk_backend_config_enter_section (PkBackendConfig *config, const gchar *name) ++{ ++ PkBackendConfigSection *section; + +- if (alpm_list_find_str (config->repos, repo) == NULL) { +- config->repos = alpm_list_add (config->repos, g_strdup (repo)); ++ g_return_val_if_fail (config != NULL, NULL); ++ g_return_val_if_fail (name != NULL, NULL); ++ ++ section = alpm_list_find (config->sections, name, ++ pk_backend_config_section_match); ++ if (section != NULL) { ++ return section; + } ++ ++ section = g_new0 (PkBackendConfigSection, 1); ++ section->name = g_strdup (name); ++ config->sections = alpm_list_add (config->sections, section); ++ return section; + } + + static gboolean +-pk_backend_config_repo_add_server (PkBackendConfig *config, const gchar *repo, +- const gchar *value, GError **e) ++pk_backend_config_add_server (PkBackendConfig *config, ++ PkBackendConfigSection *section, ++ const gchar *address, GError **e) + { +- alpm_list_t *list; + gchar *url; + + g_return_val_if_fail (config != NULL, FALSE); +- g_return_val_if_fail (repo != NULL, FALSE); +- g_return_val_if_fail (alpm_list_find_str (config->repos, repo) != NULL, +- FALSE); +- g_return_val_if_fail (value != NULL, FALSE); ++ g_return_val_if_fail (section != NULL, FALSE); ++ g_return_val_if_fail (address != NULL, FALSE); + +- url = g_regex_replace_literal (config->xrepo, value, -1, 0, repo, 0, e); ++ url = g_regex_replace_literal (config->xrepo, address, -1, 0, ++ section->name, 0, e); + if (url == NULL) { + return FALSE; + } +@@ -488,105 +478,26 @@ pk_backend_config_repo_add_server (PkBackendConfig *config, const gchar *repo, + "url contained $arch, which is not set"); + } + +- list = (alpm_list_t *) g_hash_table_lookup (config->servers, repo); +- list = alpm_list_add (list, url); +- g_hash_table_insert (config->servers, g_strdup (repo), list); ++ section->servers = alpm_list_add (section->servers, url); + + return TRUE; + } + +-static gboolean +-pk_backend_config_set_siglevel (PkBackendConfig *config, const gchar *section, +- const gchar *list, GError **error) ++static void ++pk_backend_config_add_siglevel (PkBackendConfig *config, ++ PkBackendConfigSection *section, ++ const gchar *words) + { +- 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; ++ g_return_val_if_fail (words != NULL, FALSE); + +- 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")) { +- if (package) { +- *level &= ~ALPM_SIG_PACKAGE; +- } +- if (database) { +- *level &= ~ALPM_SIG_DATABASE; +- } +- } else if (g_str_has_prefix (list, "Optional")) { +- 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")) { +- 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")) { +- 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")) { +- 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; ++ section->siglevels = alpm_list_add_words (section->siglevels, words); + } + + static gboolean + pk_backend_config_parse (PkBackendConfig *config, const gchar *filename, +- gchar *section, GError **error) ++ PkBackendConfigSection *section, GError **error) + { + GFile *file; + GFileInputStream *is; +@@ -610,7 +521,6 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename, + } + + input = g_data_input_stream_new (G_INPUT_STREAM (is)); +- section = g_strdup (section); + + for (;; g_free (line), ++num) { + line = g_data_input_stream_read_line (input, NULL, NULL, &e); +@@ -642,13 +552,7 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename, + break; + } + +- g_free (section); +- section = g_strdup (str); +- +- if (g_strcmp0 (section, "options") != 0) { +- pk_backend_config_add_repo (config, section); +- } +- ++ section = pk_backend_config_enter_section (config, str); + continue; + } + +@@ -668,7 +572,8 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename, + + if (str == NULL) { + /* set a boolean directive */ +- if (g_strcmp0 (section, "options") == 0 && ++ if (pk_backend_config_section_match (section, ++ "options") == 0 && + pk_backend_config_set_boolean (config, key)) { + continue; + } +@@ -697,7 +602,8 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename, + } else { + continue; + } +- } else if (g_strcmp0 (section, "options") == 0) { ++ } else if (pk_backend_config_section_match (section, ++ "options") == 0) { + /* set a string or list directive */ + if (pk_backend_config_set_string (config, key, str) || + pk_backend_config_set_list (config, key, str)) { +@@ -705,8 +611,8 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename, + } + /* report error below */ + } else if (g_strcmp0 (key, "Server") == 0) { +- if (!pk_backend_config_repo_add_server (config, section, +- str, &e)) { ++ if (!pk_backend_config_add_server (config, section, ++ str, &e)) { + break; + } else { + continue; +@@ -714,12 +620,8 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename, + } + + if (g_strcmp0 (key, "SigLevel") == 0 && str != NULL) { +- if (!pk_backend_config_set_siglevel (config, section, +- str, &e)) { +- break; +- } else { +- continue; +- } ++ pk_backend_config_add_siglevel (config, section, str); ++ continue; + } + + /* report errors from above */ +@@ -728,8 +630,6 @@ pk_backend_config_parse (PkBackendConfig *config, const gchar *filename, + break; + } + +- g_free (section); +- + g_object_unref (input); + g_object_unref (is); + g_object_unref (file); +@@ -746,7 +646,7 @@ static alpm_handle_t * + pk_backend_config_initialize_alpm (PkBackendConfig *config, GError **error) + { + alpm_handle_t *handle; +- enum _alpm_errno_t errno; ++ alpm_errno_t errno; + gsize dir = 1; + + g_return_val_if_fail (config != NULL, FALSE); +@@ -817,11 +717,160 @@ pk_backend_config_initialize_alpm (PkBackendConfig *config, GError **error) + return handle; + } + ++static alpm_siglevel_t ++alpm_siglevel_parse (alpm_siglevel_t base, const alpm_list_t *list, ++ GError **error) ++{ ++ for (; list != NULL; list = list->next) { ++ gboolean package = TRUE, database = TRUE; ++ const gchar *level = (const gchar *) list->data; ++ ++ if (g_str_has_prefix (level, "Package")) { ++ database = FALSE; ++ level += 7; ++ } else if (g_str_has_prefix (level, "Database")) { ++ package = FALSE; ++ level += 8; ++ } ++ ++ if (g_strcmp0 (level, "Never") == 0) { ++ if (package) { ++ base &= ~ALPM_SIG_PACKAGE; ++ base |= ALPM_SIG_PACKAGE_SET; ++ } ++ if (database) { ++ base &= ~ALPM_SIG_DATABASE; ++ } ++ } else if (g_strcmp0 (level, "Optional") == 0) { ++ if (package) { ++ base |= ALPM_SIG_PACKAGE; ++ base |= ALPM_SIG_PACKAGE_OPTIONAL; ++ base |= ALPM_SIG_PACKAGE_SET; ++ } ++ if (database) { ++ base |= ALPM_SIG_DATABASE; ++ base |= ALPM_SIG_DATABASE_OPTIONAL; ++ } ++ } else if (g_strcmp0 (level, "Required") == 0) { ++ if (package) { ++ base |= ALPM_SIG_PACKAGE; ++ base &= ~ALPM_SIG_PACKAGE_OPTIONAL; ++ base |= ALPM_SIG_PACKAGE_SET; ++ } ++ if (database) { ++ base |= ALPM_SIG_DATABASE; ++ base &= ~ALPM_SIG_DATABASE_OPTIONAL; ++ } ++ } else if (g_strcmp0 (level, "TrustedOnly") == 0) { ++ if (package) { ++ base &= ~ALPM_SIG_PACKAGE_MARGINAL_OK; ++ base &= ~ALPM_SIG_PACKAGE_UNKNOWN_OK; ++ base |= ALPM_SIG_PACKAGE_TRUST_SET; ++ } ++ if (database) { ++ base &= ~ALPM_SIG_DATABASE_MARGINAL_OK; ++ base &= ~ALPM_SIG_DATABASE_UNKNOWN_OK; ++ } ++ } else if (g_strcmp0 (level, "TrustAll") == 0) { ++ if (package) { ++ base |= ALPM_SIG_PACKAGE_MARGINAL_OK; ++ base |= ALPM_SIG_PACKAGE_UNKNOWN_OK; ++ base |= ALPM_SIG_PACKAGE_TRUST_SET; ++ } ++ if (database) { ++ base |= ALPM_SIG_DATABASE_MARGINAL_OK; ++ base |= ALPM_SIG_DATABASE_UNKNOWN_OK; ++ } ++ } else { ++ g_set_error (error, ALPM_ERROR, ALPM_ERR_CONFIG_INVALID, ++ "invalid SigLevel value: %s", level); ++ return ALPM_SIG_USE_DEFAULT; ++ } ++ } ++ ++ return base; ++} ++ ++static alpm_siglevel_t ++alpm_siglevel_cross (alpm_siglevel_t base, const alpm_list_t *list, ++ GError **error) ++{ ++ alpm_siglevel_t level; ++ ++ if (list == NULL) { ++ return base; ++ } ++ ++ level = alpm_siglevel_parse (0, list, error); ++ if (level == ALPM_SIG_USE_DEFAULT) { ++ return level; ++ } ++ ++ /* based on unexplained code in pacman */ ++ if ((level & ALPM_SIG_PACKAGE_SET) == 0) { ++ level |= base & (ALPM_SIG_PACKAGE | ALPM_SIG_PACKAGE_OPTIONAL); ++ } ++ if ((level & ALPM_SIG_PACKAGE_TRUST_SET) == 0) { ++ level |= base & (ALPM_SIG_PACKAGE_MARGINAL_OK | ++ ALPM_SIG_PACKAGE_UNKNOWN_OK); ++ } ++ ++ return level; ++} ++ ++static gboolean ++pk_backend_config_configure_repos (PkBackendConfig *config, ++ alpm_handle_t *handle, GError **error) ++{ ++ alpm_siglevel_t base, local, remote; ++ const alpm_list_t *i; ++ PkBackendConfigSection *options; ++ ++ g_return_val_if_fail (config != NULL, FALSE); ++ ++ base = ALPM_SIG_PACKAGE | ALPM_SIG_PACKAGE_OPTIONAL | ++ ALPM_SIG_DATABASE | ALPM_SIG_DATABASE_OPTIONAL; ++ ++ i = config->sections; ++ options = i->data; ++ ++ base = alpm_siglevel_parse (base, options->siglevels, error); ++ if (base == ALPM_SIG_USE_DEFAULT) { ++ return FALSE; ++ } ++ ++ local = alpm_siglevel_cross (base, config->localfilesiglevels, error); ++ if (local == ALPM_SIG_USE_DEFAULT) { ++ return FALSE; ++ } ++ ++ remote = alpm_siglevel_cross (base, config->remotefilesiglevels, error); ++ if (remote == ALPM_SIG_USE_DEFAULT) { ++ return FALSE; ++ } ++ ++ alpm_option_set_default_siglevel (handle, base); ++ alpm_option_set_local_file_siglevel (handle, local); ++ alpm_option_set_remote_file_siglevel (handle, remote); ++ ++ while ((i = i->next) != NULL) { ++ PkBackendConfigSection *repo = i->data; ++ alpm_siglevel_t level; ++ ++ level = alpm_siglevel_parse (base, repo->siglevels, error); ++ if (level == ALPM_SIG_USE_DEFAULT) { ++ return FALSE; ++ } ++ pk_backend_add_database (repo->name, repo->servers, level); ++ } ++ ++ return TRUE; ++} ++ + static alpm_handle_t * + pk_backend_config_configure_alpm (PkBackendConfig *config, GError **error) + { + alpm_handle_t *handle; +- alpm_siglevel_t *level; + + g_return_val_if_fail (config != NULL, FALSE); + +@@ -831,12 +880,9 @@ pk_backend_config_configure_alpm (PkBackendConfig *config, GError **error) + } + + 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); +- +- level = g_hash_table_lookup (config->levels, "options"); +- alpm_option_set_default_siglevel (handle, *level); ++ alpm_option_set_deltaratio (handle, config->deltaratio); + + /* backend takes ownership */ + g_free (xfercmd); +@@ -854,11 +900,6 @@ pk_backend_config_configure_alpm (PkBackendConfig *config, GError **error) + holdpkgs = config->holdpkgs; + config->holdpkgs = NULL; + +- /* backend takes ownership */ +- FREELIST (syncfirsts); +- syncfirsts = config->syncfirsts; +- config->syncfirsts = NULL; +- + /* alpm takes ownership */ + alpm_option_set_ignoregroups (handle, config->ignoregroups); + config->ignoregroups = NULL; +@@ -875,8 +916,7 @@ pk_backend_config_configure_alpm (PkBackendConfig *config, GError **error) + alpm_option_set_noupgrades (handle, config->noupgrades); + config->noupgrades = NULL; + +- pk_backend_configure_repos (config->repos, config->servers, +- config->levels); ++ pk_backend_config_configure_repos (config, handle, error); + + return handle; + } +@@ -892,6 +932,7 @@ pk_backend_configure (const gchar *filename, GError **error) + + g_debug ("reading config from %s", filename); + config = pk_backend_config_new (); ++ pk_backend_config_enter_section (config, "options"); + + if (pk_backend_config_parse (config, filename, NULL, &e)) { + handle = pk_backend_config_configure_alpm (config, &e); +diff --git a/backends/alpm/pk-backend-databases.c b/backends/alpm/pk-backend-databases.c +index a123297..09d5a73 100644 +--- a/backends/alpm/pk-backend-databases.c ++++ b/backends/alpm/pk-backend-databases.c +@@ -140,8 +140,8 @@ disabled_repos_configure (GHashTable *table, gboolean only_trusted, + g_return_val_if_fail (table != NULL, FALSE); + g_return_val_if_fail (alpm != NULL, FALSE); + +- if (alpm_db_unregister_all (alpm) < 0) { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ if (alpm_unregister_all_syncdbs (alpm) < 0) { ++ alpm_errno_t errno = alpm_errno (alpm); + g_set_error_literal (error, ALPM_ERROR, errno, + alpm_strerror (errno)); + return FALSE; +@@ -161,9 +161,9 @@ disabled_repos_configure (GHashTable *table, gboolean only_trusted, + level &= ~ALPM_SIG_USE_DEFAULT; + } + +- db = alpm_db_register_sync (alpm, repo->name, level); ++ db = alpm_register_syncdb (alpm, repo->name, level); + if (db == NULL) { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ alpm_errno_t errno = alpm_errno (alpm); + g_set_error (error, ALPM_ERROR, errno, "[%s]: %s", + repo->name, alpm_strerror (errno)); + return FALSE; +@@ -176,29 +176,18 @@ disabled_repos_configure (GHashTable *table, gboolean only_trusted, + } + + void +-pk_backend_configure_repos (alpm_list_t *repos, GHashTable *servers, +- GHashTable *levels) ++pk_backend_add_database (const gchar *name, alpm_list_t *servers, ++ alpm_siglevel_t level) + { +- 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); ++ PkBackendRepo *repo = g_new (PkBackendRepo, 1); + +- repo->name = g_strdup ((const gchar *) i->data); +- repo->servers = alpm_list_strdup ((alpm_list_t *) value); ++ g_return_if_fail (name != NULL); + +- value = g_hash_table_lookup (levels, i->data); +- if (value != NULL) { +- repo->level = *(alpm_siglevel_t *) value; +- } else { +- repo->level = ALPM_SIG_USE_DEFAULT; +- } ++ repo->name = g_strdup (name); ++ repo->servers = alpm_list_strdup (servers); ++ repo->level = level; + +- configured = alpm_list_add (configured, repo); +- } ++ configured = alpm_list_add (configured, repo); + } + + gboolean +@@ -282,7 +271,7 @@ pk_backend_get_repo_list_thread (PkBackend *self) + g_return_val_if_fail (disabled != NULL, FALSE); + + /* emit enabled repos */ +- for (i = alpm_option_get_syncdbs (alpm); i != NULL; i = i->next) { ++ for (i = alpm_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); + +@@ -368,13 +357,13 @@ pk_backend_repo_disable_thread (PkBackend *self) + + g_return_val_if_fail (repo != NULL, FALSE); + +- for (i = alpm_option_get_syncdbs (alpm); i != NULL; i = i->next) { ++ for (i = alpm_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) { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ alpm_errno_t errno = alpm_errno (alpm); + g_set_error (&error, ALPM_ERROR, errno, + "[%s]: %s", repo, + alpm_strerror (errno)); +diff --git a/backends/alpm/pk-backend-databases.h b/backends/alpm/pk-backend-databases.h +index d9b9e78..d0dbb7c 100644 +--- a/backends/alpm/pk-backend-databases.h ++++ b/backends/alpm/pk-backend-databases.h +@@ -24,9 +24,9 @@ + #include + #include + +-void pk_backend_configure_repos (alpm_list_t *repos, +- GHashTable *servers, +- GHashTable *levels); ++void pk_backend_add_database (const gchar *name, ++ alpm_list_t *servers, ++ alpm_siglevel_t level); + + gboolean pk_backend_disable_signatures (PkBackend *self, + GError **error); +diff --git a/backends/alpm/pk-backend-depends.c b/backends/alpm/pk-backend-depends.c +index 7c7b45a..c3d82a0 100644 +--- a/backends/alpm/pk-backend-depends.c ++++ b/backends/alpm/pk-backend-depends.c +@@ -85,7 +85,7 @@ pk_backend_find_provider (PkBackend *self, alpm_list_t *pkgs, + } + + /* look for remote dependencies */ +- syncdbs = alpm_option_get_syncdbs (alpm); ++ syncdbs = alpm_get_syncdbs (alpm); + provider = alpm_find_dbs_satisfier (alpm, syncdbs, depend); + + if (provider != NULL) { +@@ -184,7 +184,7 @@ pk_backend_get_depends_thread (PkBackend *self) + depend = alpm_dep_compute_string (depends->data); + pkgs = pk_backend_find_provider (self, pkgs, depend, + &error); +- g_free (depend); ++ free (depend); + } + } + +diff --git a/backends/alpm/pk-backend-install.c b/backends/alpm/pk-backend-install.c +index d0cbca2..0b036f3 100644 +--- a/backends/alpm/pk-backend-install.c ++++ b/backends/alpm/pk-backend-install.c +@@ -39,7 +39,7 @@ alpm_add_file (const gchar *filename) + g_return_val_if_fail (filename != NULL, -1); + g_return_val_if_fail (alpm != NULL, -1); + +- level = alpm_option_get_default_siglevel (alpm); ++ level = alpm_option_get_local_file_siglevel (alpm); + + if (alpm_pkg_load (alpm, filename, 1, level, &pkg) < 0) { + return -1; +@@ -66,7 +66,7 @@ pk_backend_transaction_add_targets (PkBackend *self, GError **error) + + for (; *paths != NULL; ++paths) { + if (alpm_add_file (*paths) < 0) { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ 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 c90cd7d..86b1ef7 100644 +--- a/backends/alpm/pk-backend-packages.c ++++ b/backends/alpm/pk-backend-packages.c +@@ -42,7 +42,7 @@ alpm_pkg_build_id (alpm_pkg_t *pkg) + } + + /* TODO: check correctness */ +- if (alpm_pkg_get_origin (pkg) == PKG_FROM_SYNCDB) { ++ if (alpm_pkg_get_origin (pkg) == ALPM_PKG_FROM_SYNCDB) { + repo = alpm_db_get_name (alpm_pkg_get_db (pkg)); + } else { + repo = "installed"; +@@ -84,7 +84,7 @@ 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 = alpm_option_get_syncdbs (alpm); ++ const alpm_list_t *i = alpm_get_syncdbs (alpm); + for (; i != NULL; i = i->next) { + const gchar *repo = alpm_db_get_name (i->data); + +@@ -140,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_origin (pkg) == PKG_FROM_LOCALDB) { ++ if (alpm_pkg_get_origin (pkg) == ALPM_PKG_FROM_LOCALDB) { + if (!skip_local) { + pk_backend_pkg (self, pkg, PK_INFO_ENUM_INSTALLED); + } +@@ -179,7 +179,7 @@ pk_backend_resolve_name (PkBackend *self, const gchar *name, GError **error) + return TRUE; + } + } else if (!skip_remote) { +- const alpm_list_t *i = alpm_option_get_syncdbs (alpm); ++ const alpm_list_t *i = alpm_get_syncdbs (alpm); + for (; i != NULL; i = i->next) { + pkg = alpm_db_get_pkg (i->data, name); + if (pkg != NULL) { +@@ -287,7 +287,7 @@ pk_backend_get_details_thread (PkBackend *self) + desc = alpm_pkg_get_desc (pkg); + url = alpm_pkg_get_url (pkg); + +- if (alpm_pkg_get_origin (pkg) == PKG_FROM_LOCALDB) { ++ if (alpm_pkg_get_origin (pkg) == ALPM_PKG_FROM_LOCALDB) { + size = alpm_pkg_get_isize (pkg); + } else { + size = alpm_pkg_download_size (pkg); +diff --git a/backends/alpm/pk-backend-remove.c b/backends/alpm/pk-backend-remove.c +index 1993061..331684f 100644 +--- a/backends/alpm/pk-backend-remove.c ++++ b/backends/alpm/pk-backend-remove.c +@@ -48,7 +48,7 @@ pk_backend_transaction_remove_targets (PkBackend *self, GError **error) + + 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); ++ alpm_errno_t errno = alpm_errno (alpm); + g_set_error (error, ALPM_ERROR, errno, "%s: %s", name, + alpm_strerror (errno)); + g_strfreev (package); +diff --git a/backends/alpm/pk-backend-search.c b/backends/alpm/pk-backend-search.c +index c4e80ae..4cfeeb2 100644 +--- a/backends/alpm/pk-backend-search.c ++++ b/backends/alpm/pk-backend-search.c +@@ -374,7 +374,7 @@ pk_backend_search_thread (PkBackend *self) + goto out; + } + +- for (i = alpm_option_get_syncdbs (alpm); i != NULL; i = i->next) { ++ for (i = alpm_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 d2f363b..80d5ae0 100644 +--- a/backends/alpm/pk-backend-sync.c ++++ b/backends/alpm/pk-backend-sync.c +@@ -48,7 +48,7 @@ pk_backend_transaction_sync_targets (PkBackend *self, GError **error) + gchar *repo = package[PK_PACKAGE_ID_DATA]; + gchar *name = package[PK_PACKAGE_ID_NAME]; + +- const alpm_list_t *i = alpm_option_get_syncdbs (alpm); ++ const alpm_list_t *i = alpm_get_syncdbs (alpm); + alpm_pkg_t *pkg; + + for (; i != NULL; i = i->next) { +@@ -58,7 +58,7 @@ pk_backend_transaction_sync_targets (PkBackend *self, GError **error) + } + + if (i == NULL) { +- enum _alpm_errno_t errno = ALPM_ERR_DB_NOT_FOUND; ++ 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); +@@ -67,7 +67,7 @@ pk_backend_transaction_sync_targets (PkBackend *self, GError **error) + + 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); ++ 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); +@@ -274,7 +274,7 @@ pk_backend_update_packages_thread (PkBackend *self) + for (i = asdeps; i != NULL; i = i->next) { + const gchar *name = (const gchar *) i->data; + alpm_pkg_t *pkg = alpm_db_get_pkg (localdb, name); +- alpm_db_set_pkgreason (alpm, pkg, ALPM_PKG_REASON_DEPEND); ++ alpm_pkg_set_reason (pkg, ALPM_PKG_REASON_DEPEND); + } + + out: +diff --git a/backends/alpm/pk-backend-transaction.c b/backends/alpm/pk-backend-transaction.c +index 76402f0..5e32151 100644 +--- a/backends/alpm/pk-backend-transaction.c ++++ b/backends/alpm/pk-backend-transaction.c +@@ -63,7 +63,7 @@ alpm_pkg_has_basename (alpm_pkg_t *pkg, const gchar *basename) + return TRUE; + } + +- if (alpm_option_get_usedelta (alpm) == 0) { ++ if (alpm_option_get_deltaratio (alpm) == 0.0) { + return FALSE; + } + +@@ -210,16 +210,18 @@ pk_backend_transaction_progress_cb (alpm_progress_t type, const gchar *target, + static gint recent = 101; + gsize overall = percent + (current - 1) * 100; + +- /* TODO: revert when fixed upstream */ ++ /* TODO: remove block if/when this is made consistent upstream */ + if (type == ALPM_PROGRESS_CONFLICTS_START || + type == ALPM_PROGRESS_DISKSPACE_START || + type == ALPM_PROGRESS_INTEGRITY_START || +- type == ALPM_PROGRESS_LOAD_START) { ++ type == ALPM_PROGRESS_LOAD_START || ++ type == ALPM_PROGRESS_KEYRING_START) { + if (current < targets) { +- overall = percent + current++ * 100; ++ ++current; ++ overall += 100; + } + } +- ++ + if (current < 1 || targets < current) { + g_warning ("TODO: CURRENT/TARGETS FAILED for %d", type); + } +@@ -233,11 +235,14 @@ pk_backend_transaction_progress_cb (alpm_progress_t type, const gchar *target, + switch (type) { + case ALPM_PROGRESS_ADD_START: + case ALPM_PROGRESS_UPGRADE_START: ++ case ALPM_PROGRESS_DOWNGRADE_START: ++ case ALPM_PROGRESS_REINSTALL_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: ++ case ALPM_PROGRESS_KEYRING_START: + if (percent == recent) { + break; + } +@@ -388,6 +393,17 @@ pk_backend_output (PkBackend *self, const gchar *output) + } + + static void ++pk_backend_output_once (PkBackend *self, alpm_pkg_t *pkg, const gchar *output) ++{ ++ g_return_if_fail (self != NULL); ++ g_return_if_fail (pkg != NULL); ++ g_return_if_fail (output != NULL); ++ ++ pk_backend_message (self, PK_MESSAGE_ENUM_UNKNOWN, "%s\n%s", ++ alpm_pkg_get_name (pkg), output); ++} ++ ++static void + pk_backend_transaction_dep_resolve (PkBackend *self) + { + g_return_if_fail (self != NULL); +@@ -427,7 +443,8 @@ pk_backend_transaction_add_done (PkBackend *self, alpm_pkg_t *pkg) + name = alpm_pkg_get_name (pkg); + version = alpm_pkg_get_version (pkg); + +- alpm_logaction (alpm, "installed %s (%s)\n", name, version); ++ alpm_logaction (alpm, PK_LOG_PREFIX, "installed %s (%s)\n", name, ++ version); + pk_backend_pkg (self, pkg, PK_INFO_ENUM_FINISHED); + + optdepends = alpm_pkg_get_optdepends (pkg); +@@ -435,8 +452,10 @@ pk_backend_transaction_add_done (PkBackend *self, alpm_pkg_t *pkg) + pk_backend_output (self, "Optional dependencies:\n"); + + for (i = optdepends; i != NULL; i = i->next) { +- const gchar *depend = i->data; ++ gchar *depend = alpm_dep_compute_string (i->data); + gchar *output = g_strdup_printf ("%s\n", depend); ++ free (depend); ++ + pk_backend_output (self, output); + g_free (output); + } +@@ -467,7 +486,8 @@ pk_backend_transaction_remove_done (PkBackend *self, alpm_pkg_t *pkg) + name = alpm_pkg_get_name (pkg); + version = alpm_pkg_get_version (pkg); + +- alpm_logaction (alpm, "removed %s (%s)\n", name, version); ++ alpm_logaction (alpm, PK_LOG_PREFIX, "removed %s (%s)\n", name, ++ version); + pk_backend_pkg (self, pkg, PK_INFO_ENUM_FINISHED); + pk_backend_output_end (self); + } +@@ -498,45 +518,106 @@ pk_backend_transaction_upgrade_start (PkBackend *self, alpm_pkg_t *pkg, + pk_backend_output_start (self, pkg); + } + ++static gint ++alpm_depend_compare (gconstpointer a, gconstpointer b) ++{ ++ const alpm_depend_t *first = a; ++ const alpm_depend_t *second = b; ++ gint result; ++ ++ g_return_val_if_fail (first != NULL, 0); ++ g_return_val_if_fail (second != NULL, 0); ++ ++ result = g_strcmp0 (first->name, second->name); ++ if (result == 0) { ++ result = first->mod - second->mod; ++ if (result == 0) { ++ result = g_strcmp0 (first->version, second->version); ++ if (result == 0) { ++ result = g_strcmp0 (first->desc, second->desc); ++ } ++ } ++ } ++ ++ return result; ++} ++ + static void +-pk_backend_transaction_upgrade_done (PkBackend *self, alpm_pkg_t *pkg, +- alpm_pkg_t *old) ++pk_backend_transaction_process_new_optdepends (PkBackend *self, alpm_pkg_t *pkg, ++ alpm_pkg_t *old) + { +- const gchar *name, *pre, *post; +- const alpm_list_t *i; + alpm_list_t *optdepends; ++ const alpm_list_t *i; + + g_return_if_fail (self != NULL); + g_return_if_fail (pkg != NULL); + g_return_if_fail (old != NULL); ++ ++ optdepends = alpm_list_diff (alpm_pkg_get_optdepends (pkg), ++ alpm_pkg_get_optdepends (old), ++ alpm_depend_compare); ++ if (optdepends == NULL) { ++ return; ++ } ++ ++ pk_backend_output (self, "New optional dependencies:\n"); ++ ++ for (i = optdepends; i != NULL; i = i->next) { ++ gchar *depend = alpm_dep_compute_string (i->data); ++ gchar *output = g_strdup_printf ("%s\n", depend); ++ free (depend); ++ ++ pk_backend_output (self, output); ++ g_free (output); ++ } ++ ++ alpm_list_free (optdepends); ++} ++ ++static void ++pk_backend_transaction_upgrade_done (PkBackend *self, alpm_pkg_t *pkg, ++ alpm_pkg_t *old, gint direction) ++{ ++ const gchar *name, *pre, *post; ++ ++ g_return_if_fail (self != NULL); ++ g_return_if_fail (pkg != NULL); ++ g_return_if_fail (old != NULL || direction == 0); + g_return_if_fail (alpm != NULL); + + name = alpm_pkg_get_name (pkg); +- pre = alpm_pkg_get_version (old); ++ if (direction != 0) { ++ pre = alpm_pkg_get_version (old); ++ } + post = alpm_pkg_get_version (pkg); + +- alpm_logaction (alpm, "upgraded %s (%s -> %s)\n", name, pre, post); ++ if (direction > 0) { ++ alpm_logaction (alpm, PK_LOG_PREFIX, "upgraded %s (%s -> %s)\n", ++ name, pre, post); ++ } else if (direction < 0) { ++ alpm_logaction (alpm, PK_LOG_PREFIX, ++ "downgraded %s (%s -> %s)\n", name, pre, post); ++ } else { ++ alpm_logaction (alpm, PK_LOG_PREFIX, "reinstalled %s (%s)\n", ++ name, post); ++ } + pk_backend_pkg (self, pkg, PK_INFO_ENUM_FINISHED); + +- optdepends = alpm_list_diff (alpm_pkg_get_optdepends (pkg), +- alpm_pkg_get_optdepends (old), +- (alpm_list_fn_cmp) g_strcmp0); +- if (optdepends != NULL) { +- pk_backend_output (self, "New optional dependencies:\n"); +- +- for (i = optdepends; i != NULL; i = i->next) { +- const gchar *depend = i->data; +- gchar *output = g_strdup_printf ("%s\n", depend); +- pk_backend_output (self, output); +- g_free (output); +- } +- +- alpm_list_free (optdepends); ++ if (direction != 0) { ++ pk_backend_transaction_process_new_optdepends (self, pkg, old); + } + pk_backend_output_end (self); + } + + static void ++pk_backend_transaction_sig_check (PkBackend *self) ++{ ++ g_return_if_fail (self != NULL); ++ ++ pk_backend_set_status (self, PK_STATUS_ENUM_SIG_CHECK); ++} ++ ++static void + pk_backend_transaction_setup (PkBackend *self) + { + g_return_if_fail (self != NULL); +@@ -545,12 +626,46 @@ pk_backend_transaction_setup (PkBackend *self) + } + + static void ++pk_backend_transaction_repackaging (PkBackend *self) ++{ ++ g_return_if_fail (self != NULL); ++ ++ pk_backend_set_status (self, PK_STATUS_ENUM_REPACKAGING); ++} ++ ++static void ++pk_backend_transaction_download (PkBackend *self) ++{ ++ g_return_if_fail (self != NULL); ++ ++ pk_backend_set_status (self, PK_STATUS_ENUM_DOWNLOAD); ++} ++ ++static void ++pk_backend_transaction_optdepend_required (PkBackend *self, alpm_pkg_t *pkg, ++ alpm_depend_t *optdepend) ++{ ++ gchar *depend, *output; ++ ++ g_return_if_fail (self != NULL); ++ g_return_if_fail (pkg != NULL); ++ g_return_if_fail (optdepend != NULL); ++ ++ depend = alpm_dep_compute_string (optdepend); ++ output = g_strdup_printf ("optionally requires %s\n", depend); ++ free (depend); ++ ++ pk_backend_output_once (self, pkg, output); ++ g_free (output); ++} ++ ++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 */ ++ /* figure out backend status and process package changes */ + switch (event) { + case ALPM_EVENT_CHECKDEPS_START: + case ALPM_EVENT_RESOLVEDEPS_START: +@@ -559,7 +674,6 @@ pk_backend_transaction_event_cb (alpm_event_t event, gpointer data, + + 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); +@@ -582,23 +696,73 @@ pk_backend_transaction_event_cb (alpm_event_t event, gpointer data, + break; + + case ALPM_EVENT_UPGRADE_START: ++ case ALPM_EVENT_DOWNGRADE_START: ++ case ALPM_EVENT_REINSTALL_START: + pk_backend_transaction_upgrade_start (backend, data, + old); + break; + + case ALPM_EVENT_UPGRADE_DONE: + pk_backend_transaction_upgrade_done (backend, data, +- old); ++ old, 1); ++ break; ++ ++ case ALPM_EVENT_DOWNGRADE_DONE: ++ pk_backend_transaction_upgrade_done (backend, data, ++ old, -1); ++ break; ++ ++ case ALPM_EVENT_REINSTALL_DONE: ++ pk_backend_transaction_upgrade_done (backend, data, ++ old, 0); ++ break; ++ ++ case ALPM_EVENT_INTEGRITY_START: ++ case ALPM_EVENT_KEYRING_START: ++ pk_backend_transaction_sig_check (backend); + break; + + case ALPM_EVENT_LOAD_START: + pk_backend_transaction_setup (backend); + break; + ++ case ALPM_EVENT_DELTA_PATCHES_START: ++ case ALPM_EVENT_DELTA_PATCH_START: ++ pk_backend_transaction_repackaging (backend); ++ break; ++ + case ALPM_EVENT_SCRIPTLET_INFO: + pk_backend_output (backend, data); + break; + ++ case ALPM_EVENT_RETRIEVE_START: ++ pk_backend_transaction_download (backend); ++ break; ++ ++ case ALPM_EVENT_OPTDEP_REQUIRED: ++ /* TODO: remove if this results in notification spam */ ++ pk_backend_transaction_optdepend_required (backend, ++ data, old); ++ break; ++ ++ case ALPM_EVENT_CHECKDEPS_DONE: ++ case ALPM_EVENT_FILECONFLICTS_DONE: ++ case ALPM_EVENT_RESOLVEDEPS_DONE: ++ case ALPM_EVENT_INTERCONFLICTS_DONE: ++ case ALPM_EVENT_INTEGRITY_DONE: ++ case ALPM_EVENT_LOAD_DONE: ++ case ALPM_EVENT_DELTA_INTEGRITY_DONE: ++ case ALPM_EVENT_DELTA_PATCHES_DONE: ++ case ALPM_EVENT_DELTA_PATCH_DONE: ++ case ALPM_EVENT_DELTA_PATCH_FAILED: ++ case ALPM_EVENT_DISKSPACE_DONE: ++ case ALPM_EVENT_DATABASE_MISSING: ++ case ALPM_EVENT_KEYRING_DONE: ++ case ALPM_EVENT_KEY_DOWNLOAD_START: ++ case ALPM_EVENT_KEY_DOWNLOAD_DONE: ++ /* ignored */ ++ break; ++ + default: + g_debug ("unhandled event %d", event); + break; +@@ -623,7 +787,7 @@ pk_backend_transaction_initialize (PkBackend *self, alpm_transflag_t flags, + g_return_val_if_fail (cancellable != NULL, FALSE); + + if (alpm_trans_init (alpm, flags) < 0) { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ alpm_errno_t errno = alpm_errno (alpm); + g_set_error_literal (error, ALPM_ERROR, errno, + alpm_strerror (errno)); + return FALSE; +@@ -692,6 +856,7 @@ alpm_depend_free (alpm_depend_t *depend) + { + free (depend->name); + free (depend->version); ++ free (depend->desc); + free (depend); + } + +@@ -731,7 +896,7 @@ alpm_conflict_build_list (const alpm_list_t *i) + g_string_append_printf (list, "%s <-> %s (%s), ", + conflict->package1, + conflict->package2, reason); +- g_free (reason); ++ free (reason); + } + } + +@@ -837,12 +1002,12 @@ pk_backend_transaction_simulate (PkBackend *self, GError **error) + } + + if (prefix != NULL) { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ alpm_errno_t errno = alpm_errno (alpm); + g_set_error (error, ALPM_ERROR, errno, "%s: %s", prefix, + alpm_strerror (errno)); + g_free (prefix); + } else { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ alpm_errno_t errno = alpm_errno (alpm); + g_set_error_literal (error, ALPM_ERROR, errno, + alpm_strerror (errno)); + } +@@ -959,12 +1124,12 @@ pk_backend_transaction_commit (PkBackend *self, GError **error) + } + + if (prefix != NULL) { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ alpm_errno_t errno = alpm_errno (alpm); + g_set_error (error, ALPM_ERROR, errno, "%s: %s", prefix, + alpm_strerror (errno)); + g_free (prefix); + } else { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ alpm_errno_t errno = alpm_errno (alpm); + g_set_error_literal (error, ALPM_ERROR, errno, + alpm_strerror (errno)); + } +@@ -993,7 +1158,7 @@ pk_backend_transaction_end (PkBackend *self, GError **error) + } + + if (alpm_trans_release (alpm) < 0) { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ 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-update.c b/backends/alpm/pk-backend-update.c +index 37ade1e..ff83b5e 100644 +--- a/backends/alpm/pk-backend-update.c ++++ b/backends/alpm/pk-backend-update.c +@@ -130,6 +130,20 @@ alpm_pkg_same_pkgver (alpm_pkg_t *a, alpm_pkg_t *b) + } + } + ++static gchar * ++alpm_time_to_iso8601 (alpm_time_t time) ++{ ++ GDateTime *date = g_date_time_new_from_unix_utc (time); ++ ++ if (date != NULL) { ++ gchar *result = g_date_time_format (date, "%FT%TZ"); ++ g_date_time_unref (date); ++ return result; ++ } else { ++ return NULL; ++ } ++} ++ + static gboolean + pk_backend_get_update_detail_thread (PkBackend *self) + { +@@ -154,7 +168,7 @@ pk_backend_get_update_detail_thread (PkBackend *self) + PkRestartEnum restart; + PkUpdateStateEnum state; + +- GTimeVal built = { 0 }, installed = { 0 }; ++ alpm_time_t built, installed; + gchar *issued, *updated; + + if (pk_backend_cancelled (self)) { +@@ -195,17 +209,17 @@ pk_backend_get_update_detail_thread (PkBackend *self) + state = PK_UPDATE_STATE_ENUM_STABLE; + } + +- built.tv_sec = alpm_pkg_get_builddate (pkg); +- if (built.tv_sec > 0) { +- issued = g_time_val_to_iso8601 (&built); ++ built = alpm_pkg_get_builddate (pkg); ++ if (built > 0) { ++ issued = alpm_time_to_iso8601 (built); + } else { + issued = NULL; + } + + if (upgrades != NULL) { +- installed.tv_sec = alpm_pkg_get_installdate (old); +- if (installed.tv_sec > 0) { +- updated = g_time_val_to_iso8601 (&installed); ++ installed = alpm_pkg_get_installdate (old); ++ if (installed > 0) { ++ updated = alpm_time_to_iso8601 (installed); + } else { + updated = NULL; + } +@@ -251,13 +265,14 @@ pk_backend_update_databases (PkBackend *self, gint force, GError **error) { + return FALSE; + } + +- alpm_logaction (alpm, "synchronizing package lists\n"); ++ alpm_logaction (alpm, PK_LOG_PREFIX, "synchronizing package lists\n"); ++ pk_backend_set_status (self, PK_STATUS_ENUM_DOWNLOAD_PACKAGELIST); + + 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 (alpm); ++ i = alpm_get_syncdbs (alpm); + totaldlcb (-alpm_list_count (i)); + + for (; i != NULL; i = i->next) { +@@ -275,7 +290,7 @@ 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) { +- enum _alpm_errno_t errno = alpm_errno (alpm); ++ alpm_errno_t errno = alpm_errno (alpm); + g_set_error (error, ALPM_ERROR, errno, "[%s]: %s", + alpm_db_get_name (i->data), + alpm_strerror (errno)); +@@ -398,7 +413,7 @@ pk_backend_get_updates_thread (PkBackend *self) + } + + /* find outdated and replacement packages */ +- syncdbs = alpm_option_get_syncdbs (alpm); ++ syncdbs = alpm_get_syncdbs (alpm); + for (i = alpm_db_get_pkgcache (localdb); i != NULL; i = i->next) { + alpm_pkg_t *upgrade = alpm_pkg_find_update (i->data, syncdbs); + +diff --git a/configure.ac b/configure.ac +index 37e8a64..2e85f6f 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -707,9 +707,7 @@ if test x$enable_opkg = xyes; then + fi + + if test x$enable_alpm = xyes; then +- AC_CHECK_HEADER([alpm.h], +- [], +- [AC_MSG_ERROR([No ALPM headers found])]) ++ PKG_CHECK_MODULES(ALPM, libalpm >= 4.1.0) + fi + + if test x$enable_poldek = xyes; then -- cgit v1.2.3-54-g00ecf