static void backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
gchar **package_ids;
PkRoleEnum role;
role = pk_backend_job_get_role(job);
g_variant_get(params, "(^a&s)",
&package_ids);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug ("Failed to create apt cache");
return;
}
if (package_ids == NULL) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_ID_INVALID,
"Invalid package id");
return;
}
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
PkgList pkgs = apt->resolvePackageIds(package_ids);
if (role == PK_ROLE_ENUM_GET_UPDATE_DETAIL) {
apt->emitUpdateDetails(pkgs);
} else {
apt->emitDetails(pkgs);
}
}
static void
pk_backend_install_ignorepkg (PkBackend *self, alpm_pkg_t *pkg, gint *result)
{
gchar *output;
g_return_if_fail (self != NULL);
g_return_if_fail (pkg != NULL);
g_return_if_fail (result != NULL);
switch (pk_backend_job_get_role (self)) {
case PK_ROLE_ENUM_INSTALL_PACKAGES:
output = g_strdup_printf ("%s: was not ignored\n",
alpm_pkg_get_name (pkg));
pk_backend_output (self, output);
g_free (output);
case PK_ROLE_ENUM_DOWNLOAD_PACKAGES:
case PK_ROLE_ENUM_SIMULATE_INSTALL_PACKAGES:
*result = 1;
break;
default:
*result = 0;
break;
}
}
static void
pk_backend_transaction_upgrade_start (PkBackend *self, alpm_pkg_t *pkg,
alpm_pkg_t *old)
{
PkRoleEnum role;
PkStatusEnum state;
PkInfoEnum info;
g_return_if_fail (self != NULL);
g_return_if_fail (pkg != NULL);
role = pk_backend_job_get_role (self);
if (role == PK_ROLE_ENUM_INSTALL_FILES ||
role == PK_ROLE_ENUM_SIMULATE_INSTALL_FILES) {
state = PK_STATUS_ENUM_INSTALL;
info = PK_INFO_ENUM_INSTALLING;
} else {
state = PK_STATUS_ENUM_UPDATE;
info = PK_INFO_ENUM_UPDATING;
}
pk_backend_job_set_status (self, state);
pk_backend_pkg (self, pkg, info);
pk_backend_output_start (self, pkg);
}
static void backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
gchar **package_ids = nullptr;
gchar **files = nullptr;
PkRoleEnum role;
role = pk_backend_job_get_role(job);
if (role == PK_ROLE_ENUM_GET_DETAILS_LOCAL) {
g_variant_get(params, "(^a&s)",
&files);
} else {
g_variant_get(params, "(^a&s)",
&package_ids);
}
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init(files)) {
g_debug ("Failed to create apt cache");
return;
}
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
PkgList pkgs;
if (role == PK_ROLE_ENUM_GET_DETAILS_LOCAL) {
pkgs = apt->resolveLocalFiles(files);
} else {
pkgs = apt->resolvePackageIds(package_ids);
}
if (role == PK_ROLE_ENUM_GET_UPDATE_DETAIL) {
apt->emitUpdateDetails(pkgs);
} else {
apt->emitDetails(pkgs);
}
}
static void backend_depends_on_or_requires_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
PkRoleEnum role;
PkBitfield filters;
gchar **package_ids;
gboolean recursive;
gchar *pi;
g_variant_get(params, "(t^a&sb)",
&filters,
&package_ids,
&recursive);
role = pk_backend_job_get_role(job);
pk_backend_job_set_allow_cancel(job, true);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug("Failed to create apt cache");
return;
}
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
PkgList output;
for (uint i = 0; i < g_strv_length(package_ids); ++i) {
if (apt->cancelled()) {
break;
}
pi = package_ids[i];
if (pk_package_id_check(pi) == false) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_ID_INVALID,
"%s",
pi);
return;
}
const pkgCache::VerIterator &ver = apt->aptCacheFile()->resolvePkgID(pi);
if (ver.end()) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_NOT_FOUND,
"Couldn't find package %s",
pi);
return;
}
if (role == PK_ROLE_ENUM_DEPENDS_ON) {
apt->getDepends(output, ver, recursive);
} else {
apt->getRequires(output, ver, recursive);
}
}
// It's faster to emit the packages here than in the matching part
apt->emitPackages(output, filters);
}
/**
* pk_plugin_finished_cb:
**/
static void
pk_plugin_finished_cb (PkBackendJob *job,
PkExitEnum exit_enum,
PkPlugin *plugin)
{
if (!g_main_loop_is_running (plugin->priv->loop))
return;
if (exit_enum != PK_EXIT_ENUM_SUCCESS) {
g_warning ("%s failed with exit code: %s",
pk_role_enum_to_string (pk_backend_job_get_role (job)),
pk_exit_enum_to_string (exit_enum));
}
g_main_loop_quit (plugin->priv->loop);
}
static void
pk_backend_transaction_download_start (PkBackend *self, const gchar *basename)
{
gchar *path;
const alpm_list_t *i;
g_return_if_fail (self != NULL);
g_return_if_fail (basename != NULL);
g_return_if_fail (alpm != NULL);
/* continue or finish downloading the current package */
if (dpkg != NULL) {
if (alpm_pkg_has_basename (dpkg, basename)) {
if (dfiles != NULL) {
path = pk_backend_resolve_path (self, basename);
g_string_append_printf (dfiles, ";%s", path);
g_free (path);
}
return;
} else {
pk_backend_transaction_download_end (self);
dpkg = NULL;
}
}
/* figure out what the next package is */
for (i = alpm_trans_get_add (alpm); i != NULL; i = i->next) {
alpm_pkg_t *pkg = (alpm_pkg_t *) i->data;
if (alpm_pkg_has_basename (pkg, basename)) {
dpkg = pkg;
break;
}
}
if (dpkg == NULL) {
return;
}
pk_backend_pkg (self, dpkg, PK_INFO_ENUM_DOWNLOADING);
/* start collecting files for the new package */
if (pk_backend_job_get_role (self) == PK_ROLE_ENUM_DOWNLOAD_PACKAGES) {
path = pk_backend_resolve_path (self, basename);
dfiles = g_string_new (path);
g_free (path);
}
}
void
pk_backend_transaction_packages (PkBackend *self)
{
const alpm_list_t *i;
PkInfoEnum info;
g_return_if_fail (self != NULL);
g_return_if_fail (alpm != NULL);
g_return_if_fail (localdb != NULL);
/* emit packages that would have been installed */
for (i = alpm_trans_get_add (alpm); i != NULL; i = i->next) {
if (pk_backend_cancelled (self)) {
break;
} else {
const gchar *name = alpm_pkg_get_name (i->data);
if (alpm_db_get_pkg (localdb, name) != NULL) {
info = PK_INFO_ENUM_UPDATING;
} else {
info = PK_INFO_ENUM_INSTALLING;
}
pk_backend_pkg (self, i->data, info);
}
}
switch (pk_backend_job_get_role (self)) {
case PK_ROLE_ENUM_SIMULATE_UPDATE_PACKAGES:
info = PK_INFO_ENUM_OBSOLETING;
break;
default:
info = PK_INFO_ENUM_REMOVING;
break;
}
/* emit packages that would have been removed */
for (i = alpm_trans_get_remove (alpm); i != NULL; i = i->next) {
if (pk_backend_cancelled (self)) {
break;
} else {
pk_backend_pkg (self, i->data, info);
}
}
}
static void backend_search_package_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
gchar **values;
gchar *search;
PkBitfield filters;
PkRoleEnum role;
g_variant_get(params, "(t^a&s)",
&filters,
&values);
search = g_strjoinv("|", values);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug("Failed to create apt cache");
g_free(search);
apt->emitFinished();
return;
}
if (_error->PendingError() == true) {
g_free(search);
apt->emitFinished();
return;
}
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
pk_backend_job_set_percentage(job, PK_BACKEND_PERCENTAGE_INVALID);
pk_backend_job_set_allow_cancel(job, true);
PkgList output;
role = pk_backend_job_get_role(job);
if (role == PK_ROLE_ENUM_SEARCH_DETAILS) {
output = apt->searchPackageDetails(search);
} else {
output = apt->searchPackageName(search);
}
g_free(search);
// It's faster to emmit the packages here than in the matching part
apt->emitPackages(output, filters);
pk_backend_job_set_percentage(job, 100);
apt->emitFinished();
}
static void backend_repo_manager_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
// list
PkBitfield filters;
PkBitfield transaction_flags = 0;
// enable
const gchar *repo_id;
gboolean enabled;
gboolean autoremove;
bool found = false;
// generic
PkRoleEnum role;
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
role = pk_backend_job_get_role(job);
if (role == PK_ROLE_ENUM_GET_REPO_LIST) {
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
g_variant_get(params, "(t)",
&filters);
} else if (role == PK_ROLE_ENUM_REPO_REMOVE) {
g_variant_get(params, "(t&sb)",
&transaction_flags,
&repo_id,
&autoremove);
} else {
pk_backend_job_set_status(job, PK_STATUS_ENUM_REQUEST);
g_variant_get (params, "(&sb)",
&repo_id,
&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(job, PK_ERROR_ENUM_FAILED_CONFIG_PARSING);
return;
}
for (SourcesListIter it = _lst.SourceRecords.begin();
it != _lst.SourceRecords.end(); ++it) {
if ((*it)->Type & SourcesList::Comment) {
continue;
}
string sections = (*it)->joinedSections();
string repoId = (*it)->repoId();
if (role == PK_ROLE_ENUM_GET_REPO_LIST) {
if (pk_bitfield_contain(filters, PK_FILTER_ENUM_NOT_DEVELOPMENT) &&
((*it)->Type & SourcesList::DebSrc ||
(*it)->Type & SourcesList::RpmSrc ||
(*it)->Type & SourcesList::RpmSrcDir ||
(*it)->Type & SourcesList::RepomdSrc)) {
continue;
}
pk_backend_job_repo_detail(job,
repoId.c_str(),
(*it)->niceName().c_str(),
!((*it)->Type & SourcesList::Disabled));
} else if (repoId.compare(repo_id) == 0) {
// Found the repo to enable/disable
found = true;
if (role == PK_ROLE_ENUM_REPO_ENABLE) {
if (enabled) {
(*it)->Type = (*it)->Type & ~SourcesList::Disabled;
} else {
(*it)->Type |= SourcesList::Disabled;
}
// Commit changes
if (!_lst.UpdateSources()) {
_error->Error("Could not update sources file");
show_errors(job, PK_ERROR_ENUM_CANNOT_WRITE_REPO_CONFIG);
}
} else if (role == PK_ROLE_ENUM_REPO_REMOVE) {
if (autoremove) {
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug("Failed to create apt cache");
return;
}
PkgList removePkgs = apt->getPackagesFromRepo(*it);
if (removePkgs.size() > 0) {
// Install/Update/Remove packages, or just simulate
bool ret;
ret = apt->runTransaction(PkgList(),
removePkgs,
false,
false,
transaction_flags,
false);
if (!ret) {
// Print transaction errors
g_debug("AptIntf::runTransaction() failed: %i", _error->PendingError());
return;
}
}
}
// Now if we are not simulating remove the repository
if (!pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
_lst.RemoveSource(*it);
// Commit changes
if (!_lst.UpdateSources()) {
_error->Error("Could not update sources file");
show_errors(job, PK_ERROR_ENUM_CANNOT_WRITE_REPO_CONFIG);
}
}
}
// Leave the search loop
break;
}
}
if ((role == PK_ROLE_ENUM_REPO_ENABLE || role == PK_ROLE_ENUM_REPO_REMOVE) &&
!found) {
_error->Error("Could not found the repository");
show_errors(job, PK_ERROR_ENUM_REPO_NOT_AVAILABLE);
}
}
static void backend_manage_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
// Transaction flags
PkBitfield transaction_flags = 0;
gboolean allow_deps = false;
gboolean autoremove = false;
bool fileInstall = false;
gchar **full_paths = NULL;
gchar **package_ids = NULL;
// Get the transaction role since this method is called by install/remove/update/repair
PkRoleEnum role = pk_backend_job_get_role(job);
if (role == PK_ROLE_ENUM_INSTALL_FILES) {
g_variant_get(params, "(t^a&s)",
&transaction_flags,
&full_paths);
fileInstall = true;
} else if (role == PK_ROLE_ENUM_REMOVE_PACKAGES) {
g_variant_get(params, "(t^a&sbb)",
&transaction_flags,
&package_ids,
&allow_deps,
&autoremove);
} else if (role == PK_ROLE_ENUM_INSTALL_PACKAGES) {
g_variant_get(params, "(t^a&s)",
&transaction_flags,
&package_ids);
} else if (role == PK_ROLE_ENUM_UPDATE_PACKAGES) {
g_variant_get(params, "(t^a&s)",
&transaction_flags,
&package_ids);
}
// Check if we should only simulate the install (calculate dependencies)
bool simulate;
simulate = pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE);
// Check if we should only download all the required packages for this transaction
bool downloadOnly;
downloadOnly = pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_ONLY_DOWNLOAD);
// Check if we should fix broken packages
bool fixBroken = false;
if (role == PK_ROLE_ENUM_REPAIR_SYSTEM) {
// On fix broken mode no package to remove/install is allowed
fixBroken = true;
}
g_debug("FILE INSTALL: %i", fileInstall);
pk_backend_job_set_allow_cancel(job, true);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug("Failed to create apt cache");
return;
}
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
PkgList installPkgs, removePkgs;
if (fileInstall) {
// File installation EXPERIMENTAL
// GDebi can not install more than one package at time
if (g_strv_length(full_paths) > 1) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_NOT_SUPPORTED,
"The backend can only process one file at time.");
return;
}
// get the list of packages to install
if (!apt->markFileForInstall(full_paths[0], installPkgs, removePkgs)) {
return;
}
cout << "installPkgs.size: " << installPkgs.size() << endl;
cout << "removePkgs.size: " << removePkgs.size() << endl;
} else if (!fixBroken) {
// Resolve the given packages
if (role == PK_ROLE_ENUM_REMOVE_PACKAGES) {
removePkgs = apt->resolvePackageIds(package_ids);
} else {
installPkgs = apt->resolvePackageIds(package_ids);
}
if (removePkgs.size() == 0 && installPkgs.size() == 0) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_NOT_FOUND,
"Could not find package(s)");
return;
}
}
// Install/Update/Remove packages, or just simulate
bool ret;
ret = apt->runTransaction(installPkgs,
removePkgs,
fileInstall, // Mark newly installed packages as auto-installed
// (they're dependencies of the new local package)
fixBroken,
transaction_flags,
autoremove);
if (!ret) {
// Print transaction errors
g_debug("AptIntf::runTransaction() failed: %i", _error->PendingError());
return;
}
if (fileInstall) {
// Now perform the installation!
gchar *path;
for (uint i = 0; i < g_strv_length(full_paths); ++i) {
if (apt->cancelled()) {
break;
}
path = full_paths[i];
if (!apt->installFile(path, simulate)) {
cout << "Installation of DEB file " << path << " failed." << endl;
return;
}
}
}
}
static void backend_manage_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
// Transaction flags
PkBitfield transaction_flags = 0;
gboolean allow_deps = false;
gboolean autoremove = false;
bool fileInstall = false;
gchar **full_paths = NULL;
gchar **package_ids = NULL;
// Get the transaction role since this method is called by install/remove/update/repair
PkRoleEnum role = pk_backend_job_get_role(job);
if (role == PK_ROLE_ENUM_INSTALL_FILES) {
g_variant_get(params, "(t^a&s)",
&transaction_flags,
&full_paths);
fileInstall = true;
} else if (role == PK_ROLE_ENUM_REMOVE_PACKAGES) {
g_variant_get(params, "(t^a&sbb)",
&transaction_flags,
&package_ids,
&allow_deps,
&autoremove);
} else if (role == PK_ROLE_ENUM_INSTALL_PACKAGES) {
g_variant_get(params, "(t^a&s)",
&transaction_flags,
&package_ids);
} else if (role == PK_ROLE_ENUM_UPDATE_PACKAGES) {
g_variant_get(params, "(t^a&s)",
&transaction_flags,
&package_ids);
}
// Check if we should only simulate the install (calculate dependencies)
bool simulate;
simulate = pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE);
// Check if we should only download all the required packages for this transaction
bool downloadOnly;
downloadOnly = pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_ONLY_DOWNLOAD);
// Check if we should fix broken packages
bool fixBroken = false;
if (role == PK_ROLE_ENUM_REPAIR_SYSTEM) {
// On fix broken mode no package to remove/install is allowed
fixBroken = true;
}
pk_backend_job_set_allow_cancel(job, true);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init(full_paths)) {
g_debug("Failed to create apt cache");
return;
}
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
PkgList installPkgs, removePkgs, updatePkgs;
if (!fixBroken) {
// Resolve the given packages
if (role == PK_ROLE_ENUM_REMOVE_PACKAGES) {
removePkgs = apt->resolvePackageIds(package_ids);
} else if (role == PK_ROLE_ENUM_INSTALL_PACKAGES) {
installPkgs = apt->resolvePackageIds(package_ids);
} else if (role == PK_ROLE_ENUM_UPDATE_PACKAGES) {
updatePkgs = apt->resolvePackageIds(package_ids);
} else if (role == PK_ROLE_ENUM_INSTALL_FILES) {
installPkgs = apt->resolveLocalFiles(full_paths);
} else {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_NOT_FOUND,
"Could not figure out what to do to apply the change.");
return;
}
if (removePkgs.size() == 0 && installPkgs.size() == 0 && updatePkgs.size() == 0) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_NOT_FOUND,
"Could not find package(s)");
return;
}
}
// Install/Update/Remove packages, or just simulate
bool ret = apt->runTransaction(installPkgs,
removePkgs,
updatePkgs,
fixBroken,
transaction_flags,
autoremove);
if (!ret) {
// Print transaction errors
g_debug("AptIntf::runTransaction() failed: %i", _error->PendingError());
return;
}
}
static void backend_repo_manager_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
// list
PkBitfield filters;
// enable
const gchar *repo_id;
gboolean enabled;
bool found = false;
// generic
PkRoleEnum role;
const char *const salt = "$1$/iSaq7rB$EoUw5jJPPvAPECNaaWzMK/";
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
role = pk_backend_job_get_role(job);
if (role == PK_ROLE_ENUM_GET_REPO_LIST) {
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
g_variant_get(params, "(t)",
&filters);
} else {
pk_backend_job_set_status(job, PK_STATUS_ENUM_REQUEST);
g_variant_get (params, "(&sb)",
&repo_id,
&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(job, PK_ERROR_ENUM_FAILED_CONFIG_PARSING);
apt->emitFinished();
return;
}
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 (pk_bitfield_contain(filters, PK_FILTER_ENUM_NOT_DEVELOPMENT) &&
((*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 (role == PK_ROLE_ENUM_GET_REPO_LIST) {
pk_backend_job_repo_detail(job,
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 (role == PK_ROLE_ENUM_REPO_ENABLE) {
if (!found) {
_error->Error("Could not found the repositorie");
show_errors(job, PK_ERROR_ENUM_REPO_NOT_AVAILABLE);
} else if (!_lst.UpdateSources()) {
_error->Error("Could not update sources file");
show_errors(job, PK_ERROR_ENUM_CANNOT_WRITE_REPO_CONFIG);
}
}
apt->emitFinished();
}
static void
pk_backend_search_thread (PkBackendJob *job, GVariant* params, gpointer p)
{
PkBackend *backend = pk_backend_job_get_backend (job);
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
gchar **needles = NULL;
SearchType type;
PatternFunc pattern_func;
GDestroyNotify pattern_free;
MatchFunc match_func;
PkRoleEnum role;
PkBitfield filters = 0;
gboolean skip_local, skip_remote;
const alpm_list_t *i;
alpm_list_t *patterns = NULL;
_cleanup_error_free_ GError *error = NULL;
g_return_if_fail (p == NULL);
role = pk_backend_job_get_role(job);
switch(role) {
case PK_ROLE_ENUM_GET_PACKAGES:
type = SEARCH_TYPE_ALL;
g_variant_get (params, "(t)", &filters);
break;
case PK_ROLE_ENUM_GET_DETAILS:
type = SEARCH_TYPE_DETAILS;
g_variant_get (params, "(^a&s)", &needles);
break;
case PK_ROLE_ENUM_SEARCH_FILE:
type = SEARCH_TYPE_FILES;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_SEARCH_GROUP:
type = SEARCH_TYPE_GROUP;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_SEARCH_NAME:
type = SEARCH_TYPE_NAME;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_WHAT_PROVIDES:
type = SEARCH_TYPE_PROVIDES;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_SEARCH_DETAILS:
type = SEARCH_TYPE_DETAILS;
g_variant_get (params, "(t^a&s)",
&filters,
&needles);
break;
default:
g_assert_not_reached ();
break;
}
g_return_if_fail (type < SEARCH_TYPE_LAST);
pattern_func = pattern_funcs[type];
pattern_free = pattern_frees[type];
match_func = match_funcs[type];
g_return_if_fail (pattern_func != NULL);
g_return_if_fail (match_func != NULL);
skip_local = pk_bitfield_contain (filters,
PK_FILTER_ENUM_NOT_INSTALLED);
skip_remote = pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED);
/* convert search terms to the pattern requested */
if (needles) {
for (; *needles != NULL; ++needles) {
gpointer pattern = pattern_func (backend, *needles, &error);
if (pattern == NULL)
goto out;
patterns = alpm_list_add (patterns, pattern);
}
}
/* find installed packages first */
if (!skip_local)
pk_backend_search_db (job, priv->localdb, match_func, patterns);
if (skip_remote)
goto out;
for (i = alpm_get_syncdbs (priv->alpm); i != NULL; i = i->next) {
if (pk_backend_job_is_cancelled (job))
break;
pk_backend_search_db (job, i->data, match_func, patterns);
}
out:
if (pattern_free != NULL)
alpm_list_free_inner (patterns, pattern_free);
alpm_list_free (patterns);
pk_alpm_finish (job, error);
}
