/** * backend_search_group_thread: */ static gboolean backend_search_group_thread (PkBackend *backend) { pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); /* emit */ pk_backend_package (backend, PK_INFO_ENUM_INSTALLED, "glib2;2.14.0;i386;fedora", "The GLib library"); pk_backend_package (backend, PK_INFO_ENUM_INSTALLED, "gtk2;gtk2-2.11.6-6.fc8;i386;fedora", "GTK+ Libraries for GIMP"); pk_backend_finished (backend); return TRUE; }
/** * backend_get_requires: */ static void backend_get_requires (PkBackend *backend, PkBitfield filters, gchar **package_ids, gboolean recursive) { guint i; guint len; const gchar *package_id; PkPackageId *pi; slapt_pkg_info_t *pkg; slapt_pkg_list_t *installed; slapt_pkg_list_t *available; slapt_pkg_list_t *requires; PkInfoEnum state; const char *summary; installed = slapt_get_installed_pkgs(); available = slapt_get_available_pkgs(); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); len = g_strv_length (package_ids); for (i=0; i<len; i++) { package_id = package_ids[i]; pi = pk_package_id_new_from_string (package_id); if (pi == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "invalid package id"); pk_backend_finished (backend); return; } pkg = _get_pkg_from_id(pi, available, installed); pk_package_id_free (pi); if (pkg == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found"); continue; } requires = slapt_is_required_by(_config, available, pkg); for (i = 0; i < requires->pkg_count; i++) { pkg = requires->pkgs[i]; state = pkg->installed ? PK_INFO_ENUM_INSTALLED : PK_INFO_ENUM_AVAILABLE; package_id = _get_string_from_pkg(pkg); summary = _get_pkg_summary(pkg); pk_backend_package (backend, state, package_id, summary); g_free((gpointer) summary); g_free((gpointer) package_id); } slapt_free_pkg_list(requires); } slapt_free_pkg_list(available); slapt_free_pkg_list(installed); pk_backend_finished (backend); }
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); }
/** * backend_download_packages: */ static void backend_download_packages (PkBackend *backend, gchar **package_ids, const gchar *directory) { guint i; guint len; const gchar *package_id; const gchar *files; const char *error; slapt_pkg_list_t *installed; slapt_pkg_list_t *available; slapt_pkg_info_t *pkg; const char *summary; const char *note = NULL; char *filename; pk_backend_set_status (backend, PK_STATUS_ENUM_LOADING_CACHE); installed = slapt_get_installed_pkgs(); available = slapt_get_available_pkgs(); pk_backend_set_status (backend, PK_STATUS_ENUM_DOWNLOAD); pk_backend_set_percentage (backend, 0); len = g_strv_length (package_ids); for (i=0; i<len; i++) { package_id = package_ids[i]; pkg = _get_pkg_from_string(package_id, available, installed); if (pkg == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found"); continue; } summary = _get_pkg_summary(pkg); pk_backend_package (backend, PK_INFO_ENUM_DOWNLOADING, package_id, summary); g_free((gpointer) summary); error = slapt_download_pkg(_config, pkg, note); if (error == NULL) { filename = slapt_gen_pkg_file_name(_config, pkg); files = g_strdup(filename); pk_backend_files (backend, package_id, files); g_free((gpointer) files); free(filename); } else { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED, error); } } slapt_free_pkg_list(available); slapt_free_pkg_list(installed); pk_backend_set_percentage (backend, 100); pk_backend_finished (backend); }
/** * backend_search_group: */ static void backend_search_group (PkBackend *backend, PkBitfield filters, const gchar *search) { guint i; const gchar *package_id; slapt_pkg_list_t *pkglist; slapt_pkg_info_t *pkg = NULL; PkGroupEnum group; PkGroupEnum search_group; const char *category; struct category_map *catgroup; PkInfoEnum state; const char *summary; pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); pk_backend_set_percentage (backend, 0); if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) { pkglist = slapt_get_installed_pkgs(); state = PK_INFO_ENUM_INSTALLED; } else { pkglist = slapt_get_available_pkgs(); state = PK_INFO_ENUM_AVAILABLE; } search_group = pk_group_enum_from_string(search); for (i = 0; i < pkglist->pkg_count; i++) { pkg = pkglist->pkgs[i]; category = _get_pkg_category(pkg); group = PK_GROUP_ENUM_UNKNOWN; for (catgroup = CATGROUP; catgroup->category != NULL; catgroup++) { if (strcmp(catgroup->category, category) == 0) { group = catgroup->group; break; } } if (group == search_group) { package_id = _get_string_from_pkg(pkg); summary = _get_pkg_summary(pkg); pk_backend_package (backend, state, package_id, summary); g_free((gpointer) summary); g_free((gpointer) package_id); } } slapt_free_pkg_list(pkglist); pk_backend_set_percentage (backend, 100); pk_backend_finished (backend); }
/* Emits a dependency that has not been found in the database. */ static bool emit_missing_dependency(PkBackend *backend, gchar *package_id) { return pk_backend_package(backend, PK_INFO_ENUM_UNKNOWN, package_id, "Could not find this package."); }
/** * backend_search_groups: */ static void backend_search_groups (PkBackend *backend, PkBitfield filters, gchar **values) { guint i; gchar *search; const gchar *package_id; slapt_pkg_list_t *pkglist; slapt_pkg_info_t *pkg = NULL; PkGroupEnum group; PkGroupEnum search_group; const char *category; PkInfoEnum state; const char *summary; pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); pk_backend_set_percentage (backend, 0); search = g_strjoinv ("&", values); if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) { pkglist = slapt_get_installed_pkgs(); state = PK_INFO_ENUM_INSTALLED; } else { pkglist = slapt_get_available_pkgs(); state = PK_INFO_ENUM_AVAILABLE; } search_group = pk_group_enum_from_string(search); for (i = 0; i < pkglist->pkg_count; i++) { pkg = pkglist->pkgs[i]; category = _get_pkg_category(pkg); group = _get_pkg_group(category); if (group == search_group) { package_id = _get_string_from_pkg(pkg); summary = _get_pkg_summary(pkg); pk_backend_package (backend, state, package_id, summary); g_free((gpointer) summary); g_free((gpointer) package_id); } } slapt_free_pkg_list(pkglist); g_free (search); pk_backend_set_percentage (backend, 100); pk_backend_finished (backend); }
/** * backend_resolve: */ static void backend_resolve (PkBackend *backend, PkBitfield filters, gchar **packages) { guint i; guint len; const gchar *package_id; slapt_pkg_list_t *pkglist; slapt_pkg_info_t *pkg = NULL; slapt_pkg_list_t *results = NULL; PkInfoEnum state; const gchar *search; const char *summary; pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); pk_backend_set_percentage (backend, 0); if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) { pkglist = slapt_get_installed_pkgs(); state = PK_INFO_ENUM_INSTALLED; } else { pkglist = slapt_get_available_pkgs(); state = PK_INFO_ENUM_AVAILABLE; } len = g_strv_length (packages); for (i=0; i<len; i++) { search = g_strdup_printf("^%s$", packages[i]); /* regexp */ results = slapt_search_pkg_list(pkglist, search); g_free((gpointer) search); if (results == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found"); continue; } for (i = 0; i < results->pkg_count; i++) { pkg = results->pkgs[i]; package_id = _get_string_from_pkg(pkg); summary = _get_pkg_summary(pkg); pk_backend_package (backend, state, package_id, summary); g_free((gpointer) summary); g_free((gpointer) package_id); } slapt_free_pkg_list(results); } slapt_free_pkg_list(pkglist); pk_backend_set_percentage (backend, 100); pk_backend_finished (backend); }
/** * backend_search_names: */ static void backend_search_names (PkBackend *backend, PkBitfield filters, gchar **values) { unsigned int i; gchar *search; const gchar *package_id; slapt_pkg_list_t *pkglist; slapt_pkg_info_t *pkg = NULL; slapt_pkg_list_t *results = NULL; PkInfoEnum state; const char *summary; pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); pk_backend_set_percentage (backend, 0); search = g_strjoinv ("&", values); if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) { pkglist = slapt_get_installed_pkgs(); state = PK_INFO_ENUM_INSTALLED; } else { pkglist = slapt_get_available_pkgs(); state = PK_INFO_ENUM_AVAILABLE; } results = slapt_search_pkg_list(pkglist, search); g_free((gpointer) search); if (results == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found"); goto out; } for (i = 0; i < results->pkg_count; i++) { pkg = results->pkgs[i]; package_id = _get_string_from_pkg(pkg); summary = _get_pkg_summary(pkg); pk_backend_package (backend, state, package_id, summary); g_free((gpointer) summary); g_free((gpointer) package_id); } slapt_free_pkg_list(results); out: slapt_free_pkg_list(pkglist); g_free (search); pk_backend_set_percentage (backend, 100); pk_backend_finished (backend); }
/** * backend_search_name_thread: */ static gboolean backend_search_name_thread (PkBackend *backend) { GTimer *timer; guint percentage; PkBitfield filters; gchar *filters_text; const gchar *search; filters = pk_backend_get_uint (backend, "filters"); search = pk_backend_get_string (backend, "search"); filters_text = pk_filter_bitfield_to_text (filters); egg_debug ("started task (%p) search=%s filters=%s", backend, search, filters_text); g_free (filters_text); pk_backend_set_status (backend, 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_error_code (backend, PK_ERROR_ENUM_TRANSACTION_CANCELLED, "The thread was stopped successfully"); pk_backend_finished (backend); return TRUE; } pk_backend_set_percentage (backend, percentage); percentage += 10; g_usleep (1000*100); } while (percentage < 100); g_timer_destroy (timer); pk_backend_set_percentage (backend, 100); egg_debug ("exited task (%p)", backend); pk_backend_package (backend, PK_INFO_ENUM_INSTALLED, "glib2;2.14.0;i386;fedora", "The GLib library"); pk_backend_package (backend, PK_INFO_ENUM_INSTALLED, "gtk2;gtk2-2.11.6-6.fc8;i386;fedora", "GTK+ Libraries for GIMP"); pk_backend_finished (backend); return TRUE; }
/** * backend_get_updates: */ static void backend_get_updates (PkBackend *backend, PkBitfield filters) { guint i; const gchar *package_id; const gchar *new_package_id; slapt_pkg_list_t *installed; slapt_pkg_list_t *available; slapt_pkg_info_t *pkg; slapt_pkg_info_t *newpkg; const gchar *summary; const char *changelog; PkInfoEnum state; pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); pk_backend_set_percentage (backend, 0); installed = slapt_get_installed_pkgs(); available = slapt_get_available_pkgs(); for (i = 0; i < installed->pkg_count; i++) { pkg = installed->pkgs[i]; newpkg = slapt_get_newest_pkg(available, pkg->name); if (newpkg == NULL) continue; if (slapt_cmp_pkgs(pkg,newpkg) >= 0) continue; package_id = _get_string_from_pkg(pkg); new_package_id = _get_string_from_pkg(newpkg); changelog = slapt_get_pkg_changelog(newpkg); if (changelog != NULL && strstr(changelog, "(* Security fix *)") != NULL) state = PK_INFO_ENUM_SECURITY; else state = PK_INFO_ENUM_NORMAL; summary =_get_pkg_summary(newpkg); pk_backend_package (backend, state, new_package_id, summary); g_free((gpointer) summary); g_free((gpointer) new_package_id); g_free((gpointer) package_id); } slapt_free_pkg_list(available); slapt_free_pkg_list(installed); pk_backend_set_percentage (backend, 100); pk_backend_finished (backend); }
void zypp_emit_packages_in_list (PkBackend *backend, std::vector<zypp::sat::Solvable> *v, PkBitfield filters) { for (std::vector<zypp::sat::Solvable>::iterator it = v->begin (); it != v->end (); it++) { gchar *package_id = zypp_build_package_id_from_resolvable (*it); // iterate through the given filters if (filters != 0){ gboolean print = TRUE; for (guint i = 0; i < PK_FILTER_ENUM_LAST; i++) { if ((filters & pk_bitfield_value (i)) == 0) continue; if (i == PK_FILTER_ENUM_INSTALLED && !(it->isSystem ())) print = FALSE; if (i == PK_FILTER_ENUM_NOT_INSTALLED && it->isSystem ()) print = FALSE;; if (i == PK_FILTER_ENUM_ARCH) { if (it->arch () != zypp::ZConfig::defaultSystemArchitecture () && it->arch () != zypp::Arch_noarch && ! system_and_package_are_x86 (*it)) print = FALSE; } if (i == PK_FILTER_ENUM_NOT_ARCH) { if (it->arch () == zypp::ZConfig::defaultSystemArchitecture () || system_and_package_are_x86 (*it)) print = FALSE; } if (i == PK_FILTER_ENUM_SOURCE && !(zypp::isKind<zypp::SrcPackage>(*it))) { print = FALSE; } if (i == PK_FILTER_ENUM_NOT_SOURCE && zypp::isKind<zypp::SrcPackage>(*it)) { print = FALSE; } //const gchar * myarch = zypp::ZConfig::defaultSystemArchitecture().asString().c_str(); //egg_debug ("my default arch is %s", myarch); } if (!print) continue; } pk_backend_package (backend, it->isSystem() == true ? PK_INFO_ENUM_INSTALLED : PK_INFO_ENUM_AVAILABLE, package_id, it->lookupStrAttribute (zypp::sat::SolvAttr::summary).c_str ()); 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); }
static void pk_opkg_list_upgradable_cb (pkg_t *pkg, void *data) { PkBackend *backend = (PkBackend*) data; gchar *uid; gint status; if (pkg->state_status == SS_INSTALLED) status = PK_INFO_ENUM_INSTALLED; else status = PK_INFO_ENUM_AVAILABLE; uid = g_strdup_printf ("%s;%s;%s;", pkg->name, pkg->version, pkg->architecture); pk_backend_package (backend, status, uid, pkg->description); g_free(uid); }
/** * backend_search_details: */ static void backend_search_details (PkBackend *backend, PkBitfield filters, const gchar *search) { guint i; const gchar *package_id; slapt_pkg_list_t *pkglist; slapt_pkg_info_t *pkg = NULL; slapt_pkg_list_t *results = NULL; PkInfoEnum state; const char *summary; pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); pk_backend_set_percentage (backend, 0); if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) { pkglist = slapt_get_installed_pkgs(); state = PK_INFO_ENUM_INSTALLED; } else { pkglist = slapt_get_available_pkgs(); state = PK_INFO_ENUM_AVAILABLE; } results = slapt_search_pkg_list(pkglist, search); for (i = 0; i < results->pkg_count; i++) { pkg = results->pkgs[i]; package_id = _get_string_from_pkg(pkg); summary = _get_pkg_summary(pkg); pk_backend_package (backend, state, package_id, summary); g_free((gpointer) summary); g_free((gpointer) package_id); } slapt_free_pkg_list(results); slapt_free_pkg_list(pkglist); pk_backend_set_percentage (backend, 100); pk_backend_finished (backend); }
static void pk_opkg_progress_cb (const opkg_progress_data_t *pdata, void *data) { PkBackend *backend = (PkBackend*) data; if (!backend) return; pk_backend_set_percentage (backend, pdata->percentage); if (pdata->pkg) { gchar *uid; pkg_t *pkg = pdata->pkg; gint status = PK_INFO_ENUM_UNKNOWN; uid = g_strdup_printf ("%s;%s;%s;", pkg->name, pkg->version, pkg->architecture); if (pdata->action == OPKG_DOWNLOAD) status = PK_INFO_ENUM_DOWNLOADING; else if (pdata->action == OPKG_INSTALL) status = PK_INFO_ENUM_INSTALLING; else if (pdata->action == OPKG_REMOVE) status = PK_INFO_ENUM_REMOVING; pk_backend_package (backend, status, uid, pkg->description); g_free (uid); } switch (pdata->action) { case OPKG_DOWNLOAD: pk_backend_set_status (backend, PK_STATUS_ENUM_DOWNLOAD); break; case OPKG_INSTALL: pk_backend_set_status (backend, PK_STATUS_ENUM_INSTALL); break; case OPKG_REMOVE: pk_backend_set_status (backend, PK_STATUS_ENUM_REMOVE); break; } }
static void add_packages_from_list (PkBackend *backend, GList *list, gboolean updates) { PackageSearch *package = NULL; GList *li = NULL; gchar *pkg_string = NULL; PkInfoEnum info; for (li = list; li != NULL; li = li->next) { package = (PackageSearch*)li->data; pkg_string = pk_package_id_build (package->package, package->version, package->arch, package->reponame); if (updates == TRUE) info = PK_INFO_ENUM_NORMAL; else if (package->installed) info = PK_INFO_ENUM_INSTALLED; else info = PK_INFO_ENUM_AVAILABLE; pk_backend_package (backend, info, pkg_string, package->description); g_free (pkg_string); } }
/** * 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; }
static void pk_opkg_package_list_cb (pkg_t *pkg, void *data) { SearchParams *params = (SearchParams*) data; gchar *uid; gchar *haystack; gint status, match; PkBitfield filters = params->filters; if (!pkg->name) return; switch (params->search_type) { case SEARCH_NAME: if (!pkg->name) return; haystack = g_utf8_strdown (pkg->name, -1); match = (g_strrstr (haystack, params->needle) != NULL); g_free (haystack); if (!match) return; break; case SEARCH_DESCRIPTION: if (!pkg->description) return; haystack = g_utf8_strdown (pkg->description, -1); match = (g_strrstr (haystack, params->needle) != NULL); g_free (haystack); if (!match) return; break; case SEARCH_TAG: if (!pkg->tags) return; if (!g_strrstr (pkg->tags, params->needle)) return; break; } uid = g_strdup_printf ("%s;%s;%s;", pkg->name, pkg->version, pkg->architecture); if (pkg->state_status == SS_INSTALLED) status = PK_INFO_ENUM_INSTALLED; else status = PK_INFO_ENUM_AVAILABLE; /* check filters */ if (pk_bitfield_contain(filters, PK_FILTER_ENUM_DEVELOPMENT) && !opkg_is_devel_pkg (pkg)) goto end_handle; if (pk_bitfield_contain(filters, PK_FILTER_ENUM_NOT_DEVELOPMENT) && opkg_is_devel_pkg (pkg)) goto end_handle; if (pk_bitfield_contain(filters, PK_FILTER_ENUM_GUI) && !opkg_is_gui_pkg (pkg)) goto end_handle; if (pk_bitfield_contain(filters, PK_FILTER_ENUM_NOT_GUI) && opkg_is_gui_pkg (pkg)) goto end_handle; if (pk_bitfield_contain(filters, PK_FILTER_ENUM_INSTALLED) && (pkg->state_status != SS_INSTALLED)) goto end_handle; if (pk_bitfield_contain(filters, PK_FILTER_ENUM_NOT_INSTALLED) && (pkg->state_status == SS_INSTALLED)) goto end_handle; pk_backend_package (params->backend, status, uid, pkg->description); end_handle: g_free(uid); }
/** * backend_get_packages: */ static void backend_get_packages (PkBackend *backend, PkBitfield filters) { PkFilterEnum list_order[] = { PK_FILTER_ENUM_INSTALLED, PK_FILTER_ENUM_NOT_INSTALLED, PK_FILTER_ENUM_UNKNOWN }; PkFilterEnum *list_filter; slapt_pkg_list_t *pkglist; slapt_pkg_info_t *pkg; slapt_pkg_info_t *other_pkg; unsigned int i; const gchar *package_id; slapt_pkg_list_t *installed; slapt_pkg_list_t *available; PkInfoEnum state; const char *summary; installed = slapt_get_installed_pkgs(); available = slapt_get_available_pkgs(); pk_backend_set_status (backend, PK_STATUS_ENUM_REQUEST); for (list_filter = list_order; *list_filter != PK_FILTER_ENUM_UNKNOWN; list_filter++) { if (*list_filter == PK_FILTER_ENUM_INSTALLED) { if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) break; pkglist = installed; } else if (*list_filter == PK_FILTER_ENUM_NOT_INSTALLED) { if (pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED)) break; pkglist = available; } else { continue; } for (i = 0; i < pkglist->pkg_count; i++) { pkg = pkglist->pkgs[i]; /* check so that we don't show installed pkgs twice */ if (*list_filter == PK_FILTER_ENUM_NOT_INSTALLED && !pk_bitfield_contain (filters, PK_FILTER_ENUM_NOT_INSTALLED)) { other_pkg = slapt_get_exact_pkg(installed, pkg->name, pkg->version); if (other_pkg != NULL) { continue; } } /* only display the newest pkg in each pkglist */ if (pk_bitfield_contain (filters, PK_FILTER_ENUM_NEWEST)) { other_pkg = slapt_get_newest_pkg(pkglist, pkg->name); if (slapt_cmp_pkgs(pkg, other_pkg) <= 0) { continue; } } state = pkg->installed ? PK_INFO_ENUM_INSTALLED : PK_INFO_ENUM_AVAILABLE; package_id = _get_string_from_pkg(pkg); summary = _get_pkg_summary(pkg); pk_backend_package (backend, state, package_id, summary); g_free((gpointer) summary); g_free((gpointer) package_id); } } slapt_free_pkg_list(available); slapt_free_pkg_list(installed); pk_backend_finished (backend); }
/** * backend_get_depends: */ static void backend_get_depends (PkBackend *backend, PkBitfield filters, gchar **package_ids, gboolean recursive) { guint i; guint len; const gchar *package_id; gchar *pi; slapt_pkg_info_t *pkg; int ret; slapt_pkg_list_t *installed; slapt_pkg_list_t *available; slapt_pkg_list_t *depends; slapt_pkg_err_list_t *conflicts; slapt_pkg_err_list_t *missing; PkInfoEnum state; const char *summary; installed = slapt_get_installed_pkgs(); available = slapt_get_available_pkgs(); conflicts = slapt_init_pkg_err_list(); missing = slapt_init_pkg_err_list(); pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); len = g_strv_length (package_ids); for (i=0; i<len; i++) { pi = package_ids[i]; if (pi == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, "invalid package id"); pk_backend_finished (backend); return; } pkg = _get_pkg_from_id(pi, available, installed); if (pkg == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found"); continue; } depends = slapt_init_pkg_list(); ret = slapt_get_pkg_dependencies(_config, available, installed, pkg, depends, conflicts, missing); for (i = 0; i < depends->pkg_count; i++) { pkg = depends->pkgs[i]; state = pkg->installed ? PK_INFO_ENUM_INSTALLED : PK_INFO_ENUM_AVAILABLE; package_id = _get_string_from_pkg(pkg); summary = _get_pkg_summary(pkg); pk_backend_package (backend, state, package_id, summary); g_free((gpointer) summary); g_free((gpointer) package_id); } slapt_free_pkg_list(depends); } slapt_free_pkg_err_list(missing); slapt_free_pkg_err_list(conflicts); slapt_free_pkg_list(available); slapt_free_pkg_list(installed); pk_backend_finished (backend); }