#include "includes.h"
#include <dirent.h>
#include <glob.h>
+#include <fnmatch.h>
#include "opkg_conf.h"
#include "opkg_cmd.h"
#include "libbb/libbb.h"
#include "opkg_utils.h"
#include "opkg_defines.h"
-
-#include <fnmatch.h>
-
-
#include "opkg_download.h"
#include "opkg_install.h"
#include "opkg_upgrade.h"
#include "opkg_remove.h"
#include "opkg_configure.h"
#include "opkg_message.h"
-
#include "libopkg.h"
-static void *p_userdata = NULL;
+#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);
{"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_pending", 0, (opkg_cmd_fun_t)opkg_install_pending_cmd},
+ {"install-pending", 0, (opkg_cmd_fun_t)opkg_install_pending_cmd},
{"install", 1, (opkg_cmd_fun_t)opkg_install_cmd},
{"remove", 1, (opkg_cmd_fun_t)opkg_remove_cmd},
{"purge", 1, (opkg_cmd_fun_t)opkg_purge_cmd},
{"whatconflicts", 1, (opkg_cmd_fun_t)opkg_whatconflicts_cmd},
};
+static void print_pkg(pkg_t *pkg)
+{
+ char *version = pkg_version_str_alloc(pkg);
+ if (pkg->description)
+ printf("%s - %s - %s\n", pkg->name, version, pkg->description);
+ else
+ printf("%s - %s\n", pkg->name, version);
+ free(version);
+}
+
int opkg_state_changed;
static void write_status_files_if_changed(opkg_conf_t *conf)
{
return NULL;
}
-void opkg_print_error_list (opkg_conf_t *conf)
-{
- if ( error_list ) {
- reverse_error_list(&error_list);
-
- printf ("Collected errors:\n");
- /* Here we print the errors collected and free the list */
- while (error_list != NULL) {
- printf (" * %s", error_list->errmsg);
- error_list = error_list->next;
-
- }
- free_error_list();
- }
-
-}
-
int opkg_cmd_exec(opkg_cmd_t *cmd, opkg_conf_t *conf, int argc, const char **argv, void *userdata)
{
int result;
- p_userdata = userdata;
-
result = (cmd->fun)(conf, argc, argv);
- if ( result != 0 && !error_list) {
- opkg_message(conf, OPKG_NOTICE, "An error ocurred, return value: %d.\n", result);
- }
+ print_error_list();
+ free_error_list();
- opkg_print_error_list (conf);
-
- p_userdata = NULL;
return result;
}
"%s: ERROR: %s exists, but is not a directory\n",
__FUNCTION__, lists_dir);
free(lists_dir);
- return EINVAL;
+ return -1;
}
err = file_mkdir_hier(lists_dir, 0755);
if (err) {
"%s: ERROR: failed to make directory %s: %s\n",
__FUNCTION__, lists_dir, strerror(errno));
free(lists_dir);
- return EINVAL;
+ return -1;
}
}
failures = 0;
-
- tmp = strdup ("/tmp/opkg.XXXXXX");
-
+ sprintf_alloc(&tmp, "%s/update-XXXXXX", conf->tmp_dir);
if (mkdtemp (tmp) == NULL) {
perror ("mkdtemp");
- failures++;
+ return -1;
}
- for (iter = conf->pkg_src_list.head; iter; iter = iter->next) {
+ 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 = iter->data;
+ src = (pkg_src_t *)iter->data;
if (src->extra_data) /* debian style? */
sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
fclose (out);
unlink (tmp_file_name);
}
+ free(tmp_file_name);
} else
err = opkg_download(conf, url, list_file_name, NULL, NULL);
if (err) {
list_file_name);
}
free(url);
-
-#ifdef HAVE_GPGME
- /* download detached signitures to verify the package lists */
- /* get the url for the sig file */
- if (src->extra_data) /* debian style? */
- sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
- "Packages.sig");
- else
- sprintf_alloc(&url, "%s/%s", src->value, "Packages.sig");
-
- /* create temporary file for it */
- char *tmp_file_name;
-
- sprintf_alloc (&tmp_file_name, "%s/%s", tmp, "Packages.sig");
-
- err = opkg_download(conf, url, tmp_file_name, NULL, NULL);
- if (err) {
- failures++;
- opkg_message (conf, OPKG_NOTICE, "Signature check failed\n");
- } else {
- int err;
- err = opkg_verify_file (conf, list_file_name, tmp_file_name);
- if (err == 0)
- opkg_message (conf, OPKG_NOTICE, "Signature check passed\n");
- else
- opkg_message (conf, OPKG_NOTICE, "Signature check failed\n");
- }
- unlink (tmp_file_name);
- free (tmp_file_name);
- free (url);
+#if defined(HAVE_GPGME) || defined(HAVE_OPENSSL)
+ if (conf->check_signature) {
+ /* download detached signitures to verify the package lists */
+ /* get the url for the sig file */
+ if (src->extra_data) /* debian style? */
+ sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
+ "Packages.sig");
+ else
+ sprintf_alloc(&url, "%s/%s", src->value, "Packages.sig");
+
+ /* create temporary file for it */
+ char *tmp_file_name;
+
+ /* 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);
+ if (err) {
+ failures++;
+ opkg_message (conf, OPKG_NOTICE, "Signature check failed\n");
+ } else {
+ int err;
+ err = opkg_verify_file (conf, list_file_name, tmp_file_name);
+ if (err == 0)
+ opkg_message (conf, OPKG_NOTICE, "Signature check passed\n");
+ else
+ opkg_message (conf, OPKG_NOTICE, "Signature check failed\n");
+ }
+ /* We shouldn't unlink the signature ! */
+ // unlink (tmp_file_name);
+ free (tmp_file_name);
+ free (url);
+ }
#else
- opkg_message (conf, OPKG_NOTICE, "Signature check for %s skipped "
- "because GPG support was not enabled in this build\n", src->name);
+ // Do nothing
#endif
free(list_file_name);
}
static opkg_intercept_t opkg_prep_intercepts(opkg_conf_t *conf)
{
opkg_intercept_t ctx;
- char *oldpath;
char *newpath;
- int gen;
-
- ctx = calloc (1, sizeof (*ctx));
- oldpath = getenv ("PATH");
- if (oldpath) {
- ctx->oldpath = strdup (oldpath);
- } else {
- ctx->oldpath = 0;
- }
-
- sprintf_alloc (&newpath, "%s/opkg/intercept:%s", DATADIR, ctx->oldpath);
- setenv ("PATH", newpath, 1);
- free (newpath);
-
- gen = 0;
- retry:
- sprintf_alloc (&ctx->statedir, "/tmp/opkg-intercept-%d-%d", getpid (), gen);
- if (mkdir (ctx->statedir, 0770) < 0) {
- if (errno == EEXIST) {
- free (ctx->statedir);
- gen++;
- goto retry;
- }
- perror (ctx->statedir);
+ ctx = xcalloc(1, sizeof (*ctx));
+ ctx->oldpath = xstrdup(getenv("PATH"));
+ sprintf_alloc(&newpath, "%s/opkg/intercept:%s", DATADIR, ctx->oldpath);
+ 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));
+ free(ctx->oldpath);
+ free(ctx->statedir);
+ free(newpath);
+ free(ctx);
return NULL;
}
- setenv ("OPKG_INTERCEPT_DIR", ctx->statedir, 1);
+
+ setenv("OPKG_INTERCEPT_DIR", ctx->statedir, 1);
+ setenv("PATH", newpath, 1);
+ free(newpath);
+
return ctx;
}
static int opkg_finalize_intercepts(opkg_intercept_t ctx)
{
- char *cmd;
DIR *dir;
int err = 0;
- if (ctx->oldpath) {
- setenv ("PATH", ctx->oldpath, 1);
- free (ctx->oldpath);
- } else {
- unsetenv("PATH");
- }
+ setenv ("PATH", ctx->oldpath, 1);
+ free (ctx->oldpath);
dir = opendir (ctx->statedir);
if (dir) {
struct dirent *de;
while (de = readdir (dir), de != NULL) {
char *path;
-
+
if (de->d_name[0] == '.')
continue;
sprintf_alloc (&path, "%s/%s", ctx->statedir, de->d_name);
if (access (path, X_OK) == 0) {
- if (system (path)) {
- err = errno;
- perror (de->d_name);
- }
+ const char *argv[] = {"sh", "-c", path, NULL};
+ xsystem (argv);
}
free (path);
}
+ closedir(dir);
} else
perror (ctx->statedir);
- sprintf_alloc (&cmd, "rm -rf %s", ctx->statedir);
- err = system (cmd);
- free (cmd);
-
+ rm_r(ctx->statedir);
free (ctx->statedir);
free (ctx);
dependents = abpkg->provided_by->pkgs;
l = 0;
if (dependents != NULL)
- while (dependents [l] != NULL && l < abpkg->provided_by->len) {
+ while (l < abpkg->provided_by->len && dependents[l] != NULL) {
opkg_message(conf, OPKG_INFO,
" Descending on pkg: %s\n",
dependents [l]->name);
static int opkg_configure_packages(opkg_conf_t *conf, char *pkg_name)
{
- pkg_vec_t *all, *ordered, *visited;
+ pkg_vec_t *all, *ordered, *visited;
int i;
pkg_t *pkg;
opkg_intercept_t ic;
opkg_recurse_pkgs_in_order(conf, pkg, all, visited, ordered);
}
-
ic = opkg_prep_intercepts (conf);
+ if (ic == NULL) {
+ err = -1;
+ goto error;
+ }
for(i = 0; i < all->len; i++) {
pkg = all->pkgs[i];
if (r && !err)
err = r;
+error:
pkg_vec_free(all);
pkg_vec_free(ordered);
pkg_vec_free(visited);
}
}
- /* recheck to verify that all dependences are satisfied */
- if (0) opkg_satisfy_all_dependences(conf);
-
opkg_configure_packages(conf, NULL);
write_status_files_if_changed(conf);
pkg_vec_free(installed);
}
- /* recheck to verify that all dependences are satisfied */
- if (0) opkg_satisfy_all_dependences(conf);
-
opkg_configure_packages(conf, NULL);
write_status_files_if_changed(conf);
static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv)
{
- int i ;
+ int i;
pkg_vec_t *available;
pkg_t *pkg;
- char desc_short[OPKG_LIST_DESCRIPTION_LENGTH];
- char *newline;
char *pkg_name = NULL;
- char *version_str;
if (argc > 0) {
pkg_name = argv[0];
/* 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 (pkg->description) {
- strncpy(desc_short, pkg->description, OPKG_LIST_DESCRIPTION_LENGTH);
- } else {
- desc_short[0] = '\0';
- }
- desc_short[OPKG_LIST_DESCRIPTION_LENGTH - 1] = '\0';
- newline = strchr(desc_short, '\n');
- if (newline) {
- *newline = '\0';
- }
- if (opkg_cb_list) {
- version_str = pkg_version_str_alloc(pkg);
- opkg_cb_list(pkg->name,desc_short,
- version_str,
- pkg->state_status,
- p_userdata);
- free(version_str);
- }
+ print_pkg(pkg);
}
pkg_vec_free(available);
int i ;
pkg_vec_t *available;
pkg_t *pkg;
- char desc_short[OPKG_LIST_DESCRIPTION_LENGTH];
- char *newline;
char *pkg_name = NULL;
- char *version_str;
if (argc > 0) {
pkg_name = argv[0];
/* 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 (pkg->description) {
- strncpy(desc_short, pkg->description, OPKG_LIST_DESCRIPTION_LENGTH);
- } else {
- desc_short[0] = '\0';
- }
- desc_short[OPKG_LIST_DESCRIPTION_LENGTH - 1] = '\0';
- newline = strchr(desc_short, '\n');
- if (newline) {
- *newline = '\0';
- }
- if (opkg_cb_list) {
- version_str = pkg_version_str_alloc(pkg);
- opkg_cb_list(pkg->name,desc_short,
- version_str,
- pkg->state_status,
- p_userdata);
- free(version_str);
- }
+ print_pkg(pkg);
}
+ pkg_vec_free(available);
+
return 0;
}
_new_pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, _old_pkg->name, NULL);
old_v = pkg_version_str_alloc(_old_pkg);
new_v = pkg_version_str_alloc(_new_pkg);
- if (opkg_cb_list)
- opkg_cb_list(_old_pkg->name, new_v, old_v, _old_pkg->state_status, p_userdata);
+ printf("%s - %s - %s\n", _old_pkg->name, old_v, new_v);
free(old_v);
free(new_v);
}
pkg_vec_t *available;
pkg_t *pkg;
char *pkg_name = NULL;
- char **pkg_fields = NULL;
- int n_fields = 0;
- char *buff ;
if (argc > 0) {
pkg_name = argv[0];
}
- if (argc > 1) {
- pkg_fields = &argv[1];
- n_fields = argc - 1;
- }
available = pkg_vec_alloc();
if (installed_only)
pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
else
pkg_hash_fetch_available(&conf->pkg_hash, available);
+
for (i=0; i < available->len; i++) {
pkg = available->pkgs[i];
if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
continue;
}
- buff = pkg_formatted_info(pkg);
- if ( buff ) {
- if (opkg_cb_status) opkg_cb_status(pkg->name,
- pkg->state_status,
- buff,
- p_userdata);
-/*
- We should not forget that actually the pointer is allocated.
- We need to free it :) ( Thanks florian for seeing the error )
-*/
- free(buff);
- }
- if (conf->verbosity > 1) {
+ pkg_formatted_info(stdout, pkg);
+
+ if (conf->verbosity >= OPKG_NOTICE) {
conffile_list_elt_t *iter;
- for (iter = pkg->conffiles.head; iter; iter = iter->next) {
- conffile_t *cf = iter->data;
+ 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);
- opkg_message(conf, OPKG_NOTICE, "conffile=%s md5sum=%s modified=%d\n",
+ if (cf->value)
+ opkg_message(conf, OPKG_NOTICE,
+ "conffile=%s md5sum=%s modified=%d\n",
cf->name, cf->value, modified);
}
}
static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv)
{
- int i,a,done;
+ int i, a, done;
pkg_t *pkg;
pkg_t *pkg_to_remove;
pkg_vec_t *available;
- char *pkg_name = NULL;
+
global_conf = conf;
+ done = 0;
+
signal(SIGINT, sigint_handler);
-// ENH: Add the "no pkg removed" just in case.
+ pkg_info_preinstall_check(conf);
- done = 0;
+ available = pkg_vec_alloc();
+ pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
- pkg_info_preinstall_check(conf);
- if ( argc > 0 ) {
- available = pkg_vec_alloc();
- pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
- for (i=0; i < argc; i++) {
- pkg_name = calloc(1, strlen(argv[i])+2);
- strcpy(pkg_name,argv[i]);
- for (a=0; a < available->len; a++) {
- pkg = available->pkgs[a];
- if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
- continue;
- }
- if (conf->restrict_to_default_dest) {
- pkg_to_remove = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
- pkg->name,
- conf->default_dest);
- } else {
- pkg_to_remove = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name );
- }
+ for (i=0; i<argc; i++) {
+ for (a=0; a<available->len; a++) {
+ pkg = available->pkgs[a];
+ if (fnmatch(argv[i], pkg->name, 0)) {
+ continue;
+ }
+ if (conf->restrict_to_default_dest) {
+ pkg_to_remove = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
+ pkg->name,
+ conf->default_dest);
+ } else {
+ pkg_to_remove = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name );
+ }
- if (pkg == NULL) {
- opkg_message(conf, OPKG_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);
- continue;
- }
- opkg_remove_pkg(conf, pkg_to_remove,0);
- done = 1;
- }
- free (pkg_name);
+ if (pkg_to_remove == NULL) {
+ opkg_message(conf, OPKG_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);
+ continue;
+ }
+ opkg_remove_pkg(conf, pkg_to_remove, 0);
+ done = 1;
}
- pkg_vec_free(available);
- } else {
- pkg_vec_t *installed_pkgs = pkg_vec_alloc();
- int i;
- int flagged_pkg_count = 0;
- int removed;
-
- pkg_hash_fetch_all_installed(&conf->pkg_hash, installed_pkgs);
-
- for (i = 0; i < installed_pkgs->len; i++) {
- pkg_t *pkg = installed_pkgs->pkgs[i];
- if (pkg->state_flag & SF_USER) {
- flagged_pkg_count++;
- } else {
- if (!pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL))
- opkg_message(conf, OPKG_NOTICE, "Non-user leaf package: %s\n", pkg->name);
- }
- }
- if (!flagged_pkg_count) {
- opkg_message(conf, OPKG_NOTICE, "No packages flagged as installed by user, \n"
- "so refusing to uninstall unflagged non-leaf packages\n");
- return 0;
- }
-
- /* find packages not flagged SF_USER (i.e., installed to
- * satisfy a dependence) and not having any dependents, and
- * remove them */
- do {
- removed = 0;
- for (i = 0; i < installed_pkgs->len; i++) {
- pkg_t *pkg = installed_pkgs->pkgs[i];
- if (!(pkg->state_flag & SF_USER)
- && !pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL)) {
- removed++;
- opkg_message(conf, OPKG_NOTICE, "Removing non-user leaf package %s\n");
- opkg_remove_pkg(conf, pkg,0);
- done = 1;
- }
- }
- } while (removed);
- pkg_vec_free(installed_pkgs);
}
- if ( done == 0 )
+ pkg_vec_free(available);
+
+ if (done == 0)
opkg_message(conf, OPKG_NOTICE, "No packages removed.\n");
write_status_files_if_changed(conf);
static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv)
{
pkg_t *pkg;
- str_list_t *installed_files;
+ str_list_t *files;
str_list_elt_t *iter;
char *pkg_version;
- size_t buff_len = 8192;
- size_t used_len;
- char *buff ;
-
- buff = (char *)calloc(1, buff_len);
- if ( buff == NULL ) {
- fprintf( stderr,"%s: Unable to allocate memory \n",__FUNCTION__);
- return ENOMEM;
- }
-
+
if (argc < 1) {
return EINVAL;
}
return 0;
}
- installed_files = pkg_get_installed_files(pkg);
+ files = pkg_get_installed_files(conf, pkg);
pkg_version = pkg_version_str_alloc(pkg);
- if (buff) {
- try_again:
- used_len = snprintf(buff, buff_len, "Package %s (%s) is installed on %s and has the following files:\n",
- pkg->name, pkg_version, pkg->dest->name) + 1;
- if (used_len > buff_len) {
- buff_len *= 2;
- buff = realloc (buff, buff_len);
- goto try_again;
- }
- for (iter = installed_files->head; iter; iter = iter->next) {
- used_len += strlen (iter->data) + 1;
- while (buff_len <= used_len) {
- buff_len *= 2;
- buff = realloc (buff, buff_len);
- }
- strncat(buff, iter->data, buff_len);
- strncat(buff, "\n", buff_len);
- }
- if (opkg_cb_list) opkg_cb_list(pkg->name,
- buff,
- pkg_version_str_alloc(pkg),
- pkg->state_status,
- p_userdata);
- free(buff);
- }
+ printf("Package %s (%s) is installed on %s and has the following files:\n",
+ pkg->name, pkg_version, pkg->dest->name);
+
+ for (iter=str_list_first(files); iter; iter=str_list_next(files, iter))
+ printf("%s\n", (char *)iter->data);
free(pkg_version);
pkg_free_installed_files(pkg);
const char *target = argv[i];
int j;
- opkg_message(conf, OPKG_ERROR, "target=%s\n", target);
+ opkg_message(conf, OPKG_NOTICE, "target=%s\n", target);
for (j = 0; j < available_pkgs->len; j++) {
pkg_t *pkg = available_pkgs->pkgs[j];
if (fnmatch(target, pkg->name, 0) == 0) {
int k;
int count = pkg->depends_count + pkg->pre_depends_count;
- opkg_message(conf, OPKG_ERROR, "What %s (arch=%s) %s\n",
+ opkg_message(conf, OPKG_NOTICE, "What %s (arch=%s) %s\n",
target, pkg->architecture, rel_str);
for (k = 0; k < count; k++) {
compound_depend_t *cdepend = &pkg->depends[k];
int l;
for (l = 0; l < cdepend->possibility_count; l++) {
depend_t *possibility = cdepend->possibilities[l];
- opkg_message(conf, OPKG_ERROR, " %s", possibility->pkg->name);
- if (conf->verbosity > 0) {
- // char *ver = abstract_pkg_version_str_alloc(possibility->pkg);
- opkg_message(conf, OPKG_NOTICE, " %s", possibility->version);
+ opkg_message(conf, OPKG_NOTICE, " %s", possibility->pkg->name);
+ if (conf->verbosity >= OPKG_NOTICE) {
if (possibility->version) {
char *typestr = NULL;
+ opkg_message(conf, OPKG_NOTICE, " %s", possibility->version);
switch (possibility->constraint) {
case NONE: typestr = "none"; break;
case EARLIER: typestr = "<"; break;
}
opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
}
- // free(ver);
}
- opkg_message(conf, OPKG_ERROR, "\n");
+ opkg_message(conf, OPKG_NOTICE, "\n");
}
}
}
WHATSUGGESTS
};
-static int opkg_what_depends_conflicts_cmd(opkg_conf_t *conf, enum what_field_type what_field_type, int recursive, int argc, char **argv)
+static int opkg_what_depends_conflicts_cmd(opkg_conf_t *conf, enum depend_type what_field_type, int recursive, int argc, char **argv)
{
if (argc > 0) {
int changed;
switch (what_field_type) {
- case WHATDEPENDS: rel_str = "depends on"; break;
- case WHATCONFLICTS: rel_str = "conflicts with"; break;
- case WHATSUGGESTS: rel_str = "suggests"; break;
- case WHATRECOMMENDS: rel_str = "recommends"; break;
- case WHATPROVIDES: rel_str = "provides"; break;
- case WHATREPLACES: rel_str = "replaces"; break;
+ case DEPEND: rel_str = "depends on"; break;
+ case CONFLICTS: rel_str = "conflicts with"; break;
+ case SUGGEST: rel_str = "suggests"; break;
+ case RECOMMEND: rel_str = "recommends"; break;
+ default: return -1;
}
if (conf->query_all)
for (j = 0; j < available_pkgs->len; j++) {
pkg_t *pkg = available_pkgs->pkgs[j];
int k;
- int count = ((what_field_type == WHATCONFLICTS)
+ int count = ((what_field_type == CONFLICTS)
? pkg->conflicts_count
: pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count);
/* skip this package if it is already marked */
}
for (k = 0; k < count; k++) {
compound_depend_t *cdepend =
- (what_field_type == WHATCONFLICTS) ? &pkg->conflicts[k] : &pkg->depends[k];
+ (what_field_type == CONFLICTS) ? &pkg->conflicts[k] : &pkg->depends[k];
int l;
+ if (what_field_type != cdepend->type)
+ continue;
for (l = 0; l < cdepend->possibility_count; l++) {
depend_t *possibility = cdepend->possibilities[l];
if (possibility->pkg->state_flag & SF_MARKED) {
pkg_mark_provides(pkg);
changed++;
- opkg_message(conf, OPKG_NOTICE, " %s", pkg->name);
- if (conf->verbosity > 0) {
+ if (conf->verbosity >= OPKG_NOTICE) {
char *ver = pkg_version_str_alloc(pkg);
+ opkg_message(conf, OPKG_NOTICE, " %s", pkg->name);
opkg_message(conf, OPKG_NOTICE, " %s", ver);
opkg_message(conf, OPKG_NOTICE, "\t%s %s", rel_str, possibility->pkg->name);
if (possibility->version) {
static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv)
{
- return opkg_what_depends_conflicts_cmd(conf, WHATDEPENDS, 1, argc, 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, WHATDEPENDS, 0, argc, argv);
+ return opkg_what_depends_conflicts_cmd(conf, DEPEND, 0, argc, argv);
}
static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv)
{
- return opkg_what_depends_conflicts_cmd(conf, WHATSUGGESTS, 0, argc, argv);
+ return opkg_what_depends_conflicts_cmd(conf, SUGGEST, 0, argc, argv);
}
static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv)
{
- return opkg_what_depends_conflicts_cmd(conf, WHATRECOMMENDS, 0, argc, argv);
+ return opkg_what_depends_conflicts_cmd(conf, RECOMMEND, 0, argc, argv);
}
static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv)
{
- return opkg_what_depends_conflicts_cmd(conf, WHATCONFLICTS, 0, argc, argv);
+ return opkg_what_depends_conflicts_cmd(conf, 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)
for (i=0; i < installed->len; i++) {
pkg = installed->pkgs[i];
- installed_files = pkg_get_installed_files(pkg);
+ installed_files = pkg_get_installed_files(conf, pkg);
- for (iter = installed_files->head; iter; iter = iter->next) {
- installed_file = iter->data;
- if (fnmatch(argv[0], installed_file, 0)==0) {
- if (opkg_cb_list) opkg_cb_list(pkg->name,
- installed_file,
- pkg_version_str_alloc(pkg),
- pkg->state_status, p_userdata);
- }
+ 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)
+ print_pkg(pkg);
}
pkg_free_installed_files(pkg);
if (argc == 3) {
/* this is a bit gross */
struct pkg p1, p2;
- parseVersion(&p1, argv[0]);
- parseVersion(&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,
}
}
-#ifndef HOST_CPU_STR
-#define HOST_CPU_STR__(X) #X
-#define HOST_CPU_STR_(X) HOST_CPU_STR__(X)
-#define HOST_CPU_STR HOST_CPU_STR_(HOST_CPU_FOO)
-#endif
-
static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv)
{
nv_pair_list_elt_t *l;
- l = conf->arch_list.head;
- while (l) {
- nv_pair_t *nv = l->data;
+ list_for_each_entry(l, &conf->arch_list.head, node) {
+ nv_pair_t *nv = (nv_pair_t *)l->data;
printf("arch %s %s\n", nv->name, nv->value);
- l = l->next;
}
return 0;
}
-
-
projects / oweals / opkg-lede.git / blobdiff