/** * backend_update_package: */ static gboolean backend_update_package_thread (PkBackend *backend) { gchar **parts; gint err = 0; const gchar *package_id; /* FIXME: support only_trusted */ package_id = pk_backend_get_string (backend, "pkgid"); parts = pk_package_id_split (package_id); if (!parts) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "Package not found"); pk_backend_finished (backend); return FALSE; } err = opkg_upgrade_package (parts[PK_PACKAGE_ID_NAME], pk_opkg_progress_cb, backend); if (err) handle_install_error (backend, err); g_strfreev (parts); pk_backend_finished (backend); return (err != 0); }
static gboolean pk_backend_repo_enable_thread (PkBackend *self) { const gchar *repo; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); repo = pk_backend_get_string (self, "repo_id"); g_return_val_if_fail (repo != NULL, FALSE); if (g_hash_table_remove (disabled, repo)) { /* reload configuration to preserve ordering */ if (disabled_repos_configure (disabled, TRUE, &error)) { pk_backend_repo_list_changed (self); } } else { int code = ALPM_ERR_DB_NOT_NULL; g_set_error (&error, ALPM_ERROR, code, "[%s]: %s", repo, alpm_strerror (code)); } if (error != NULL) { pk_backend_error (self, error); g_error_free (error); } pk_backend_thread_finished (self); return (error == NULL); }
/** * backend_update_package: */ static void backend_update_package_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { gchar **parts; gint err = 0; const gchar *package_id; /* FIXME: support only_trusted */ package_id = pk_backend_get_string (backend, "pkgid"); parts = pk_package_id_split (package_id); if (!parts) { pk_backend_job_error_code (job, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "Package not found"); pk_backend_job_finished (job); return FALSE; } err = opkg_upgrade_package (parts[PK_PACKAGE_ID_NAME], pk_opkg_progress_cb, backend); if (err) handle_install_error (backend, err); g_strfreev (parts); pk_backend_job_finished (job); }
static void pk_backend_repo_enable_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { const gchar *repo; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); repo = pk_backend_get_string (self, "repo_id"); if (g_hash_table_remove (disabled, repo)) { /* reload configuration to preserve ordering */ if (disabled_repos_configure (disabled, &error)) { pk_backend_repo_list_changed (self); } } else { int code = PM_ERR_DB_NOT_NULL; g_set_error (&error, ALPM_ERROR, code, "[%s]: %s", repo, alpm_strerror (code)); } if (error != NULL) { pk_backend_error (self, error); g_error_free (error); } pk_backend_job_finished (self); }
static gboolean backend_repo_enable_thread (PkBackend *backend) { GError *error = NULL; const gchar *repo; gboolean enabled; g_return_val_if_fail (pacman != NULL, FALSE); g_return_val_if_fail (disabled_repos != NULL, FALSE); g_return_val_if_fail (backend != NULL, FALSE); repo = pk_backend_get_string (backend, "repo_id"); enabled = pk_backend_get_bool (backend, "enabled"); g_return_val_if_fail (repo != NULL, FALSE); if (enabled) { /* check that repo is indeed disabled */ if (g_hash_table_remove (disabled_repos, repo)) { /* reload configuration to preserve the correct order */ if (disabled_repos_configure (disabled_repos, &error)) { pk_backend_repo_list_changed (backend); } else { backend_error (backend, error); pk_backend_thread_finished (backend); return FALSE; } } else { pk_backend_error_code (backend, PK_ERROR_ENUM_REPO_NOT_FOUND, "Could not find repo [%s]", repo); pk_backend_thread_finished (backend); return FALSE; } } else { PacmanDatabase *database = pacman_manager_find_sync_database (pacman, repo); if (database != NULL) { if (pacman_manager_unregister_database (pacman, database, &error)) { g_hash_table_insert (disabled_repos, g_strdup (repo), GINT_TO_POINTER (1)); } else { backend_error (backend, error); pk_backend_thread_finished (backend); return FALSE; } } else { pk_backend_error_code (backend, PK_ERROR_ENUM_REPO_NOT_FOUND, "Could not find repo [%s]", repo); pk_backend_thread_finished (backend); return FALSE; } } pk_backend_thread_finished (backend); return TRUE; }
static gchar * pk_backend_resolve_path (PkBackend *self, const gchar *basename) { const gchar *dirname; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (basename != NULL, NULL); dirname = pk_backend_get_string (self, "directory"); g_return_val_if_fail (dirname != NULL, NULL); return g_build_filename (dirname, basename, NULL); }
static gboolean pk_backend_repo_disable_thread (PkBackend *self) { const alpm_list_t *i; const gchar *repo; GError *error = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (alpm != NULL, FALSE); g_return_val_if_fail (disabled != NULL, FALSE); repo = pk_backend_get_string (self, "repo_id"); g_return_val_if_fail (repo != NULL, FALSE); 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) { alpm_errno_t errno = alpm_errno (alpm); g_set_error (&error, ALPM_ERROR, errno, "[%s]: %s", repo, alpm_strerror (errno)); } else { g_hash_table_insert (disabled, g_strdup (repo), GINT_TO_POINTER (1)); } break; } } if (i == NULL) { int code = ALPM_ERR_DB_NULL; g_set_error (&error, ALPM_ERROR, code, "[%s]: %s", repo, alpm_strerror (code)); } if (error != NULL) { pk_backend_error (self, error); g_error_free (error); } pk_backend_thread_finished (self); return (error == NULL); }
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; }
/** * 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 void pk_backend_repo_disable_thread (PkBackendJob *job, GVariant *params, gpointer user_data) { const alpm_list_t *i; const gchar *repo; GError *error = NULL; repo = pk_backend_get_string (self, "repo_id"); for (i = alpm_option_get_syncdbs (); i != NULL; i = i->next) { pmdb_t *db = (pmdb_t *) i->data; const gchar *name = alpm_db_get_name (db); if (g_strcmp0 (repo, name) == 0) { if (alpm_db_unregister (db) < 0) { g_set_error (&error, ALPM_ERROR, pm_errno, "[%s]: %s", repo, alpm_strerrorlast ()); } else { g_hash_table_insert (disabled, g_strdup (repo), GINT_TO_POINTER (1)); } break; } } if (i == NULL) { int code = PM_ERR_DB_NULL; g_set_error (&error, ALPM_ERROR, code, "[%s]: %s", repo, alpm_strerror (code)); } if (error != NULL) { pk_backend_error (self, error); g_error_free (error); } pk_backend_job_finished (self); }
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_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_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; }