static gboolean pk_backend_install_files_thread (PkBackendJob *self) { gboolean only_trusted; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); only_trusted = pk_backend_get_bool (self, "only_trusted"); if (!only_trusted && !pk_backend_disable_signatures (self, &error)) { goto out; } if (pk_backend_transaction_initialize (self, 0, &error) && pk_backend_transaction_add_targets (self, &error) && pk_backend_transaction_simulate (self, &error)) { pk_backend_transaction_commit (self, &error); } out: pk_backend_transaction_end (self, (error == NULL) ? &error : NULL); if (!only_trusted) { GError **e = (error == NULL) ? &error : NULL; pk_backend_enable_signatures (self, e); } return pk_backend_finish (self, error); }
static gboolean pk_backend_resolve_thread (PkBackend *self) { gchar **packages; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); for (; *packages != NULL; ++packages) { if (pk_backend_cancelled (self)) { break; } /* find a package with the given id or name */ if (pk_package_id_check (*packages)) { if (!pk_backend_resolve_package (self, *packages, &error)) { break; } } else { if (!pk_backend_resolve_name (self, *packages, &error)) { break; } } } return pk_backend_finish (self, error); }
gboolean pk_backend_transaction_finish (PkBackend *self, GError *error) { g_return_val_if_fail (self != NULL, FALSE); pk_backend_transaction_end (self, (error == NULL) ? &error : NULL); return pk_backend_finish (self, error); }
static gboolean pk_backend_depends_on_thread (PkBackend *self) { gchar **packages; alpm_list_t *i, *pkgs = NULL; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); /* construct an initial package list */ for (; *packages != NULL; ++packages) { alpm_pkg_t *pkg; if (pk_backend_cancelled (self)) { break; } pkg = pk_backend_find_pkg (self, *packages, &error); if (pkg == NULL) { break; } pkgs = alpm_list_add (pkgs, pkg); } /* package list might be modified along the way but that is ok */ for (i = pkgs; i != NULL; i = i->next) { const alpm_list_t *depends; if (pk_backend_cancelled (self) || error != NULL) { break; } depends = alpm_pkg_depends_on (i->data); for (; depends != NULL; depends = depends->next) { gchar *depend; if (pk_backend_cancelled (self) || error != NULL) { break; } depend = alpm_dep_compute_string (depends->data); pkgs = pk_backend_find_provider (self, pkgs, depend, &error); free (depend); } } alpm_list_free (pkgs); return pk_backend_finish (self, NULL); }
static gboolean pk_backend_required_by_thread (PkBackend *self) { gchar **packages; alpm_list_t *i, *pkgs = NULL; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); /* construct an initial package list */ for (; *packages != NULL; ++packages) { alpm_pkg_t *pkg; if (pk_backend_cancelled (self)) { break; } pkg = pk_backend_find_pkg (self, *packages, &error); if (pkg == NULL) { break; } pkgs = alpm_list_add (pkgs, pkg); } /* package list might be modified along the way but that is ok */ for (i = pkgs; i != NULL; i = i->next) { alpm_list_t *requiredby; if (pk_backend_cancelled (self) || error != NULL) { break; } requiredby = alpm_pkg_compute_requiredby (i->data); for (; requiredby != NULL; requiredby = requiredby->next) { if (pk_backend_cancelled (self) || error != NULL) { break; } pkgs = pk_backend_find_requirer (self, pkgs, requiredby->data, &error); } FREELIST (requiredby); } alpm_list_free (pkgs); return pk_backend_finish (self, error); }
static gboolean pk_backend_refresh_cache_thread (PkBackend *self) { gint force; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); /* download databases even if they are older than current */ force = (gint) pk_backend_get_bool (self, "force"); pk_backend_update_databases (self, force, &error); return pk_backend_finish (self, error); }
static gboolean pk_backend_get_updates_thread (PkBackend *self) { struct stat cache; time_t one_hour_ago; const alpm_list_t *i, *syncdbs; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (localdb != NULL, FALSE); time (&one_hour_ago); one_hour_ago -= 60 * 60; /* refresh databases if they are older than an hour */ if (g_stat (ALPM_CACHE_PATH, &cache) < 0 || cache.st_mtime < one_hour_ago) { GError *error = NULL; /* show updates even if the databases could not be updated */ if (!pk_backend_update_databases (self, 0, &error)) { g_warning ("%s", error->message); } } else { g_debug ("databases have been refreshed recently"); } /* find outdated and replacement packages */ syncdbs = alpm_option_get_syncdbs (); for (i = alpm_db_get_pkgcache (localdb); i != NULL; i = i->next) { pmpkg_t *upgrade = alpm_pkg_find_update (i->data, syncdbs); if (pk_backend_cancelled (self)) { break; } else if (upgrade != NULL) { PkInfoEnum info; if (alpm_pkg_is_ignorepkg (upgrade)) { info = PK_INFO_ENUM_BLOCKED; } else if (alpm_pkg_is_syncfirst (upgrade)) { info = PK_INFO_ENUM_IMPORTANT; } else { info = PK_INFO_ENUM_NORMAL; } pk_backend_pkg (self, upgrade, info); } } return pk_backend_finish (self, NULL); }
static gboolean pk_backend_get_files_thread (PkBackend *self) { gchar **packages; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); for (; *packages != NULL; ++packages) { alpm_pkg_t *pkg; const gchar *root; GString *files; alpm_filelist_t *filelist; gsize i; if (pk_backend_cancelled (self)) { break; } pkg = pk_backend_find_pkg (self, *packages, &error); if (pkg == NULL) { break; } root = alpm_option_get_root (alpm); files = g_string_new (""); filelist = alpm_pkg_get_files (pkg); for (i = 0; i < filelist->count; ++i) { const gchar *file = filelist->files[i].name; g_string_append_printf (files, "%s%s;", root, file); } g_string_truncate (files, MAX (files->len, 1) - 1); pk_backend_job_files (self, *packages, files->str); g_string_free (files, TRUE); } return pk_backend_finish (self, error); }
static gboolean pk_backend_get_repo_list_thread (PkBackend *self) { const alpm_list_t *i; GHashTableIter iter; gpointer key, value; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); /* emit enabled repos */ for (i = alpm_get_syncdbs (alpm); i != NULL; i = i->next) { alpm_db_t *db = (alpm_db_t *) i->data; const gchar *repo = alpm_db_get_name (db); if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, TRUE); } } /* emit disabled repos */ g_hash_table_iter_init (&iter, disabled); while (g_hash_table_iter_next (&iter, &key, &value)) { const gchar *repo = (const gchar *) key; if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, FALSE); } } out: return pk_backend_finish (self, NULL); }
static void pk_backend_get_repo_list_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { const alpm_list_t *i; GHashTableIter iter; gpointer key, value; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); /* emit enabled repos */ for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) { pmdb_t *db = (pmdb_t *) i->data; const gchar *repo = alpm_db_get_name (db); if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, TRUE); } } /* emit disabled repos */ g_hash_table_iter_init (&iter, disabled); while (g_hash_table_iter_next (&iter, &key, &value)) { const gchar *repo = (const gchar *) key; if (pk_backend_cancelled (self)) { goto out; } else { pk_backend_repo_info (self, repo, FALSE); } } out: pk_backend_finish (self, NULL); }
static gboolean pk_backend_get_update_detail_thread (PkBackend *self) { gchar **packages; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (localdb != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); /* collect details about updates */ for (; *packages != NULL; ++packages) { pmpkg_t *pkg, *old; pmdb_t *db; gchar *upgrades, *replaces, *urls; const gchar *reason; PkRestartEnum restart; PkUpdateStateEnum state; GTimeVal built = { 0 }, installed = { 0 }; gchar *issued, *updated; if (pk_backend_cancelled (self)) { break; } pkg = pk_backend_find_pkg (self, *packages, &error); if (pkg == NULL) { break; } old = alpm_db_get_pkg (localdb, alpm_pkg_get_name (pkg)); if (old != NULL) { upgrades = alpm_pkg_build_id (old); if (alpm_pkg_same_pkgver (pkg, old)) { reason = "Update to a newer release"; } else { reason = "Update to a new upstream version"; } } else { upgrades = NULL; reason = "Install to replace an older package"; } db = alpm_pkg_get_db (pkg); replaces = alpm_pkg_build_replaces (pkg); urls = alpm_pkg_build_urls (pkg); if (g_str_has_prefix (alpm_pkg_get_name (pkg), "kernel")) { restart = PK_RESTART_ENUM_SYSTEM; } else { restart = PK_RESTART_ENUM_NONE; } if (g_str_has_suffix (alpm_db_get_name (db), "testing")) { state = PK_UPDATE_STATE_ENUM_TESTING; } else { 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); } 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); } else { updated = NULL; } } else { updated = NULL; } pk_backend_update_detail (self, *packages, upgrades, replaces, urls, NULL, NULL, restart, reason, NULL, state, issued, updated); g_free (issued); g_free (updated); g_free (urls); g_free (replaces); g_free (upgrades); } return pk_backend_finish (self, error); }
static gboolean pk_backend_get_details_thread (PkBackend *self) { gchar **packages; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (localdb != NULL, FALSE); packages = pk_backend_get_strv (self, "package_ids"); g_return_val_if_fail (packages != NULL, FALSE); for (; *packages != NULL; ++packages) { alpm_pkg_t *pkg; const alpm_list_t *i; GString *licenses; PkGroupEnum group; const gchar *desc, *url; gulong size; if (pk_backend_cancelled (self)) { break; } pkg = pk_backend_find_pkg (self, *packages, &error); if (pkg == NULL) { break; } i = alpm_pkg_get_licenses (pkg); if (i == NULL) { licenses = g_string_new ("Unknown"); } else { licenses = g_string_new ((const gchar *) i->data); while ((i = i->next) != NULL) { const gchar *license = (const gchar *) i->data; /* assume OR although it may not be correct */ g_string_append_printf (licenses, " or %s", license); } } group = pk_group_enum_from_string (alpm_pkg_get_group (pkg)); desc = alpm_pkg_get_desc (pkg); url = alpm_pkg_get_url (pkg); if (alpm_pkg_get_origin (pkg) == ALPM_PKG_FROM_LOCALDB) { size = alpm_pkg_get_isize (pkg); } else { size = alpm_pkg_download_size (pkg); } pk_backend_job_details (self, *packages, licenses->str, group, desc, url, size); g_string_free (licenses, TRUE); } return pk_backend_finish (self, error); }