X-Git-Url: https://git.librecmc.org/?p=oweals%2Fopkg-lede.git;a=blobdiff_plain;f=libopkg%2Fopkg_cmd.c;h=eba833bd7bdce4083f2070907c38c59da0eacf92;hp=b0e5552b42e96bbbf859e48ae33ff3e8cdddc329;hb=673d7213175c2cf209b25c8eb2632941cdbb8519;hpb=7fc9b3b1705f104eb66510d771994fb46b01d1e6 diff --git a/libopkg/opkg_cmd.c b/libopkg/opkg_cmd.c index b0e5552..eba833b 100644 --- a/libopkg/opkg_cmd.c +++ b/libopkg/opkg_cmd.c @@ -27,6 +27,7 @@ #include "opkg_conf.h" #include "opkg_cmd.h" #include "opkg_message.h" +#include "release.h" #include "pkg.h" #include "pkg_dest.h" #include "pkg_parse.h" @@ -63,7 +64,7 @@ write_status_files_if_changed(void) opkg_msg(INFO, "Writing status file.\n"); opkg_conf_write_status_files(); pkg_write_changed_filelists(); - } else { + } else { opkg_msg(DEBUG, "Nothing to be done.\n"); } } @@ -87,9 +88,9 @@ opkg_update_cmd(int argc, char **argv) pkg_src_list_elt_t *iter; pkg_src_t *src; - + sprintf_alloc(&lists_dir, "%s", conf->restrict_to_default_dest ? conf->default_dest->lists_dir : conf->lists_dir); - + if (! file_is_dir(lists_dir)) { if (file_exists(lists_dir)) { opkg_msg(ERROR, "%s exists, but is not a directory.\n", @@ -101,8 +102,8 @@ opkg_update_cmd(int argc, char **argv) if (err) { free(lists_dir); return -1; - } - } + } + } failures = 0; @@ -113,13 +114,49 @@ opkg_update_cmd(int argc, char **argv) } + for (iter = void_list_first(&conf->dist_src_list); iter; iter = void_list_next(&conf->dist_src_list, iter)) { + char *url, *list_file_name; + + src = (pkg_src_t *)iter->data; + + sprintf_alloc(&url, "%s/dists/%s/Release", src->value, src->name); + + sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name); + err = opkg_download(url, list_file_name, NULL, NULL, 0); + if (!err) { + opkg_msg(NOTICE, "Downloaded release files for dist %s.\n", + src->name); + release_t *release = release_new(); + err = release_init_from_file(release, list_file_name); + if (!err) { + if (!release_comps_supported(release, src->extra_data)) + err = -1; + } + if (!err) { + err = release_download(release, src, lists_dir, tmp); + } + release_deinit(release); + if (err) + unlink(list_file_name); + } + + if (err) + failures++; + + free(list_file_name); + free(url); + } + for (iter = void_list_first(&conf->pkg_src_list); iter; iter = void_list_next(&conf->pkg_src_list, iter)) { char *url, *list_file_name; src = (pkg_src_t *)iter->data; + if (src->extra_data && strcmp(src->extra_data, "__dummy__ ")) + continue; + if (src->extra_data) /* debian style? */ - sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data, + sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data, src->gzip ? "Packages.gz" : "Packages"); else sprintf_alloc(&url, "%s/%s", src->value, src->gzip ? "Packages.gz" : "Packages"); @@ -128,9 +165,9 @@ opkg_update_cmd(int argc, char **argv) if (src->gzip) { char *tmp_file_name; FILE *in, *out; - + sprintf_alloc (&tmp_file_name, "%s/%s.gz", tmp, src->name); - err = opkg_download(url, tmp_file_name, NULL, NULL); + err = opkg_download(url, tmp_file_name, NULL, NULL, 0); if (err == 0) { opkg_msg(NOTICE, "Inflating %s.\n", url); in = fopen (tmp_file_name, "r"); @@ -147,7 +184,7 @@ opkg_update_cmd(int argc, char **argv) } free(tmp_file_name); } else - err = opkg_download(url, list_file_name, NULL, NULL); + err = opkg_download(url, list_file_name, NULL, NULL, 0); if (err) { failures++; } else { @@ -171,7 +208,7 @@ opkg_update_cmd(int argc, char **argv) /* Put the signature in the right place */ sprintf_alloc (&tmp_file_name, "%s/%s.sig", lists_dir, src->name); - err = opkg_download(url, tmp_file_name, NULL, NULL); + err = opkg_download(url, tmp_file_name, NULL, NULL, 0); if (err) { failures++; opkg_msg(NOTICE, "Signature check failed.\n"); @@ -182,6 +219,12 @@ opkg_update_cmd(int argc, char **argv) else opkg_msg(NOTICE, "Signature check failed.\n"); } + if (err) { + /* The signature was wrong so delete it */ + opkg_msg(NOTICE, "Remove wrong Signature file.\n"); + unlink (tmp_file_name); + unlink (list_file_name); + } /* We shouldn't unlink the signature ! */ // unlink (tmp_file_name); free (tmp_file_name); @@ -252,7 +295,7 @@ opkg_finalize_intercepts(opkg_intercept_t ctx) if (de->d_name[0] == '.') continue; - + sprintf_alloc (&path, "%s/%s", ctx->statedir, de->d_name); if (access (path, X_OK) == 0) { const char *argv[] = {"sh", "-c", path, NULL}; @@ -263,7 +306,7 @@ opkg_finalize_intercepts(opkg_intercept_t ctx) closedir(dir); } else opkg_perror(ERROR, "Failed to open dir %s", ctx->statedir); - + rm_r(ctx->statedir); free (ctx->statedir); free (ctx); @@ -272,10 +315,10 @@ opkg_finalize_intercepts(opkg_intercept_t ctx) } /* For package pkg do the following: If it is already visited, return. If not, - add it in visited list and recurse to its deps. Finally, add it to ordered + add it in visited list and recurse to its deps. Finally, add it to ordered list. pkg_vec all contains all available packages in repos. - pkg_vec visited contains packages already visited by this function, and is + pkg_vec visited contains packages already visited by this function, and is used to end recursion and avoid an infinite loop on graph cycles. pkg_vec ordered will finally contain the ordered set of packages. */ @@ -293,21 +336,21 @@ opkg_recurse_pkgs_in_order(pkg_t *pkg, pkg_vec_t *all, /* If it's just an available package, that is, not installed and not even unpacked, skip it */ - /* XXX: This is probably an overkill, since a state_status != SS_UNPACKED - would do here. However, if there is an intermediate node (pkg) that is - configured and installed between two unpacked packages, the latter + /* XXX: This is probably an overkill, since a state_status != SS_UNPACKED + would do here. However, if there is an intermediate node (pkg) that is + configured and installed between two unpacked packages, the latter won't be properly reordered, unless all installed/unpacked pkgs are checked */ - if (pkg->state_status == SS_NOT_INSTALLED) + if (pkg->state_status == SS_NOT_INSTALLED) return 0; /* If the package has already been visited (by this function), skip it */ - for(j = 0; j < visited->len; j++) + for(j = 0; j < visited->len; j++) if ( ! strcmp(visited->pkgs[j]->name, pkg->name)) { opkg_msg(DEBUG, "pkg %s already visited, skipping.\n", pkg->name); return 0; } - + pkg_vec_insert(visited, pkg); count = pkg->pre_depends_count + pkg->depends_count + \ @@ -315,9 +358,9 @@ opkg_recurse_pkgs_in_order(pkg_t *pkg, pkg_vec_t *all, opkg_msg(DEBUG, "pkg %s.\n", pkg->name); - /* Iterate over all the dependencies of pkg. For each one, find a package + /* Iterate over all the dependencies of pkg. For each one, find a package that is either installed or unpacked and satisfies this dependency. - (there should only be one such package per dependency installed or + (there should only be one such package per dependency installed or unpacked). Then recurse to the dependency package */ for (j=0; j < count ; j++) { compound_depend = &pkg->depends[j]; @@ -328,16 +371,16 @@ opkg_recurse_pkgs_in_order(pkg_t *pkg, pkg_vec_t *all, l = 0; if (dependents != NULL) while (l < abpkg->provided_by->len && dependents[l] != NULL) { - opkg_msg(DEBUG, "Descending on pkg %s.\n", + opkg_msg(DEBUG, "Descending on pkg %s.\n", dependents [l]->name); - + /* find whether dependent l is installed or unpacked, * and then find which package in the list satisfies it */ for(m = 0; m < all->len; m++) { dep = all->pkgs[m]; if ( dep->state_status != SS_NOT_INSTALLED) if ( ! strcmp(dep->name, dependents[l]->name)) { - opkg_recurse_pkgs_in_order(dep, all, + opkg_recurse_pkgs_in_order(dep, all, visited, ordered); /* Stop the outer loop */ l = abpkg->provided_by->len; @@ -350,7 +393,7 @@ opkg_recurse_pkgs_in_order(pkg_t *pkg, pkg_vec_t *all, } } - /* When all recursions from this node down, are over, and all + /* When all recursions from this node down, are over, and all dependencies have been added in proper order in the ordered array, add also the package pkg to ordered array */ pkg_vec_insert(ordered, pkg); @@ -389,11 +432,11 @@ opkg_configure_packages(char *pkg_name) err = -1; goto error; } - + for(i = 0; i < ordered->len; i++) { pkg = ordered->pkgs[i]; - if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) + if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) continue; if (pkg->state_status == SS_UNPACKED) { @@ -405,15 +448,13 @@ opkg_configure_packages(char *pkg_name) pkg->state_flag &= ~SF_PREFER; opkg_state_changed++; } else { - if (!err) - err = r; + err = -1; } } } - r = opkg_finalize_intercepts (ic); - if (r && !err) - err = r; + if (opkg_finalize_intercepts (ic)) + err = -1; error: pkg_vec_free(all); @@ -429,9 +470,9 @@ opkg_remove_cmd(int argc, char **argv); static int opkg_install_cmd(int argc, char **argv) { - int i, r; + int i; char *arg; - int err=0; + int err = 0; if (conf->force_reinstall) { int saved_force_depends = conf->force_depends; @@ -450,23 +491,21 @@ opkg_install_cmd(int argc, char **argv) arg = argv[i]; opkg_msg(DEBUG2, "%s\n", arg); - err = opkg_prepare_url_for_install(arg, &argv[i]); - if (err) - return err; + if (opkg_prepare_url_for_install(arg, &argv[i])) + return -1; } pkg_info_preinstall_check(); for (i=0; i < argc; i++) { arg = argv[i]; - err = opkg_install_by_name(arg); - if (err) { + if (opkg_install_by_name(arg)) { opkg_msg(ERROR, "Cannot install package %s.\n", arg); + err = -1; } } - r = opkg_configure_packages(NULL); - if (!err) - err = r; + if (opkg_configure_packages(NULL)) + err = -1; write_status_files_if_changed(); @@ -476,9 +515,9 @@ opkg_install_cmd(int argc, char **argv) static int opkg_upgrade_cmd(int argc, char **argv) { - int i, r; + int i; pkg_t *pkg; - int err; + int err = 0; signal(SIGINT, sigint_handler); @@ -486,9 +525,8 @@ opkg_upgrade_cmd(int argc, char **argv) for (i=0; i < argc; i++) { char *arg = argv[i]; - err = opkg_prepare_url_for_install(arg, &arg); - if (err) - return err; + if (opkg_prepare_url_for_install(arg, &arg)) + return -1; } pkg_info_preinstall_check(); @@ -505,32 +543,22 @@ opkg_upgrade_cmd(int argc, char **argv) } else { pkg = pkg_hash_fetch_installed_by_name(argv[i]); } - if (pkg) - opkg_upgrade_pkg(pkg); - else { - opkg_install_by_name(arg); + if (pkg) { + if (opkg_upgrade_pkg(pkg)) + err = -1; + } else { + if (opkg_install_by_name(arg)) + err = -1; } } - } else { - pkg_vec_t *installed = pkg_vec_alloc(); - - pkg_info_preinstall_check(); - - pkg_hash_fetch_all_installed(installed); - for (i = 0; i < installed->len; i++) { - pkg = installed->pkgs[i]; - opkg_upgrade_pkg(pkg); - } - pkg_vec_free(installed); } - r = opkg_configure_packages(NULL); - if (!err) - err = r; + if (opkg_configure_packages(NULL)) + err = -1; write_status_files_if_changed(); - return 0; + return err; } static int @@ -550,7 +578,8 @@ opkg_download_cmd(int argc, char **argv) continue; } - err = opkg_download_pkg(pkg, "."); + if (opkg_download_pkg(pkg, ".")) + err = -1; if (err) { opkg_msg(ERROR, "Failed to download %s.\n", pkg->name); @@ -581,7 +610,7 @@ opkg_list_cmd(int argc, char **argv) for (i=0; i < available->len; i++) { pkg = available->pkgs[i]; /* if we have package name or pattern and pkg does not match, then skip it */ - if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) + if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) continue; print_pkg(pkg); } @@ -608,7 +637,7 @@ opkg_list_installed_cmd(int argc, char **argv) for (i=0; i < available->len; i++) { pkg = available->pkgs[i]; /* if we have package name or pattern and pkg does not match, then skip it */ - if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) + if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) continue; print_pkg(pkg); } @@ -618,6 +647,39 @@ opkg_list_installed_cmd(int argc, char **argv) return 0; } +static int +opkg_list_changed_conffiles_cmd(int argc, char **argv) +{ + int i ; + pkg_vec_t *available; + pkg_t *pkg; + char *pkg_name = NULL; + conffile_list_elt_t *iter; + conffile_t *cf; + + if (argc > 0) { + pkg_name = argv[0]; + } + available = pkg_vec_alloc(); + pkg_hash_fetch_all_installed(available); + pkg_vec_sort(available, pkg_compare_names); + for (i=0; i < available->len; i++) { + pkg = available->pkgs[i]; + /* if we have package name or pattern and pkg does not match, then skip it */ + if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) + continue; + if (nv_pair_list_empty(&pkg->conffiles)) + continue; + for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) { + cf = (conffile_t *)iter->data; + if (cf->name && cf->value && conffile_has_been_modified(cf)) + printf("%s\n", cf->name); + } + } + pkg_vec_free(available); + return 0; +} + static int opkg_list_upgradable_cmd(int argc, char **argv) { @@ -713,7 +775,7 @@ opkg_configure_cmd(int argc, char **argv) static int opkg_remove_cmd(int argc, char **argv) { - int i, a, done, r, err = 0; + int i, a, done, err = 0; pkg_t *pkg; pkg_t *pkg_to_remove; pkg_vec_t *available; @@ -740,20 +802,20 @@ opkg_remove_cmd(int argc, char **argv) } else { pkg_to_remove = pkg_hash_fetch_installed_by_name(pkg->name); } - + if (pkg_to_remove == NULL) { opkg_msg(ERROR, "Package %s is not installed.\n", pkg->name); continue; } - if (pkg->state_status == SS_NOT_INSTALLED) { // Added the control, so every already removed package could be skipped + if (pkg->state_status == SS_NOT_INSTALLED) { opkg_msg(ERROR, "Package %s not installed.\n", pkg->name); continue; } - r = opkg_remove_pkg(pkg_to_remove, 0); - if (!err) - err = r; - done = 1; + if (opkg_remove_pkg(pkg_to_remove, 0)) + err = -1; + else + done = 1; } } @@ -772,7 +834,7 @@ opkg_flag_cmd(int argc, char **argv) int i; pkg_t *pkg; const char *flags = argv[0]; - + signal(SIGINT, sigint_handler); for (i=1; i < argc; i++) { @@ -792,7 +854,7 @@ opkg_flag_cmd(int argc, char **argv) pkg->state_flag = pkg_state_flag_from_str(flags); } - /* + /* * Useful if a package is installed in an offline_root, and * should be configured by opkg-cl configure at a later date. */ @@ -933,7 +995,7 @@ opkg_what_depends_conflicts_cmd(enum depend_type what_field_type, int recursive, case RECOMMEND: rel_str = "recommends"; break; default: return -1; } - + available_pkgs = pkg_vec_alloc(); if (conf->query_all) @@ -989,14 +1051,14 @@ opkg_what_depends_conflicts_cmd(enum depend_type what_field_type, int recursive, & SF_MARKED) != SF_MARKED) continue; - + /* mark the depending package so we * won't visit it again */ pkg->state_flag |= SF_MARKED; pkg_mark_provides(pkg); changed++; - ver = pkg_version_str_alloc(pkg); + ver = pkg_version_str_alloc(pkg); opkg_msg(NOTICE, "\t%s %s\t%s %s", pkg->name, ver, @@ -1011,7 +1073,7 @@ opkg_what_depends_conflicts_cmd(enum depend_type what_field_type, int recursive, if (!pkg_dependence_satisfiable(possibility)) opkg_msg(NOTICE, " unsatisfiable"); - opkg_msg(NOTICE, "\n"); + opkg_message(NOTICE, "\n"); goto next_package; } } @@ -1063,7 +1125,7 @@ opkg_what_provides_replaces_cmd(enum what_field_type what_field_type, int argc, pkg_vec_t *available_pkgs = pkg_vec_alloc(); const char *rel_str = (what_field_type == WHATPROVIDES ? "provides" : "replaces"); int i; - + pkg_info_preinstall_check(); if (conf->query_all) @@ -1081,8 +1143,8 @@ opkg_what_provides_replaces_cmd(enum what_field_type what_field_type, int argc, int k; int count = (what_field_type == WHATPROVIDES) ? pkg->provides_count : pkg->replaces_count; for (k = 0; k < count; k++) { - abstract_pkg_t *apkg = - ((what_field_type == WHATPROVIDES) + abstract_pkg_t *apkg = + ((what_field_type == WHATPROVIDES) ? pkg->provides[k] : pkg->replaces[k]); if (fnmatch(target, apkg->name, 0) == 0) { @@ -1090,7 +1152,7 @@ opkg_what_provides_replaces_cmd(enum what_field_type what_field_type, int argc, if (strcmp(target, apkg->name) != 0) opkg_msg(NOTICE, "\t%s %s\n", rel_str, apkg->name); - opkg_msg(NOTICE, "\n"); + opkg_message(NOTICE, "\n"); } } } @@ -1126,7 +1188,7 @@ opkg_search_cmd(int argc, char **argv) if (argc < 1) { return -1; } - + installed = pkg_vec_alloc(); pkg_hash_fetch_all_installed(installed); pkg_vec_sort(installed, pkg_compare_names); @@ -1156,8 +1218,8 @@ opkg_compare_versions_cmd(int argc, char **argv) if (argc == 3) { /* this is a bit gross */ struct pkg p1, p2; - parse_version(&p1, argv[0]); - parse_version(&p2, argv[2]); + parse_version(&p1, argv[0]); + parse_version(&p2, argv[2]); return pkg_version_satisfied(&p1, &p2, argv[1]); } else { opkg_msg(ERROR, @@ -1184,12 +1246,14 @@ opkg_print_architecture_cmd(int argc, char **argv) array for easier maintenance */ static opkg_cmd_t cmds[] = { {"update", 0, (opkg_cmd_fun_t)opkg_update_cmd, PFM_DESCRIPTION|PFM_SOURCE}, - {"upgrade", 0, (opkg_cmd_fun_t)opkg_upgrade_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"upgrade", 1, (opkg_cmd_fun_t)opkg_upgrade_cmd, PFM_DESCRIPTION|PFM_SOURCE}, {"list", 0, (opkg_cmd_fun_t)opkg_list_cmd, PFM_SOURCE}, {"list_installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd, PFM_SOURCE}, {"list-installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd, PFM_SOURCE}, {"list_upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd, PFM_SOURCE}, {"list-upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd, PFM_SOURCE}, + {"list_changed_conffiles", 0, (opkg_cmd_fun_t)opkg_list_changed_conffiles_cmd, PFM_SOURCE}, + {"list-changed-conffiles", 0, (opkg_cmd_fun_t)opkg_list_changed_conffiles_cmd, PFM_SOURCE}, {"info", 0, (opkg_cmd_fun_t)opkg_info_cmd, 0}, {"flag", 1, (opkg_cmd_fun_t)opkg_flag_cmd, PFM_DESCRIPTION|PFM_SOURCE}, {"status", 0, (opkg_cmd_fun_t)opkg_status_cmd, PFM_DESCRIPTION|PFM_SOURCE},