static gboolean backend_get_packages_thread (PkBackend *backend) { PkBitfield filters; GList *list = NULL; sqlite3 *db = NULL; filters = pk_backend_get_uint (backend, "filters"); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID); db = db_open(); 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, NULL, 0); } else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) { list = box_db_repos_packages_search_installed (db, NULL, 0); } else if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) { list = box_db_repos_packages_search_available (db, NULL, 0); } 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 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 gboolean pk_backend_resolve_package (PkBackend *self, const gchar *package, GError **error) { alpm_pkg_t *pkg; PkBitfield filters; gboolean skip_local, skip_remote; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (package != NULL, FALSE); g_return_val_if_fail (localdb != NULL, FALSE); pkg = pk_backend_find_pkg (self, package, error); if (pkg == NULL) { return FALSE; } filters = pk_backend_get_uint (self, "filters"); skip_local = pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED); skip_remote = pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED); if (alpm_pkg_get_origin (pkg) == ALPM_PKG_FROM_LOCALDB) { if (!skip_local) { pk_backend_pkg (self, pkg, PK_INFO_ENUM_INSTALLED); } } else { if (!skip_remote) { pk_backend_pkg (self, pkg, PK_INFO_ENUM_AVAILABLE); } } return TRUE; }
static gboolean backend_search_file_thread (PkBackend *backend) { const gchar *search; PkBitfield filters; search = pk_backend_get_string (backend, "search"); filters = (PkBitfield) pk_backend_get_uint (backend, "filters"); pk_backend_set_allow_cancel (backend, true); // as we can only search for installed files lets avoid the opposite if (!pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) { 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<string> packages = search_file (backend, search, _cancel); vector<pair<pkgCache::PkgIterator, pkgCache::VerIterator> > output; for(vector<string>::iterator i = packages.begin(); i != packages.end(); ++i) { if (_cancel) { break; } pkgCache::PkgIterator pkg = m_apt->packageCache->FindPkg(i->c_str()); pkgCache::VerIterator ver = m_apt->find_ver(pkg); if (ver.end() == true) { continue; } output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(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 backend_get_packages_thread (PkBackend *backend) { PkBitfield filters; filters = (PkBitfield) pk_backend_get_uint (backend, "filters"); 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> > output; output.reserve(m_apt->packageCache->HeaderP->PackageCount); for(pkgCache::PkgIterator pkg = m_apt->packageCache->PkgBegin(); !pkg.end(); ++pkg) { if (_cancel) { break; } // Ignore packages that exist only due to dependencies. if(pkg.VersionList().end() && pkg.ProvidesList().end()) continue; // Don't insert virtual packages as they don't have all kinds of info pkgCache::VerIterator ver = m_apt->find_ver(pkg); if (ver.end() == false) { output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(pkg, ver)); } } // It's faster to emmit the packages rather here than in the matching part m_apt->emit_packages(output, filters); delete m_apt; pk_backend_finished (backend); return true; }
static gboolean pk_backend_resolve_name (PkBackend *self, const gchar *name, GError **error) { alpm_pkg_t *pkg; int code; PkBitfield filters; gboolean skip_local, skip_remote; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (name != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); g_return_val_if_fail (localdb != NULL, FALSE); filters = pk_backend_get_uint (self, "filters"); skip_local = pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED); skip_remote = pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED); pkg = alpm_db_get_pkg (localdb, name); if (pkg != NULL) { if (!skip_local) { pk_backend_pkg (self, pkg, PK_INFO_ENUM_INSTALLED); return TRUE; } } else if (!skip_remote) { 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) { pk_backend_pkg (self, pkg, PK_INFO_ENUM_AVAILABLE); return TRUE; } } } code = ALPM_ERR_PKG_NOT_FOUND; g_set_error (error, ALPM_ERROR, code, "%s: %s", name, alpm_strerror (code)); return FALSE; }
/** * backend_search_name_thread: */ static gboolean backend_search_name_thread (PkBackend *backend) { GTimer *timer; guint percentage; PkBitfield filters; gchar *filters_text; const gchar *search; filters = pk_backend_get_uint (backend, "filters"); search = pk_backend_get_string (backend, "search"); filters_text = pk_filter_bitfield_to_text (filters); egg_debug ("started task (%p) search=%s filters=%s", backend, search, filters_text); g_free (filters_text); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); timer = g_timer_new (); percentage = 0; do { /* now is a good time to see if we should cancel the thread */ if (is_cancelled) { pk_backend_error_code (backend, PK_ERROR_ENUM_TRANSACTION_CANCELLED, "The thread was stopped successfully"); pk_backend_finished (backend); return TRUE; } pk_backend_set_percentage (backend, percentage); percentage += 10; g_usleep (1000*100); } while (percentage < 100); g_timer_destroy (timer); pk_backend_set_percentage (backend, 100); egg_debug ("exited task (%p)", backend); pk_backend_package (backend, PK_INFO_ENUM_INSTALLED, "glib2;2.14.0;i386;fedora", "The GLib library"); pk_backend_package (backend, PK_INFO_ENUM_INSTALLED, "gtk2;gtk2-2.11.6-6.fc8;i386;fedora", "GTK+ Libraries for GIMP"); pk_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 alpm_list_t * pk_backend_find_provider (PkBackend *self, alpm_list_t *pkgs, const gchar *depend, GError **error) { PkBitfield filters; gboolean recursive, skip_local, skip_remote; alpm_pkg_t *provider; alpm_list_t *pkgcache, *syncdbs; g_return_val_if_fail (self != NULL, pkgs); g_return_val_if_fail (depend != NULL, pkgs); g_return_val_if_fail (alpm != NULL, pkgs); g_return_val_if_fail (localdb != NULL, pkgs); recursive = pk_backend_get_bool (self, "recursive"); filters = pk_backend_get_uint (self, "filters"); skip_local = pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED); skip_remote = pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED); if (alpm_find_satisfier (pkgs, depend) != NULL) { return pkgs; } /* look for local dependencies */ pkgcache = alpm_db_get_pkgcache (localdb); provider = alpm_find_satisfier (pkgcache, depend); if (provider != NULL) { if (!skip_local) { pk_backend_pkg (self, provider, PK_INFO_ENUM_INSTALLED); /* assume later dependencies will also be local */ if (recursive) { pkgs = alpm_list_add (pkgs, provider); } } return pkgs; } /* look for remote dependencies */ syncdbs = alpm_get_syncdbs (alpm); provider = alpm_find_dbs_satisfier (alpm, syncdbs, depend); if (provider != NULL) { if (!skip_remote) { pk_backend_pkg (self, provider, PK_INFO_ENUM_AVAILABLE); } /* keep looking for local dependencies */ if (recursive) { pkgs = alpm_list_add (pkgs, provider); } } else { int code = ALPM_ERR_UNSATISFIED_DEPS; g_set_error (error, ALPM_ERROR, code, "%s: %s", depend, alpm_strerror (code)); } return pkgs; }
static gboolean backend_search_package_thread (PkBackend *backend) { const gchar *search; PkBitfield filters; search = pk_backend_get_string (backend, "search"); filters = (PkBitfield) pk_backend_get_uint (backend, "filters"); pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID); pk_backend_set_allow_cancel (backend, true); matcher *m_matcher = new matcher(string(search)); if (m_matcher->hasError()) { egg_debug("Regex compilation error"); delete m_matcher; 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_matcher; delete m_apt; pk_backend_finished (backend); return false; } if (_error->PendingError() == true) { delete m_matcher; delete m_apt; pk_backend_finished (backend); return false; } pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); pkgDepCache::Policy Plcy; vector<pair<pkgCache::PkgIterator, pkgCache::VerIterator> > output; if (pk_backend_get_bool (backend, "search_details")) { for (pkgCache::PkgIterator pkg = m_apt->packageCache->PkgBegin(); !pkg.end(); ++pkg) { if (_cancel) { break; } // Ignore packages that exist only due to dependencies. if (pkg.VersionList().end() && pkg.ProvidesList().end()) { continue; } if (m_matcher->matches(pkg.Name())) { // Don't insert virtual packages instead add what it provides pkgCache::VerIterator ver = m_apt->find_ver(pkg); if (ver.end() == false) { output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(pkg, ver)); } else { // iterate over the provides list for (pkgCache::PrvIterator Prv = pkg.ProvidesList(); Prv.end() == false; Prv++) { ver = m_apt->find_ver(Prv.OwnerPkg()); // check to see if the provided package isn't virtual too if (ver.end() == false) { // we add the package now because we will need to // remove duplicates later anyway output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(Prv.OwnerPkg(), ver)); } } } } else { // Don't insert virtual packages instead add what it provides pkgCache::VerIterator ver = m_apt->find_ver(pkg); if (ver.end() == false) { if (m_matcher->matches(get_default_short_description(ver, m_apt->packageRecords)) || m_matcher->matches(get_default_long_description(ver, m_apt->packageRecords)) || m_matcher->matches(get_short_description(ver, m_apt->packageRecords)) || m_matcher->matches(get_long_description(ver, m_apt->packageRecords))) { output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(pkg, ver)); } } else { // iterate over the provides list for (pkgCache::PrvIterator Prv = pkg.ProvidesList(); Prv.end() == false; Prv++) { ver = m_apt->find_ver(Prv.OwnerPkg()); // check to see if the provided package isn't virtual too if (ver.end() == false) { // we add the package now because we will need to // remove duplicates later anyway if (m_matcher->matches(Prv.OwnerPkg().Name()) || m_matcher->matches(get_default_short_description(ver, m_apt->packageRecords)) || m_matcher->matches(get_default_long_description(ver, m_apt->packageRecords)) || m_matcher->matches(get_short_description(ver, m_apt->packageRecords)) || m_matcher->matches(get_long_description(ver, m_apt->packageRecords))) { output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(Prv.OwnerPkg(), ver)); } } } } } } } else { for (pkgCache::PkgIterator pkg = m_apt->packageCache->PkgBegin(); !pkg.end(); ++pkg) { if (_cancel) { break; } // Ignore packages that exist only due to dependencies. if (pkg.VersionList().end() && pkg.ProvidesList().end()) { continue; } if (m_matcher->matches(pkg.Name())) { // Don't insert virtual packages instead add what it provides pkgCache::VerIterator ver = m_apt->find_ver(pkg); if (ver.end() == false) { output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(pkg, ver)); } else { // iterate over the provides list for (pkgCache::PrvIterator Prv = pkg.ProvidesList(); Prv.end() == false; Prv++) { ver = m_apt->find_ver(Prv.OwnerPkg()); // check to see if the provided package isn't virtual too if (ver.end() == false) { // we add the package now because we will need to // remove duplicates later anyway output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(Prv.OwnerPkg(), ver)); } } } } } } // It's faster to emmit the packages here than in the matching part m_apt->emit_packages(output, filters); delete m_matcher; delete m_apt; pk_backend_set_percentage (backend, 100); pk_backend_finished (backend); return true; }
static gboolean backend_search_group_thread (PkBackend *backend) { const gchar *group; PkBitfield filters; group = pk_backend_get_string (backend, "search"); filters = (PkBitfield) pk_backend_get_uint (backend, "filters"); pk_backend_set_allow_cancel (backend, true); if (group == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_GROUP_NOT_FOUND, group); pk_backend_finished (backend); return false; } pk_backend_set_percentage (backend, 0); PkGroupEnum pkGroup = pk_group_enum_from_text (group); 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> > output; for (pkgCache::PkgIterator pkg = m_apt->packageCache->PkgBegin(); !pkg.end(); ++pkg) { if (_cancel) { break; } // Ignore packages that exist only due to dependencies. if (pkg.VersionList().end() && pkg.ProvidesList().end()) { continue; } // Ignore virtual packages pkgCache::VerIterator ver = m_apt->find_ver(pkg); if (ver.end() == false) { string section = pkg.VersionList().Section(); size_t found; found = section.find_last_of("/"); section = section.substr(found + 1); // Don't insert virtual packages instead add what it provides if (pkGroup == get_enum_group(section)) { output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(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_set_percentage (backend, 100); 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 backend_what_provides_thread (PkBackend *backend) { PkProvidesEnum provides; PkBitfield filters; const gchar *search; const gchar *provides_text; gchar **values; bool error = false; filters = (PkBitfield) pk_backend_get_uint (backend, "filters"); provides = (PkProvidesEnum) pk_backend_get_uint (backend, "provides"); search = pk_backend_get_string (backend, "search"); values = g_strsplit (search, "&", 0); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); if (provides == PK_PROVIDES_ENUM_MIMETYPE || provides == PK_PROVIDES_ENUM_CODEC || provides == PK_PROVIDES_ENUM_ANY) { 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"); g_strfreev (values); delete m_apt; pk_backend_finished (backend); return false; } pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); vector<string> packages; vector<pair<pkgCache::PkgIterator, pkgCache::VerIterator> > output; if (provides == PK_PROVIDES_ENUM_MIMETYPE) { packages = searchMimeType (backend, values, error, _cancel); } else if (provides == PK_PROVIDES_ENUM_CODEC) { m_apt->povidesCodec(output, values); } else { // any... packages = searchMimeType (backend, values, error, _cancel); m_apt->povidesCodec(output, values); } for(vector<string>::iterator i = packages.begin(); i != packages.end(); ++i) { if (_cancel) { break; } pkgCache::PkgIterator pkg = m_apt->packageCache->FindPkg(i->c_str()); pkgCache::VerIterator ver = m_apt->find_ver(pkg); if (ver.end() == true) { continue; } output.push_back(pair<pkgCache::PkgIterator, pkgCache::VerIterator>(pkg, ver)); } if (error) { // check if app-install-data is installed pkgCache::PkgIterator pkg; pkg = m_apt->packageCache->FindPkg("app-install-data"); if (pkg->CurrentState != pkgCache::State::Installed) { pk_backend_error_code (backend, PK_ERROR_ENUM_INTERNAL_ERROR, "You need the app-install-data " "package to be able to look for " "applications that can handle " "this kind of file"); } } else { // It's faster to emmit the packages here rather than in the matching part m_apt->emit_packages(output, filters); } delete m_apt; } else { provides_text = pk_provides_enum_to_text (provides); pk_backend_error_code (backend, PK_ERROR_ENUM_NOT_SUPPORTED, "Provides %s not supported", provides_text); } g_strfreev (values); pk_backend_finished (backend); return true; }
static gboolean backend_get_or_update_system_thread (PkBackend *backend) { PkBitfield filters; bool getUpdates; filters = (PkBitfield) pk_backend_get_uint (backend, "filters"); getUpdates = pk_backend_get_bool(backend, "getUpdates"); 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); pkgCacheFile Cache; OpTextProgress Prog(*_config); int timeout = 10; // TODO test this while (Cache.Open(Prog, !getUpdates) == false) { // failed to open cache, try checkDeps then.. // || Cache.CheckDeps(CmdL.FileSize() != 1) == false if (getUpdates == true || (timeout <= 0)) { pk_backend_error_code(backend, PK_ERROR_ENUM_NO_CACHE, "Could not open package cache."); return false; } else { pk_backend_set_status (backend, PK_STATUS_ENUM_WAITING_FOR_LOCK); sleep(1); timeout--; } } pk_backend_set_status (backend, PK_STATUS_ENUM_RUNNING); if (pkgDistUpgrade(*Cache) == false) { show_broken(backend, Cache, false); egg_debug ("Internal error, DistUpgrade broke stuff"); delete m_apt; pk_backend_finished (backend); return false; } bool res = true; if (getUpdates) { vector<pair<pkgCache::PkgIterator, pkgCache::VerIterator> > update, kept; for(pkgCache::PkgIterator pkg=m_apt->packageCache->PkgBegin(); !pkg.end(); ++pkg) { if((*Cache)[pkg].Upgrade() == true && (*Cache)[pkg].NewInstall() == false) { update.push_back( pair<pkgCache::PkgIterator, pkgCache::VerIterator>(pkg, m_apt->find_candidate_ver(pkg))); } else if ((*Cache)[pkg].Upgradable() == true && pkg->CurrentVer != 0 && (*Cache)[pkg].Delete() == false) { kept.push_back( pair<pkgCache::PkgIterator, pkgCache::VerIterator>(pkg, m_apt->find_candidate_ver(pkg))); } } m_apt->emitUpdates(update, filters); m_apt->emit_packages(kept, filters, PK_INFO_ENUM_BLOCKED); } else { res = m_apt->installPackages(Cache); } delete m_apt; pk_backend_finished (backend); return res; }
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_repo_manager_thread (PkBackend *backend) { // list PkBitfield filters; bool notDevelopment; // enable const gchar *repo_id; bool enabled; bool found = false; // generic const char *const salt = "$1$/iSaq7rB$EoUw5jJPPvAPECNaaWzMK/"; bool list = pk_backend_get_bool(backend, "list"); if (list) { pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); filters = (PkBitfield) pk_backend_get_uint(backend, "filters"); notDevelopment = pk_bitfield_contain(filters, PK_FILTER_ENUM_NOT_DEVELOPMENT); } else { pk_backend_set_status (backend, PK_STATUS_ENUM_REQUEST); repo_id = pk_backend_get_string(backend, "repo_id"); enabled = pk_backend_get_bool(backend, "enabled"); } SourcesList _lst; if (_lst.ReadSources() == false) { _error-> Warning("Ignoring invalid record(s) in sources.list file!"); //return false; } if (_lst.ReadVendors() == false) { _error->Error("Cannot read vendors.list file"); show_errors(backend, PK_ERROR_ENUM_FAILED_CONFIG_PARSING); pk_backend_finished (backend); return false; } for (SourcesListIter it = _lst.SourceRecords.begin(); it != _lst.SourceRecords.end(); it++) { if ((*it)->Type & SourcesList::Comment) { continue; } string Sections; for (unsigned int J = 0; J < (*it)->NumSections; J++) { Sections += (*it)->Sections[J]; Sections += " "; } if (notDevelopment && ((*it)->Type & SourcesList::DebSrc || (*it)->Type & SourcesList::RpmSrc || (*it)->Type & SourcesList::RpmSrcDir || (*it)->Type & SourcesList::RepomdSrc)) { continue; } string repo; repo = (*it)->GetType(); repo += " " + (*it)->VendorID; repo += " " + (*it)->URI; repo += " " + (*it)->Dist; repo += " " + Sections; gchar *hash; const gchar allowedChars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; hash = crypt(repo.c_str(), salt); g_strcanon(hash, allowedChars, 'D'); string repoId(hash); if (list) { pk_backend_repo_detail(backend, repoId.c_str(), repo.c_str(), !((*it)->Type & SourcesList::Disabled)); } else { if (repoId.compare(repo_id) == 0) { if (enabled) { (*it)->Type = (*it)->Type & ~SourcesList::Disabled; } else { (*it)->Type |= SourcesList::Disabled; } found = true; break; } } } if (!list) { if (!found) { _error->Error("Could not found the repositorie"); show_errors(backend, PK_ERROR_ENUM_REPO_NOT_AVAILABLE); } else if (!_lst.UpdateSources()) { _error->Error("Could not update sources file"); show_errors(backend, PK_ERROR_ENUM_CANNOT_WRITE_REPO_CONFIG); } } pk_backend_finished (backend); return true; }