static void
pk_backend_spawn_exit_cb (PkSpawn *spawn, PkSpawnExitType exit_enum, PkBackendSpawn *backend_spawn)
{
gboolean ret;
g_return_if_fail (PK_IS_BACKEND_SPAWN (backend_spawn));
/* reset the busy flag */
backend_spawn->priv->is_busy = FALSE;
/* if we force killed the process, set an error */
if (exit_enum == PK_SPAWN_EXIT_TYPE_SIGKILL) {
/* we just call this failed, and set an error */
pk_backend_job_error_code (backend_spawn->priv->job, PK_ERROR_ENUM_PROCESS_KILL,
"Process had to be killed to be cancelled");
}
if (exit_enum == PK_SPAWN_EXIT_TYPE_DISPATCHER_EXIT ||
exit_enum == PK_SPAWN_EXIT_TYPE_DISPATCHER_CHANGED) {
g_debug ("dispatcher exited, nothing to see here");
return;
}
/* only emit if not finished */
if (!backend_spawn->priv->finished) {
g_debug ("script exited without doing finished, tidying up");
ret = pk_backend_job_has_set_error_code (backend_spawn->priv->job);
if (!ret) {
pk_backend_job_error_code (backend_spawn->priv->job,
PK_ERROR_ENUM_INTERNAL_ERROR,
"The backend exited unexpectedly. "
"This is a serious error as the spawned backend did not complete the pending transaction.");
}
pk_backend_job_finished (backend_spawn->priv->job);
}
}
/**
* pk_backend_search_files:
*/
void
pk_backend_search_files (PkBackend *backend, PkBackendJob *job, PkBitfield filters, gchar **values)
{
pk_backend_job_error_code (job, PK_ERROR_ENUM_INTERNAL_ERROR,
"Error number 1");
pk_backend_job_error_code (job, PK_ERROR_ENUM_INTERNAL_ERROR,
"Duplicate error");
pk_backend_job_finished (job);
}
static void backend_depends_on_or_requires_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
PkRoleEnum role;
PkBitfield filters;
gchar **package_ids;
gboolean recursive;
gchar *pi;
g_variant_get(params, "(t^a&sb)",
&filters,
&package_ids,
&recursive);
role = pk_backend_job_get_role(job);
pk_backend_job_set_allow_cancel(job, true);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug("Failed to create apt cache");
return;
}
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
PkgList output;
for (uint i = 0; i < g_strv_length(package_ids); ++i) {
if (apt->cancelled()) {
break;
}
pi = package_ids[i];
if (pk_package_id_check(pi) == false) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_ID_INVALID,
"%s",
pi);
return;
}
const pkgCache::VerIterator &ver = apt->aptCacheFile()->resolvePkgID(pi);
if (ver.end()) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_NOT_FOUND,
"Couldn't find package %s",
pi);
return;
}
if (role == PK_ROLE_ENUM_DEPENDS_ON) {
apt->getDepends(output, ver, recursive);
} else {
apt->getRequires(output, ver, recursive);
}
}
// It's faster to emit the packages here than in the matching part
apt->emitPackages(output, filters);
}
static void backend_get_files_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
gchar **package_ids;
gchar *pi;
g_variant_get(params, "(^a&s)",
&package_ids);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug("Failed to create apt cache");
apt->emitFinished();
return;
}
if (package_ids == NULL) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_ID_INVALID,
"Invalid package id");
pk_backend_job_finished(job);
apt->emitFinished();
return;
}
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
for (uint i = 0; i < g_strv_length(package_ids); ++i) {
pi = package_ids[i];
if (pk_package_id_check(pi) == false) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_ID_INVALID,
"%s",
pi);
apt->emitFinished();
return;
}
const pkgCache::VerIterator &ver = apt->aptCacheFile()->resolvePkgID(pi);
if (ver.end()) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_NOT_FOUND,
"Couldn't find package %s",
pi);
apt->emitFinished();
return;
}
apt->emitPackageFiles(pi);
}
apt->emitFinished();
}
/**
* 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);
}
/**
* pk_backend_refresh_cache_thread:
*/
static void pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
pk_backend_job_set_allow_cancel(job, true);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug("Failed to create apt cache");
apt->emitFinished();
return;
}
PkBackend *backend = PK_BACKEND(pk_backend_job_get_backend(job));
if (pk_backend_is_online(backend)) {
apt->refreshCache();
if (_error->PendingError() == true) {
show_errors(job, PK_ERROR_ENUM_CANNOT_FETCH_SOURCES, true);
}
} else {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_NO_NETWORK,
"Cannot refresh cache whilst offline");
}
apt->emitFinished();
}
/**
* pk_backend_upgrade_system:
*/
void
pk_backend_upgrade_system (PkBackend *backend, PkBackendJob *job, PkBitfield transaction_flags, const gchar *distro_id, PkUpgradeKindEnum upgrade_kind)
{
pk_backend_job_error_code (job, PK_ERROR_ENUM_INSTALL_ROOT_INVALID,
"Cannot find boot partition");
pk_backend_job_finished (job);
}
static void
backend_get_details_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
{
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_job_set_status (job, 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_job_error_code (job, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "cannot find package by id");
db_close (db);
return;
}
ps = (PackageSearch*) list->data;
pk_backend_job_details (job, 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);
}
static void backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
gchar **package_ids;
PkRoleEnum role;
role = pk_backend_job_get_role(job);
g_variant_get(params, "(^a&s)",
&package_ids);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug ("Failed to create apt cache");
return;
}
if (package_ids == NULL) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_ID_INVALID,
"Invalid package id");
return;
}
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
PkgList pkgs = apt->resolvePackageIds(package_ids);
if (role == PK_ROLE_ENUM_GET_UPDATE_DETAIL) {
apt->emitUpdateDetails(pkgs);
} else {
apt->emitDetails(pkgs);
}
}
/**
* pk_backend_get_details:
*/
static void
backend_get_details_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
{
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_job_error_code (job, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "invalid package id");
pk_backend_job_finished (job);
return;
}
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_job_error_code (job, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, NULL);
pk_backend_job_finished (job);
return;
}
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 & pk_backend_get_groups(backend))) continue;
if (opkg_check_tag(pkg, (const gchar *)pk_group_enum_to_string(group)))
break;
}
}
pk_backend_job_details (job, newid, NULL, NULL, group, pkg->description, NULL, pkg->size);
g_free (newid);
pk_backend_job_finished (job);
}
static void backend_what_provides_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
PkProvidesEnum provides;
PkBitfield filters;
const gchar *provides_text;
gchar **values;
bool error = false;
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
g_variant_get(params, "(tu^a&s)",
&filters,
&provides,
&values);
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
// We can handle libraries, mimetypes and codecs
if (provides == PK_PROVIDES_ENUM_SHARED_LIB ||
provides == PK_PROVIDES_ENUM_MIMETYPE ||
provides == PK_PROVIDES_ENUM_CODEC ||
provides == PK_PROVIDES_ENUM_ANY) {
if (!apt->init()) {
g_debug("Failed to create apt cache");
g_strfreev(values);
apt->emitFinished();
return;
}
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
PkgList output;
if (provides == PK_PROVIDES_ENUM_SHARED_LIB) {
apt->providesLibrary(output, values);
} else if (provides == PK_PROVIDES_ENUM_MIMETYPE) {
apt->providesMimeType(output, values);
} else if (provides == PK_PROVIDES_ENUM_CODEC) {
apt->providesCodec(output, values);
} else {
// PK_PROVIDES_ENUM_ANY, just search for everything a package can provide
apt->providesLibrary(output, values);
apt->providesCodec(output, values);
apt->providesMimeType(output, values);
}
// It's faster to emit the packages here rather than in the matching part
apt->emitPackages(output, filters);
} else {
provides_text = pk_provides_enum_to_string(provides);
pk_backend_job_error_code(job,
PK_ERROR_ENUM_NOT_SUPPORTED,
"Provides %s not supported",
provides_text);
}
apt->emitFinished();
}
/**
* pk_backend_start_job:
*/
void
pk_backend_start_job (PkBackend *backend, PkBackendJob *job)
{
if (pk_backend_spawn_is_busy (spawn)) {
pk_backend_job_error_code (job,
PK_ERROR_ENUM_LOCK_REQUIRED,
"spawned backend requires lock");
return;
}
}
static void
opkg_unknown_error (PkBackend *backend, gint error_code, const gchar *failed_cmd)
{
gchar *msg;
msg = g_strdup_printf ("%s failed with error code %d", failed_cmd, error_code);
pk_backend_job_error_code (job, PK_ERROR_ENUM_UNKNOWN, msg);
g_free (msg);
}
/**
* pk_backend_update_packages:
*/
static void
pk_backend_update_packages (PkBackend *backend, PkBackendJob *job, gboolean only_trusted, gchar **package_ids)
{
/* check network state */
if (!pk_backend_is_online (backend)) {
pk_backend_job_error_code (job, PK_ERROR_ENUM_NO_NETWORK, "Cannot update when offline");
pk_backend_job_finished (job);
return;
}
pk_backend_job_thread_create (job, backend_update_packages_thread, NULL, NULL);
}
/**
* pk_backend_start_job:
*/
void
pk_backend_start_job (PkBackend *backend, PkBackendJob *job)
{
if (pk_backend_spawn_is_busy (priv->spawn)) {
pk_backend_job_error_code (job,
PK_ERROR_ENUM_LOCK_REQUIRED,
"spawned backend requires lock");
pk_backend_job_finished (job);
return;
}
pk_backend_enable_media_repo (TRUE);
}
/**
* pk_backend_refresh_cache:
*/
void
pk_backend_refresh_cache (PkBackend *backend, PkBackendJob *job, gboolean force)
{
/* check network state */
if (!pk_backend_is_online (backend)) {
pk_backend_job_error_code (job, PK_ERROR_ENUM_NO_NETWORK, "Cannot refresh cache whilst offline");
pk_backend_job_finished (job);
return;
}
pk_backend_spawn_helper (spawn, job, BACKEND_FILE, "refresh-cache", pk_backend_bool_to_string (force), NULL);
}
gboolean
pk_backend_spawn_kill (PkBackendSpawn *backend_spawn)
{
g_return_val_if_fail (PK_IS_BACKEND_SPAWN (backend_spawn), FALSE);
/* set an error as the script will just exit without doing finished */
pk_backend_job_error_code (backend_spawn->priv->job,
PK_ERROR_ENUM_TRANSACTION_CANCELLED,
"the script was killed as the action was cancelled");
pk_spawn_kill (backend_spawn->priv->spawn);
return TRUE;
}
/**
* pk_backend_refresh_cache:
*/
static void
pk_backend_refresh_cache (PkBackend *backend, PkBackendJob *job, gboolean force)
{
/* check network state */
if (!pk_backend_is_online (backend)) {
pk_backend_job_error_code (job, PK_ERROR_ENUM_NO_NETWORK, "Cannot refresh cache whilst offline");
pk_backend_job_finished (job);
return;
}
/* FIXME: support force */
pk_backend_job_thread_create (job, backend_refresh_cache_thread, NULL, NULL);
}
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);
}
static void pk_backend_resolve_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
gchar **vals, **val;
sqlite3_stmt *stmt;
PkInfoEnum ret;
PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job);
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
pk_backend_job_set_percentage(job, 0);
g_variant_get(params, "(t^a&s)", NULL, &vals);
if ((sqlite3_prepare_v2(job_data->db,
"SELECT (p1.name || ';' || p1.ver || ';' || p1.arch || ';' || r.repo), p1.summary, "
"p1.full_name FROM pkglist AS p1 NATURAL JOIN repos AS r "
"WHERE p1.name LIKE @search AND p1.repo_order = "
"(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)",
-1,
&stmt,
NULL) == SQLITE_OK)) {
/* Output packages matching each pattern */
for (val = vals; *val; val++) {
sqlite3_bind_text(stmt, 1, *val, -1, SQLITE_TRANSIENT);
while (sqlite3_step(stmt) == SQLITE_ROW) {
ret = katja_pkg_is_installed((gchar *) sqlite3_column_text(stmt, 2));
if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING)) {
pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
(gchar *) sqlite3_column_text(stmt, 0),
(gchar *) sqlite3_column_text(stmt, 1));
} else if (ret == PK_INFO_ENUM_INSTALLING) {
pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
(gchar *) sqlite3_column_text(stmt, 0),
(gchar *) sqlite3_column_text(stmt, 1));
}
}
sqlite3_clear_bindings(stmt);
sqlite3_reset(stmt);
}
sqlite3_finalize(stmt);
} else {
pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
}
pk_backend_job_set_percentage(job, 100);
pk_backend_job_finished(job);
}
/**
* pk_backend_initialize:
*/
static void
pk_backend_initialize (GKeyFile *conf, PkBackend *backend)
{
int opkg = opkg_new ();
if (!opkg) {
pk_backend_job_error_code (job,
PK_ERROR_ENUM_FAILED_INITIALIZATION,
"Could not start Opkg");
return;
}
#ifdef OPKG_OFFLINE_ROOT
opkg_set_option ((char *) "offline_root", OPKG_OFFLINE_ROOT);
opkg_re_read_config_files ();
#endif
}
static void pk_backend_search_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
gchar **vals, *search, *query;
sqlite3_stmt *stmt;
PkInfoEnum ret;
PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job);
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
pk_backend_job_set_percentage(job, 0);
g_variant_get(params, "(t^a&s)", NULL, &vals);
search = g_strjoinv("%", vals);
query = sqlite3_mprintf("SELECT (p1.name || ';' || p1.ver || ';' || p1.arch || ';' || r.repo), p1.summary, "
"p1.full_name FROM pkglist AS p1 NATURAL JOIN repos AS r "
"WHERE p1.%s LIKE '%%%q%%' AND p1.ext NOT LIKE 'obsolete' AND p1.repo_order = "
"(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)",
(gchar *) user_data,
search);
if ((sqlite3_prepare_v2(job_data->db, query, -1, &stmt, NULL) == SQLITE_OK)) {
/* Now we're ready to output all packages */
while (sqlite3_step(stmt) == SQLITE_ROW) {
ret = katja_pkg_is_installed((gchar *) sqlite3_column_text(stmt, 2));
if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING)) {
pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
(gchar *) sqlite3_column_text(stmt, 0),
(gchar *) sqlite3_column_text(stmt, 1));
} else if (ret == PK_INFO_ENUM_INSTALLING) {
pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
(gchar *) sqlite3_column_text(stmt, 0),
(gchar *) sqlite3_column_text(stmt, 1));
}
}
sqlite3_finalize(stmt);
} else {
pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
}
sqlite3_free(query);
g_free(search);
pk_backend_job_set_percentage(job, 100);
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);
}
/**
* pk_backend_update_packages:
*/
void
pk_backend_update_packages (PkBackend *backend, PkBackendJob *job, PkBitfield transaction_flags, gchar **package_ids)
{
gchar *package_ids_temp;
gchar *transaction_flags_temp;
/* check network state */
if (!pk_backend_is_online (backend)) {
pk_backend_job_error_code (job, PK_ERROR_ENUM_NO_NETWORK, "Cannot install when offline");
pk_backend_job_finished (job);
return;
}
/* send the complete list as stdin */
package_ids_temp = pk_package_ids_to_string (package_ids);
transaction_flags_temp = pk_transaction_flag_bitfield_to_string (transaction_flags);
pk_backend_spawn_helper (spawn, job, BACKEND_FILE, "update-packages", transaction_flags_temp, package_ids_temp, NULL);
g_free (package_ids_temp);
g_free (transaction_flags_temp);
}
/**
* pk_backend_search_names_thread:
*/
static void
pk_backend_search_names_thread (PkBackendJob *job, GVariant *params, gpointer user_data)
{
GTimer *timer;
guint percentage;
PkBitfield filters;
gchar *filters_text;
gchar **search;
g_variant_get (params, "(t^a&s)",
&filters,
&search);
filters_text = pk_filter_bitfield_to_string (filters);
g_debug ("started task (%p) search=%s filters=%s", job, search[0], filters_text);
g_free (filters_text);
pk_backend_job_set_status (job, PK_STATUS_ENUM_QUERY);
timer = g_timer_new ();
percentage = 0;
do {
/* now is a good time to see if we should cancel the thread */
if (is_cancelled) {
pk_backend_job_error_code (job, PK_ERROR_ENUM_TRANSACTION_CANCELLED,
"The thread was stopped successfully");
pk_backend_job_finished (job);
return;
}
pk_backend_job_set_percentage (job, percentage);
percentage += 10;
g_usleep (1000*100);
} while (percentage < 100);
g_timer_destroy (timer);
pk_backend_job_set_percentage (job, 100);
g_debug ("exited task (%p)", job);
pk_backend_job_package (job, PK_INFO_ENUM_INSTALLED,
"glib2;2.14.0;i386;fedora", "The GLib library");
pk_backend_job_package (job, PK_INFO_ENUM_INSTALLED,
"gtk2;gtk2-2.11.6-6.fc8;i386;fedora", "GTK+ Libraries for GIMP");
pk_backend_job_finished (job);
}
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);
}
void pk_backend_start_job(PkBackend *backend, PkBackendJob *job) {
gchar *db_filename = NULL;
PkBackendKatjaJobData *job_data = g_new0(PkBackendKatjaJobData, 1);
pk_backend_job_set_allow_cancel(job, TRUE);
pk_backend_job_set_allow_cancel(job, FALSE);
db_filename = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", NULL);
if (sqlite3_open(db_filename, &job_data->db) == SQLITE_OK) { /* Some SQLite settings */
sqlite3_exec(job_data->db, "PRAGMA foreign_keys = ON", NULL, NULL, NULL);
} else {
pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_CACHE,
"%s: %s",
db_filename,
sqlite3_errmsg(job_data->db));
goto out;
}
pk_backend_job_set_user_data(job, job_data);
pk_backend_job_set_status(job, PK_STATUS_ENUM_RUNNING);
out:
g_free(db_filename);
}
static void backend_manage_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
// Transaction flags
PkBitfield transaction_flags = 0;
gboolean allow_deps = false;
gboolean autoremove = false;
bool fileInstall = false;
gchar **full_paths = NULL;
gchar **package_ids = NULL;
// Get the transaction role since this method is called by install/remove/update/repair
PkRoleEnum role = pk_backend_job_get_role(job);
if (role == PK_ROLE_ENUM_INSTALL_FILES) {
g_variant_get(params, "(t^a&s)",
&transaction_flags,
&full_paths);
fileInstall = true;
} else if (role == PK_ROLE_ENUM_REMOVE_PACKAGES) {
g_variant_get(params, "(t^a&sbb)",
&transaction_flags,
&package_ids,
&allow_deps,
&autoremove);
} else if (role == PK_ROLE_ENUM_INSTALL_PACKAGES) {
g_variant_get(params, "(t^a&s)",
&transaction_flags,
&package_ids);
} else if (role == PK_ROLE_ENUM_UPDATE_PACKAGES) {
g_variant_get(params, "(t^a&s)",
&transaction_flags,
&package_ids);
}
// Check if we should only simulate the install (calculate dependencies)
bool simulate;
simulate = pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE);
// Check if we should only download all the required packages for this transaction
bool downloadOnly;
downloadOnly = pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_ONLY_DOWNLOAD);
// Check if we should fix broken packages
bool fixBroken = false;
if (role == PK_ROLE_ENUM_REPAIR_SYSTEM) {
// On fix broken mode no package to remove/install is allowed
fixBroken = true;
}
g_debug("FILE INSTALL: %i", fileInstall);
pk_backend_job_set_allow_cancel(job, true);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug("Failed to create apt cache");
return;
}
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
PkgList installPkgs, removePkgs;
if (fileInstall) {
// File installation EXPERIMENTAL
// GDebi can not install more than one package at time
if (g_strv_length(full_paths) > 1) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_NOT_SUPPORTED,
"The backend can only process one file at time.");
return;
}
// get the list of packages to install
if (!apt->markFileForInstall(full_paths[0], installPkgs, removePkgs)) {
return;
}
cout << "installPkgs.size: " << installPkgs.size() << endl;
cout << "removePkgs.size: " << removePkgs.size() << endl;
} else if (!fixBroken) {
// Resolve the given packages
if (role == PK_ROLE_ENUM_REMOVE_PACKAGES) {
removePkgs = apt->resolvePackageIds(package_ids);
} else {
installPkgs = apt->resolvePackageIds(package_ids);
}
if (removePkgs.size() == 0 && installPkgs.size() == 0) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_NOT_FOUND,
"Could not find package(s)");
return;
}
}
// Install/Update/Remove packages, or just simulate
bool ret;
ret = apt->runTransaction(installPkgs,
removePkgs,
fileInstall, // Mark newly installed packages as auto-installed
// (they're dependencies of the new local package)
fixBroken,
transaction_flags,
autoremove);
if (!ret) {
// Print transaction errors
g_debug("AptIntf::runTransaction() failed: %i", _error->PendingError());
return;
}
if (fileInstall) {
// Now perform the installation!
gchar *path;
for (uint i = 0; i < g_strv_length(full_paths); ++i) {
if (apt->cancelled()) {
break;
}
path = full_paths[i];
if (!apt->installFile(path, simulate)) {
cout << "Installation of DEB file " << path << " failed." << endl;
return;
}
}
}
}
/**
* pk_backend_download_packages_thread:
*/
static void pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
gchar **package_ids;
const gchar *tmpDir;
string directory;
g_variant_get(params, "(^a&ss)",
&package_ids,
&tmpDir);
directory = _config->FindDir("Dir::Cache::archives");
pk_backend_job_set_allow_cancel(job, true);
AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
if (!apt->init()) {
g_debug("Failed to create apt cache");
return;
}
PkBackend *backend = PK_BACKEND(pk_backend_job_get_backend(job));
if (pk_backend_is_online(backend)) {
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
// Create the progress
AcqPackageKitStatus Stat(apt, job);
// get a fetcher
pkgAcquire fetcher(&Stat);
gchar *pi;
// TODO this might be useful when the item is in the cache
// for (pkgAcquire::ItemIterator I = fetcher.ItemsBegin(); I < fetcher.ItemsEnd();)
// {
// if ((*I)->Local == true)
// {
// I++;
// continue;
// }
//
// // Close the item and check if it was found in cache
// (*I)->Finished();
// if ((*I)->Complete == false) {
// Transient = true;
// }
//
// // Clear it out of the fetch list
// delete *I;
// I = fetcher.ItemsBegin();
// }
for (uint i = 0; i < g_strv_length(package_ids); ++i) {
pi = package_ids[i];
if (pk_package_id_check(pi) == false) {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_PACKAGE_ID_INVALID,
"%s",
pi);
return;
}
if (apt->cancelled()) {
break;
}
const pkgCache::VerIterator &ver = apt->aptCacheFile()->resolvePkgID(pi);
// Ignore packages that could not be found or that exist only due to dependencies.
if (ver.end()) {
_error->Error("Can't find this package id \"%s\".", pi);
continue;
} else {
if(!ver.Downloadable()) {
_error->Error("No downloadable files for %s,"
"perhaps it is a local or obsolete" "package?",
pi);
continue;
}
string storeFileName;
if (!apt->getArchive(&fetcher,
ver,
directory,
storeFileName)) {
return;
}
gchar **files = (gchar **) g_malloc(2 * sizeof(gchar *));
files[0] = g_strdup_printf("%s/%s", directory.c_str(), flNotDir(storeFileName).c_str());
files[1] = NULL;
pk_backend_job_files(job, pi, files);
g_strfreev(files);
}
}
if (fetcher.Run() != pkgAcquire::Continue
&& apt->cancelled() == false) {
// We failed and we did not cancel
show_errors(job, PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED);
return;
}
} else {
pk_backend_job_error_code(job,
PK_ERROR_ENUM_NO_NETWORK,
"Cannot download packages whilst offline");
}
}
void
pk_alpm_error_emit (PkBackendJob *job, GError *error)
{
PkErrorEnum code = PK_ERROR_ENUM_UNKNOWN;
g_return_if_fail (error != NULL);
if (error->domain != PK_ALPM_ERROR) {
pk_backend_job_error_code (job, code, "%s", error->message);
return;
}
switch (error->code) {
case ALPM_ERR_MEMORY:
case ALPM_ERR_SYSTEM:
code = PK_ERROR_ENUM_OOM;
break;
case ALPM_ERR_BADPERMS:
code = PK_ERROR_ENUM_NOT_AUTHORIZED;
break;
case ALPM_ERR_NOT_A_FILE:
case ALPM_ERR_NOT_A_DIR:
code = PK_ERROR_ENUM_FILE_NOT_FOUND;
break;
case ALPM_ERR_WRONG_ARGS:
case ALPM_ERR_HANDLE_NULL:
case ALPM_ERR_DB_NULL:
case ALPM_ERR_TRANS_NULL:
case ALPM_ERR_TRANS_NOT_INITIALIZED:
case ALPM_ERR_TRANS_NOT_PREPARED:
case ALPM_ERR_TRANS_NOT_LOCKED:
case ALPM_ERR_INVALID_REGEX:
code = PK_ERROR_ENUM_INTERNAL_ERROR;
break;
case ALPM_ERR_DISK_SPACE:
code = PK_ERROR_ENUM_NO_SPACE_ON_DEVICE;
break;
case ALPM_ERR_HANDLE_NOT_NULL:
case ALPM_ERR_DB_NOT_NULL:
case ALPM_ERR_TRANS_NOT_NULL:
code = PK_ERROR_ENUM_FAILED_INITIALIZATION;
break;
case ALPM_ERR_HANDLE_LOCK:
code = PK_ERROR_ENUM_CANNOT_GET_LOCK;
break;
case ALPM_ERR_DB_OPEN:
case ALPM_ERR_DB_NOT_FOUND:
case ALPM_ERR_PKG_REPO_NOT_FOUND:
code = PK_ERROR_ENUM_REPO_NOT_FOUND;
break;
case ALPM_ERR_DB_CREATE:
code = PK_ERROR_ENUM_CANNOT_WRITE_REPO_CONFIG;
break;
case ALPM_ERR_DB_INVALID:
case ALPM_ERR_DB_VERSION:
case ALPM_ERR_DB_REMOVE:
case ALPM_ERR_SERVER_BAD_URL:
code = PK_ERROR_ENUM_REPO_CONFIGURATION_ERROR;
break;
case ALPM_ERR_DB_INVALID_SIG:
case ALPM_ERR_PKG_INVALID_SIG:
case ALPM_ERR_SIG_INVALID:
code = PK_ERROR_ENUM_BAD_GPG_SIGNATURE;
break;
case ALPM_ERR_DB_WRITE:
code = PK_ERROR_ENUM_REPO_NOT_AVAILABLE;
break;
case ALPM_ERR_SERVER_NONE:
code = PK_ERROR_ENUM_NO_MORE_MIRRORS_TO_TRY;
break;
case ALPM_ERR_TRANS_DUP_TARGET:
case ALPM_ERR_TRANS_ABORT:
code = PK_ERROR_ENUM_TRANSACTION_ERROR;
break;
case ALPM_ERR_TRANS_TYPE:
code = PK_ERROR_ENUM_CANNOT_CANCEL;
break;
case ALPM_ERR_PKG_NOT_FOUND:
code = PK_ERROR_ENUM_PACKAGE_NOT_FOUND;
break;
case ALPM_ERR_PKG_IGNORED:
code = PK_ERROR_ENUM_PACKAGE_INSTALL_BLOCKED;
break;
case ALPM_ERR_PKG_INVALID:
case ALPM_ERR_PKG_OPEN:
case ALPM_ERR_PKG_INVALID_NAME:
case ALPM_ERR_DLT_INVALID:
code = PK_ERROR_ENUM_INVALID_PACKAGE_FILE;
break;
case ALPM_ERR_PKG_INVALID_CHECKSUM:
code = PK_ERROR_ENUM_PACKAGE_CORRUPT;
break;
case ALPM_ERR_PKG_CANT_REMOVE:
code = PK_ERROR_ENUM_PACKAGE_FAILED_TO_REMOVE;
break;
case ALPM_ERR_PKG_INVALID_ARCH:
code = PK_ERROR_ENUM_INCOMPATIBLE_ARCHITECTURE;
break;
case ALPM_ERR_SIG_MISSING:
code = PK_ERROR_ENUM_MISSING_GPG_SIGNATURE;
break;
case ALPM_ERR_DLT_PATCHFAILED:
code = PK_ERROR_ENUM_PACKAGE_FAILED_TO_BUILD;
break;
case ALPM_ERR_UNSATISFIED_DEPS:
code = PK_ERROR_ENUM_DEP_RESOLUTION_FAILED;
break;
case ALPM_ERR_CONFLICTING_DEPS:
code = PK_ERROR_ENUM_PACKAGE_CONFLICTS;
break;
case ALPM_ERR_FILE_CONFLICTS:
code = PK_ERROR_ENUM_FILE_CONFLICTS;
break;
case ALPM_ERR_RETRIEVE:
case ALPM_ERR_LIBCURL:
case ALPM_ERR_EXTERNAL_DOWNLOAD:
code = PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED;
break;
case ALPM_ERR_LIBARCHIVE:
code = PK_ERROR_ENUM_LOCAL_INSTALL_FAILED;
break;
case ALPM_ERR_GPGME:
code = PK_ERROR_ENUM_GPG_FAILURE;
break;
case PK_ALPM_ERR_CONFIG_INVALID:
code = PK_ERROR_ENUM_FAILED_CONFIG_PARSING;
break;
case PK_ALPM_ERR_PKG_HELD:
code = PK_ERROR_ENUM_CANNOT_REMOVE_SYSTEM_PACKAGE;
break;
}
pk_backend_job_error_code (job, code, "%s", error->message);
}
