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