archlinuxarm/PKGBUILDs
1
0
Fork 0
mirror of https://github.com/archlinuxarm/PKGBUILDs.git synced 2024-12-08 23:03:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
PKGBUILDs/community/packagekit/alpm.patch

1622 lines
50 KiB
Diff
Raw Normal View History

added community/packagekit
2013-05-17 01:26:07 +00:00
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..03adb47 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);
+}
- if (alpm_list_find_str (config->repos, repo) == NULL) {
- config->repos = alpm_list_add (config->repos, g_strdup (repo));
+static PkBackendConfigSection *
+pk_backend_config_enter_section (PkBackendConfig *config, const gchar *name)
+{
+ PkBackendConfigSection *section;
+
+ 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;
-
- 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;
- }
- }
+ g_return_if_fail (config != NULL);
+ g_return_if_fail (section != NULL);
+ g_return_if_fail (words != NULL);
- 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 <alpm.h>
#include <pk-backend.h>
-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..554f06d 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;
}
@@ -316,7 +321,6 @@ pk_backend_transaction_conv_cb (alpm_question_t question, gpointer data1,
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;
@@ -388,6 +392,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, "<b>%s</b>\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 +442,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 +451,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 +485,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 +517,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 +625,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 +673,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 +695,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 +786,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 +855,7 @@ alpm_depend_free (alpm_depend_t *depend)
{
free (depend->name);
free (depend->version);
+ free (depend->desc);
free (depend);
}
@@ -731,7 +895,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 +1001,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 +1123,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 +1157,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..4a33dbd 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 >= 8.0.1)
fi
if test x$enable_poldek = xyes; then
Reference in a new issue Copy permalink