/**
* pk_backend_refresh_cache_thread:
*/
static void pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
pk_backend_job_set_allow_cancel(job, true);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug("Failed to create apt cache");
apt->emitFinished();
return;
}
PkBackend *backend = PK_BACKEND(pk_backend_job_get_backend(job));
if (pk_backend_is_online(backend)) {
apt->refreshCache();
if (_error->PendingError() == true) {
show_errors(job, PK_ERROR_ENUM_CANNOT_FETCH_SOURCES, true);
}
} else {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_NO_NETWORK,
"Cannot refresh cache whilst offline");
}
apt->emitFinished();
}
gboolean
pk_backend_spawn_helper (PkBackendSpawn *backend_spawn,
PkBackendJob *job,
const gchar *first_element, ...)
{
gboolean ret = TRUE;
va_list args;
g_return_val_if_fail (PK_IS_BACKEND_SPAWN (backend_spawn), FALSE);
g_return_val_if_fail (first_element != NULL, FALSE);
g_return_val_if_fail (backend_spawn->priv->name != NULL, FALSE);
/* save this */
backend_spawn->priv->is_busy = TRUE;
backend_spawn->priv->job = job;
backend_spawn->priv->backend = g_object_ref (pk_backend_job_get_backend (job));
/* don't auto-kill this */
if (backend_spawn->priv->kill_id > 0) {
g_source_remove (backend_spawn->priv->kill_id);
backend_spawn->priv->kill_id = 0;
}
/* get the argument list */
va_start (args, first_element);
ret = pk_backend_spawn_helper_va_list (backend_spawn, job, first_element, &args);
va_end (args);
return ret;
}
static void
pk_backend_search_db (PkBackendJob *job, alpm_db_t *db, MatchFunc match,
const alpm_list_t *patterns)
{
PkBackend *backend = pk_backend_job_get_backend (job);
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
const alpm_list_t *i, *j;
g_return_if_fail (db != NULL);
g_return_if_fail (match != NULL);
/* emit packages that match all search terms */
for (i = alpm_db_get_pkgcache (db); i != NULL; i = i->next) {
if (pk_backend_job_is_cancelled (job))
break;
for (j = patterns; j != NULL; j = j->next) {
if (!match (i->data, j->data))
break;
}
/* all search terms matched */
if (j == NULL) {
if (db == priv->localdb) {
pk_alpm_pkg_emit (job, i->data,
PK_INFO_ENUM_INSTALLED);
} else if (!pk_alpm_pkg_is_local (job, i->data)) {
pk_alpm_pkg_emit (job, i->data,
PK_INFO_ENUM_AVAILABLE);
}
}
}
}
static gchar *
pk_alpm_pkg_build_replaces (PkBackendJob *job, alpm_pkg_t *pkg)
{
PkBackend *backend = pk_backend_job_get_backend (job);
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
const alpm_list_t *i;
GString *string = NULL;
g_return_val_if_fail (pkg != NULL, NULL);
/* make a list of the packages that package replaces */
for (i = alpm_pkg_get_replaces (pkg); i != NULL; i = i->next) {
alpm_pkg_t *replaces = alpm_db_get_pkg (priv->localdb, i->data);
if (replaces != NULL) {
_cleanup_free_ gchar *package = pk_alpm_pkg_build_id (replaces);
if (string == NULL) {
string = g_string_new (package);
} else {
g_string_append_printf (string, "&%s", package);
}
}
}
if (string == NULL)
return NULL;
return g_string_free (string, FALSE);
}
static gboolean
pk_alpm_pkg_is_local (PkBackendJob *job, alpm_pkg_t *pkg)
{
PkBackend *backend = pk_backend_job_get_backend (job);
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
alpm_pkg_t *local;
g_return_val_if_fail (pkg != NULL, FALSE);
/* find an installed package with the same name */
local = alpm_db_get_pkg (priv->localdb, alpm_pkg_get_name (pkg));
if (local == NULL)
return FALSE;
/* make sure the installed version is the same */
if (alpm_pkg_vercmp (alpm_pkg_get_version (local),
alpm_pkg_get_version (pkg)) != 0) {
return FALSE;
}
/* make sure the installed arch is the same */
if (g_strcmp0 (alpm_pkg_get_arch (local),
alpm_pkg_get_arch (pkg)) != 0) {
return FALSE;
}
return TRUE;
}
static void
pk_backend_get_repo_list_thread (PkBackendJob *job, GVariant *params, gpointer data)
{
PkBackend *backend = pk_backend_job_get_backend (job);
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
const alpm_list_t *i;
/* emit enabled repos */
for (i = alpm_get_syncdbs (priv->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_job_is_cancelled (job))
return;
pk_backend_repo_info (job, repo, TRUE);
}
}
void
pk_alpm_run (PkBackendJob *job, PkStatusEnum status, PkBackendJobThreadFunc func, gpointer data)
{
PkBackend *backend = pk_backend_job_get_backend (job);
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
g_return_if_fail (func != NULL);
if (priv->localdb_changed) {
pk_backend_destroy (backend);
pk_backend_initialize (NULL, backend);
pk_backend_installed_db_changed (backend);
}
pk_backend_job_set_allow_cancel (job, TRUE);
pk_backend_job_set_status (job, status);
pk_backend_job_thread_create (job, func, data, NULL);
}
static void
pk_backend_search_db (PkBackendJob *job, alpm_db_t *db, MatchFunc match,
const alpm_list_t *patterns, PkBitfield filters)
{
PkBackend *backend = pk_backend_job_get_backend (job);
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
const alpm_list_t *i, *j;
g_return_if_fail (db != NULL);
g_return_if_fail (match != NULL);
/* emit packages that match all search terms */
for (i = alpm_db_get_pkgcache (db); i != NULL; i = i->next) {
if (pk_backend_job_is_cancelled (job))
break;
for (j = patterns; j != NULL; j = j->next) {
if (!match (i->data, j->data))
break;
}
/* not all search terms matched */
if (j != NULL)
continue;
/* want applications */
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_APPLICATION) && !pk_alpm_search_is_application (i->data))
continue;
/* don't want applications */
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_APPLICATION) && pk_alpm_search_is_application (i->data))
continue;
if (db == priv->localdb) {
pk_alpm_pkg_emit (job, i->data, PK_INFO_ENUM_INSTALLED);
} else if (!pk_alpm_pkg_is_local (job, i->data)) {
pk_alpm_pkg_emit (job, i->data, PK_INFO_ENUM_AVAILABLE);
}
}
}
static gboolean
pk_alpm_transaction_remove_simulate (PkBackendJob *job, GError **error)
{
PkBackend *backend = pk_backend_job_get_backend (job);
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
const alpm_list_t *i;
if (!pk_alpm_transaction_simulate (job, error))
return FALSE;
for (i = alpm_trans_get_remove (priv->alpm); i != NULL; i = i->next) {
const gchar *name = alpm_pkg_get_name (i->data);
if (alpm_list_find_str (priv->holdpkgs, name)) {
g_set_error (error, PK_ALPM_ERROR, PK_ALPM_ERR_PKG_HELD,
"%s: %s", name,
"could not remove HoldPkg");
return FALSE;
}
}
return TRUE;
}
static gboolean
pk_alpm_transaction_remove_targets (PkBackendJob *job, gchar** packages, GError **error)
{
PkBackend *backend = pk_backend_job_get_backend (job);
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
g_return_val_if_fail (packages != NULL, FALSE);
for (; *packages != NULL; ++packages) {
g_auto(GStrv) package = pk_package_id_split (*packages);
gchar *name = package[PK_PACKAGE_ID_NAME];
alpm_pkg_t *pkg = alpm_db_get_pkg (priv->localdb, name);
if (pkg == NULL || alpm_remove_pkg (priv->alpm, pkg) < 0) {
alpm_errno_t errno = alpm_errno (priv->alpm);
g_set_error (error, PK_ALPM_ERROR, errno, "%s: %s", name,
alpm_strerror (errno));
return FALSE;
}
}
return TRUE;
}
/**
* pk_backend_download_packages_thread:
*/
static void pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
gchar **package_ids;
const gchar *tmpDir;
string directory;
g_variant_get(params, "(^a&ss)",
&package_ids,
&tmpDir);
directory = _config->FindDir("Dir::Cache::archives");
pk_backend_job_set_allow_cancel(job, true);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug("Failed to create apt cache");
return;
}
PkBackend *backend = PK_BACKEND(pk_backend_job_get_backend(job));
if (pk_backend_is_online(backend)) {
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
// Create the progress
AcqPackageKitStatus Stat(apt, job);
// get a fetcher
pkgAcquire fetcher(&Stat);
gchar *pi;
// TODO this might be useful when the item is in the cache
// for (pkgAcquire::ItemIterator I = fetcher.ItemsBegin(); I < fetcher.ItemsEnd();)
// {
// if ((*I)->Local == true)
// {
// I++;
// continue;
// }
//
// // Close the item and check if it was found in cache
// (*I)->Finished();
// if ((*I)->Complete == false) {
// Transient = true;
// }
//
// // Clear it out of the fetch list
// delete *I;
// I = fetcher.ItemsBegin();
// }
for (uint i = 0; i < g_strv_length(package_ids); ++i) {
pi = package_ids[i];
if (pk_package_id_check(pi) == false) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_ID_INVALID,
"%s",
pi);
return;
}
if (apt->cancelled()) {
break;
}
const pkgCache::VerIterator &ver = apt->aptCacheFile()->resolvePkgID(pi);
// Ignore packages that could not be found or that exist only due to dependencies.
if (ver.end()) {
_error->Error("Can't find this package id \"%s\".", pi);
continue;
} else {
if(!ver.Downloadable()) {
_error->Error("No downloadable files for %s,"
"perhaps it is a local or obsolete" "package?",
pi);
continue;
}
string storeFileName;
if (!apt->getArchive(&fetcher,
ver,
directory,
storeFileName)) {
return;
}
gchar **files = (gchar **) g_malloc(2 * sizeof(gchar *));
files[0] = g_strdup_printf("%s/%s", directory.c_str(), flNotDir(storeFileName).c_str());
files[1] = NULL;
pk_backend_job_files(job, pi, files);
g_strfreev(files);
}
}
if (fetcher.Run() != pkgAcquire::Continue
&& apt->cancelled() == false) {
// We failed and we did not cancel
show_errors(job, PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED);
return;
}
} else {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_NO_NETWORK,
"Cannot download packages whilst offline");
}
}
static void
pk_backend_search_thread (PkBackendJob *job, GVariant* params, gpointer p)
{
PkBackend *backend = pk_backend_job_get_backend (job);
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
gchar **needles = NULL;
SearchType type;
PatternFunc pattern_func;
GDestroyNotify pattern_free;
MatchFunc match_func;
PkRoleEnum role;
PkBitfield filters = 0;
gboolean skip_local, skip_remote;
const alpm_list_t *i;
alpm_list_t *patterns = NULL;
_cleanup_error_free_ GError *error = NULL;
g_return_if_fail (p == NULL);
role = pk_backend_job_get_role(job);
switch(role) {
case PK_ROLE_ENUM_GET_PACKAGES:
type = SEARCH_TYPE_ALL;
g_variant_get (params, "(t)", &filters);
break;
case PK_ROLE_ENUM_GET_DETAILS:
type = SEARCH_TYPE_DETAILS;
g_variant_get (params, "(^a&s)", &needles);
break;
case PK_ROLE_ENUM_SEARCH_FILE:
type = SEARCH_TYPE_FILES;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_SEARCH_GROUP:
type = SEARCH_TYPE_GROUP;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_SEARCH_NAME:
type = SEARCH_TYPE_NAME;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_WHAT_PROVIDES:
type = SEARCH_TYPE_PROVIDES;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_SEARCH_DETAILS:
type = SEARCH_TYPE_DETAILS;
g_variant_get (params, "(t^a&s)",
&filters,
&needles);
break;
default:
g_assert_not_reached ();
break;
}
g_return_if_fail (type < SEARCH_TYPE_LAST);
pattern_func = pattern_funcs[type];
pattern_free = pattern_frees[type];
match_func = match_funcs[type];
g_return_if_fail (pattern_func != NULL);
g_return_if_fail (match_func != NULL);
skip_local = pk_bitfield_contain (filters,
PK_FILTER_ENUM_NOT_INSTALLED);
skip_remote = pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED);
/* convert search terms to the pattern requested */
if (needles) {
for (; *needles != NULL; ++needles) {
gpointer pattern = pattern_func (backend, *needles, &error);
if (pattern == NULL)
goto out;
patterns = alpm_list_add (patterns, pattern);
}
}
/* find installed packages first */
if (!skip_local)
pk_backend_search_db (job, priv->localdb, match_func, patterns);
if (skip_remote)
goto out;
for (i = alpm_get_syncdbs (priv->alpm); i != NULL; i = i->next) {
if (pk_backend_job_is_cancelled (job))
break;
pk_backend_search_db (job, i->data, match_func, patterns);
}
out:
if (pattern_free != NULL)
alpm_list_free_inner (patterns, pattern_free);
alpm_list_free (patterns);
pk_alpm_finish (job, error);
}
