static gboolean
backend_get_update_detail_thread (PkBackend *backend)
{
guint iterator;
gchar **package_ids;
g_return_val_if_fail (local_database != NULL, FALSE);
g_return_val_if_fail (backend != NULL, FALSE);
package_ids = pk_backend_get_strv (backend, "package_ids");
g_return_val_if_fail (package_ids != NULL, FALSE);
/* collect details about updates */
for (iterator = 0; package_ids[iterator] != NULL; ++iterator) {
PacmanPackage *package, *upgrades;
PacmanDatabase *database;
gchar *upgrades_id, *replaces_ids, *vendor_url;
const gchar *message;
PkRestartEnum restart;
PkUpdateStateEnum state;
GTimeVal built = { 0 }, installed = { 0 };
gchar *issued, *updated;
if (backend_cancelled (backend)) {
break;
}
package = backend_get_package (backend, package_ids[iterator]);
if (package == NULL) {
backend_finished (backend);
return FALSE;
}
upgrades = pacman_database_find_package (local_database, pacman_package_get_name (package));
if (upgrades != NULL) {
upgrades_id = pacman_package_make_id (upgrades);
if (pacman_package_compare_pkgver (package, upgrades) != 0) {
message = "Update to newest upstream version";
} else {
message = "Update to newest release";
}
} else {
upgrades_id = NULL;
message = "Install as a replacement for an older package";
}
database = pacman_package_get_database (package);
replaces_ids = pacman_package_make_replaces_ids (package);
vendor_url = pacman_package_make_vendor_url (package);
if (g_str_has_prefix (pacman_package_get_name (package), "kernel")) {
restart = PK_RESTART_ENUM_SYSTEM;
} else {
restart = PK_RESTART_ENUM_NONE;
}
if (g_str_has_suffix (pacman_database_get_name (database), "testing")) {
state = PK_UPDATE_STATE_ENUM_TESTING;
} else {
state = PK_UPDATE_STATE_ENUM_STABLE;
}
built.tv_sec = pacman_package_get_build_date (package);
if (built.tv_sec > 0) {
issued = g_time_val_to_iso8601 (&built);
} else {
issued = NULL;
}
if (upgrades != NULL) {
installed.tv_sec = pacman_package_get_install_date (upgrades);
if (installed.tv_sec > 0) {
updated = g_time_val_to_iso8601 (&installed);
} else {
updated = NULL;
}
} else {
updated = NULL;
}
pk_backend_update_detail (backend, package_ids[iterator], upgrades_id, replaces_ids, vendor_url, NULL, NULL, restart, message, NULL, state, issued, updated);
g_free (issued);
g_free (updated);
g_free (vendor_url);
g_free (replaces_ids);
g_free (upgrades_id);
}
backend_finished (backend);
return TRUE;
}
static gboolean
pk_backend_get_update_detail_thread (PkBackend *self)
{
gchar **packages;
GError *error = NULL;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (localdb != NULL, FALSE);
packages = pk_backend_get_strv (self, "package_ids");
g_return_val_if_fail (packages != NULL, FALSE);
/* collect details about updates */
for (; *packages != NULL; ++packages) {
pmpkg_t *pkg, *old;
pmdb_t *db;
gchar *upgrades, *replaces, *urls;
const gchar *reason;
PkRestartEnum restart;
PkUpdateStateEnum state;
GTimeVal built = { 0 }, installed = { 0 };
gchar *issued, *updated;
if (pk_backend_cancelled (self)) {
break;
}
pkg = pk_backend_find_pkg (self, *packages, &error);
if (pkg == NULL) {
break;
}
old = alpm_db_get_pkg (localdb, alpm_pkg_get_name (pkg));
if (old != NULL) {
upgrades = alpm_pkg_build_id (old);
if (alpm_pkg_same_pkgver (pkg, old)) {
reason = "Update to a newer release";
} else {
reason = "Update to a new upstream version";
}
} else {
upgrades = NULL;
reason = "Install to replace an older package";
}
db = alpm_pkg_get_db (pkg);
replaces = alpm_pkg_build_replaces (pkg);
urls = alpm_pkg_build_urls (pkg);
if (g_str_has_prefix (alpm_pkg_get_name (pkg), "kernel")) {
restart = PK_RESTART_ENUM_SYSTEM;
} else {
restart = PK_RESTART_ENUM_NONE;
}
if (g_str_has_suffix (alpm_db_get_name (db), "testing")) {
state = PK_UPDATE_STATE_ENUM_TESTING;
} else {
state = PK_UPDATE_STATE_ENUM_STABLE;
}
built.tv_sec = alpm_pkg_get_builddate (pkg);
if (built.tv_sec > 0) {
issued = g_time_val_to_iso8601 (&built);
} else {
issued = NULL;
}
if (upgrades != NULL) {
installed.tv_sec = alpm_pkg_get_installdate (old);
if (installed.tv_sec > 0) {
updated = g_time_val_to_iso8601 (&installed);
} else {
updated = NULL;
}
} else {
updated = NULL;
}
pk_backend_update_detail (self, *packages, upgrades, replaces,
urls, NULL, NULL, restart, reason,
NULL, state, issued, updated);
g_free (issued);
g_free (updated);
g_free (urls);
g_free (replaces);
g_free (upgrades);
}
return pk_backend_finish (self, error);
}
/**
* 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);
}
/**
* pk_backend_spawn_parse_stdout:
**/
static gboolean
pk_backend_spawn_parse_stdout (PkBackendSpawn *backend_spawn, const gchar *line, GError **error)
{
gchar **sections;
guint size;
gchar *command;
gchar *text;
gboolean ret = TRUE;
guint64 speed;
PkInfoEnum info;
PkRestartEnum restart;
PkGroupEnum group;
gulong package_size;
gint percentage;
PkErrorEnum error_enum;
PkStatusEnum status_enum;
PkMessageEnum message_enum;
PkRestartEnum restart_enum;
PkSigTypeEnum sig_type;
PkUpdateStateEnum update_state_enum;
PkMediaTypeEnum media_type_enum;
PkDistroUpgradeEnum distro_upgrade_enum;
PkBackendSpawnPrivate *priv = backend_spawn->priv;
g_return_val_if_fail (PK_IS_BACKEND_SPAWN (backend_spawn), FALSE);
/* check if output line */
if (line == NULL)
return FALSE;
/* split by tab */
sections = g_strsplit (line, "\t", 0);
command = sections[0];
/* get size */
size = g_strv_length (sections);
if (g_strcmp0 (command, "package") == 0) {
if (size != 4) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
if (pk_package_id_check (sections[2]) == FALSE) {
g_set_error_literal (error, 1, 0, "invalid package_id");
ret = FALSE;
goto out;
}
info = pk_info_enum_from_string (sections[1]);
if (info == PK_INFO_ENUM_UNKNOWN) {
g_set_error (error, 1, 0, "Info enum not recognised, and hence ignored: '%s'", sections[1]);
ret = FALSE;
goto out;
}
pk_backend_package (priv->backend, info, sections[2], sections[3]);
} else if (g_strcmp0 (command, "details") == 0) {
if (size != 7) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
group = pk_group_enum_from_string (sections[3]);
/* ITS4: ignore, checked for overflow */
package_size = atol (sections[6]);
if (package_size > 1073741824) {
g_set_error_literal (error, 1, 0, "package size cannot be larger than one Gb");
ret = FALSE;
goto out;
}
text = g_strdup (sections[4]);
/* convert ; to \n as we can't emit them on stdout */
g_strdelimit (text, ";", '\n');
pk_backend_details (priv->backend, sections[1], sections[2],
group, text, sections[5], package_size);
g_free (text);
} else if (g_strcmp0 (command, "finished") == 0) {
if (size != 1) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
pk_backend_finished (priv->backend);
/* from this point on, we can start the kill timer */
pk_backend_spawn_start_kill_timer (backend_spawn);
} else if (g_strcmp0 (command, "files") == 0) {
if (size != 3) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
pk_backend_files (priv->backend, sections[1], sections[2]);
} else if (g_strcmp0 (command, "repo-detail") == 0) {
if (size != 4) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
if (g_strcmp0 (sections[3], "true") == 0) {
pk_backend_repo_detail (priv->backend, sections[1], sections[2], TRUE);
} else if (g_strcmp0 (sections[3], "false") == 0) {
pk_backend_repo_detail (priv->backend, sections[1], sections[2], FALSE);
} else {
g_set_error (error, 1, 0, "invalid qualifier '%s'", sections[3]);
ret = FALSE;
goto out;
}
} else if (g_strcmp0 (command, "updatedetail") == 0) {
if (size != 13) {
g_set_error (error, 1, 0, "invalid command '%s', size %i", command, size);
ret = FALSE;
goto out;
}
restart = pk_restart_enum_from_string (sections[7]);
if (restart == PK_RESTART_ENUM_UNKNOWN) {
g_set_error (error, 1, 0, "Restart enum not recognised, and hence ignored: '%s'", sections[7]);
ret = FALSE;
goto out;
}
update_state_enum = pk_update_state_enum_from_string (sections[10]);
/* convert ; to \n as we can't emit them on stdout */
g_strdelimit (sections[8], ";", '\n');
g_strdelimit (sections[9], ";", '\n');
pk_backend_update_detail (priv->backend, sections[1],
sections[2], sections[3], sections[4],
sections[5], sections[6], restart, sections[8],
sections[9], update_state_enum,
sections[11], sections[12]);
} else if (g_strcmp0 (command, "percentage") == 0) {
if (size != 2) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
ret = pk_strtoint (sections[1], &percentage);
if (!ret) {
g_set_error (error, 1, 0, "invalid percentage value %s", sections[1]);
ret = FALSE;
} else if (percentage < 0 || percentage > 100) {
g_set_error (error, 1, 0, "invalid percentage value %i", percentage);
ret = FALSE;
} else {
pk_backend_set_percentage (priv->backend, percentage);
}
} else if (g_strcmp0 (command, "subpercentage") == 0) {
if (size != 2) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
ret = pk_strtoint (sections[1], &percentage);
if (!ret) {
g_set_error (error, 1, 0, "invalid subpercentage value %s", sections[1]);
ret = FALSE;
} else if (percentage < 0 || percentage > 100) {
g_set_error (error, 1, 0, "invalid subpercentage value %i", percentage);
ret = FALSE;
} else {
pk_backend_set_sub_percentage (priv->backend, percentage);
}
} else if (g_strcmp0 (command, "item-percentage") == 0) {
if (size != 3) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
if (!pk_package_id_check (sections[1])) {
g_set_error (error, 1, 0, "invalid package_id");
ret = FALSE;
goto out;
}
ret = pk_strtoint (sections[2], &percentage);
if (!ret) {
g_set_error (error, 1, 0, "invalid item-percentage value %s", sections[1]);
ret = FALSE;
} else if (percentage < 0 || percentage > 100) {
g_set_error (error, 1, 0, "invalid item-percentage value %i", percentage);
ret = FALSE;
} else {
pk_backend_set_item_progress (priv->backend,
sections[1],
percentage);
}
} else if (g_strcmp0 (command, "error") == 0) {
if (size != 3) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
error_enum = pk_error_enum_from_string (sections[1]);
if (error_enum == PK_ERROR_ENUM_UNKNOWN) {
g_set_error (error, 1, 0, "Error enum not recognised, and hence ignored: '%s'", sections[1]);
ret = FALSE;
goto out;
}
/* convert back all the ;'s to newlines */
text = g_strdup (sections[2]);
/* convert ; to \n as we can't emit them on stdout */
g_strdelimit (text, ";", '\n');
/* convert % else we try to format them */
g_strdelimit (text, "%", '$');
pk_backend_error_code (priv->backend, error_enum, text);
g_free (text);
} else if (g_strcmp0 (command, "requirerestart") == 0) {
if (size != 3) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
restart_enum = pk_restart_enum_from_string (sections[1]);
if (restart_enum == PK_RESTART_ENUM_UNKNOWN) {
g_set_error (error, 1, 0, "Restart enum not recognised, and hence ignored: '%s'", sections[1]);
ret = FALSE;
goto out;
}
if (!pk_package_id_check (sections[2])) {
g_set_error (error, 1, 0, "invalid package_id");
ret = FALSE;
goto out;
}
pk_backend_require_restart (priv->backend, restart_enum, sections[2]);
} else if (g_strcmp0 (command, "message") == 0) {
if (size != 3) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
message_enum = pk_message_enum_from_string (sections[1]);
if (message_enum == PK_MESSAGE_ENUM_UNKNOWN) {
g_set_error (error, 1, 0, "Message enum not recognised, and hence ignored: '%s'", sections[1]);
ret = FALSE;
goto out;
}
text = g_strdup (sections[2]);
/* convert ; to \n as we can't emit them on stdout */
g_strdelimit (text, ";", '\n');
pk_backend_message (priv->backend, message_enum, text);
g_free (text);
} else if (g_strcmp0 (command, "change-transaction-data") == 0) {
if (size != 2) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
pk_backend_set_transaction_data (priv->backend, sections[1]);
} else if (g_strcmp0 (command, "status") == 0) {
if (size != 2) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
status_enum = pk_status_enum_from_string (sections[1]);
if (status_enum == PK_STATUS_ENUM_UNKNOWN) {
g_set_error (error, 1, 0, "Status enum not recognised, and hence ignored: '%s'", sections[1]);
ret = FALSE;
goto out;
}
pk_backend_set_status (priv->backend, status_enum);
} else if (g_strcmp0 (command, "speed") == 0) {
if (size != 2) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
ret = pk_strtouint64 (sections[1], &speed);
if (!ret) {
g_set_error (error, 1, 0,
"failed to parse speed: '%s'",
sections[1]);
ret = FALSE;
goto out;
}
pk_backend_set_speed (priv->backend, speed);
} else if (g_strcmp0 (command, "allow-cancel") == 0) {
if (size != 2) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
if (g_strcmp0 (sections[1], "true") == 0) {
pk_backend_set_allow_cancel (priv->backend, TRUE);
} else if (g_strcmp0 (sections[1], "false") == 0) {
pk_backend_set_allow_cancel (priv->backend, FALSE);
} else {
g_set_error (error, 1, 0, "invalid section '%s'", sections[1]);
ret = FALSE;
goto out;
}
} else if (g_strcmp0 (command, "no-percentage-updates") == 0) {
if (size != 1) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
pk_backend_set_percentage (priv->backend, PK_BACKEND_PERCENTAGE_INVALID);
} else if (g_strcmp0 (command, "repo-signature-required") == 0) {
if (size != 9) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
sig_type = pk_sig_type_enum_from_string (sections[8]);
if (sig_type == PK_SIGTYPE_ENUM_UNKNOWN) {
g_set_error (error, 1, 0, "Sig enum not recognised, and hence ignored: '%s'", sections[8]);
ret = FALSE;
goto out;
}
if (pk_strzero (sections[1])) {
g_set_error (error, 1, 0, "package_id blank, and hence ignored: '%s'", sections[1]);
ret = FALSE;
goto out;
}
if (pk_strzero (sections[2])) {
g_set_error (error, 1, 0, "repository name blank, and hence ignored: '%s'", sections[2]);
ret = FALSE;
goto out;
}
/* pass _all_ of the data */
ret = pk_backend_repo_signature_required (priv->backend, sections[1],
sections[2], sections[3], sections[4],
sections[5], sections[6], sections[7], sig_type);
goto out;
} else if (g_strcmp0 (command, "eula-required") == 0) {
if (size != 5) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
if (pk_strzero (sections[1])) {
g_set_error (error, 1, 0, "eula_id blank, and hence ignored: '%s'", sections[1]);
ret = FALSE;
goto out;
}
if (pk_strzero (sections[2])) {
g_set_error (error, 1, 0, "package_id blank, and hence ignored: '%s'", sections[2]);
ret = FALSE;
goto out;
}
if (pk_strzero (sections[4])) {
g_set_error (error, 1, 0, "agreement name blank, and hence ignored: '%s'", sections[4]);
ret = FALSE;
goto out;
}
ret = pk_backend_eula_required (priv->backend, sections[1], sections[2], sections[3], sections[4]);
goto out;
} else if (g_strcmp0 (command, "media-change-required") == 0) {
if (size != 4) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
media_type_enum = pk_media_type_enum_from_string (sections[1]);
if (media_type_enum == PK_MEDIA_TYPE_ENUM_UNKNOWN) {
g_set_error (error, 1, 0, "media type enum not recognised, and hence ignored: '%s'", sections[1]);
ret = FALSE;
goto out;
}
ret = pk_backend_media_change_required (priv->backend, media_type_enum, sections[2], sections[3]);
goto out;
} else if (g_strcmp0 (command, "distro-upgrade") == 0) {
if (size != 4) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
distro_upgrade_enum = pk_distro_upgrade_enum_from_string (sections[1]);
if (distro_upgrade_enum == PK_DISTRO_UPGRADE_ENUM_UNKNOWN) {
g_set_error (error, 1, 0, "distro upgrade enum not recognised, and hence ignored: '%s'", sections[1]);
ret = FALSE;
goto out;
}
ret = pk_backend_distro_upgrade (priv->backend, distro_upgrade_enum, sections[2], sections[3]);
goto out;
} else if (g_strcmp0 (command, "category") == 0) {
if (size != 6) {
g_set_error (error, 1, 0, "invalid command'%s', size %i", command, size);
ret = FALSE;
goto out;
}
if (g_strcmp0 (sections[1], sections[2]) == 0) {
g_set_error_literal (error, 1, 0, "cat_id cannot be the same as parent_id");
ret = FALSE;
goto out;
}
if (pk_strzero (sections[2])) {
g_set_error_literal (error, 1, 0, "cat_id cannot not blank");
ret = FALSE;
goto out;
}
if (pk_strzero (sections[3])) {
g_set_error_literal (error, 1, 0, "name cannot not blank");
ret = FALSE;
goto out;
}
if (pk_strzero (sections[5])) {
g_set_error_literal (error, 1, 0, "icon cannot not blank");
ret = FALSE;
goto out;
}
if (g_str_has_prefix (sections[5], "/")) {
g_set_error (error, 1, 0, "icon '%s' should be a named icon, not a path", sections[5]);
ret = FALSE;
goto out;
}
ret = pk_backend_category (priv->backend, sections[1], sections[2], sections[3], sections[4], sections[5]);
goto out;
} else {
ret = FALSE;
g_set_error (error, 1, 0, "invalid command '%s'", command);
}
out:
g_strfreev (sections);
return ret;
}
