/**
* backend_get_updates:
*/
static void
backend_get_updates (PkBackend *backend, PkBitfield filters)
{
guint i;
const gchar *package_id;
const gchar *new_package_id;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
slapt_pkg_info_t *pkg;
slapt_pkg_info_t *newpkg;
const gchar *summary;
const char *changelog;
PkInfoEnum state;
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();
for (i = 0; i < installed->pkg_count; i++) {
pkg = installed->pkgs[i];
newpkg = slapt_get_newest_pkg(available, pkg->name);
if (newpkg == NULL)
continue;
if (slapt_cmp_pkgs(pkg,newpkg) >= 0)
continue;
package_id = _get_string_from_pkg(pkg);
new_package_id = _get_string_from_pkg(newpkg);
changelog = slapt_get_pkg_changelog(newpkg);
if (changelog != NULL &&
strstr(changelog, "(* Security fix *)") != NULL)
state = PK_INFO_ENUM_SECURITY;
else
state = PK_INFO_ENUM_NORMAL;
summary =_get_pkg_summary(newpkg);
pk_backend_package (backend, state,
new_package_id, summary);
g_free((gpointer) summary);
g_free((gpointer) new_package_id);
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);
}
/**
* 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);
}
/**
* 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);
}
/**
* 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);
}
/**
* 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_names:
*/
static void
backend_search_names (PkBackend *backend, PkBitfield filters, gchar **values)
{
unsigned int i;
gchar *search;
const gchar *package_id;
slapt_pkg_list_t *pkglist;
slapt_pkg_info_t *pkg = NULL;
slapt_pkg_list_t *results = NULL;
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;
}
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");
goto out;
}
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);
out:
slapt_free_pkg_list(pkglist);
g_free (search);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_search_details:
*/
static void
backend_search_details (PkBackend *backend, PkBitfield filters, const gchar *search)
{
guint i;
const gchar *package_id;
slapt_pkg_list_t *pkglist;
slapt_pkg_info_t *pkg = NULL;
slapt_pkg_list_t *results = NULL;
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;
}
results = slapt_search_pkg_list(pkglist, search);
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_get_update_detail:
*/
static void
backend_get_update_detail (PkBackend *backend, gchar **package_ids)
{
guint i;
guint len;
const gchar *package_id;
const gchar *old_package_id;
gchar *pi;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
const gchar *search;
slapt_pkg_list_t *results;
slapt_pkg_info_t *pkg;
slapt_pkg_info_t *oldpkg;
const gchar *title;
char *changelog;
const gchar *issued;
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;
}
package_id = _get_string_from_pkg(pkg);
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];
old_package_id = _get_string_from_pkg(oldpkg);
} else {
oldpkg = NULL;
old_package_id = "";
}
changelog = slapt_get_pkg_changelog(pkg);
title = ""; /* first line of changelog */
issued = NULL;
pk_backend_update_detail (backend, package_id, old_package_id,
"", "", "", NULL, PK_RESTART_ENUM_NONE,
title, changelog, PK_UPDATE_STATE_ENUM_UNKNOWN, issued, NULL);
g_free((gpointer) issued);
if (changelog != NULL)
free(changelog);
}
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_set_percentage (backend, 100);
pk_backend_finished (backend);
}
/**
* backend_get_depends:
*/
static void
backend_get_depends (PkBackend *backend, PkBitfield filters, gchar **package_ids, gboolean recursive)
{
guint i;
guint len;
const gchar *package_id;
gchar *pi;
slapt_pkg_info_t *pkg;
int ret;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
slapt_pkg_list_t *depends;
slapt_pkg_err_list_t *conflicts;
slapt_pkg_err_list_t *missing;
PkInfoEnum state;
const char *summary;
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
conflicts = slapt_init_pkg_err_list();
missing = slapt_init_pkg_err_list();
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
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;
}
depends = slapt_init_pkg_list();
ret = slapt_get_pkg_dependencies(_config,
available, installed, pkg, depends, conflicts, missing);
for (i = 0; i < depends->pkg_count; i++) {
pkg = depends->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(depends);
}
slapt_free_pkg_err_list(missing);
slapt_free_pkg_err_list(conflicts);
slapt_free_pkg_list(available);
slapt_free_pkg_list(installed);
pk_backend_finished (backend);
}
/**
* backend_get_packages:
*/
static void
backend_get_packages (PkBackend *backend, PkBitfield filters)
{
PkFilterEnum list_order[] = {
PK_FILTER_ENUM_INSTALLED,
PK_FILTER_ENUM_NOT_INSTALLED,
PK_FILTER_ENUM_UNKNOWN
};
PkFilterEnum *list_filter;
slapt_pkg_list_t *pkglist;
slapt_pkg_info_t *pkg;
slapt_pkg_info_t *other_pkg;
unsigned int i;
const gchar *package_id;
slapt_pkg_list_t *installed;
slapt_pkg_list_t *available;
PkInfoEnum state;
const char *summary;
installed = slapt_get_installed_pkgs();
available = slapt_get_available_pkgs();
pk_backend_set_status (backend, PK_STATUS_ENUM_REQUEST);
for (list_filter = list_order; *list_filter != PK_FILTER_ENUM_UNKNOWN; list_filter++) {
if (*list_filter == PK_FILTER_ENUM_INSTALLED) {
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED))
break;
pkglist = installed;
} else if (*list_filter == PK_FILTER_ENUM_NOT_INSTALLED) {
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED))
break;
pkglist = available;
} else {
continue;
}
for (i = 0; i < pkglist->pkg_count; i++) {
pkg = pkglist->pkgs[i];
/* check so that we don't show installed pkgs twice */
if (*list_filter == PK_FILTER_ENUM_NOT_INSTALLED &&
!pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) {
other_pkg = slapt_get_exact_pkg(installed,
pkg->name, pkg->version);
if (other_pkg != NULL) {
continue;
}
}
/* only display the newest pkg in each pkglist */
if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NEWEST)) {
other_pkg = slapt_get_newest_pkg(pkglist, pkg->name);
if (slapt_cmp_pkgs(pkg, other_pkg) <= 0) {
continue;
}
}
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(available);
slapt_free_pkg_list(installed);
pk_backend_finished (backend);
}
