X-Git-Url: https://git.librecmc.org/?p=oweals%2Fopkg-lede.git;a=blobdiff_plain;f=libopkg%2Fopkg_cmd.c;h=ca9d9c930ea7f0a099c112eccbc6ab637d82c1f5;hp=2dd17b2a03ef1d02dc26be2957cbebb3ee658193;hb=b2b5908e2c248f7d21bde6cee2c523b24793dfa1;hpb=f0fe187f841a29675317835723c3591b149fdeb1

diff --git a/libopkg/opkg_cmd.c b/libopkg/opkg_cmd.c
index 2dd17b2..ca9d9c9 100644
--- a/libopkg/opkg_cmd.c
+++ b/libopkg/opkg_cmd.c
@@ -19,6 +19,7 @@
 #include "includes.h"
 #include <dirent.h>
 #include <glob.h>
+#include <fnmatch.h>
 
 #include "opkg_conf.h"
 #include "opkg_cmd.h"
@@ -29,34 +30,27 @@
 #include "sprintf_alloc.h"
 #include "pkg.h"
 #include "file_util.h"
-#include "str_util.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"
+#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_pending_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_purge_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);
@@ -81,14 +75,14 @@ static opkg_cmd_t cmds[] = {
      {"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", 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},
      {"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},
@@ -180,7 +174,7 @@ static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv)
 			    "%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) {
@@ -188,18 +182,16 @@ static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv)
 			    "%s: ERROR: failed to make directory %s: %s\n",
 			    __FUNCTION__, lists_dir, strerror(errno));
 	       free(lists_dir);
-	       return EINVAL;
+	       return -1;
 	  }	
      } 
 
      failures = 0;
 
-
-     tmp = xstrdup("/tmp/opkg.XXXXXX");
-
+     sprintf_alloc(&tmp, "%s/update-XXXXXX", conf->tmp_dir);
      if (mkdtemp (tmp) == NULL) {
 	 perror ("mkdtemp");
-	 failures++;
+	 return -1;
      }
 
 
@@ -304,57 +296,49 @@ static opkg_intercept_t opkg_prep_intercepts(opkg_conf_t *conf)
 {
     opkg_intercept_t ctx;
     char *newpath;
-    int gen;
 
     ctx = xcalloc(1, sizeof (*ctx));
     ctx->oldpath = xstrdup(getenv("PATH"));
-
-    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);
+    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);
-    }
+    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);
 	}
@@ -362,10 +346,7 @@ static int opkg_finalize_intercepts(opkg_intercept_t ctx)
     } 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);
 
@@ -464,7 +445,7 @@ 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)
 {
-    pkg_vec_t *all, *ordered, *visited;
+     pkg_vec_t *all, *ordered, *visited;
      int i;
      pkg_t *pkg;
      opkg_intercept_t ic;
@@ -489,8 +470,11 @@ static int opkg_configure_packages(opkg_conf_t *conf, char *pkg_name)
          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];
@@ -518,6 +502,7 @@ static int opkg_configure_packages(opkg_conf_t *conf, char *pkg_name)
      if (r && !err)
 	 err = r;
 
+error:
      pkg_vec_free(all);
      pkg_vec_free(ordered);
      pkg_vec_free(visited);
@@ -553,7 +538,7 @@ static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv)
 
           opkg_message(conf, OPKG_DEBUG2, "Debug install_cmd: %s  \n",arg );
           err = opkg_prepare_url_for_install(conf, arg, &argv[i]);
-          if (err != EINVAL && err != 0)
+          if (err)
               return err;
      }
      pkg_info_preinstall_check(conf);
@@ -561,10 +546,8 @@ static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv)
      for (i=0; i < argc; i++) {
 	  arg = argv[i];
           err = opkg_install_by_name(conf, arg);
-	  if (err == OPKG_PKG_HAS_NO_CANDIDATE) {
-	       opkg_message(conf, OPKG_ERROR,
-			    "Cannot find package %s.\n",
-			    arg);
+	  if (err) {
+	       opkg_message(conf, OPKG_ERROR, "Cannot find package %s.\n", arg);
 	  }
      }
 
@@ -589,7 +572,7 @@ static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv)
 	       char *arg = argv[i];
 
                err = opkg_prepare_url_for_install(conf, arg, &arg);
-               if (err != EINVAL && err != 0)
+               if (err)
                    return err;
 	  }
 	  pkg_info_preinstall_check(conf);
@@ -646,7 +629,7 @@ static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv)
      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(conf, arg);
 	  if (pkg == NULL) {
 	       opkg_message(conf, OPKG_ERROR,
 			    "Cannot find package %s.\n"
@@ -731,7 +714,9 @@ static int opkg_list_upgradable_cmd(opkg_conf_t *conf, int argc, char **argv)
     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(conf, _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);
@@ -767,13 +752,13 @@ static int opkg_info_status_cmd(opkg_conf_t *conf, int argc, char **argv, int in
 
 	  pkg_formatted_info(stdout, pkg);
 
-	  if (conf->verbosity > 1) {
+	  if (conf->verbosity >= OPKG_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);
 		    if (cf->value)
-		        opkg_message(conf, OPKG_NOTICE,
+		        opkg_message(conf, OPKG_INFO,
 				"conffile=%s md5sum=%s modified=%d\n",
 				 cf->name, cf->value, modified);
 	       }
@@ -814,167 +799,54 @@ static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv)
      return err;
 }
 
-static int opkg_install_pending_cmd(opkg_conf_t *conf, int argc, char **argv)
-{
-     int i, err;
-     char *globpattern;
-     glob_t globbuf;
-    
-     sprintf_alloc(&globpattern, "%s/*" OPKG_PKG_EXTENSION, conf->pending_dir);
-     err = glob(globpattern, 0, NULL, &globbuf);
-     free(globpattern);
-     if (err) {
-	  return 0;
-     }
-
-     opkg_message(conf, OPKG_NOTICE,
-		  "The following packages in %s will now be installed.\n",
-		  conf->pending_dir);
-     for (i = 0; i < globbuf.gl_pathc; i++) {
-	  opkg_message(conf, OPKG_NOTICE,
-		       "%s%s", i == 0 ? "" : " ", globbuf.gl_pathv[i]);
-     }
-     opkg_message(conf, OPKG_NOTICE, "\n");
-     for (i = 0; i < globbuf.gl_pathc; i++) {
-	  err = opkg_install_from_file(conf, globbuf.gl_pathv[i]);
-	  if (err == 0) {
-	       err = unlink(globbuf.gl_pathv[i]);
-	       if (err) {
-		    opkg_message(conf, OPKG_ERROR,
-				 "%s: ERROR: failed to unlink %s: %s\n",
-				 __FUNCTION__, globbuf.gl_pathv[i], strerror(err));
-		    return err;
-	       }
-	  }
-     }
-     globfree(&globbuf);
-
-     return err;
-}
-
 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 = xcalloc(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_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;
-           }
-           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 ) 
-        opkg_message(conf, OPKG_NOTICE, "No packages removed.\n");
-
-     write_status_files_if_changed(conf);
-     return 0;
-}
-
-static int opkg_purge_cmd(opkg_conf_t *conf, int argc, char **argv)
-{
-     int i;
-     pkg_t *pkg;
-
-     global_conf = conf;
-     signal(SIGINT, sigint_handler);
-
-     pkg_info_preinstall_check(conf);
-
-     for (i=0; i < argc; i++) {
-	  if (conf->restrict_to_default_dest) {
-	       pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
-							   argv[i],
-							   conf->default_dest);
-	  } else {
-	       pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
-	  }
+     pkg_vec_free(available);
 
-	  if (pkg == NULL) {
-	       opkg_message(conf, OPKG_ERROR,
-			    "Package %s is not installed.\n", argv[i]);
-	       continue;
-	  }
-	  opkg_purge_pkg(conf, pkg);
-     }
+     if (done == 0)
+        opkg_message(conf, OPKG_NOTICE, "No packages removed.\n");
 
      write_status_files_if_changed(conf);
      return 0;
@@ -1007,11 +879,15 @@ static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv)
               ( strcmp(flags,"user")==0)||( strcmp(flags,"ok")==0)) {
 	      pkg->state_flag = pkg_state_flag_from_str(flags);
           }
-/* pb_ asked this feature 03292004 */
-/* Actually I will use only this two, but this is an open for various status */
+
+	  /* 
+	   * Useful if a package is installed in an offline_root, and
+	   * should be configured by opkg-cl configure at a later date.
+	   */
           if (( strcmp(flags,"installed")==0)||( strcmp(flags,"unpacked")==0)){
 	      pkg->state_status = pkg_state_status_from_str(flags);
           }
+
 	  opkg_state_changed++;
 	  opkg_message(conf, OPKG_NOTICE,
 		       "Setting flags for package %s to %s\n",
@@ -1041,7 +917,7 @@ static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv)
 	  return 0;
      }
 
-     files = pkg_get_installed_files(pkg);
+     files = pkg_get_installed_files(conf, pkg);
      pkg_version = pkg_version_str_alloc(pkg);
 
      printf("Package %s (%s) is installed on %s and has the following files:\n",
@@ -1058,63 +934,52 @@ static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv)
 
 static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv)
 {
+	int i, j, k;
+	int depends_count;
+	pkg_vec_t *available_pkgs;
+	compound_depend_t *cdep;
+	pkg_t *pkg;
+	char *str;
 
-     if (argc > 0) {
-	  pkg_vec_t *available_pkgs = pkg_vec_alloc();
-	  const char *rel_str = "depends on";
-	  int i;
-     
-	  pkg_info_preinstall_check(conf);
+	pkg_info_preinstall_check(conf);
 
-	  if (conf->query_all)
+	available_pkgs = pkg_vec_alloc();
+	if (conf->query_all)
 	       pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
-	  else
+	else
 	       pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
-	  for (i = 0; i < argc; i++) {
-	       const char *target = argv[i];
-	       int j;
 
-	       opkg_message(conf, OPKG_ERROR, "target=%s\n", target);
+	for (i=0; i<argc; i++) {
+		for (j=0; j<available_pkgs->len; j++) {
+			pkg = available_pkgs->pkgs[j];
+
+			if (fnmatch(argv[i], pkg->name, 0) != 0)
+				continue;
+
+			depends_count = pkg->depends_count +
+					pkg->pre_depends_count +
+					pkg->recommends_count +
+					pkg->suggests_count;
+
+			opkg_message(conf, OPKG_NOTICE, "%s depends on:\n",
+				      pkg->name);
+
+			for (k=0; k<depends_count; k++) {
+				cdep = &pkg->depends[k];
+
+				if (cdep->type != DEPEND)
+				      continue;
+
+				str = pkg_depend_str(pkg, k);
+				opkg_message(conf, OPKG_NOTICE, "\t%s\n", str);
+				free(str);
+			}
 
-	       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",
-				      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);
-					if (possibility->version) {
-					     char *typestr = NULL;
-					     switch (possibility->constraint) {
-					     case NONE: typestr = "none"; break;
-					     case EARLIER: typestr = "<"; break;
-					     case EARLIER_EQUAL: typestr = "<="; break;
-					     case EQUAL: typestr = "="; break;
-					     case LATER_EQUAL: typestr = ">="; break;
-					     case LATER: typestr = ">"; break;
-					     }
-					     opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
-					}
-					// free(ver);
-				   }
-				   opkg_message(conf, OPKG_ERROR, "\n");
-			      }
-			 }
-		    }
 	       }
-	  }
-	  pkg_vec_free(available_pkgs);
-     }
-     return 0;
+	}
+
+	pkg_vec_free(available_pkgs);
+	return 0;
 }
 
 enum what_field_type {
@@ -1126,106 +991,116 @@ enum what_field_type {
   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) {
-	  pkg_vec_t *available_pkgs = pkg_vec_alloc();
-	  const char *rel_str = NULL;
-	  int i;
-	  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;
-	  }
+	depend_t *possibility;
+	compound_depend_t *cdep;
+	pkg_vec_t *available_pkgs;
+	pkg_t *pkg;
+	int i, j, k, l;
+	int changed, count;
+	const char *rel_str = NULL;
+	char *ver;
+
+	switch (what_field_type) {
+	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)
+	available_pkgs = pkg_vec_alloc();
+
+	if (conf->query_all)
 	       pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
-	  else
+	else
 	       pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
 
-	  /* mark the root set */
-	  pkg_vec_clear_marks(available_pkgs);
-	  opkg_message(conf, OPKG_NOTICE, "Root set:\n");
-	  for (i = 0; i < argc; i++) {
-	       const char *dependee_pattern = argv[i];
-	       pkg_vec_mark_if_matches(available_pkgs, dependee_pattern);
-	  }
-	  for (i = 0; i < available_pkgs->len; i++) {
-	       pkg_t *pkg = available_pkgs->pkgs[i];
+	/* mark the root set */
+	pkg_vec_clear_marks(available_pkgs);
+	opkg_message(conf, OPKG_NOTICE, "Root set:\n");
+	for (i = 0; i < argc; i++)
+	       pkg_vec_mark_if_matches(available_pkgs, argv[i]);
+
+	for (i = 0; i < available_pkgs->len; i++) {
+	       pkg = available_pkgs->pkgs[i];
 	       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_message(conf, OPKG_NOTICE, "What %s root set\n", rel_str);
-	  do {
-	       int j;
-	       changed = 0;
+	opkg_message(conf, OPKG_NOTICE, "What %s root set\n", rel_str);
+	do {
+		changed = 0;
 
-	       for (j = 0; j < available_pkgs->len; j++) {
-		    pkg_t *pkg = available_pkgs->pkgs[j];
-		    int k;
-		    int count = ((what_field_type == WHATCONFLICTS)
+		for (j=0; j<available_pkgs->len; j++) {
+
+			pkg = available_pkgs->pkgs[j];
+			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 */
-		    if (pkg->parent->state_flag & SF_MARKED) {
-			 continue;
-		    }
-		    for (k = 0; k < count; k++) {
-			 compound_depend_t *cdepend = 
-			      (what_field_type == WHATCONFLICTS) ? &pkg->conflicts[k] : &pkg->depends[k];
-			 int l;
-			 for (l = 0; l < cdepend->possibility_count; l++) {
-			      depend_t *possibility = cdepend->possibilities[l];
-			      if (possibility->pkg->state_flag & SF_MARKED) {
-				   /* mark the depending package so we won't visit it again */
-				   pkg->state_flag |= SF_MARKED;
-				   pkg_mark_provides(pkg);
-				   changed++;
-
-				   opkg_message(conf, OPKG_NOTICE, "    %s", pkg->name);
-				   if (conf->verbosity > 0) {
-					char *ver = pkg_version_str_alloc(pkg); 
-					opkg_message(conf, OPKG_NOTICE, " %s", ver);
-					opkg_message(conf, OPKG_NOTICE, "\t%s %s", rel_str, possibility->pkg->name);
+				 : pkg->pre_depends_count +
+				 pkg->depends_count +
+				 pkg->recommends_count +
+				 pkg->suggests_count);
+
+			/* skip this package if it is already marked */
+			if (pkg->parent->state_flag & SF_MARKED)
+				continue;
+
+			for (k=0; k<count; k++) {
+				cdep = (what_field_type == CONFLICTS)
+					? &pkg->conflicts[k]
+					: &pkg->depends[k];
+
+				if (what_field_type != cdep->type)
+					continue;
+
+				for (l=0; l<cdep->possibility_count; l++) {
+					possibility = cdep->possibilities[l];
+
+					if ((possibility->pkg->state_flag
+								& 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",
+							pkg->name,
+							ver,
+							rel_str,
+							possibility->pkg->name);
+					free(ver);
 					if (possibility->version) {
-					     char *typestr = NULL;
-					     switch (possibility->constraint) {
-					     case NONE: typestr = "none"; break;
-					     case EARLIER: typestr = "<"; break;
-					     case EARLIER_EQUAL: typestr = "<="; break;
-					     case EQUAL: typestr = "="; break;
-					     case LATER_EQUAL: typestr = ">="; break;
-					     case LATER: typestr = ">"; break;
-					     }
-					     opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
+						opkg_message(conf, OPKG_NOTICE,
+							" (%s%s)",
+							constraint_to_str(possibility->constraint),
+							possibility->version);
 					}
-					free(ver);
 					if (!pkg_dependence_satisfiable(conf, possibility))
-					     opkg_message(conf, OPKG_NOTICE, " unsatisfiable");
-				   }
-				   opkg_message(conf, OPKG_NOTICE, "\n");
-				   goto next_package;
-			      }
-			 }
-		    }
-	       next_package:
-		    ;
-	       }
-	  } while (changed && recursive);
-	  pkg_vec_free(available_pkgs);
-     }
+						opkg_message(conf, OPKG_NOTICE,
+							" unsatisfiable");
+					opkg_message(conf, OPKG_NOTICE, "\n");
+					goto next_package;
+				}
+			}
+next_package:
+			;
+		}
+	} while (changed && recursive);
 
-     return 0;
+	pkg_vec_free(available_pkgs);
+
+	return 0;
 }
 
 static int pkg_mark_provides(pkg_t *pkg)
@@ -1242,26 +1117,26 @@ static int pkg_mark_provides(pkg_t *pkg)
 
 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)
@@ -1338,7 +1213,7 @@ static int opkg_search_cmd(opkg_conf_t *conf, 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 = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) {
 	       installed_file = (char *)iter->data;
@@ -1359,8 +1234,8 @@ static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv)
      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,