static gboolean backend_get_depends_requires_thread (PkBackend *backend) { GList *list = NULL; sqlite3 *db; gchar **package_ids; int deps_type; gchar **package_id_data; db = db_open (); package_ids = pk_backend_get_strv (backend, "package_ids"); deps_type = pk_backend_get_uint (backend, "type"); /* FIXME: support multiple packages */ package_id_data = pk_package_id_split (package_ids[0]); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); if (deps_type == DEPS_TYPE_DEPENDS) list = box_db_repos_get_depends (db, package_id_data[PK_PACKAGE_ID_NAME]); else if (deps_type == DEPS_TYPE_REQUIRES) list = box_db_repos_get_requires (db, package_id_data[PK_PACKAGE_ID_NAME]); add_packages_from_list (backend, list, FALSE); box_db_repos_package_list_free (list); db_close (db); pk_backend_finished (backend); return TRUE; }
static void backend_install_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { gint err, i; gchar **package_ids; gchar **parts; package_ids = pk_backend_get_strv (backend, "pkids"); err = 0; for (i = 0; package_ids[i]; i++) { pk_backend_job_package (job, PK_INFO_ENUM_INSTALLING, package_ids[i], NULL); parts = pk_package_id_split (package_ids[i]); err = opkg_install_package (parts[PK_PACKAGE_ID_NAME], pk_opkg_progress_cb, backend); if (err) handle_install_error (backend, err); g_strfreev (parts); if (err != 0) break; } pk_backend_job_finished (job); }
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); }
static gboolean backend_get_details_thread (PkBackend *backend) { PackageSearch *ps; GList *list; sqlite3 *db; gchar **package_ids; gchar **package_id_data; package_ids = pk_backend_get_strv (backend, "package_ids"); /* FIXME: support multiple packages */ package_id_data = pk_package_id_split (package_ids[0]); db = db_open (); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); /* only one element is returned */ list = box_db_repos_packages_search_by_data (db, package_id_data[PK_PACKAGE_ID_NAME], package_id_data[PK_PACKAGE_ID_VERSION]); if (list == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "cannot find package by id"); db_close (db); return FALSE; } ps = (PackageSearch*) list->data; pk_backend_details (backend, package_ids[0], "unknown", PK_GROUP_ENUM_OTHER, ps->description, "", 0); box_db_repos_package_list_free (list); db_close (db); pk_backend_finished (backend); return TRUE; }
static gboolean backend_install_packages_thread (PkBackend *backend) { gint err, i; gchar **package_ids; gchar **parts; package_ids = pk_backend_get_strv (backend, "pkids"); err = 0; for (i = 0; package_ids[i]; i++) { pk_backend_package (backend, PK_INFO_ENUM_INSTALLING, package_ids[i], NULL); parts = pk_package_id_split (package_ids[i]); err = opkg_install_package (parts[PK_PACKAGE_ID_NAME], pk_opkg_progress_cb, backend); if (err) handle_install_error (backend, err); g_strfreev (parts); if (err != 0) break; } pk_backend_finished (backend); return (err == 0); }
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 backend_get_files_thread (PkBackend *backend) { gchar **package_ids; gchar *pi; package_ids = pk_backend_get_strv (backend, "package_ids"); if (package_ids == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "Invalid package id"); pk_backend_finished (backend); return false; } aptcc *m_apt = new aptcc(backend, _cancel); pk_backend_set_pointer(backend, "aptcc_obj", m_apt); if (m_apt->init()) { egg_debug ("Failed to create apt cache"); delete m_apt; pk_backend_finished (backend); return false; } pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); for (uint i = 0; i < g_strv_length(package_ids); i++) { pi = package_ids[i]; if (pk_package_id_check(pi) == false) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, pi); delete m_apt; pk_backend_finished (backend); return false; } pair<pkgCache::PkgIterator, pkgCache::VerIterator> pkg_ver; pkg_ver = m_apt->find_package_id(pi); if (pkg_ver.second.end() == true) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "Couldn't find package"); delete m_apt; pk_backend_finished (backend); return false; } emit_files (backend, pi); } delete m_apt; pk_backend_finished (backend); return true; }
static void backend_install_files_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { gboolean result; gchar **full_paths; pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY); full_paths = pk_backend_get_strv (backend, "full_paths"); result = box_package_install (full_paths[0], ROOT_DIRECTORY, common_progress, backend, FALSE); pk_backend_job_finished (job); return result; }
static gboolean backend_install_files_thread (PkBackend *backend) { gboolean result; gchar **full_paths; pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); full_paths = pk_backend_get_strv (backend, "full_paths"); result = box_package_install (full_paths[0], ROOT_DIRECTORY, common_progress, backend, FALSE); pk_backend_finished (backend); return result; }
/** * backend_get_details: */ static gboolean backend_get_details_thread (PkBackend *backend) { gchar **package_ids; gchar **parts; int group_index; PkGroupEnum group = 0; pkg_t *pkg; gchar *newid; package_ids = pk_backend_get_strv(backend, "package_ids"); parts = pk_package_id_split (package_ids[0]); if (!parts) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "invalid package id"); pk_backend_finished (backend); return FALSE; } pkg = opkg_find_package (parts[PK_PACKAGE_ID_NAME], parts[PK_PACKAGE_ID_VERSION], parts[PK_PACKAGE_ID_ARCH], parts[PK_PACKAGE_ID_DATA]); g_strfreev (parts); if (!pkg) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, NULL); pk_backend_finished (backend); return FALSE; } newid = g_strdup_printf ("%s;%s;%s;%s", pkg->name, pkg->version, pkg->architecture, pkg->src->name); if (pkg->tags) { for (group_index = 0; group < PK_GROUP_ENUM_LAST; group_index++) { group = 1 << group_index; if (!(group & backend_get_groups(backend))) continue; if (opkg_check_tag(pkg, (const gchar *)pk_group_enum_to_string(group))) break; } } pk_backend_details (backend, newid, NULL, group, pkg->description, NULL, pkg->size); g_free (newid); pk_backend_finished (backend); return TRUE; }
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 void backend_update_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { gboolean result = TRUE; gchar **package_ids; size_t i; pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY); /* FIXME: support only_trusted */ package_ids = pk_backend_get_strv (backend, "package_ids"); for (i = 0; i < g_strv_length (package_ids); i++) { result |= box_package_install (package_ids[i], ROOT_DIRECTORY, common_progress, backend, FALSE); } pk_backend_job_finished (job); }
static void backend_remove_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { gchar **package_ids; gchar **package_id_data; package_ids = pk_backend_get_strv (backend, "package_ids"); /* FIXME: support multiple packages */ package_id_data = pk_package_id_split (package_ids[0]); pk_backend_job_set_status (job, PK_STATUS_ENUM_REMOVE); if (!box_package_uninstall (package_id_data[PK_PACKAGE_ID_NAME], ROOT_DIRECTORY, common_progress, backend, FALSE)) { pk_backend_job_error_code (job, PK_ERROR_ENUM_DEP_RESOLUTION_FAILED, "Cannot uninstall"); } pk_backend_finished (backend); }
static gboolean backend_update_packages_thread (PkBackend *backend) { gboolean result = TRUE; gchar **package_ids; size_t i; pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); /* FIXME: support only_trusted */ package_ids = pk_backend_get_strv (backend, "package_ids"); for (i = 0; i < g_strv_length (package_ids); i++) { result |= box_package_install (package_ids[i], ROOT_DIRECTORY, common_progress, backend, FALSE); } pk_backend_finished (backend); return result; }
static gboolean backend_remove_packages_thread (PkBackend *backend) { gchar **package_ids; gchar **package_id_data; package_ids = pk_backend_get_strv (backend, "package_ids"); /* FIXME: support multiple packages */ package_id_data = pk_package_id_split (package_ids[0]); pk_backend_set_status (backend, PK_STATUS_ENUM_REMOVE); if (!box_package_uninstall (package_id_data[PK_PACKAGE_ID_NAME], ROOT_DIRECTORY, common_progress, backend, FALSE)) { pk_backend_error_code (backend, PK_ERROR_ENUM_DEP_RESOLUTION_FAILED, "Cannot uninstall"); } pk_backend_finished (backend); return TRUE; }
static PacmanList * backend_remove_list_targets (PkBackend *backend) { gchar **package_ids; guint iterator; PacmanList *list = NULL; g_return_val_if_fail (backend != NULL, NULL); package_ids = pk_backend_get_strv (backend, "package_ids"); g_return_val_if_fail (package_ids != NULL, NULL); for (iterator = 0; package_ids[iterator] != NULL; ++iterator) { gchar **package_id_data = pk_package_id_split (package_ids[iterator]); list = pacman_list_add (list, g_strdup (package_id_data[PK_PACKAGE_ID_NAME])); g_strfreev (package_id_data); } return list; }
static gboolean pk_backend_transaction_add_targets (PkBackend *self, GError **error) { gchar **paths; g_return_val_if_fail (self != NULL, FALSE); paths = pk_backend_get_strv (self, "full_paths"); g_return_val_if_fail (paths != NULL, FALSE); for (; *paths != NULL; ++paths) { if (alpm_add_file (*paths) < 0) { alpm_errno_t errno = alpm_errno (alpm); g_set_error (error, ALPM_ERROR, errno, "%s: %s", *paths, alpm_strerror (errno)); return FALSE; } } return TRUE; }
static void backend_get_files_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { gchar *files; sqlite3 *db; gchar **package_ids; gchar **package_id_data; db = db_open(); package_ids = pk_backend_get_strv (backend, "package_ids"); /* FIXME: support multiple packages */ package_id_data = pk_package_id_split (package_ids[0]); pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY); files = box_db_repos_get_files_string (db, package_id_data[PK_PACKAGE_ID_NAME], package_id_data[PK_PACKAGE_ID_VERSION]); pk_backend_job_files (job, package_ids[0], files); db_close (db); g_free (files); pk_backend_finished (backend); }
static gboolean backend_get_files_thread (PkBackend *backend) { gchar *files; sqlite3 *db; gchar **package_ids; gchar **package_id_data; db = db_open(); package_ids = pk_backend_get_strv (backend, "package_ids"); /* FIXME: support multiple packages */ package_id_data = pk_package_id_split (package_ids[0]); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); files = box_db_repos_get_files_string (db, package_id_data[PK_PACKAGE_ID_NAME], package_id_data[PK_PACKAGE_ID_VERSION]); pk_backend_files (backend, package_ids[0], files); db_close (db); g_free (files); pk_backend_finished (backend); return TRUE; }
static gboolean backend_manage_packages_thread (PkBackend *backend) { gchar **package_ids; gchar *pi; bool simulate; bool remove; package_ids = pk_backend_get_strv (backend, "package_ids"); simulate = pk_backend_get_bool (backend, "simulate"); remove = pk_backend_get_bool (backend, "remove"); pk_backend_set_allow_cancel (backend, true); aptcc *m_apt = new aptcc(backend, _cancel); pk_backend_set_pointer(backend, "aptcc_obj", m_apt); if (m_apt->init()) { egg_debug ("Failed to create apt cache"); delete m_apt; pk_backend_finished (backend); return false; } pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); vector<pair<pkgCache::PkgIterator, pkgCache::VerIterator> > pkgs; for (uint i = 0; i < g_strv_length(package_ids); i++) { if (_cancel) { break; } pi = package_ids[i]; if (pk_package_id_check(pi) == false) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, pi); delete m_apt; pk_backend_finished (backend); return false; } pair<pkgCache::PkgIterator, pkgCache::VerIterator> pkg_ver; pkg_ver = m_apt->find_package_id(pi); // Ignore packages that could not be found or that exist only due to dependencies. if (pkg_ver.second.end() == true) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "couldn't find package"); delete m_apt; pk_backend_finished (backend); return false; } else { pkgs.push_back(pkg_ver); } } if (!m_apt->runTransaction(pkgs, simulate, remove)) { // Print transaction errors cout << "runTransaction failed" << endl; delete m_apt; pk_backend_finished (backend); return false; } delete m_apt; pk_backend_finished (backend); return true; }
/** * backend_download_packages_thread: */ static gboolean backend_download_packages_thread (PkBackend *backend) { gchar **package_ids; string directory; package_ids = pk_backend_get_strv(backend, "package_ids"); directory = _config->FindDir("Dir::Cache::archives") + "partial/"; pk_backend_set_allow_cancel (backend, true); aptcc *m_apt = new aptcc(backend, _cancel); pk_backend_set_pointer(backend, "aptcc_obj", m_apt); if (m_apt->init()) { egg_debug ("Failed to create apt cache"); delete m_apt; pk_backend_finished (backend); return false; } pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); // Create the progress AcqPackageKitStatus Stat(m_apt, backend, _cancel); // get a fetcher pkgAcquire fetcher(&Stat); string filelist; 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_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, pi); delete m_apt; pk_backend_finished (backend); return false; } if (_cancel) { break; } pair<pkgCache::PkgIterator, pkgCache::VerIterator> pkg_ver; pkg_ver = m_apt->find_package_id(pi); // Ignore packages that could not be found or that exist only due to dependencies. if (pkg_ver.second.end() == true) { _error->Error("Can't find this package id \"%s\".", pi); continue; } else { if(!pkg_ver.second.Downloadable()) { _error->Error("No downloadable files for %s," "perhaps it is a local or obsolete" "package?", pi); continue; } string storeFileName; if (get_archive(&fetcher, m_apt->packageSourceList, m_apt->packageRecords, pkg_ver.second, directory, storeFileName)) { Stat.addPackagePair(pkg_ver); } string destFile = directory + "/" + flNotDir(storeFileName); if (filelist.empty()) { filelist = destFile; } else { filelist.append(";" + destFile); } } } if (fetcher.Run() != pkgAcquire::Continue && _cancel == false) // We failed and we did not cancel { show_errors(backend, PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED); delete m_apt; pk_backend_finished (backend); return _cancel; } // send the filelist pk_backend_files(backend, NULL, filelist.c_str()); delete m_apt; pk_backend_finished (backend); return true; }
static gboolean backend_resolve_thread (PkBackend *backend) { gchar **package_ids; PkBitfield filters; filters = (PkBitfield) pk_backend_get_uint (backend, "filters"); package_ids = pk_backend_get_strv (backend, "package_ids"); pk_backend_set_allow_cancel (backend, true); aptcc *m_apt = new aptcc(backend, _cancel); pk_backend_set_pointer(backend, "aptcc_obj", m_apt); if (m_apt->init()) { egg_debug ("Failed to create apt cache"); delete m_apt; pk_backend_finished (backend); return false; } pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); gchar *pi; vector<pair<pkgCache::PkgIterator, pkgCache::VerIterator> > output; for (uint i = 0; i < g_strv_length(package_ids); i++) { if (_cancel) { break; } pair<pkgCache::PkgIterator, pkgCache::VerIterator> pkg_ver; pi = package_ids[i]; if (pk_package_id_check(pi) == false) { pkg_ver.first = m_apt->packageCache->FindPkg(pi); // Ignore packages that could not be found or that exist only due to dependencies. if (pkg_ver.first.end() == true || (pkg_ver.first.VersionList().end() && pkg_ver.first.ProvidesList().end())) { continue; } pkg_ver.second = m_apt->find_ver(pkg_ver.first); // check to see if the provided package isn't virtual too if (pkg_ver.second.end() == false) { output.push_back(pkg_ver); } pkg_ver.second = m_apt->find_candidate_ver(pkg_ver.first); // check to see if the provided package isn't virtual too if (pkg_ver.second.end() == false) { output.push_back(pkg_ver); } } else { pkg_ver = m_apt->find_package_id(pi); // check to see if we found the package if (pkg_ver.second.end() == false) { output.push_back(pkg_ver); } } } // It's faster to emmit the packages here rather than in the matching part m_apt->emit_packages(output, filters); delete m_apt; pk_backend_finished (backend); return true; }
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); }
static gboolean backend_get_depends_or_requires_thread (PkBackend *backend) { gchar **package_ids; PkBitfield filters; gchar *pi; bool recursive; package_ids = pk_backend_get_strv (backend, "package_ids"); filters = (PkBitfield) pk_backend_get_uint (backend, "filters"); recursive = pk_backend_get_bool (backend, "recursive"); pk_backend_set_allow_cancel (backend, true); aptcc *m_apt = new aptcc(backend, _cancel); pk_backend_set_pointer(backend, "aptcc_obj", m_apt); if (m_apt->init()) { egg_debug ("Failed to create apt cache"); delete m_apt; pk_backend_finished (backend); return false; } bool depends = pk_backend_get_bool(backend, "get_depends"); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); vector<pair<pkgCache::PkgIterator, pkgCache::VerIterator> > output; for (uint i = 0; i < g_strv_length(package_ids); i++) { if (_cancel) { break; } pi = package_ids[i]; if (pk_package_id_check(pi) == false) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, pi); delete m_apt; pk_backend_finished (backend); return false; } pair<pkgCache::PkgIterator, pkgCache::VerIterator> pkg_ver; pkg_ver = m_apt->find_package_id(pi); if (pkg_ver.second.end() == true) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "Couldn't find package"); delete m_apt; pk_backend_finished (backend); return false; } if (depends) { m_apt->get_depends(output, pkg_ver.first, recursive); } else { m_apt->get_requires(output, pkg_ver.first, recursive); } } // It's faster to emmit the packages here than in the matching part m_apt->emit_packages(output, filters); delete m_apt; pk_backend_finished (backend); return true; }
static gboolean backend_get_update_detail_thread (PkBackend *backend) { guint iterator; gchar **package_ids; g_return_val_if_fail (local_database != NULL, FALSE); g_return_val_if_fail (backend != NULL, FALSE); package_ids = pk_backend_get_strv (backend, "package_ids"); g_return_val_if_fail (package_ids != NULL, FALSE); /* collect details about updates */ for (iterator = 0; package_ids[iterator] != NULL; ++iterator) { PacmanPackage *package, *upgrades; PacmanDatabase *database; gchar *upgrades_id, *replaces_ids, *vendor_url; const gchar *message; PkRestartEnum restart; PkUpdateStateEnum state; GTimeVal built = { 0 }, installed = { 0 }; gchar *issued, *updated; if (backend_cancelled (backend)) { break; } package = backend_get_package (backend, package_ids[iterator]); if (package == NULL) { backend_finished (backend); return FALSE; } upgrades = pacman_database_find_package (local_database, pacman_package_get_name (package)); if (upgrades != NULL) { upgrades_id = pacman_package_make_id (upgrades); if (pacman_package_compare_pkgver (package, upgrades) != 0) { message = "Update to newest upstream version"; } else { message = "Update to newest release"; } } else { upgrades_id = NULL; message = "Install as a replacement for an older package"; } database = pacman_package_get_database (package); replaces_ids = pacman_package_make_replaces_ids (package); vendor_url = pacman_package_make_vendor_url (package); if (g_str_has_prefix (pacman_package_get_name (package), "kernel")) { restart = PK_RESTART_ENUM_SYSTEM; } else { restart = PK_RESTART_ENUM_NONE; } if (g_str_has_suffix (pacman_database_get_name (database), "testing")) { state = PK_UPDATE_STATE_ENUM_TESTING; } else { state = PK_UPDATE_STATE_ENUM_STABLE; } built.tv_sec = pacman_package_get_build_date (package); if (built.tv_sec > 0) { issued = g_time_val_to_iso8601 (&built); } else { issued = NULL; } if (upgrades != NULL) { installed.tv_sec = pacman_package_get_install_date (upgrades); if (installed.tv_sec > 0) { updated = g_time_val_to_iso8601 (&installed); } else { updated = NULL; } } else { updated = NULL; } pk_backend_update_detail (backend, package_ids[iterator], upgrades_id, replaces_ids, vendor_url, NULL, NULL, restart, message, NULL, state, issued, updated); g_free (issued); g_free (updated); g_free (vendor_url); g_free (replaces_ids); g_free (upgrades_id); } backend_finished (backend); return TRUE; }
static gboolean backend_find_packages_thread (PkBackend *backend) { PkBitfield filters; const gchar *search; gchar **values; guint mode; GList *list = NULL; sqlite3 *db = NULL; gint filter_box = 0; filters = pk_backend_get_uint (backend, "filters"); mode = pk_backend_get_uint (backend, "mode"); values = pk_backend_get_strv (backend, "search"); /* FIXME: support multiple packages */ search = values[0]; pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) { filter_box = filter_box | PKG_INSTALLED; } if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) { filter_box = filter_box | PKG_AVAILABLE; } if (pk_bitfield_contain (filters, PK_FILTER_ENUM_DEVELOPMENT)) { filter_box = filter_box | PKG_DEVEL; } if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_DEVELOPMENT)) { filter_box = filter_box | PKG_NON_DEVEL; } if (pk_bitfield_contain (filters, PK_FILTER_ENUM_GUI)) { filter_box = filter_box | PKG_GUI; } if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_GUI)) { filter_box = filter_box | PKG_TEXT; } if (mode == SEARCH_TYPE_DETAILS) { filter_box = filter_box | PKG_SEARCH_DETAILS; } pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID); db = db_open (); if (mode == SEARCH_TYPE_FILE) { list = box_db_repos_search_file_with_filter (db, search, filter_box); add_packages_from_list (backend, list, FALSE); box_db_repos_package_list_free (list); } else if (mode == SEARCH_TYPE_RESOLVE) { list = box_db_repos_packages_search_one (db, (gchar *)search); add_packages_from_list (backend, list, FALSE); box_db_repos_package_list_free (list); } else { if ((pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED) && pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) || (!pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED) && !pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED))) { list = box_db_repos_packages_search_all (db, (gchar *)search, filter_box); } else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) { list = box_db_repos_packages_search_installed (db, (gchar *)search, filter_box); } else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) { list = box_db_repos_packages_search_available (db, (gchar *)search, filter_box); } add_packages_from_list (backend, list, FALSE); box_db_repos_package_list_free (list); } db_close (db); pk_backend_finished (backend); return TRUE; }
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); }