X-Git-Url: https://git.librecmc.org/?p=oweals%2Fopkg-lede.git;a=blobdiff_plain;f=libopkg%2Fopkg_cmd.c;h=d2adc3102ff9fe57a7d9ff60dcfcf0f6f241ace3;hp=82a623eeaa365c939f5543e800c5e327a0f2379d;hb=a79c1af5c0d3908a3ad30806530c754b42cf80e2;hpb=7ea0060e3b5c0f4d261cf4291bcd160ec94164c2 diff --git a/libopkg/opkg_cmd.c b/libopkg/opkg_cmd.c index 82a623e..d2adc31 100644 --- a/libopkg/opkg_cmd.c +++ b/libopkg/opkg_cmd.c @@ -15,11 +15,14 @@ General Public License for more details. */ +#include "config.h" -#include "includes.h" +#include #include #include #include +#include +#include #include "opkg_conf.h" #include "opkg_cmd.h" @@ -38,159 +41,77 @@ #include "opkg_upgrade.h" #include "opkg_remove.h" #include "opkg_configure.h" -#include "opkg_message.h" -#include "libopkg.h" #include "xsystem.h" -static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_info_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_status_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_list_upgradable_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_whatdepends_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_whatprovides_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_whatreplaces_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv); -static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv); -static int pkg_mark_provides(pkg_t *pkg); - -/* XXX: CLEANUP: The usage strings should be incorporated into this - array for easier maintenance */ -static opkg_cmd_t cmds[] = { - {"update", 0, (opkg_cmd_fun_t)opkg_update_cmd}, - {"upgrade", 0, (opkg_cmd_fun_t)opkg_upgrade_cmd}, - {"list", 0, (opkg_cmd_fun_t)opkg_list_cmd}, - {"list_installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd}, - {"list-installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd}, - {"list_upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd}, - {"list-upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd}, - {"info", 0, (opkg_cmd_fun_t)opkg_info_cmd}, - {"flag", 1, (opkg_cmd_fun_t)opkg_flag_cmd}, - {"status", 0, (opkg_cmd_fun_t)opkg_status_cmd}, - {"install", 1, (opkg_cmd_fun_t)opkg_install_cmd}, - {"remove", 1, (opkg_cmd_fun_t)opkg_remove_cmd}, - {"configure", 0, (opkg_cmd_fun_t)opkg_configure_cmd}, - {"files", 1, (opkg_cmd_fun_t)opkg_files_cmd}, - {"search", 1, (opkg_cmd_fun_t)opkg_search_cmd}, - {"download", 1, (opkg_cmd_fun_t)opkg_download_cmd}, - {"compare_versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd}, - {"compare-versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd}, - {"print-architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd}, - {"print_architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd}, - {"print-installation-architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd}, - {"print_installation_architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd}, - {"depends", 1, (opkg_cmd_fun_t)opkg_depends_cmd}, - {"whatdepends", 1, (opkg_cmd_fun_t)opkg_whatdepends_cmd}, - {"whatdependsrec", 1, (opkg_cmd_fun_t)opkg_whatdepends_recursively_cmd}, - {"whatrecommends", 1, (opkg_cmd_fun_t)opkg_whatrecommends_cmd}, - {"whatsuggests", 1, (opkg_cmd_fun_t)opkg_whatsuggests_cmd}, - {"whatprovides", 1, (opkg_cmd_fun_t)opkg_whatprovides_cmd}, - {"whatreplaces", 1, (opkg_cmd_fun_t)opkg_whatreplaces_cmd}, - {"whatconflicts", 1, (opkg_cmd_fun_t)opkg_whatconflicts_cmd}, -}; - -static void print_pkg(pkg_t *pkg) +static void +print_pkg(pkg_t *pkg) { char *version = pkg_version_str_alloc(pkg); + printf("%s - %s", pkg->name, version); + if (conf->size) + printf(" - %lu", pkg->size); if (pkg->description) - printf("%s - %s - %s\n", pkg->name, version, pkg->description); - else - printf("%s - %s\n", pkg->name, version); + printf(" - %s", pkg->description); + printf("\n"); free(version); } int opkg_state_changed; -static void write_status_files_if_changed(opkg_conf_t *conf) -{ - if (opkg_state_changed && !conf->noaction) { - opkg_message(conf, OPKG_INFO, - " writing status file\n"); - opkg_conf_write_status_files(conf); - pkg_write_changed_filelists(conf); - } else { - opkg_message(conf, OPKG_DEBUG, "Nothing to be done\n"); - } -} - -static int num_cmds = sizeof(cmds) / sizeof(opkg_cmd_t); - -opkg_cmd_t *opkg_cmd_find(const char *name) +static void +write_status_files_if_changed(void) { - int i; - opkg_cmd_t *cmd; - - for (i=0; i < num_cmds; i++) { - cmd = &cmds[i]; - if (strcmp(name, cmd->name) == 0) { - return cmd; - } + if (opkg_state_changed && !conf->noaction) { + opkg_msg(INFO, "Writing status file.\n"); + opkg_conf_write_status_files(); + pkg_write_changed_filelists(); + } else { + opkg_msg(DEBUG, "Nothing to be done.\n"); } - - return NULL; } -int opkg_cmd_exec(opkg_cmd_t *cmd, opkg_conf_t *conf, int argc, const char **argv, void *userdata) +static void +sigint_handler(int sig) { - int result; - - result = (cmd->fun)(conf, argc, argv); - - print_error_list(); - free_error_list(); - - return result; + signal(sig, SIG_DFL); + opkg_msg(NOTICE, "Interrupted. Writing out status database.\n"); + write_status_files_if_changed(); + exit(128 + sig); } -static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_update_cmd(int argc, char **argv) { char *tmp; int err; int failures; + int pkglist_dl_error; char *lists_dir; 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_message(conf, OPKG_ERROR, - "%s: ERROR: %s exists, but is not a directory\n", - __FUNCTION__, lists_dir); + opkg_msg(ERROR, "%s exists, but is not a directory.\n", + lists_dir); free(lists_dir); return -1; } err = file_mkdir_hier(lists_dir, 0755); if (err) { - opkg_message(conf, OPKG_ERROR, - "%s: ERROR: failed to make directory %s: %s\n", - __FUNCTION__, lists_dir, strerror(errno)); free(lists_dir); return -1; - } - } + } + } failures = 0; sprintf_alloc(&tmp, "%s/update-XXXXXX", conf->tmp_dir); if (mkdtemp (tmp) == NULL) { - perror ("mkdtemp"); + opkg_perror(ERROR, "Failed to make temp dir %s", conf->tmp_dir); return -1; } @@ -200,46 +121,29 @@ static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv) 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"); sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name); - if (src->gzip) { - char *tmp_file_name; - FILE *in, *out; - - sprintf_alloc (&tmp_file_name, "%s/%s.gz", tmp, src->name); - err = opkg_download(conf, url, tmp_file_name, NULL, NULL); - if (err == 0) { - opkg_message (conf, OPKG_NOTICE, "Inflating %s\n", url); - in = fopen (tmp_file_name, "r"); - out = fopen (list_file_name, "w"); - if (in && out) - unzip (in, out); - else - err = 1; - if (in) - fclose (in); - if (out) - fclose (out); - unlink (tmp_file_name); - } - free(tmp_file_name); - } else - err = opkg_download(conf, url, list_file_name, NULL, NULL); - if (err) { + pkglist_dl_error = 0; + if (opkg_download(url, list_file_name, NULL, NULL, 0)) { failures++; + pkglist_dl_error = 1; + opkg_msg(NOTICE, "*** Failed to download the package list from %s\n\n", + url); } else { - opkg_message(conf, OPKG_NOTICE, - "Updated list of available packages in %s\n", + opkg_msg(NOTICE, "Updated list of available packages in %s\n", list_file_name); } free(url); -#if defined(HAVE_GPGME) || defined(HAVE_OPENSSL) - if (conf->check_signature) { +#if defined(HAVE_GPGME) || defined(HAVE_OPENSSL) || defined(HAVE_USIGN) + if (pkglist_dl_error == 0 && conf->check_signature) { /* download detached signitures to verify the package lists */ /* get the url for the sig file */ if (src->extra_data) /* debian style? */ @@ -254,17 +158,22 @@ static int opkg_update_cmd(opkg_conf_t *conf, 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(conf, url, tmp_file_name, NULL, NULL); + err = opkg_download(url, tmp_file_name, NULL, NULL, 0); if (err) { failures++; - opkg_message (conf, OPKG_NOTICE, "Signature check failed\n"); + opkg_msg(NOTICE, "Signature file download failed.\n"); } else { - int err; - err = opkg_verify_file (conf, list_file_name, tmp_file_name); + err = opkg_verify_file (list_file_name, tmp_file_name); if (err == 0) - opkg_message (conf, OPKG_NOTICE, "Signature check passed\n"); + opkg_msg(NOTICE, "Signature check passed.\n"); else - opkg_message (conf, OPKG_NOTICE, "Signature check failed\n"); + opkg_msg(NOTICE, "Signature check failed.\n"); + } + if (err && !conf->force_signature) { + /* 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); @@ -292,7 +201,8 @@ struct opkg_intercept typedef struct opkg_intercept *opkg_intercept_t; -static opkg_intercept_t opkg_prep_intercepts(opkg_conf_t *conf) +static opkg_intercept_t +opkg_prep_intercepts(void) { opkg_intercept_t ctx; char *newpath; @@ -303,7 +213,7 @@ static opkg_intercept_t opkg_prep_intercepts(opkg_conf_t *conf) sprintf_alloc(&ctx->statedir, "%s/opkg-intercept-XXXXXX", conf->tmp_dir); if (mkdtemp(ctx->statedir) == NULL) { - fprintf(stderr, "%s: mkdtemp: %s\n", __FUNCTION__, strerror(errno)); + opkg_perror(ERROR,"Failed to make temp dir %s", ctx->statedir); free(ctx->oldpath); free(ctx->statedir); free(newpath); @@ -318,7 +228,8 @@ static opkg_intercept_t opkg_prep_intercepts(opkg_conf_t *conf) return ctx; } -static int opkg_finalize_intercepts(opkg_intercept_t ctx) +static int +opkg_finalize_intercepts(opkg_intercept_t ctx) { DIR *dir; int err = 0; @@ -334,7 +245,7 @@ static int 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}; @@ -344,8 +255,8 @@ static int opkg_finalize_intercepts(opkg_intercept_t ctx) } closedir(dir); } else - perror (ctx->statedir); - + opkg_perror(ERROR, "Failed to open dir %s", ctx->statedir); + rm_r(ctx->statedir); free (ctx->statedir); free (ctx); @@ -354,14 +265,15 @@ static int 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. */ -static int opkg_recurse_pkgs_in_order(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *all, +static int +opkg_recurse_pkgs_in_order(pkg_t *pkg, pkg_vec_t *all, pkg_vec_t *visited, pkg_vec_t *ordered) { int j,k,l,m; @@ -374,33 +286,31 @@ static int opkg_recurse_pkgs_in_order(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t * /* 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_message(conf, OPKG_INFO, - " pkg: %s already visited\n", 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 + \ pkg->recommends_count + pkg->suggests_count; - opkg_message(conf, OPKG_INFO, - " pkg: %s\n", pkg->name); + 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]; @@ -411,17 +321,16 @@ static int opkg_recurse_pkgs_in_order(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t * l = 0; if (dependents != NULL) while (l < abpkg->provided_by->len && dependents[l] != NULL) { - opkg_message(conf, OPKG_INFO, - " 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(conf, dep, all, + opkg_recurse_pkgs_in_order(dep, all, visited, ordered); /* Stop the outer loop */ l = abpkg->provided_by->len; @@ -434,7 +343,7 @@ static int opkg_recurse_pkgs_in_order(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t * } } - /* 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); @@ -443,7 +352,8 @@ static int opkg_recurse_pkgs_in_order(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t * } -static int opkg_configure_packages(opkg_conf_t *conf, char *pkg_name) +static int +opkg_configure_packages(char *pkg_name) { pkg_vec_t *all, *ordered, *visited; int i; @@ -451,56 +361,50 @@ static int opkg_configure_packages(opkg_conf_t *conf, char *pkg_name) opkg_intercept_t ic; int r, err = 0; - opkg_message(conf, OPKG_INFO, - "Configuring unpacked packages\n"); - fflush( stdout ); + opkg_msg(INFO, "Configuring unpacked packages.\n"); all = pkg_vec_alloc(); - pkg_hash_fetch_available(&conf->pkg_hash, all); + pkg_hash_fetch_available(all); /* Reorder pkgs in order to be configured according to the Depends: tag order */ - opkg_message(conf, OPKG_INFO, - "Reordering packages before configuring them...\n"); + opkg_msg(INFO, "Reordering packages before configuring them...\n"); ordered = pkg_vec_alloc(); visited = pkg_vec_alloc(); for(i = 0; i < all->len; i++) { pkg = all->pkgs[i]; - opkg_recurse_pkgs_in_order(conf, pkg, all, visited, ordered); + opkg_recurse_pkgs_in_order(pkg, all, visited, ordered); } - ic = opkg_prep_intercepts (conf); + ic = opkg_prep_intercepts(); if (ic == NULL) { err = -1; goto error; } - - for(i = 0; i < all->len; i++) { - pkg = all->pkgs[i]; - if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) + for(i = 0; i < ordered->len; i++) { + pkg = ordered->pkgs[i]; + + if (pkg_name && fnmatch(pkg_name, pkg->name, conf->nocase)) continue; if (pkg->state_status == SS_UNPACKED) { - opkg_message(conf, OPKG_NOTICE, - "Configuring %s\n", pkg->name); - fflush( stdout ); - r = opkg_configure(conf, pkg); + opkg_msg(NOTICE, "Configuring %s.\n", pkg->name); + r = opkg_configure(pkg); if (r == 0) { pkg->state_status = SS_INSTALLED; pkg->parent->state_status = SS_INSTALLED; 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); @@ -510,24 +414,24 @@ error: return err; } -static opkg_conf_t *global_conf; - -static void sigint_handler(int sig) -{ - signal(sig, SIG_DFL); - opkg_message(NULL, OPKG_NOTICE, - "opkg: interrupted. writing out status database\n"); - write_status_files_if_changed(global_conf); - exit(128 + sig); -} +static int +opkg_remove_cmd(int argc, char **argv); -static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_install_cmd(int argc, char **argv) { int i; char *arg; - int err=0; + int err = 0; + + if (conf->force_reinstall) { + int saved_force_depends = conf->force_depends; + conf->force_depends = 1; + (void)opkg_remove_cmd(argc, argv); + conf->force_depends = saved_force_depends; + conf->force_reinstall = 0; + } - global_conf = conf; signal(SIGINT, sigint_handler); /* @@ -536,125 +440,111 @@ static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv) for (i=0; i < argc; i++) { arg = argv[i]; - opkg_message(conf, OPKG_DEBUG2, "Debug install_cmd: %s \n",arg ); - err = opkg_prepare_url_for_install(conf, arg, &argv[i]); - if (err) - return err; + opkg_msg(DEBUG2, "%s\n", arg); + if (opkg_prepare_url_for_install(arg, &argv[i])) + return -1; } - pkg_info_preinstall_check(conf); + pkg_info_preinstall_check(); for (i=0; i < argc; i++) { arg = argv[i]; - err = opkg_install_by_name(conf, arg); - if (err) { - opkg_message(conf, OPKG_ERROR, "Cannot find package %s.\n", arg); + if (opkg_install_by_name(arg)) { + opkg_msg(ERROR, "Cannot install package %s.\n", arg); + err = -1; } } - opkg_configure_packages(conf, NULL); + if (opkg_configure_packages(NULL)) + err = -1; - write_status_files_if_changed(conf); + write_status_files_if_changed(); return err; } -static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_upgrade_cmd(int argc, char **argv) { int i; pkg_t *pkg; - int err; + int err = 0; - global_conf = conf; signal(SIGINT, sigint_handler); if (argc) { for (i=0; i < argc; i++) { char *arg = argv[i]; - err = opkg_prepare_url_for_install(conf, arg, &arg); - if (err) - return err; + if (opkg_prepare_url_for_install(arg, &arg)) + return -1; } - pkg_info_preinstall_check(conf); + pkg_info_preinstall_check(); for (i=0; i < argc; i++) { char *arg = argv[i]; if (conf->restrict_to_default_dest) { - pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash, - argv[i], - conf->default_dest); + pkg = pkg_hash_fetch_installed_by_name_dest(argv[i], + conf->default_dest); if (pkg == NULL) { - opkg_message(conf, OPKG_NOTICE, - "Package %s not installed in %s\n", + opkg_msg(NOTICE, "Package %s not installed in %s.\n", argv[i], conf->default_dest->name); continue; } } else { - pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, - argv[i]); + pkg = pkg_hash_fetch_installed_by_name(argv[i]); } - if (pkg) - opkg_upgrade_pkg(conf, pkg); - else { - opkg_install_by_name(conf, 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(conf); - - pkg_hash_fetch_all_installed(&conf->pkg_hash, installed); - for (i = 0; i < installed->len; i++) { - pkg = installed->pkgs[i]; - opkg_upgrade_pkg(conf, pkg); - } - pkg_vec_free(installed); } - opkg_configure_packages(conf, NULL); + if (opkg_configure_packages(NULL)) + err = -1; - write_status_files_if_changed(conf); + write_status_files_if_changed(); - return 0; + return err; } -static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_download_cmd(int argc, char **argv) { - int i, err; + int i, err = 0; char *arg; pkg_t *pkg; - pkg_info_preinstall_check(conf); + pkg_info_preinstall_check(); for (i = 0; i < argc; i++) { arg = argv[i]; - pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, arg, &err); + pkg = pkg_hash_fetch_best_installation_candidate_by_name(arg); if (pkg == NULL) { - opkg_message(conf, OPKG_ERROR, - "Cannot find package %s.\n" - "Check the spelling or perhaps run 'opkg update'\n", - arg); + opkg_msg(ERROR, "Cannot find package %s.\n", arg); continue; } - err = opkg_download_pkg(conf, pkg, "."); + if (opkg_download_pkg(pkg, ".")) + err = -1; if (err) { - opkg_message(conf, OPKG_ERROR, - "Failed to download %s\n", pkg->name); + opkg_msg(ERROR, "Failed to download %s.\n", pkg->name); } else { - opkg_message(conf, OPKG_NOTICE, - "Downloaded %s as %s\n", + opkg_msg(NOTICE, "Downloaded %s as %s.\n", pkg->name, pkg->local_filename); } } - return 0; + return err; } -static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_list_find_cmd(int argc, char **argv, int use_desc) { int i; pkg_vec_t *available; @@ -665,12 +555,13 @@ static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv) pkg_name = argv[0]; } available = pkg_vec_alloc(); - pkg_hash_fetch_available(&conf->pkg_hash, available); + pkg_hash_fetch_available(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)) + if (pkg_name && fnmatch(pkg_name, pkg->name, conf->nocase) && + (!use_desc || !pkg->description || fnmatch(pkg_name, pkg->description, conf->nocase))) continue; print_pkg(pkg); } @@ -679,8 +570,21 @@ static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv) return 0; } +static int +opkg_list_cmd(int argc, char **argv) +{ + return opkg_list_find_cmd(argc, argv, 0); +} -static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_find_cmd(int argc, char **argv) +{ + return opkg_list_find_cmd(argc, argv, 1); +} + + +static int +opkg_list_installed_cmd(int argc, char **argv) { int i ; pkg_vec_t *available; @@ -691,12 +595,12 @@ static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv) pkg_name = argv[0]; } available = pkg_vec_alloc(); - pkg_hash_fetch_all_installed(&conf->pkg_hash, available); + 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)) + if (pkg_name && fnmatch(pkg_name, pkg->name, conf->nocase)) continue; print_pkg(pkg); } @@ -706,15 +610,51 @@ static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv) return 0; } -static int opkg_list_upgradable_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_list_changed_conffiles_cmd(int argc, char **argv) { - struct active_list *head = prepare_upgrade_list(conf); + 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, conf->nocase)) + 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) +{ + struct active_list *head = prepare_upgrade_list(); struct active_list *node=NULL; pkg_t *_old_pkg, *_new_pkg; char *old_v, *new_v; for (node = active_list_next(head, head); node;node = active_list_next(head,node)) { _old_pkg = list_entry(node, pkg_t, list); - _new_pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, _old_pkg->name, NULL); + _new_pkg = pkg_hash_fetch_best_installation_candidate_by_name(_old_pkg->name); + if (_new_pkg == NULL) + continue; old_v = pkg_version_str_alloc(_old_pkg); new_v = pkg_version_str_alloc(_new_pkg); printf("%s - %s - %s\n", _old_pkg->name, old_v, new_v); @@ -725,7 +665,8 @@ static int opkg_list_upgradable_cmd(opkg_conf_t *conf, int argc, char **argv) return 0; } -static int opkg_info_status_cmd(opkg_conf_t *conf, int argc, char **argv, int installed_only) +static int +opkg_info_status_cmd(int argc, char **argv, int installed_only) { int i; pkg_vec_t *available; @@ -738,26 +679,25 @@ static int opkg_info_status_cmd(opkg_conf_t *conf, int argc, char **argv, int in available = pkg_vec_alloc(); if (installed_only) - pkg_hash_fetch_all_installed(&conf->pkg_hash, available); + pkg_hash_fetch_all_installed(available); else - pkg_hash_fetch_available(&conf->pkg_hash, available); + pkg_hash_fetch_available(available); for (i=0; i < available->len; i++) { pkg = available->pkgs[i]; - if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) { + if (pkg_name && fnmatch(pkg_name, pkg->name, conf->nocase)) { continue; } pkg_formatted_info(stdout, pkg); - if (conf->verbosity >= OPKG_NOTICE) { + if (conf->verbosity >= NOTICE) { conffile_list_elt_t *iter; for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) { conffile_t *cf = (conffile_t *)iter->data; - int modified = conffile_has_been_modified(conf, cf); + int modified = conffile_has_been_modified(cf); if (cf->value) - opkg_message(conf, OPKG_INFO, - "conffile=%s md5sum=%s modified=%d\n", + opkg_msg(INFO, "conffile=%s md5sum=%s modified=%d.\n", cf->name, cf->value, modified); } } @@ -767,110 +707,109 @@ static int opkg_info_status_cmd(opkg_conf_t *conf, int argc, char **argv, int in return 0; } -static int opkg_info_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_info_cmd(int argc, char **argv) { - return opkg_info_status_cmd(conf, argc, argv, 0); + return opkg_info_status_cmd(argc, argv, 0); } -static int opkg_status_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_status_cmd(int argc, char **argv) { - return opkg_info_status_cmd(conf, argc, argv, 1); + return opkg_info_status_cmd(argc, argv, 1); } -static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_configure_cmd(int argc, char **argv) { - - int err; - if (argc > 0) { - char *pkg_name = NULL; + int err; + char *pkg_name = NULL; - pkg_name = argv[0]; + if (argc > 0) + pkg_name = argv[0]; - err = opkg_configure_packages (conf, pkg_name); - - } else { - err = opkg_configure_packages (conf, NULL); - } + err = opkg_configure_packages(pkg_name); - write_status_files_if_changed(conf); + write_status_files_if_changed(); - return err; + return err; } -static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_remove_cmd(int argc, char **argv) { - int i, a, done; + int i, a, done, err = 0; pkg_t *pkg; pkg_t *pkg_to_remove; pkg_vec_t *available; - global_conf = conf; done = 0; signal(SIGINT, sigint_handler); - pkg_info_preinstall_check(conf); + pkg_info_preinstall_check(); available = pkg_vec_alloc(); - pkg_hash_fetch_all_installed(&conf->pkg_hash, available); + pkg_hash_fetch_all_installed(available); for (i=0; ilen; a++) { pkg = available->pkgs[a]; - if (fnmatch(argv[i], pkg->name, 0)) { + if (fnmatch(argv[i], pkg->name, conf->nocase)) { continue; } if (conf->restrict_to_default_dest) { - pkg_to_remove = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash, + pkg_to_remove = pkg_hash_fetch_installed_by_name_dest( pkg->name, conf->default_dest); } else { - pkg_to_remove = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name ); + pkg_to_remove = pkg_hash_fetch_installed_by_name(pkg->name); } - + if (pkg_to_remove == NULL) { - opkg_message(conf, OPKG_ERROR, "Package %s is not installed.\n", pkg->name); + 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 - opkg_message(conf, OPKG_ERROR, "Package seems to be %s not installed (STATUS = NOT_INSTALLED).\n", pkg->name); + if (pkg->state_status == SS_NOT_INSTALLED) { + opkg_msg(ERROR, "Package %s not installed.\n", pkg->name); continue; } - opkg_remove_pkg(conf, pkg_to_remove, 0); - done = 1; + + if (opkg_remove_pkg(pkg_to_remove, 0)) + err = -1; + else + done = 1; } } pkg_vec_free(available); if (done == 0) - opkg_message(conf, OPKG_NOTICE, "No packages removed.\n"); + opkg_msg(NOTICE, "No packages removed.\n"); - write_status_files_if_changed(conf); - return 0; + write_status_files_if_changed(); + return err; } -static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_flag_cmd(int argc, char **argv) { int i; pkg_t *pkg; const char *flags = argv[0]; - - global_conf = conf; + signal(SIGINT, sigint_handler); for (i=1; i < argc; i++) { if (conf->restrict_to_default_dest) { - pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash, - argv[i], + pkg = pkg_hash_fetch_installed_by_name_dest(argv[i], conf->default_dest); } else { - pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]); + pkg = pkg_hash_fetch_installed_by_name(argv[i]); } if (pkg == NULL) { - opkg_message(conf, OPKG_ERROR, - "Package %s is not installed.\n", argv[i]); + opkg_msg(ERROR, "Package %s is not installed.\n", argv[i]); continue; } if (( strcmp(flags,"hold")==0)||( strcmp(flags,"noprune")==0)|| @@ -878,7 +817,7 @@ static int opkg_flag_cmd(opkg_conf_t *conf, 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. */ @@ -887,16 +826,16 @@ static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv) } opkg_state_changed++; - opkg_message(conf, OPKG_NOTICE, - "Setting flags for package %s to %s\n", + opkg_msg(NOTICE, "Setting flags for package %s to %s.\n", pkg->name, flags); } - write_status_files_if_changed(conf); + write_status_files_if_changed(); return 0; } -static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_files_cmd(int argc, char **argv) { pkg_t *pkg; str_list_t *files; @@ -904,18 +843,16 @@ static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv) char *pkg_version; if (argc < 1) { - return EINVAL; + return -1; } - pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, - argv[0]); + pkg = pkg_hash_fetch_installed_by_name(argv[0]); if (pkg == NULL) { - opkg_message(conf, OPKG_ERROR, - "Package %s not installed.\n", argv[0]); + opkg_msg(ERROR, "Package %s not installed.\n", argv[0]); return 0; } - files = pkg_get_installed_files(conf, pkg); + files = pkg_get_installed_files(pkg); pkg_version = pkg_version_str_alloc(pkg); printf("Package %s (%s) is installed on %s and has the following files:\n", @@ -930,7 +867,8 @@ static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv) return 0; } -static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_depends_cmd(int argc, char **argv) { int i, j, k; int depends_count; @@ -939,19 +877,19 @@ static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv) pkg_t *pkg; char *str; - pkg_info_preinstall_check(conf); + pkg_info_preinstall_check(); available_pkgs = pkg_vec_alloc(); if (conf->query_all) - pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs); + pkg_hash_fetch_available(available_pkgs); else - pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs); + pkg_hash_fetch_all_installed(available_pkgs); for (i=0; ilen; j++) { pkg = available_pkgs->pkgs[j]; - if (fnmatch(argv[i], pkg->name, 0) != 0) + if (fnmatch(argv[i], pkg->name, conf->nocase) != 0) continue; depends_count = pkg->depends_count + @@ -959,8 +897,7 @@ static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv) pkg->recommends_count + pkg->suggests_count; - opkg_message(conf, OPKG_NOTICE, "%s depends on:\n", - pkg->name); + opkg_msg(NOTICE, "%s depends on:\n", pkg->name); for (k=0; kdepends[k]; @@ -969,7 +906,7 @@ static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv) continue; str = pkg_depend_str(pkg, k); - opkg_message(conf, OPKG_NOTICE, "\t%s\n", str); + opkg_msg(NOTICE, "\t%s\n", str); free(str); } @@ -980,6 +917,19 @@ static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv) return 0; } +static int +pkg_mark_provides(pkg_t *pkg) +{ + int provides_count = pkg->provides_count; + abstract_pkg_t **provides = pkg->provides; + int i; + pkg->parent->state_flag |= SF_MARKED; + for (i = 0; i < provides_count; i++) { + provides[i]->state_flag |= SF_MARKED; + } + return 0; +} + enum what_field_type { WHATDEPENDS, WHATCONFLICTS, @@ -989,7 +939,8 @@ enum what_field_type { WHATSUGGESTS }; -static int opkg_what_depends_conflicts_cmd(opkg_conf_t *conf, enum depend_type what_field_type, int recursive, int argc, char **argv) +static int +opkg_what_depends_conflicts_cmd(enum depend_type what_field_type, int recursive, int argc, char **argv) { depend_t *possibility; compound_depend_t *cdep; @@ -1007,17 +958,17 @@ static int opkg_what_depends_conflicts_cmd(opkg_conf_t *conf, enum depend_type w case RECOMMEND: rel_str = "recommends"; break; default: return -1; } - + available_pkgs = pkg_vec_alloc(); if (conf->query_all) - pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs); + pkg_hash_fetch_available(available_pkgs); else - pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs); + pkg_hash_fetch_all_installed(available_pkgs); /* mark the root set */ pkg_vec_clear_marks(available_pkgs); - opkg_message(conf, OPKG_NOTICE, "Root set:\n"); + opkg_msg(NOTICE, "Root set:\n"); for (i = 0; i < argc; i++) pkg_vec_mark_if_matches(available_pkgs, argv[i]); @@ -1026,11 +977,11 @@ static int opkg_what_depends_conflicts_cmd(opkg_conf_t *conf, enum depend_type w if (pkg->state_flag & SF_MARKED) { /* mark the parent (abstract) package */ pkg_mark_provides(pkg); - opkg_message(conf, OPKG_NOTICE, " %s\n", pkg->name); + opkg_msg(NOTICE, " %s\n", pkg->name); } } - opkg_message(conf, OPKG_NOTICE, "What %s root set\n", rel_str); + opkg_msg(NOTICE, "What %s root set\n", rel_str); do { changed = 0; @@ -1063,31 +1014,29 @@ static int opkg_what_depends_conflicts_cmd(opkg_conf_t *conf, enum depend_type w & 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); - opkg_message(conf, OPKG_NOTICE, - "\t%s %s\t%s %s", + ver = pkg_version_str_alloc(pkg); + opkg_msg(NOTICE, "\t%s %s\t%s %s", pkg->name, ver, rel_str, possibility->pkg->name); free(ver); if (possibility->version) { - opkg_message(conf, OPKG_NOTICE, - " (%s%s)", + opkg_msg(NOTICE, " (%s%s)", constraint_to_str(possibility->constraint), possibility->version); } - if (!pkg_dependence_satisfiable(conf, possibility)) - opkg_message(conf, OPKG_NOTICE, + if (!pkg_dependence_satisfiable(possibility)) + opkg_msg(NOTICE, " unsatisfiable"); - opkg_message(conf, OPKG_NOTICE, "\n"); + opkg_message(NOTICE, "\n"); goto next_package; } } @@ -1101,76 +1050,72 @@ next_package: return 0; } -static int pkg_mark_provides(pkg_t *pkg) +static int +opkg_whatdepends_recursively_cmd(int argc, char **argv) { - int provides_count = pkg->provides_count; - abstract_pkg_t **provides = pkg->provides; - int i; - pkg->parent->state_flag |= SF_MARKED; - for (i = 0; i < provides_count; i++) { - provides[i]->state_flag |= SF_MARKED; - } - return 0; + return opkg_what_depends_conflicts_cmd(DEPEND, 1, argc, argv); } -static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_whatdepends_cmd(int argc, char **argv) { - return opkg_what_depends_conflicts_cmd(conf, DEPEND, 1, argc, argv); -} -static int opkg_whatdepends_cmd(opkg_conf_t *conf, int argc, char **argv) -{ - return opkg_what_depends_conflicts_cmd(conf, DEPEND, 0, argc, argv); + return opkg_what_depends_conflicts_cmd(DEPEND, 0, argc, argv); } -static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_whatsuggests_cmd(int argc, char **argv) { - return opkg_what_depends_conflicts_cmd(conf, SUGGEST, 0, argc, argv); + return opkg_what_depends_conflicts_cmd(SUGGEST, 0, argc, argv); } -static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_whatrecommends_cmd(int argc, char **argv) { - return opkg_what_depends_conflicts_cmd(conf, RECOMMEND, 0, argc, argv); + return opkg_what_depends_conflicts_cmd(RECOMMEND, 0, argc, argv); } -static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_whatconflicts_cmd(int argc, char **argv) { - return opkg_what_depends_conflicts_cmd(conf, CONFLICTS, 0, argc, argv); + return opkg_what_depends_conflicts_cmd(CONFLICTS, 0, argc, argv); } -static int opkg_what_provides_replaces_cmd(opkg_conf_t *conf, enum what_field_type what_field_type, int argc, char **argv) +static int +opkg_what_provides_replaces_cmd(enum what_field_type what_field_type, int argc, char **argv) { if (argc > 0) { pkg_vec_t *available_pkgs = pkg_vec_alloc(); const char *rel_str = (what_field_type == WHATPROVIDES ? "provides" : "replaces"); int i; - - pkg_info_preinstall_check(conf); + + pkg_info_preinstall_check(); if (conf->query_all) - pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs); + pkg_hash_fetch_available(available_pkgs); else - pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs); + pkg_hash_fetch_all_installed(available_pkgs); for (i = 0; i < argc; i++) { const char *target = argv[i]; int j; - opkg_message(conf, OPKG_ERROR, "What %s %s\n", + opkg_msg(NOTICE, "What %s %s\n", rel_str, target); for (j = 0; j < available_pkgs->len; j++) { pkg_t *pkg = available_pkgs->pkgs[j]; 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) { - opkg_message(conf, OPKG_ERROR, " %s", pkg->name); - if (strcmp(target, apkg->name) != 0) - opkg_message(conf, OPKG_ERROR, "\t%s %s\n", rel_str, apkg->name); - opkg_message(conf, OPKG_ERROR, "\n"); + if (fnmatch(target, apkg->name, conf->nocase) == 0) { + opkg_msg(NOTICE, " %s", pkg->name); + if ((conf->nocase ? strcasecmp(target, apkg->name) : strcmp(target, apkg->name)) != 0) + opkg_msg(NOTICE, "\t%s %s\n", + rel_str, apkg->name); + opkg_message(NOTICE, "\n"); } } } @@ -1180,17 +1125,20 @@ static int opkg_what_provides_replaces_cmd(opkg_conf_t *conf, enum what_field_ty return 0; } -static int opkg_whatprovides_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_whatprovides_cmd(int argc, char **argv) { - return opkg_what_provides_replaces_cmd(conf, WHATPROVIDES, argc, argv); + return opkg_what_provides_replaces_cmd(WHATPROVIDES, argc, argv); } -static int opkg_whatreplaces_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_whatreplaces_cmd(int argc, char **argv) { - return opkg_what_provides_replaces_cmd(conf, WHATREPLACES, argc, argv); + return opkg_what_provides_replaces_cmd(WHATREPLACES, argc, argv); } -static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_search_cmd(int argc, char **argv) { int i; @@ -1201,21 +1149,21 @@ static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv) char *installed_file; if (argc < 1) { - return EINVAL; + return -1; } - + installed = pkg_vec_alloc(); - pkg_hash_fetch_all_installed(&conf->pkg_hash, installed); + pkg_hash_fetch_all_installed(installed); pkg_vec_sort(installed, pkg_compare_names); for (i=0; i < installed->len; i++) { pkg = installed->pkgs[i]; - installed_files = pkg_get_installed_files(conf, pkg); + installed_files = pkg_get_installed_files(pkg); for (iter = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) { installed_file = (char *)iter->data; - if (fnmatch(argv[0], installed_file, 0)==0) + if (fnmatch(argv[0], installed_file, conf->nocase)==0) print_pkg(pkg); } @@ -1227,23 +1175,25 @@ static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv) return 0; } -static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +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_message(conf, OPKG_ERROR, + opkg_msg(ERROR, "opkg compare_versions \n" " is one of <= >= << >> =\n"); return -1; } } -static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv) +static int +opkg_print_architecture_cmd(int argc, char **argv) { nv_pair_list_elt_t *l; @@ -1253,3 +1203,64 @@ static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv) } return 0; } + + +/* XXX: CLEANUP: The usage strings should be incorporated into this + array for easier maintenance */ +static opkg_cmd_t cmds[] = { + {"update", 0, (opkg_cmd_fun_t)opkg_update_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}, + {"install", 1, (opkg_cmd_fun_t)opkg_install_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"remove", 1, (opkg_cmd_fun_t)opkg_remove_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"configure", 0, (opkg_cmd_fun_t)opkg_configure_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"files", 1, (opkg_cmd_fun_t)opkg_files_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"search", 1, (opkg_cmd_fun_t)opkg_search_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"find", 1, (opkg_cmd_fun_t)opkg_find_cmd, PFM_SOURCE}, + {"download", 1, (opkg_cmd_fun_t)opkg_download_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"compare_versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"compare-versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"print-architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"print_architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"print-installation-architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"print_installation_architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"depends", 1, (opkg_cmd_fun_t)opkg_depends_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"whatdepends", 1, (opkg_cmd_fun_t)opkg_whatdepends_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"whatdependsrec", 1, (opkg_cmd_fun_t)opkg_whatdepends_recursively_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"whatrecommends", 1, (opkg_cmd_fun_t)opkg_whatrecommends_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"whatsuggests", 1, (opkg_cmd_fun_t)opkg_whatsuggests_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"whatprovides", 1, (opkg_cmd_fun_t)opkg_whatprovides_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"whatreplaces", 1, (opkg_cmd_fun_t)opkg_whatreplaces_cmd, PFM_DESCRIPTION|PFM_SOURCE}, + {"whatconflicts", 1, (opkg_cmd_fun_t)opkg_whatconflicts_cmd, PFM_DESCRIPTION|PFM_SOURCE}, +}; + +opkg_cmd_t * +opkg_cmd_find(const char *name) +{ + int i; + opkg_cmd_t *cmd; + int num_cmds = sizeof(cmds) / sizeof(opkg_cmd_t); + + for (i=0; i < num_cmds; i++) { + cmd = &cmds[i]; + if (strcmp(name, cmd->name) == 0) + return cmd; + } + + return NULL; +} + +int +opkg_cmd_exec(opkg_cmd_t *cmd, int argc, const char **argv) +{ + return (cmd->fun)(argc, argv); +}