static void pk_backend_update_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
gchar *dest_dir_name, *cmd_line, **pkg_tokens, **pkg_ids;
guint i;
GSList *repo;
PkBitfield transaction_flags = 0;
g_variant_get(params, "(t^a&s)", &transaction_flags, &pkg_ids);
if (!pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD);
/* Download the packages */
dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", NULL);
for (i = 0; pkg_ids[i]; i++) {
pkg_tokens = pk_package_id_split(pkg_ids[i]);
if (g_strcmp0(pkg_tokens[PK_PACKAGE_ID_DATA], "obsolete")) {
repo = g_slist_find_custom(repos, pkg_tokens[PK_PACKAGE_ID_DATA], katja_cmp_repo);
if (repo)
katja_pkgtools_download(KATJA_PKGTOOLS(repo->data), job,
dest_dir_name,
pkg_tokens[PK_PACKAGE_ID_NAME]);
}
g_strfreev(pkg_tokens);
}
g_free(dest_dir_name);
/* Install the packages */
pk_backend_job_set_status(job, PK_STATUS_ENUM_UPDATE);
for (i = 0; pkg_ids[i]; i++) {
pkg_tokens = pk_package_id_split(pkg_ids[i]);
if (g_strcmp0(pkg_tokens[PK_PACKAGE_ID_DATA], "obsolete")) {
repo = g_slist_find_custom(repos, pkg_tokens[PK_PACKAGE_ID_DATA], katja_cmp_repo);
if (repo)
katja_pkgtools_install(KATJA_PKGTOOLS(repo->data), job, pkg_tokens[PK_PACKAGE_ID_NAME]);
} else {
/* Remove obsolete package
* TODO: Removing should be an independent operation (not during installing updates) */
cmd_line = g_strconcat("/sbin/removepkg ", pkg_tokens[PK_PACKAGE_ID_NAME], NULL);
g_spawn_command_line_sync(cmd_line, NULL, NULL, NULL, NULL);
g_free(cmd_line);
}
g_strfreev(pkg_tokens);
}
}
pk_backend_job_finished(job);
}
/**
* pk_package_sack_sort_compare_name_func:
**/
static gint
pk_package_sack_sort_compare_name_func (PkPackage **a, PkPackage **b)
{
const gchar *package_id1;
const gchar *package_id2;
g_auto(GStrv) split1 = NULL;
g_auto(GStrv) split2 = NULL;
package_id1 = pk_package_get_id (*a);
package_id2 = pk_package_get_id (*b);
split1 = pk_package_id_split (package_id1);
split2 = pk_package_id_split (package_id2);
return g_strcmp0 (split1[PK_PACKAGE_ID_NAME], split2[PK_PACKAGE_ID_NAME]);
}
/**
* backend_update_package:
*/
static void
backend_update_package_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
{
gchar **parts;
gint err = 0;
const gchar *package_id;
/* FIXME: support only_trusted */
package_id = pk_backend_get_string (backend, "pkgid");
parts = pk_package_id_split (package_id);
if (!parts)
{
pk_backend_job_error_code (job, PK_ERROR_ENUM_PACKAGE_NOT_FOUND,
"Package not found");
pk_backend_job_finished (job);
return FALSE;
}
err = opkg_upgrade_package (parts[PK_PACKAGE_ID_NAME], pk_opkg_progress_cb, backend);
if (err)
handle_install_error (backend, err);
g_strfreev (parts);
pk_backend_job_finished (job);
}
/**
* dnf_get_filter_for_ids:
*/
PkBitfield
dnf_get_filter_for_ids (gchar **package_ids)
{
gboolean available = FALSE;
gboolean installed = FALSE;
guint i;
PkBitfield filters = 0;
for (i = 0; package_ids[i] != NULL && (!installed || !available); i++) {
g_auto(GStrv) split = pk_package_id_split (package_ids[i]);
if (g_strcmp0 (split[PK_PACKAGE_ID_DATA], "installed") == 0)
installed = TRUE;
else
available = TRUE;
}
/* a mixture */
if (installed && available)
return pk_bitfield_value (PK_FILTER_ENUM_NONE);
/* we can restrict what's loaded into the sack */
if (!installed)
filters = pk_bitfield_value (PK_FILTER_ENUM_NOT_INSTALLED);
if (!available)
filters = pk_bitfield_value (PK_FILTER_ENUM_INSTALLED);
return filters;
}
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;
}
static gboolean
backend_install_packages_thread (PkBackend *backend)
{
gint err, i;
gchar **package_ids;
gchar **parts;
package_ids = pk_backend_get_strv (backend, "pkids");
err = 0;
for (i = 0; package_ids[i]; i++)
{
pk_backend_package (backend, PK_INFO_ENUM_INSTALLING, package_ids[i], NULL);
parts = pk_package_id_split (package_ids[i]);
err = opkg_install_package (parts[PK_PACKAGE_ID_NAME], pk_opkg_progress_cb, backend);
if (err)
handle_install_error (backend, err);
g_strfreev (parts);
if (err != 0)
break;
}
pk_backend_finished (backend);
return (err == 0);
}
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;
}
/**
* pk_package_sack_find_by_id_name_arch:
* @sack: a valid #PkPackageSack instance
* @package_id: a package_id descriptor
*
* Finds a package in a sack by package name and architecture. As soon as one
* package is found the search is stopped.
*
* Return value: (transfer full): the #PkPackage object, or %NULL if not found.
*
* Since: 0.8.16
*/
PkPackage *
pk_package_sack_find_by_id_name_arch (PkPackageSack *sack, const gchar *package_id)
{
PkPackage *pkg_tmp;
guint i;
g_auto(GStrv) split = NULL;
g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), NULL);
g_return_val_if_fail (package_id != NULL, NULL);
/* does the package name feature in the array */
split = pk_package_id_split (package_id);
if (split == NULL)
return NULL;
for (i = 0; i < sack->priv->array->len; i++) {
pkg_tmp = g_ptr_array_index (sack->priv->array, i);
if (g_strcmp0 (pk_package_get_name (pkg_tmp),
split[PK_PACKAGE_ID_NAME]) == 0 &&
g_strcmp0 (pk_package_get_arch (pkg_tmp),
split[PK_PACKAGE_ID_ARCH]) == 0) {
return g_object_ref (pkg_tmp);
}
}
return NULL;
}
static gboolean
gpk_log_filter (PkTransactionPast *item)
{
gboolean ret = FALSE;
guint i;
guint length;
g_auto(GStrv) packages = NULL;
g_autofree gchar *tid = NULL;
gboolean succeeded;
g_autofree gchar *cmdline = NULL;
g_autofree gchar *data = NULL;
/* get data */
g_object_get (item,
"tid", &tid,
"succeeded", &succeeded,
"cmdline", &cmdline,
"data", &data,
NULL);
/* only show transactions that succeeded */
if (!succeeded) {
g_debug ("tid %s did not succeed, so not adding", tid);
return FALSE;
}
if (filter == NULL)
return TRUE;
/* matches cmdline */
if (cmdline != NULL && g_strrstr (cmdline, filter) != NULL)
ret = TRUE;
/* look in all the data for the filter string */
packages = g_strsplit (data, "\n", 0);
length = g_strv_length (packages);
for (i = 0; i < length; i++) {
g_auto(GStrv) split = NULL;
g_auto(GStrv) sections = NULL;
sections = g_strsplit (packages[i], "\t", 0);
/* check if type matches filter */
if (g_strrstr (sections[0], filter) != NULL)
ret = TRUE;
/* check to see if package name, version or arch matches */
split = pk_package_id_split (sections[1]);
if (g_strrstr (split[0], filter) != NULL)
ret = TRUE;
if (split[1] != NULL && g_strrstr (split[1], filter) != NULL)
ret = TRUE;
if (split[2] != NULL && g_strrstr (split[2], filter) != NULL)
ret = TRUE;
/* shortcut for speed */
if (ret)
break;
}
return ret;
}
/**
* backend_update_package:
*/
static gboolean
backend_update_package_thread (PkBackend *backend)
{
gchar **parts;
gint err = 0;
const gchar *package_id;
/* FIXME: support only_trusted */
package_id = pk_backend_get_string (backend, "pkgid");
parts = pk_package_id_split (package_id);
if (!parts)
{
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND,
"Package not found");
pk_backend_finished (backend);
return FALSE;
}
err = opkg_upgrade_package (parts[PK_PACKAGE_ID_NAME], pk_opkg_progress_cb, backend);
if (err)
handle_install_error (backend, err);
g_strfreev (parts);
pk_backend_finished (backend);
return (err != 0);
}
static void
backend_install_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
{
gint err, i;
gchar **package_ids;
gchar **parts;
package_ids = pk_backend_get_strv (backend, "pkids");
err = 0;
for (i = 0; package_ids[i]; i++)
{
pk_backend_job_package (job, PK_INFO_ENUM_INSTALLING, package_ids[i], NULL);
parts = pk_package_id_split (package_ids[i]);
err = opkg_install_package (parts[PK_PACKAGE_ID_NAME], pk_opkg_progress_cb, backend);
if (err)
handle_install_error (backend, err);
g_strfreev (parts);
if (err != 0)
break;
}
pk_backend_job_finished (job);
}
gchar *
gpk_package_id_format_twoline (GtkStyleContext *style,
const gchar *package_id,
const gchar *summary)
{
g_autofree gchar *summary_safe = NULL;
GString *string;
g_auto(GStrv) split = NULL;
g_autofree gchar *color = NULL;
const gchar *arch;
GdkRGBA inactive;
g_return_val_if_fail (package_id != NULL, NULL);
/* get style color */
if (style != NULL) {
gtk_style_context_get_color (style,
GTK_STATE_FLAG_INSENSITIVE,
&inactive);
color = g_strdup_printf ("#%02x%02x%02x",
(guint) (inactive.red * 255.0f),
(guint) (inactive.green * 255.0f),
(guint) (inactive.blue * 255.0f));
} else {
color = g_strdup ("gray");
}
/* optional */
split = pk_package_id_split (package_id);
if (split == NULL) {
g_warning ("could not parse %s", package_id);
return NULL;
}
/* no summary */
if (summary == NULL || summary[0] == '\0') {
string = g_string_new (split[PK_PACKAGE_ID_NAME]);
if (split[PK_PACKAGE_ID_VERSION][0] != '\0')
g_string_append_printf (string, "-%s", split[PK_PACKAGE_ID_VERSION]);
arch = gpk_get_pretty_arch (split[PK_PACKAGE_ID_ARCH]);
if (arch != NULL)
g_string_append_printf (string, " (%s)", arch);
return g_string_free (string, FALSE);
}
/* name and summary */
string = g_string_new ("");
summary_safe = g_markup_escape_text (summary, -1);
g_string_append_printf (string, "%s\n", summary_safe);
g_string_append_printf (string, "<span color=\"%s\">", color);
g_string_append (string, split[PK_PACKAGE_ID_NAME]);
if (split[PK_PACKAGE_ID_VERSION][0] != '\0')
g_string_append_printf (string, "-%s", split[PK_PACKAGE_ID_VERSION]);
arch = gpk_get_pretty_arch (split[PK_PACKAGE_ID_ARCH]);
if (arch != NULL)
g_string_append_printf (string, " (%s)", arch);
g_string_append (string, "</span>");
return g_string_free (string, FALSE);
}
static gboolean
gs_plugin_add_sources_related (GsPlugin *plugin,
GHashTable *hash,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
guint i;
GsApp *app;
GsApp *app_tmp;
PkBitfield filter;
ProgressData data;
const gchar *id;
gboolean ret = TRUE;
g_autoptr(GsAppList) installed = gs_app_list_new ();
g_autoptr(PkResults) results = NULL;
g_autoptr(AsProfileTask) ptask = NULL;
data.app = NULL;
data.plugin = plugin;
data.ptask = NULL;
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"packagekit::add-sources-related");
g_assert (ptask != NULL);
filter = pk_bitfield_from_enums (PK_FILTER_ENUM_INSTALLED,
PK_FILTER_ENUM_NEWEST,
PK_FILTER_ENUM_ARCH,
PK_FILTER_ENUM_NOT_COLLECTIONS,
-1);
results = pk_client_get_packages (PK_CLIENT(priv->task),
filter,
cancellable,
gs_plugin_packagekit_progress_cb, &data,
error);
if (!gs_plugin_packagekit_results_valid (results, error))
return FALSE;
ret = gs_plugin_packagekit_add_results (plugin,
installed,
results,
error);
if (!ret)
return FALSE;
for (i = 0; i < gs_app_list_length (installed); i++) {
g_auto(GStrv) split = NULL;
app = gs_app_list_index (installed, i);
split = pk_package_id_split (gs_app_get_source_id_default (app));
if (g_str_has_prefix (split[PK_PACKAGE_ID_DATA], "installed:")) {
id = split[PK_PACKAGE_ID_DATA] + 10;
app_tmp = g_hash_table_lookup (hash, id);
if (app_tmp != NULL) {
g_debug ("found package %s from %s",
gs_app_get_source_default (app), id);
gs_app_add_related (app_tmp, app);
}
}
}
return TRUE;
}
/**
* pk_package_sack_sort_compare_name_func:
**/
static gint
pk_package_sack_sort_compare_name_func (PkPackage **a, PkPackage **b)
{
const gchar *package_id1;
const gchar *package_id2;
gchar **split1;
gchar **split2;
gint retval;
package_id1 = pk_package_get_id (*a);
package_id2 = pk_package_get_id (*b);
split1 = pk_package_id_split (package_id1);
split2 = pk_package_id_split (package_id2);
retval = g_strcmp0 (split1[PK_PACKAGE_ID_NAME], split2[PK_PACKAGE_ID_NAME]);
g_strfreev (split1);
g_strfreev (split2);
return retval;
}
gboolean
gs_plugin_add_updates (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
guint i;
g_autoptr(GError) error_local = NULL;
g_auto(GStrv) package_ids = NULL;
/* get the id's if the file exists */
package_ids = pk_offline_get_prepared_ids (&error_local);
if (package_ids == NULL) {
if (g_error_matches (error_local,
PK_OFFLINE_ERROR,
PK_OFFLINE_ERROR_NO_DATA)) {
return TRUE;
}
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_INVALID_FORMAT,
"Failed to get prepared IDs: %s",
error_local->message);
return FALSE;
}
/* add them to the new array */
for (i = 0; package_ids[i] != NULL; i++) {
g_autoptr(GsApp) app = NULL;
g_auto(GStrv) split = NULL;
/* search in the cache */
app = gs_plugin_cache_lookup (plugin, package_ids[i]);
if (app != NULL) {
gs_app_list_add (list, app);
continue;
}
/* create new app */
app = gs_app_new (NULL);
gs_app_add_quirk (app, AS_APP_QUIRK_NEEDS_REBOOT);
gs_app_set_management_plugin (app, "packagekit");
gs_app_add_source_id (app, package_ids[i]);
split = pk_package_id_split (package_ids[i]);
gs_app_add_source (app, split[PK_PACKAGE_ID_NAME]);
gs_app_set_update_version (app, split[PK_PACKAGE_ID_VERSION]);
gs_app_set_state (app, AS_APP_STATE_UPDATABLE);
gs_app_set_kind (app, AS_APP_KIND_GENERIC);
gs_app_set_size_download (app, 0);
gs_app_list_add (list, app);
/* save in the cache */
gs_plugin_cache_add (plugin, package_ids[i], app);
}
return TRUE;
}
/**
* pk_action_lookup_package_ids_to_string:
**/
static gchar *
pk_action_lookup_package_ids_to_string (gchar **package_ids)
{
gchar **split;
GPtrArray *array = NULL;
gchar **names = NULL;
gchar *names_str = NULL;
guint i;
guint len;
/* invalid */
if (package_ids == NULL)
goto out;
/* we show different data for different numbers of packages */
len = g_strv_length (package_ids);
if (len > 5) {
/* TRANSLATORS: too many packages to list each one */
names_str = g_strdup (N_("Many packages"));
goto out;
}
/* create array of name-version */
array = g_ptr_array_new ();
for (i=0; package_ids[i] != NULL; i++) {
split = pk_package_id_split (package_ids[i]);
if (len == 1) {
names_str = g_strdup_printf ("%s-%s (%s)",
split[PK_PACKAGE_ID_NAME],
split[PK_PACKAGE_ID_VERSION],
split[PK_PACKAGE_ID_DATA]);
} else if (len <= 3) {
names_str = g_strdup_printf ("%s-%s",
split[PK_PACKAGE_ID_NAME],
split[PK_PACKAGE_ID_VERSION]);
} else {
names_str = g_strdup (split[PK_PACKAGE_ID_NAME]);
}
g_ptr_array_add (array, names_str);
g_strfreev (split);
}
/* create string */
names = pk_ptr_array_to_strv (array);
names_str = g_strjoinv (", ", names);
out:
if (array != NULL) {
g_ptr_array_foreach (array, (GFunc) g_free, NULL);
g_ptr_array_free (array, TRUE);
}
g_strfreev (names);
return names_str;
}
alpm_pkg_t *
pk_backend_find_pkg (PkBackend *self, const gchar *package_id, GError **error)
{
gchar **package;
const gchar *repo_id;
alpm_db_t *db = NULL;
alpm_pkg_t *pkg;
g_return_val_if_fail (self != NULL, NULL);
g_return_val_if_fail (package_id != NULL, NULL);
g_return_val_if_fail (alpm != NULL, NULL);
g_return_val_if_fail (localdb != NULL, NULL);
package = pk_package_id_split (package_id);
repo_id = package[PK_PACKAGE_ID_DATA];
/* find the database to search in */
if (g_strcmp0 (repo_id, "installed") == 0) {
db = localdb;
} else {
const alpm_list_t *i = alpm_get_syncdbs (alpm);
for (; i != NULL; i = i->next) {
const gchar *repo = alpm_db_get_name (i->data);
if (g_strcmp0 (repo, repo_id) == 0) {
db = i->data;
break;
}
}
}
if (db != NULL) {
pkg = alpm_db_get_pkg (db, package[PK_PACKAGE_ID_NAME]);
} else {
pkg = NULL;
}
if (pkg != NULL) {
const gchar *version = alpm_pkg_get_version (pkg);
if (g_strcmp0 (version, package[PK_PACKAGE_ID_VERSION]) != 0) {
pkg = NULL;
}
}
if (pkg == NULL) {
int code = ALPM_ERR_PKG_NOT_FOUND;
g_set_error (error, ALPM_ERROR, code, "%s: %s", package_id,
alpm_strerror (code));
}
g_strfreev (package);
return pkg;
}
/**
* pk_plugin_files_cb:
**/
static void
pk_plugin_files_cb (PkBackendJob *job,
PkFiles *files,
PkPlugin *plugin)
{
guint i;
guint len;
gboolean ret;
gchar **package;
gchar *md5;
gchar **filenames = NULL;
gchar *package_id = NULL;
/* get data */
g_object_get (files,
"package-id", &package_id,
"files", &filenames,
NULL);
package = pk_package_id_split (package_id);
/* check each file */
len = g_strv_length (filenames);
for (i=0; i<len; i++) {
/* exists? */
ret = g_file_test (filenames[i], G_FILE_TEST_EXISTS);
if (!ret)
continue;
/* .desktop file? */
ret = g_str_has_suffix (filenames[i], ".desktop");
if (!ret)
continue;
/* in the datadir */
ret = g_str_has_prefix (filenames[i], "/usr/share/applications");
if (!ret)
continue;
g_debug ("adding filename %s", filenames[i]);
md5 = pk_plugin_get_filename_md5 (filenames[i]);
pk_plugin_sqlite_add_filename_details (plugin,
filenames[i],
package[PK_PACKAGE_ID_NAME],
md5);
g_free (md5);
}
g_strfreev (filenames);
g_strfreev (package);
g_free (package_id);
}
static gboolean
backend_remove_packages_thread (PkBackend *backend)
{
gint err, i;
gchar **package_ids;
gchar **parts;
gboolean allow_deps;
gboolean autoremove;
gpointer *data;
data = pk_backend_get_pointer (backend, "remove-params");
package_ids = (gchar**) data[0];
allow_deps = GPOINTER_TO_INT (data[1]);
autoremove = GPOINTER_TO_INT (data[2]);
g_free (data);
opkg_set_option ((char *)"autoremove", &autoremove);
opkg_set_option ((char *)"force_removal_of_dependent_packages", &allow_deps);
err = 0;
for (i = 0; package_ids[i]; i++)
{
pk_backend_package (backend, PK_INFO_ENUM_REMOVING, package_ids[i], NULL);
parts = pk_package_id_split (package_ids[i]);
err = opkg_remove_package (parts[PK_PACKAGE_ID_NAME], pk_opkg_progress_cb, backend);
switch (err)
{
//case OPKG_NO_ERROR:
// break;
//case OPKG_PACKAGE_NOT_INSTALLED:
// pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_INSTALLED, NULL);
// break;
default:
opkg_unknown_error (backend, err, "Remove");
}
g_strfreev (parts);
if (err != 0)
break;
}
pk_backend_finished (backend);
return (err == 0);
}
/*
* Converts a PackageKit package ID to a query ID. Overwrites the contents of
* *query_id with said ID.
*/
bool
query_id_from_package_id(const gchar *package_id, struct query_id *query_id)
{
bool success;
gchar **split_package_id;
assert(package_id != NULL);
assert(query_id != NULL);
success = false;
split_package_id = pk_package_id_split(package_id);
if (split_package_id != NULL) {
bool have_name;
bool have_version;
gchar *name;
gchar *version;
gchar *arch;
gchar *repo;
/* We're not allowed to have an empty name or version. */
name = split_package_id[PK_PACKAGE_ID_NAME];
have_name = (name != NULL && name[0] != '\0');
version = split_package_id[PK_PACKAGE_ID_VERSION];
have_version = (version != NULL && version[0] != '\0');
/*
* Names and versions are mandatory. Anything else is
* optional.
*/
if (have_name && have_version) {
query_id->namever = namever_from_name_and_version(name,
version);
arch = split_package_id[PK_PACKAGE_ID_ARCH];
query_id->arch = strdup_null_if_empty(arch);
repo = split_package_id[PK_PACKAGE_ID_DATA];
query_id->repo = strdup_null_if_empty(repo);
success = true;
}
g_strfreev(split_package_id);
}
return success;
}
static void pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
gchar *dir_path, *path, **pkg_ids, **pkg_tokens, *to_strv[] = {NULL, NULL};
guint i;
GSList *repo;
sqlite3_stmt *stmt;
PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job);
g_variant_get(params, "(^a&ss)", &pkg_ids, &dir_path);
pk_backend_job_set_status (job, PK_STATUS_ENUM_DOWNLOAD);
if ((sqlite3_prepare_v2(job_data->db,
"SELECT summary, (full_name || '.' || ext) FROM pkglist NATURAL JOIN repos "
"WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo",
-1,
&stmt,
NULL) != SQLITE_OK)) {
pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
goto out;
}
for (i = 0; pkg_ids[i]; i++) {
pkg_tokens = pk_package_id_split(pkg_ids[i]);
sqlite3_bind_text(stmt, 1, pkg_tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 2, pkg_tokens[PK_PACKAGE_ID_VERSION], -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 3, pkg_tokens[PK_PACKAGE_ID_ARCH], -1, SQLITE_TRANSIENT);
sqlite3_bind_text(stmt, 4, pkg_tokens[PK_PACKAGE_ID_DATA], -1, SQLITE_TRANSIENT);
if (sqlite3_step(stmt) == SQLITE_ROW) {
if ((repo = g_slist_find_custom(repos, pkg_tokens[PK_PACKAGE_ID_DATA], katja_cmp_repo))) {
pk_backend_job_package(job, PK_INFO_ENUM_DOWNLOADING,
pkg_ids[i],
(gchar *) sqlite3_column_text(stmt, 0));
katja_pkgtools_download(KATJA_PKGTOOLS(repo->data), job, dir_path, pkg_tokens[PK_PACKAGE_ID_NAME]);
path = g_build_filename(dir_path, (gchar *) sqlite3_column_text(stmt, 1), NULL);
to_strv[0] = path;
pk_backend_job_files(job, NULL, to_strv);
g_free(path);
}
}
sqlite3_clear_bindings(stmt);
sqlite3_reset(stmt);
g_strfreev(pkg_tokens);
}
out:
sqlite3_finalize(stmt);
pk_backend_job_finished (job);
}
gchar *
gpk_package_id_format_oneline (const gchar *package_id, const gchar *summary)
{
g_autofree gchar *summary_safe = NULL;
g_auto(GStrv) split = NULL;
g_return_val_if_fail (package_id != NULL, NULL);
split = pk_package_id_split (package_id);
if (summary == NULL || summary[0] == '\0') {
/* just have name */
return g_strdup (split[PK_PACKAGE_ID_NAME]);
}
summary_safe = g_markup_escape_text (summary, -1);
return g_strdup_printf ("<b>%s</b> (%s)", summary_safe, split[PK_PACKAGE_ID_NAME]);
}
/**
* backend_get_details:
*/
static gboolean
backend_get_details_thread (PkBackend *backend)
{
gchar **package_ids;
gchar **parts;
int group_index;
PkGroupEnum group = 0;
pkg_t *pkg;
gchar *newid;
package_ids = pk_backend_get_strv(backend, "package_ids");
parts = pk_package_id_split (package_ids[0]);
if (!parts)
{
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "invalid package id");
pk_backend_finished (backend);
return FALSE;
}
pkg = opkg_find_package (parts[PK_PACKAGE_ID_NAME], parts[PK_PACKAGE_ID_VERSION], parts[PK_PACKAGE_ID_ARCH], parts[PK_PACKAGE_ID_DATA]);
g_strfreev (parts);
if (!pkg)
{
pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, NULL);
pk_backend_finished (backend);
return FALSE;
}
newid = g_strdup_printf ("%s;%s;%s;%s", pkg->name, pkg->version, pkg->architecture, pkg->src->name);
if (pkg->tags) {
for (group_index = 0; group < PK_GROUP_ENUM_LAST; group_index++) {
group = 1 << group_index;
if (!(group & backend_get_groups(backend))) continue;
if (opkg_check_tag(pkg, (const gchar *)pk_group_enum_to_string(group)))
break;
}
}
pk_backend_details (backend, newid, NULL, group, pkg->description, NULL, pkg->size);
g_free (newid);
pk_backend_finished (backend);
return TRUE;
}
/**
* pk_debuginfo_install_print_array:
**/
static void
pk_debuginfo_install_print_array (GPtrArray *array)
{
guint i;
const gchar *package_id;
gchar **split;
for (i=0; i<array->len; i++) {
package_id = g_ptr_array_index (array, i);
split = pk_package_id_split (package_id);
g_print ("%i\t%s-%s(%s)\t%s\n", i+1,
split[PK_PACKAGE_ID_NAME],
split[PK_PACKAGE_ID_VERSION],
split[PK_PACKAGE_ID_ARCH],
split[PK_PACKAGE_ID_DATA]);
g_strfreev (split);
}
}
/**
* gpk_package_entry_completion_model_new:
*
* Creates a tree model containing completions from the system package list
**/
static GtkTreeModel *
gpk_package_entry_completion_model_new (void)
{
GPtrArray *list;
guint i;
PkPackage *item;
GHashTable *hash;
gpointer data;
GtkListStore *store;
GtkTreeIter iter;
gchar **split;
store = gtk_list_store_new (1, G_TYPE_STRING);
hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
list = gpk_package_entry_completion_get_names_from_file (PK_SYSTEM_PACKAGE_LIST_FILENAME);
if (list == NULL) {
egg_warning ("no package list, try refreshing");
return NULL;
}
egg_debug ("loading %i autocomplete items", list->len);
for (i=0; i<list->len; i++) {
item = g_ptr_array_index (list, i);
if (item == NULL || pk_package_get_id (item) == NULL) {
egg_warning ("item invalid!");
break;
}
split = pk_package_id_split (pk_package_get_id (item));
data = g_hash_table_lookup (hash, (gpointer) split[PK_PACKAGE_ID_NAME]);
if (data == NULL) {
/* append just the name */
g_hash_table_insert (hash, g_strdup (split[PK_PACKAGE_ID_NAME]), GINT_TO_POINTER (1));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, split[PK_PACKAGE_ID_NAME], -1);
}
g_strfreev (split);
}
g_hash_table_unref (hash);
g_ptr_array_unref (list);
return GTK_TREE_MODEL (store);
}
static void
backend_install_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
{
gboolean result = TRUE;
gchar **package_ids;
size_t i;
pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
/* FIXME: support only_trusted */
package_ids = pk_backend_get_strv (backend, "package_ids");
for (i = 0; i < g_strv_length (package_ids); i++) {
gchar **package_id_data = pk_package_id_split (package_ids[i]);
result = box_package_install (package_id_data[PK_PACKAGE_ID_NAME], ROOT_DIRECTORY, common_progress, backend, FALSE);
}
pk_backend_job_finished (job);
}
static void
backend_remove_packages_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
{
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]);
pk_backend_job_set_status (job, PK_STATUS_ENUM_REMOVE);
if (!box_package_uninstall (package_id_data[PK_PACKAGE_ID_NAME], ROOT_DIRECTORY, common_progress, backend, FALSE))
{
pk_backend_job_error_code (job, PK_ERROR_ENUM_DEP_RESOLUTION_FAILED, "Cannot uninstall");
}
pk_backend_finished (backend);
}
static gboolean
backend_remove_packages_thread (PkBackend *backend)
{
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]);
pk_backend_set_status (backend, PK_STATUS_ENUM_REMOVE);
if (!box_package_uninstall (package_id_data[PK_PACKAGE_ID_NAME], ROOT_DIRECTORY, common_progress, backend, FALSE))
{
pk_backend_error_code (backend, PK_ERROR_ENUM_DEP_RESOLUTION_FAILED, "Cannot uninstall");
}
pk_backend_finished (backend);
return TRUE;
}
static void pk_backend_remove_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
gchar **pkg_tokens, **pkg_ids, *cmd_line;
guint i;
gdouble percent_step;
gboolean allow_deps, autoremove;
GError *err = NULL;
PkBitfield transaction_flags = 0;
g_variant_get(params, "(t^a&sbb)", &transaction_flags, &pkg_ids, &allow_deps, &autoremove);
if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
pk_backend_job_set_status(job, PK_STATUS_ENUM_DEP_RESOLVE);
} else {
pk_backend_job_set_status(job, PK_STATUS_ENUM_REMOVE);
/* Add percent_step percents per removed package */
percent_step = 100.0 / g_strv_length(pkg_ids);
for (i = 0; pkg_ids[i]; i++) {
pk_backend_job_set_percentage(job, percent_step * i);
pkg_tokens = pk_package_id_split(pkg_ids[i]);
cmd_line = g_strconcat("/sbin/removepkg ", pkg_tokens[PK_PACKAGE_ID_NAME], NULL);
/* Pkgtools return always 0 */
g_spawn_command_line_sync(cmd_line, NULL, NULL, NULL, &err);
g_free(cmd_line);
g_strfreev(pkg_tokens);
if (err) {
pk_backend_job_error_code(job, PK_ERROR_ENUM_PACKAGE_FAILED_TO_REMOVE, "%s", err->message);
g_error_free(err);
goto out;
}
pk_backend_job_set_percentage(job, 100);
}
}
out:
pk_backend_job_finished(job);
}
static gboolean
backend_install_packages_thread (PkBackend *backend)
{
gboolean result = TRUE;
gchar **package_ids;
size_t i;
pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY);
/* FIXME: support only_trusted */
package_ids = pk_backend_get_strv (backend, "package_ids");
for (i = 0; i < g_strv_length (package_ids); i++) {
gchar **package_id_data = pk_package_id_split (package_ids[i]);
result = box_package_install (package_id_data[PK_PACKAGE_ID_NAME], ROOT_DIRECTORY, common_progress, backend, FALSE);
}
pk_backend_finished (backend);
return result;
}
