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