/** * backend_update_packages: */ static void backend_update_packages (PkBackend *backend, gboolean only_trusted, gchar **package_ids) { guint i; guint len; const gchar *package_id; int ret; slapt_pkg_list_t *installed; slapt_pkg_list_t *available; const gchar *search; slapt_pkg_list_t *results = NULL; slapt_transaction_t *transaction; slapt_pkg_info_t *pkg; slapt_pkg_info_t *oldpkg; /* FIXME: support only_trusted */ pk_backend_set_status (backend, PK_STATUS_ENUM_UPDATE); pk_backend_set_percentage (backend, 0); installed = slapt_get_installed_pkgs(); available = slapt_get_available_pkgs(); transaction = slapt_init_transaction(); 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; } oldpkg = NULL; 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]; } else { continue; } slapt_add_upgrade_to_transaction(transaction, oldpkg, pkg); } ret = slapt_handle_transaction(_config, transaction); if (ret != 0) { pk_backend_error_code (backend, PK_ERROR_ENUM_TRANSACTION_ERROR, "install failed"); } slapt_free_transaction(transaction); slapt_free_pkg_list(available); slapt_free_pkg_list(installed); pk_backend_set_percentage (backend, 100); pk_backend_finished (backend); }
/** * backend_remove_packages: */ static void backend_remove_packages (PkBackend *backend, gchar **package_ids, gboolean allow_deps, gboolean autoremove) { guint i; guint len; gchar *pi; int ret; slapt_pkg_list_t *installed; slapt_pkg_list_t *available; slapt_transaction_t *transaction; slapt_pkg_info_t *pkg; /* FIXME: support only_trusted */ pk_backend_set_status (backend, PK_STATUS_ENUM_REMOVE); pk_backend_set_percentage (backend, 0); installed = slapt_get_installed_pkgs(); available = slapt_get_available_pkgs(); transaction = slapt_init_transaction(); 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, installed, NULL); if (pkg == NULL) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_FOUND, "package not found"); continue; } if (!pkg->installed) { char *pkgname = slapt_stringify_pkg(pkg); pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_NOT_INSTALLED, "package %s not installed", pkgname); free(pkgname); continue; } slapt_add_remove_to_transaction(transaction, pkg); } ret = slapt_handle_transaction(_config, transaction); if (ret != 0) { pk_backend_error_code (backend, PK_ERROR_ENUM_TRANSACTION_ERROR, "remove failed"); } slapt_free_transaction(transaction); slapt_free_pkg_list(available); slapt_free_pkg_list(installed); pk_backend_set_percentage (backend, 100); pk_backend_finished (backend); }
/** * 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); }
/** * 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_get_details: */ static void backend_get_details (PkBackend *backend, gchar **package_ids) { guint i; guint len; const gchar *package_id; gchar *pi; const gchar *license = ""; const gchar *homepage = ""; const gchar *description; PkGroupEnum group; slapt_pkg_list_t *installed; slapt_pkg_list_t *available; slapt_pkg_info_t *pkg; const char *category; 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; } category = _get_pkg_category(pkg); group = _get_pkg_group(category); package_id = _get_string_from_pkg(pkg); description = g_strstrip((gchar*) _get_pkg_description(pkg)); pk_backend_details (backend, package_id, license, group, description, homepage, pkg->size_c * 1024); g_free((gpointer) description); 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); }
/** * 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_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); }
/* make sure pkg isn't conflicted with what's already in the transaction */ slapt_pkg_list_t *slapt_is_conflicted(slapt_transaction_t *tran, slapt_pkg_list_t *avail_pkgs, slapt_pkg_list_t *installed_pkgs, slapt_pkg_info_t *pkg) { unsigned int i; slapt_pkg_list_t *conflicts = NULL; slapt_pkg_list_t *conflicts_in_transaction = slapt_init_pkg_list(); /* if conflicts exist, check to see if they are installed or in the current transaction */ conflicts = slapt_get_pkg_conflicts(avail_pkgs,installed_pkgs,pkg); for (i = 0; i < conflicts->pkg_count; ++i) { slapt_pkg_info_t *p = conflicts->pkgs[i]; if ( slapt_search_upgrade_transaction(tran,p) == 1 || slapt_get_newest_pkg(tran->install_pkgs,p->name) != NULL ) { printf(gettext("%s, which is to be installed, conflicts with %s\n"), p->name,pkg->name); slapt_add_pkg_to_pkg_list(conflicts_in_transaction, p); } if (slapt_get_newest_pkg(installed_pkgs,p->name) != NULL) { printf(gettext("Installed %s conflicts with %s\n"), p->name,pkg->name); slapt_add_pkg_to_pkg_list(conflicts_in_transaction, p); } } slapt_free_pkg_list(conflicts); return conflicts_in_transaction; }
END_TEST START_TEST (test_pkg_search) { slapt_pkg_info_t *p = NULL; slapt_pkg_list_t *l = NULL; slapt_pkg_list_t *list = slapt_init_pkg_list(); slapt_add_pkg_to_pkg_list(list, &pkg); p = slapt_get_newest_pkg(list, "gslapt"); fail_if (p == NULL); p = slapt_get_exact_pkg(list, "gslapt", "0.3.15-i386-1"); fail_if (p == NULL); p = slapt_get_pkg_by_details(list, "gslapt", "0.3.15-i386-1", "."); fail_if (p == NULL); l = slapt_search_pkg_list(list, "^gslapt$"); fail_if (l == NULL); fail_unless (l->pkg_count == 1); slapt_free_pkg_list(list); }
END_TEST START_TEST (test_pkg_list) { slapt_pkg_list_t *list = slapt_init_pkg_list(); fail_if (list == NULL); fail_unless (list->pkg_count == 0); slapt_add_pkg_to_pkg_list(list, &pkg); fail_unless (list->pkg_count == 1); slapt_free_pkg_list(list); list = NULL; list = slapt_get_installed_pkgs(); fail_if (list == NULL); /* fail_unless (list->pkg_count == 0); could be anything */ slapt_free_pkg_list(list); list = NULL; /* parse the PACKAGES.TXT file slapt_pkg_list_t *slapt_parse_packages_txt(FILE *); */ /* return a list of available packages must be already chdir'd to rc_config->working_dir. Otherwise, open a filehandle to the package data and pass it to slapt_parse_packages_txt(); slapt_pkg_list_t *slapt_get_available_pkgs(void); */ /* get a list of obsolete packages slapt_pkg_list_t * slapt_get_obsolete_pkgs ( const slapt_rc_config *global_config, slapt_pkg_list_t *avail_pkgs, slapt_pkg_list_t *installed_pkgs); */ /* fill in the md5sum of the package void slapt_get_md5sums(slapt_pkg_list_t *pkgs, FILE *checksum_file); */ }
/** * 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); }
/** * 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_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); }
int main (int argc, char *argv[]) { int c = -1, option_index = 0, action = 0, i = 0, rval = 0; slapt_list_t *names = slapt_init_list (); slapt_src_config *config = NULL; slapt_src_slackbuild_list *sbs = NULL; slapt_src_slackbuild_list *remote_sbs = NULL; slapt_pkg_list_t *installed = NULL; SLAPT_BOOL_T prompt = SLAPT_TRUE, do_dep = SLAPT_TRUE, simulate = SLAPT_FALSE; char *config_file = NULL, *postcmd = NULL; static struct option long_options[] = { {"version", no_argument, 0, VERSION_OPT}, {"help", no_argument, 0, HELP_OPT}, {"update", no_argument, 0, UPDATE_OPT}, {"list", no_argument, 0, LIST_OPT}, {"clean", no_argument, 0, CLEAN_OPT}, {"e", no_argument, 0, CLEAN_OPT}, {"search", required_argument, 0, SEARCH_OPT}, {"s", required_argument, 0, SEARCH_OPT}, {"show", required_argument, 0, SHOW_OPT}, {"w", required_argument, 0, SHOW_OPT}, {"fetch", required_argument, 0, FETCH_OPT}, {"build", required_argument, 0, BUILD_OPT}, {"install", required_argument, 0, INSTALL_OPT}, {"yes", no_argument, 0, YES_OPT}, {"simulate", no_argument, 0, SIMULATE_OPT}, {"t", no_argument, 0, SIMULATE_OPT}, {"no-dep", no_argument, 0, NODEP_OPT}, {"config", required_argument, 0, CONFIG_OPT}, {"c", required_argument, 0, CONFIG_OPT}, {"postprocess", required_argument, 0, POSTCMD_OPT}, {0, 0, 0, 0} }; /* initialization */ setbuf (stdout, NULL); #ifdef ENABLE_NLS setlocale (LC_ALL,""); textdomain (GETTEXT_PACKAGE); #endif #ifdef SLAPT_HAS_GPGME gpgme_check_version (NULL); #ifdef ENABLE_NLS gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL)); #endif #endif curl_global_init (CURL_GLOBAL_ALL); uname (&uname_v); /* stop early */ if (argc < 2) { help (); exit (EXIT_SUCCESS); } while ( (c = getopt_long_only (argc, argv, "", long_options, &option_index)) != -1) { switch (c) { case HELP_OPT: help (); break; case VERSION_OPT: version (); break; case UPDATE_OPT: action = UPDATE_OPT; break; case LIST_OPT: action = LIST_OPT; break; case CLEAN_OPT: action = CLEAN_OPT; break; case FETCH_OPT: action = FETCH_OPT; slapt_add_list_item (names, optarg); break; case SEARCH_OPT: action = SEARCH_OPT; slapt_add_list_item (names, optarg); break; case SHOW_OPT: action = SHOW_OPT; slapt_add_list_item (names, optarg); break; case BUILD_OPT: action = BUILD_OPT; slapt_add_list_item (names, optarg); break; case INSTALL_OPT: action = INSTALL_OPT; slapt_add_list_item (names, optarg); break; case YES_OPT: prompt = SLAPT_FALSE; break; case SIMULATE_OPT: simulate = SLAPT_TRUE; break; case NODEP_OPT: do_dep = SLAPT_FALSE; break; case CONFIG_OPT: config_file = strdup (optarg); break; case POSTCMD_OPT: postcmd = strdup (optarg); break; default: help (); exit (EXIT_FAILURE); } } /* add extra arguments */ while (optind < argc) { slapt_add_list_item (names, argv[optind]); ++optind; } if (config_file != NULL) config = slapt_src_read_config (config_file); else config = slapt_src_read_config (SLAPT_SRC_RC); if (config == NULL) { fprintf (stderr, gettext ("Failed to read %s\n"), SLAPT_SRC_RC); exit (EXIT_FAILURE); } /* honor command line option */ config->do_dep = do_dep; config->postcmd = postcmd; /* to be freed in slapt_src_config_free */ init_builddir (config); if ( (chdir (config->builddir)) != 0) { perror (gettext ("Failed to chdir to build directory")); exit (EXIT_FAILURE); } /* setup, fetch, and other preperation steps */ switch (action) { case LIST_OPT: case SEARCH_OPT: case SHOW_OPT: remote_sbs = slapt_src_get_available_slackbuilds (); break; case FETCH_OPT: case BUILD_OPT: case INSTALL_OPT: remote_sbs = slapt_src_get_available_slackbuilds (); installed = slapt_get_installed_pkgs (); /* convert all names to slackbuilds */ if (names->count > 0) { sbs = slapt_src_names_to_slackbuilds (config, remote_sbs, names, installed); if (sbs == NULL || sbs->count == 0) { printf (gettext ("Unable to find all specified slackbuilds.\n")); exit (EXIT_FAILURE); } } /* provide summary */ if (!simulate) action = show_summary (sbs, names, action, prompt); break; } /* now, actually do what was requested */ switch (action) { case UPDATE_OPT: rval = slapt_src_update_slackbuild_cache (config); break; case FETCH_OPT: for (i = 0; i < sbs->count; i++) { if (simulate) { printf (gettext ("FETCH: %s\n"), sbs->slackbuilds[i]->name); continue; } else slapt_src_fetch_slackbuild (config, sbs->slackbuilds[i]); } break; case BUILD_OPT: for (i = 0; i < sbs->count; i++) { slapt_src_slackbuild *sb = sbs->slackbuilds[i]; int r = 0, nv_len = strlen (sb->name) + strlen (sb->version) + 2; char *namever = slapt_malloc (sizeof *namever * nv_len); r = snprintf (namever, nv_len, "%s:%s", sb->name, sb->version); if (r+1 != nv_len) exit (EXIT_FAILURE); if (simulate) { printf (gettext ("BUILD: %s\n"), sb->name); free (namever); continue; } slapt_src_fetch_slackbuild (config, sb); slapt_src_build_slackbuild (config, sb); /* XXX we assume if we didn't request the slackbuild, then it is a dependency, and needs to be installed */ if (slapt_search_list (names, sb->name) == NULL && slapt_search_list (names, namever) == NULL) slapt_src_install_slackbuild (config, sbs->slackbuilds[i]); free (namever); } break; case INSTALL_OPT: for (i = 0; i < sbs->count; i++) { slapt_src_slackbuild *sb = sbs->slackbuilds[i]; if (simulate) { printf (gettext ("INSTALL: %s\n"), sb->name); continue; } slapt_src_fetch_slackbuild (config, sb); slapt_src_build_slackbuild (config, sb); slapt_src_install_slackbuild (config, sb); } break; case SEARCH_OPT: { slapt_src_slackbuild_list *search = slapt_src_search_slackbuild_cache (remote_sbs, names); for (i = 0; i < search->count; i++) { slapt_src_slackbuild *sb = search->slackbuilds[i]; printf ("%s:%s - %s\n", sb->name, sb->version, sb->short_desc != NULL ? sb->short_desc : "" ); } slapt_src_slackbuild_list_free (search); } break; case LIST_OPT: for (i = 0; i < remote_sbs->count; i++) { slapt_src_slackbuild *sb = remote_sbs->slackbuilds[i]; printf ("%s:%s - %s\n", sb->name, sb->version, sb->short_desc != NULL ? sb->short_desc : "" ); } break; case SHOW_OPT: { int c; for (i = 0; i < names->count; i++) { slapt_src_slackbuild *sb = NULL; slapt_list_t *parts = slapt_parse_delimited_list (names->items[i], ':'); const char *name = parts->items[0]; const char *ver = NULL; if (parts->count > 1) ver = parts->items[1]; sb = slapt_src_get_slackbuild (remote_sbs, name, ver); if (sb != NULL) { printf (gettext ("SlackBuild Name: %s\n"), sb->name); printf (gettext ("SlackBuild Version: %s\n"), sb->version); printf (gettext ("SlackBuild Category: %s\n"), sb->location); printf (gettext ("SlackBuild Description: %s\n"), sb->short_desc != NULL ? sb->short_desc : ""); printf (gettext ("SlackBuild Files:\n")); for (c = 0; c < sb->files->count; c++) { printf (" %s\n", sb->files->items[c]); } if (sb->requires != NULL) printf (gettext ("SlackBuild Requires: %s\n"), sb->requires); if (i+1 != names->count) printf ("\n"); /* slapt_src_slackbuild_free (sb); NO FREE */ } slapt_free_list (parts); } } break; case CLEAN_OPT: clean (config); break; } if (names != NULL) slapt_free_list (names); if (sbs != NULL) slapt_src_slackbuild_list_free (sbs); if (remote_sbs != NULL) slapt_src_slackbuild_list_free (remote_sbs); if (installed != NULL) slapt_free_pkg_list (installed); if (config_file != NULL) free (config_file); slapt_src_config_free (config); return rval; }
/* needed check to see if a package is conflicted */ int slapt_add_deps_to_trans(const slapt_rc_config *global_config, slapt_transaction_t *tran, slapt_pkg_list_t *avail_pkgs, slapt_pkg_list_t *installed_pkgs, slapt_pkg_info_t *pkg) { unsigned int c; int dep_return = -1; slapt_pkg_list_t *deps = NULL; if (global_config->disable_dep_check == SLAPT_TRUE) return 0; if (pkg == NULL) return 0; deps = slapt_init_pkg_list(); dep_return = slapt_get_pkg_dependencies( global_config,avail_pkgs,installed_pkgs,pkg, deps,tran->conflict_err,tran->missing_err ); /* check to see if there where issues with dep checking */ /* exclude the package if dep check barfed */ if ((dep_return == -1) && (global_config->ignore_dep == SLAPT_FALSE) && (slapt_get_exact_pkg(tran->exclude_pkgs,pkg->name,pkg->version) == NULL) ) { slapt_free_pkg_list(deps); return -1; } /* loop through the deps */ for (c = 0; c < deps->pkg_count; ++c) { unsigned int cindex = 0; slapt_pkg_info_t *dep = deps->pkgs[c]; slapt_pkg_info_t *dep_installed = NULL; slapt_pkg_list_t *conflicts = NULL; /* * the dep wouldn't get this far if it where excluded, * so we don't check for that here */ conflicts = slapt_is_conflicted(tran,avail_pkgs,installed_pkgs,dep); for (cindex = 0; cindex < conflicts->pkg_count;cindex++) { slapt_add_remove_to_transaction(tran,conflicts->pkgs[cindex]); } slapt_free_pkg_list(conflicts); dep_installed = slapt_get_newest_pkg(installed_pkgs,dep->name); if (dep_installed == NULL) { slapt_add_install_to_transaction(tran,dep); } else { /* add only if its a valid upgrade */ if (slapt_cmp_pkgs(dep_installed,dep) < 0) slapt_add_upgrade_to_transaction(tran,dep_installed,dep); } } slapt_free_pkg_list(deps); return 0; }
/** * 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); }
/** * 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); }
/** * 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); }
END_TEST START_TEST (test_dependency) { unsigned int i = 0; FILE *fh = NULL; slapt_pkg_info_t *p = NULL; slapt_pkg_list_t *avail = NULL; slapt_pkg_list_t *required_by = slapt_init_pkg_list (); slapt_pkg_list_t *installed = slapt_init_pkg_list (); slapt_pkg_list_t *pkgs_to_install = slapt_init_pkg_list (); slapt_pkg_list_t *pkgs_to_remove = slapt_init_pkg_list (); slapt_pkg_list_t *conflicts = NULL, *deps = slapt_init_pkg_list (); slapt_pkg_err_list_t *conflict = slapt_init_pkg_err_list (), *missing = slapt_init_pkg_err_list (); slapt_rc_config *rc = slapt_read_rc_config ("./data/rc1"); fh = fopen ("data/avail_deps", "r"); fail_unless (fh != NULL); avail = slapt_parse_packages_txt (fh); fclose (fh); fh = fopen ("data/installed_deps", "r"); fail_unless (fh != NULL); installed = slapt_parse_packages_txt (fh); fclose (fh); /* dependency tests */ p = slapt_get_newest_pkg(avail, "slapt-src"); fail_unless (p != NULL); i = slapt_get_pkg_dependencies (rc, avail, installed, p, deps, conflict, missing); /* we expect 22 deps to return given our current hardcoded data files */ fail_unless (i != 22); /* we should have slapt-get as a dependency for slapt-src */ fail_unless ( slapt_search_pkg_list(deps, "slapt-get") != NULL); /* conflicts tests */ /* scim conflicts with ibus */ p = slapt_get_newest_pkg(avail, "scim"); fail_unless (p != NULL); conflicts = slapt_get_pkg_conflicts (avail, installed, p); fail_unless (conflicts != NULL); fail_unless (conflicts->pkg_count == 1); fail_unless ( strcmp (conflicts->pkgs[0]->name, "ibus") == 0); slapt_free_pkg_list (conflicts); /* required by tests */ /* slapt-get reverse dep test */ p = slapt_get_newest_pkg(avail, "slapt-get"); fail_unless (p != NULL); required_by = slapt_is_required_by(rc, avail, installed, pkgs_to_install, pkgs_to_remove, p); fail_unless (required_by->pkg_count == 5); fail_unless ( strcmp (required_by->pkgs[0]->name,"slapt-src") == 0); fail_unless ( strcmp (required_by->pkgs[1]->name,"gslapt") == 0); fail_unless ( strcmp (required_by->pkgs[2]->name,"foo") == 0); fail_unless ( strcmp (required_by->pkgs[3]->name,"boz") == 0); fail_unless ( strcmp (required_by->pkgs[4]->name,"bar") == 0); slapt_free_pkg_list (required_by); /* glib reverse dep test */ p = slapt_get_newest_pkg(avail, "glib"); fail_unless (p != NULL); required_by = slapt_is_required_by(rc, avail, installed, pkgs_to_install, pkgs_to_remove, p); fail_unless (required_by->pkg_count == 2); fail_unless ( strcmp (required_by->pkgs[0]->name,"xmms") == 0); fail_unless ( strcmp (required_by->pkgs[1]->name,"gtk+") == 0); slapt_free_pkg_list (required_by); /* glib2 reverse dep test */ p = slapt_get_newest_pkg(avail, "glib2"); fail_unless (p != NULL); required_by = slapt_is_required_by(rc, avail, installed, pkgs_to_install, pkgs_to_remove, p); fail_unless (required_by->pkg_count == 4); fail_unless ( strcmp (required_by->pkgs[0]->name,"ConsoleKit") == 0); fail_unless ( strcmp (required_by->pkgs[1]->name,"dbus-glib") == 0); fail_unless ( strcmp (required_by->pkgs[2]->name,"gslapt") == 0); fail_unless ( strcmp (required_by->pkgs[3]->name,"scim") == 0); slapt_free_pkg_list (required_by); slapt_free_pkg_list (installed); slapt_free_pkg_list (pkgs_to_install); slapt_free_pkg_list (pkgs_to_remove); slapt_free_pkg_list (avail); slapt_free_rc_config (rc); }