/**
* 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;
}
