/**
* backend_download_packages:
*/
static void
backend_download_packages (PkBackend *backend, gchar **package_ids, const gchar *directory)
{
guint i;
guint len;
const gchar *package_id;
const gchar *files;
const char *error;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
slapt_pkg_info_t *pkg;
const char *summary;
const char *note = NULL;
char *filename;
pk_backend_set_status (backend, PK_STATUS_ENUM_LOADING_CACHE);
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
pk_backend_set_status (backend, PK_STATUS_ENUM_DOWNLOAD);
pk_backend_set_percentage (backend, 0);
len = g_strv_length (package_ids);
for (i=0; i<len; i++) {
package_id = package_ids[i];
pkg = _get_pkg_from_string(package_id, available, installed);
if (pkg == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
summary = _get_pkg_summary(pkg);
pk_backend_package (backend, PK_INFO_ENUM_DOWNLOADING, package_id, summary);
g_free((gpointer) summary);
error = slapt_download_pkg(_config, pkg, note);
if (error == NULL) {
filename = slapt_gen_pkg_file_name(_config, pkg);
files = g_strdup(filename);
pk_backend_files (backend, package_id, files);
g_free((gpointer) files);
free(filename);
} else {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED, error);
}
}
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
static void
pk_backend_transaction_sig_check (PkBackend *self)
{
g_return_if_fail (self != NULL);
pk_backend_set_status (self, PK_STATUS_ENUM_SIG_CHECK);
}
/**
* backend_get_requires:
*/
static void
backend_get_requires (PkBackend *backend, PkBitfield filters, gchar **package_ids, gboolean recursive)
{
guint i;
guint len;
const gchar *package_id;
PkPackageId *pi;
slapt_pkg_info_t *pkg;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
slapt_pkg_list_t *requires;
PkInfoEnum state;
const char *summary;
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
len = g_strv_length (package_ids);
for (i=0; i<len; i++) {
package_id = package_ids[i];
pi = pk_package_id_new_from_string (package_id);
if (pi == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "invalid package id");
pk_backend_finished (backend);
return;
}
pkg = _get_pkg_from_id(pi, available, installed);
pk_package_id_free (pi);
if (pkg == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
requires = slapt_is_required_by(_config, available, pkg);
for (i = 0; i < requires->pkg_count; i++) {
pkg = requires->pkgs[i];
state = pkg->installed ? PK_INFO_ENUM_INSTALLED : PK_INFO_ENUM_AVAILABLE;
package_id = _get_string_from_pkg(pkg);
summary = _get_pkg_summary(pkg);
pk_backend_package (backend, state, package_id, summary);
g_free((gpointer) summary);
g_free((gpointer) package_id);
}
slapt_free_pkg_list(requires);
}
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_finished (backend);
}
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_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_set_status (self, state);
pk_backend_pkg (self, pkg, info);
pk_backend_output_start (self, pkg);
}
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;
}
/**
* backend_update_packages:
*/
static void
backend_update_packages (PkBackend *backend, gboolean only_trusted, gchar **package_ids)
{
guint i;
guint len;
const gchar *package_id;
int ret;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
const gchar *search;
slapt_pkg_list_t *results = NULL;
slapt_transaction_t *transaction;
slapt_pkg_info_t *pkg;
slapt_pkg_info_t *oldpkg;
/* FIXME: support only_trusted */
pk_backend_set_status (backend, PK_STATUS_ENUM_UPDATE);
pk_backend_set_percentage (backend, 0);
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
transaction = slapt_init_transaction();
len = g_strv_length (package_ids);
for (i=0; i<len; i++) {
package_id = package_ids[i];
pkg = _get_pkg_from_string(package_id, available, installed);
if (pkg == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
oldpkg = NULL;
search = g_strdup_printf("^%s$", pkg->name);
results = slapt_search_pkg_list(installed, search);
g_free((gpointer) search);
if (results->pkg_count > 0) {
oldpkg = results->pkgs[0];
} else {
continue;
}
slapt_add_upgrade_to_transaction(transaction, oldpkg, pkg);
}
ret = slapt_handle_transaction(_config, transaction);
if (ret != 0) {
pk_backend_error_code (backend, PK_ERROR_ENUM_TRANSACTION_ERROR, "install failed");
}
slapt_free_transaction(transaction);
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
static void
pk_backend_transaction_test_commit (PkBackend *self)
{
g_return_if_fail (self != NULL);
pk_backend_set_status (self, PK_STATUS_ENUM_TEST_COMMIT);
}
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 void
pk_backend_transaction_setup (PkBackend *self)
{
g_return_if_fail (self != NULL);
pk_backend_set_status (self, PK_STATUS_ENUM_SETUP);
}
static void
pk_backend_transaction_download (PkBackend *self)
{
g_return_if_fail (self != NULL);
pk_backend_set_status (self, PK_STATUS_ENUM_DOWNLOAD);
}
static void
pk_backend_transaction_dep_resolve (PkBackend *self)
{
g_return_if_fail (self != NULL);
pk_backend_set_status (self, PK_STATUS_ENUM_DEP_RESOLVE);
}
static void
pk_backend_transaction_repackaging (PkBackend *self)
{
g_return_if_fail (self != NULL);
pk_backend_set_status (self, PK_STATUS_ENUM_REPACKAGING);
}
/**
* backend_remove_packages:
*/
static void
backend_remove_packages (PkBackend *backend, gchar **package_ids, gboolean allow_deps, gboolean autoremove)
{
guint i;
guint len;
gchar *pi;
int ret;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
slapt_transaction_t *transaction;
slapt_pkg_info_t *pkg;
/* FIXME: support only_trusted */
pk_backend_set_status (backend, PK_STATUS_ENUM_REMOVE);
pk_backend_set_percentage (backend, 0);
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
transaction = slapt_init_transaction();
len = g_strv_length (package_ids);
for (i=0; i<len; i++) {
pi = package_ids[i];
if (pi == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "invalid package id");
pk_backend_finished (backend);
return;
}
pkg = _get_pkg_from_id(pi, installed, NULL);
if (pkg == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
if (!pkg->installed) {
char *pkgname = slapt_stringify_pkg(pkg);
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_INSTALLED, "package %s not installed", pkgname);
free(pkgname);
continue;
}
slapt_add_remove_to_transaction(transaction, pkg);
}
ret = slapt_handle_transaction(_config, transaction);
if (ret != 0) {
pk_backend_error_code (backend, PK_ERROR_ENUM_TRANSACTION_ERROR, "remove failed");
}
slapt_free_transaction(transaction);
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
static gboolean
backend_get_details_thread (PkBackend *backend)
{
PackageSearch *ps;
GList *list;
sqlite3 *db;
gchar **package_ids;
gchar **package_id_data;
package_ids = pk_backend_get_strv (backend, "package_ids");
/* FIXME: support multiple packages */
package_id_data = pk_package_id_split (package_ids[0]);
db = db_open ();
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
/* only one element is returned */
list = box_db_repos_packages_search_by_data (db, package_id_data[PK_PACKAGE_ID_NAME], package_id_data[PK_PACKAGE_ID_VERSION]);
if (list == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "cannot find package by id");
db_close (db);
return FALSE;
}
ps = (PackageSearch*) list->data;
pk_backend_details (backend, package_ids[0], "unknown", PK_GROUP_ENUM_OTHER, ps->description, "", 0);
box_db_repos_package_list_free (list);
db_close (db);
pk_backend_finished (backend);
return TRUE;
}
/**
* backend_refresh_cache:
*/
static void
backend_refresh_cache (PkBackend *backend, gboolean force)
{
pk_backend_set_status (backend, PK_STATUS_ENUM_REFRESH_CACHE);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
pk_backend_thread_create (backend, backend_refresh_cache_thread);
}
static void
backend_get_updates (PkBackend *backend, PkBitfield filters)
{
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
pk_backend_thread_create (backend, backend_get_updates_thread);
}
static void
backend_update_system (PkBackend *backend, gboolean only_trusted)
{
pk_backend_set_status (backend, PK_STATUS_ENUM_UPDATE);
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
pk_backend_thread_create (backend, backend_update_system_thread);
}
/**
* backend_refresh_cache:
*/
static void
backend_refresh_cache (PkBackend *backend, gboolean force)
{
pk_backend_set_allow_cancel (backend, TRUE);
pk_backend_set_status (backend, PK_STATUS_ENUM_REFRESH_CACHE);
slapt_update_pkg_cache(_config);
pk_backend_finished (backend);
}
/**
* backend_refresh_cache_thread:
*/
static gboolean
backend_refresh_cache_thread (PkBackend *backend)
{
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_REFRESH_CACHE);
// Lock the list directory
FileFd Lock;
if (_config->FindB("Debug::NoLocking", false) == false)
{
Lock.Fd(GetLock(_config->FindDir("Dir::State::Lists") + "lock"));
if (_error->PendingError() == true) {
pk_backend_error_code (backend, PK_ERROR_ENUM_CANNOT_GET_LOCK, "Unable to lock the list directory");
delete m_apt;
pk_backend_finished (backend);
return false;
// return _error->Error(_("Unable to lock the list directory"));
}
}
// Create the progress
AcqPackageKitStatus Stat(m_apt, backend, _cancel);
// do the work
if (_config->FindB("APT::Get::Download",true) == true) {
ListUpdate(Stat, *m_apt->packageSourceList);
}
// Rebuild the cache.
pkgCacheFile Cache;
OpTextProgress Prog(*_config);
if (Cache.BuildCaches(Prog, true) == false) {
if (_error->PendingError() == true) {
show_errors(backend, PK_ERROR_ENUM_CANNOT_GET_LOCK);
}
delete m_apt;
pk_backend_finished (backend);
return false;
}
// missing gpg signature would appear here
// TODO we need a better enum
if (_error->PendingError() == false && _error->empty() == false) {
show_warnings(backend, PK_MESSAGE_ENUM_UNTRUSTED_PACKAGE);
}
pk_backend_finished (backend);
delete m_apt;
return true;
}
/**
* backend_repo_enable:
**/
void
backend_repo_enable (PkBackend *backend, const gchar *repo, gboolean enabled)
{
g_return_if_fail (backend != NULL);
g_return_if_fail (repo != NULL);
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_thread_create (backend, backend_repo_enable_thread);
}
/**
* backend_repo_enable:
*/
static void
backend_repo_enable (PkBackend *backend, const gchar *rid, gboolean enabled)
{
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
box_repos_enable_repo(rid, enabled);
pk_backend_finished (backend);
}
static gboolean
backend_refresh_cache_thread (PkBackend *backend)
{
pk_backend_set_status (backend, PK_STATUS_ENUM_REFRESH_CACHE);
box_repos_sync(ROOT_DIRECTORY, common_progress, backend);
pk_backend_finished (backend);
return TRUE;
}
/**
* backend_search_group:
*/
static void
backend_search_group (PkBackend *backend, PkBitfield filters, const gchar *search)
{
guint i;
const gchar *package_id;
slapt_pkg_list_t *pkglist;
slapt_pkg_info_t *pkg = NULL;
PkGroupEnum group;
PkGroupEnum search_group;
const char *category;
struct category_map *catgroup;
PkInfoEnum state;
const char *summary;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
pkglist = slapt_get_installed_pkgs();
state = PK_INFO_ENUM_INSTALLED;
} else {
pkglist = slapt_get_available_pkgs();
state = PK_INFO_ENUM_AVAILABLE;
}
search_group = pk_group_enum_from_string(search);
for (i = 0; i < pkglist->pkg_count; i++) {
pkg = pkglist->pkgs[i];
category = _get_pkg_category(pkg);
group = PK_GROUP_ENUM_UNKNOWN;
for (catgroup = CATGROUP; catgroup->category != NULL; catgroup++) {
if (strcmp(catgroup->category, category) == 0) {
group = catgroup->group;
break;
}
}
if (group == search_group) {
package_id = _get_string_from_pkg(pkg);
summary = _get_pkg_summary(pkg);
pk_backend_package (backend, state, package_id, summary);
g_free((gpointer) summary);
g_free((gpointer) package_id);
}
}
slapt_free_pkg_list(pkglist);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_get_details:
*/
static void
backend_get_details (PkBackend *backend, gchar **package_ids)
{
guint i;
guint len;
const gchar *package_id;
gchar *pi;
const gchar *license = "";
const gchar *homepage = "";
const gchar *description;
PkGroupEnum group;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
slapt_pkg_info_t *pkg;
const char *category;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
len = g_strv_length (package_ids);
for (i=0; i<len; i++) {
pi = package_ids[i];
if (pi == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "invalid package id");
pk_backend_finished (backend);
return;
}
pkg = _get_pkg_from_id(pi, available, installed);
if (pkg == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
category = _get_pkg_category(pkg);
group = _get_pkg_group(category);
package_id = _get_string_from_pkg(pkg);
description = g_strstrip((gchar*) _get_pkg_description(pkg));
pk_backend_details (backend, package_id,
license, group, description, homepage, pkg->size_c * 1024);
g_free((gpointer) description);
g_free((gpointer) package_id);
}
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
static void
pk_backend_transaction_remove_start (PkBackend *self, alpm_pkg_t *pkg)
{
g_return_if_fail (self != NULL);
g_return_if_fail (pkg != NULL);
pk_backend_set_status (self, PK_STATUS_ENUM_REMOVE);
pk_backend_pkg (self, pkg, PK_INFO_ENUM_REMOVING);
pk_backend_output_start (self, pkg);
}
static void
backend_install_packages (PkBackend *backend, gboolean only_trusted, gchar **package_ids)
{
pk_backend_set_percentage (backend, PK_BACKEND_PERCENTAGE_INVALID);
pk_backend_set_status (backend, PK_STATUS_ENUM_INSTALL);
pk_backend_set_strv (backend, "pkids", package_ids);
pk_backend_thread_create (backend, backend_install_packages_thread);
}
/**
* backend_resolve:
*/
static void
backend_resolve (PkBackend *backend, PkBitfield filters, gchar **packages)
{
guint i;
guint len;
const gchar *package_id;
slapt_pkg_list_t *pkglist;
slapt_pkg_info_t *pkg = NULL;
slapt_pkg_list_t *results = NULL;
PkInfoEnum state;
const gchar *search;
const char *summary;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
pkglist = slapt_get_installed_pkgs();
state = PK_INFO_ENUM_INSTALLED;
} else {
pkglist = slapt_get_available_pkgs();
state = PK_INFO_ENUM_AVAILABLE;
}
len = g_strv_length (packages);
for (i=0; i<len; i++) {
search = g_strdup_printf("^%s$", packages[i]); /* regexp */
results = slapt_search_pkg_list(pkglist, search);
g_free((gpointer) search);
if (results == NULL) {
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found");
continue;
}
for (i = 0; i < results->pkg_count; i++) {
pkg = results->pkgs[i];
package_id = _get_string_from_pkg(pkg);
summary = _get_pkg_summary(pkg);
pk_backend_package (backend, state, package_id, summary);
g_free((gpointer) summary);
g_free((gpointer) package_id);
}
slapt_free_pkg_list(results);
}
slapt_free_pkg_list(pkglist);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_search_groups:
*/
static void
backend_search_groups (PkBackend *backend, PkBitfield filters, gchar **values)
{
guint i;
gchar *search;
const gchar *package_id;
slapt_pkg_list_t *pkglist;
slapt_pkg_info_t *pkg = NULL;
PkGroupEnum group;
PkGroupEnum search_group;
const char *category;
PkInfoEnum state;
const char *summary;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
pk_backend_set_percentage (backend, 0);
search = g_strjoinv ("&", values);
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) {
pkglist = slapt_get_installed_pkgs();
state = PK_INFO_ENUM_INSTALLED;
} else {
pkglist = slapt_get_available_pkgs();
state = PK_INFO_ENUM_AVAILABLE;
}
search_group = pk_group_enum_from_string(search);
for (i = 0; i < pkglist->pkg_count; i++) {
pkg = pkglist->pkgs[i];
category = _get_pkg_category(pkg);
group = _get_pkg_group(category);
if (group == search_group) {
package_id = _get_string_from_pkg(pkg);
summary = _get_pkg_summary(pkg);
pk_backend_package (backend, state, package_id, summary);
g_free((gpointer) summary);
g_free((gpointer) package_id);
}
}
slapt_free_pkg_list(pkglist);
g_free (search);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
gboolean
pk_backend_transaction_commit (PkBackend *self, GError **error)
{
alpm_list_t *data = NULL;
gchar *prefix;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (alpm != NULL, FALSE);
if (pk_backend_cancelled (self)) {
return TRUE;
}
pk_backend_set_allow_cancel (self, FALSE);
pk_backend_set_status (self, PK_STATUS_ENUM_RUNNING);
if (alpm_trans_commit (alpm, &data) >= 0) {
return TRUE;
}
switch (alpm_errno (alpm)) {
case ALPM_ERR_FILE_CONFLICTS:
prefix = alpm_fileconflict_build_list (data);
alpm_list_free_inner (data, alpm_fileconflict_free);
alpm_list_free (data);
break;
case ALPM_ERR_PKG_INVALID:
case ALPM_ERR_DLT_INVALID:
prefix = alpm_string_build_list (data);
alpm_list_free (data);
break;
default:
prefix = NULL;
if (data != NULL) {
g_warning ("unhandled error %d",
alpm_errno (alpm));
}
break;
}
if (prefix != NULL) {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error (error, ALPM_ERROR, errno, "%s: %s", prefix,
alpm_strerror (errno));
g_free (prefix);
} else {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error_literal (error, ALPM_ERROR, errno,
alpm_strerror (errno));
}
return FALSE;
}
/**
* backend_repo_set_data:
*/
static void
backend_repo_set_data (PkBackend *backend, const gchar *rid, const gchar *parameter, const gchar *value)
{
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
if (!box_repos_set_param (rid, parameter, value)) {
g_warning ("Cannot set PARAMETER '%s' TO '%s' for REPO '%s'", parameter, value, rid);
}
pk_backend_finished (backend);
}