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; }