X-Git-Url: https://git.librecmc.org/?p=oweals%2Fopkg-lede.git;a=blobdiff_plain;f=libopkg%2Fopkg_cmd.c;h=c30e34dc226c8c397bc5c8bb9c33a5a85986dc30;hp=30d312637ceaa6d25f29a35f0ceb636f95c9ecb5;hb=71f02a3eb65b2996957faf81c2e54196a35f3c59;hpb=2fdb3fc0b67757afd6fe7a244b6e14d2a546af0e

diff --git a/libopkg/opkg_cmd.c b/libopkg/opkg_cmd.c
index 30d3126..c30e34d 100644
--- a/libopkg/opkg_cmd.c
+++ b/libopkg/opkg_cmd.c
@@ -15,15 +15,19 @@
    General Public License for more details.
 */
 
+#include "config.h"
 
-#include "includes.h"
+#include <stdio.h>
 #include <dirent.h>
 #include <glob.h>
 #include <fnmatch.h>
+#include <signal.h>
+#include <unistd.h>
 
 #include "opkg_conf.h"
 #include "opkg_cmd.h"
 #include "opkg_message.h"
+#include "release.h"
 #include "pkg.h"
 #include "pkg_dest.h"
 #include "pkg_parse.h"
@@ -38,7 +42,6 @@
 #include "opkg_upgrade.h"
 #include "opkg_remove.h"
 #include "opkg_configure.h"
-#include "libopkg.h"
 #include "xsystem.h"
 
 static void
@@ -61,7 +64,7 @@ write_status_files_if_changed(void)
 	  opkg_msg(INFO, "Writing status file.\n");
 	  opkg_conf_write_status_files();
 	  pkg_write_changed_filelists();
-     } else { 
+     } else {
 	  opkg_msg(DEBUG, "Nothing to be done.\n");
      }
 }
@@ -85,9 +88,9 @@ opkg_update_cmd(int argc, char **argv)
      pkg_src_list_elt_t *iter;
      pkg_src_t *src;
 
- 
+
     sprintf_alloc(&lists_dir, "%s", conf->restrict_to_default_dest ? conf->default_dest->lists_dir : conf->lists_dir);
- 
+
     if (! file_is_dir(lists_dir)) {
 	  if (file_exists(lists_dir)) {
 	       opkg_msg(ERROR, "%s exists, but is not a directory.\n",
@@ -99,8 +102,8 @@ opkg_update_cmd(int argc, char **argv)
 	  if (err) {
 	       free(lists_dir);
 	       return -1;
-	  }	
-     } 
+	  }
+     }
 
      failures = 0;
 
@@ -111,49 +114,62 @@ opkg_update_cmd(int argc, char **argv)
      }
 
 
+     for (iter = void_list_first(&conf->dist_src_list); iter; iter = void_list_next(&conf->dist_src_list, iter)) {
+	  char *url, *list_file_name;
+
+	  src = (pkg_src_t *)iter->data;
+
+	  sprintf_alloc(&url, "%s/dists/%s/Release", src->value, src->name);
+
+	  sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name);
+	  err = opkg_download(url, list_file_name, NULL, NULL, 0);
+	  if (!err) {
+	       opkg_msg(NOTICE, "Downloaded release files for dist %s.\n",
+			    src->name);
+	       release_t *release = release_new(); 
+	       err = release_init_from_file(release, list_file_name);
+	       if (!err) {
+		    if (!release_comps_supported(release, src->extra_data))
+			 err = -1;
+	       }
+	       if (!err) {
+		    err = release_download(release, src, lists_dir, tmp);
+	       }
+	       release_deinit(release); 
+	       if (err)
+		    unlink(list_file_name);
+	  }
+
+	  if (err)
+	       failures++;
+
+	  free(list_file_name);
+	  free(url);
+     }
+
      for (iter = void_list_first(&conf->pkg_src_list); iter; iter = void_list_next(&conf->pkg_src_list, iter)) {
 	  char *url, *list_file_name;
 
 	  src = (pkg_src_t *)iter->data;
 
+	  if (src->extra_data && strcmp(src->extra_data, "__dummy__ "))
+	      continue;
+
 	  if (src->extra_data)	/* debian style? */
-	      sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data, 
+	      sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
 			    src->gzip ? "Packages.gz" : "Packages");
 	  else
 	      sprintf_alloc(&url, "%s/%s", src->value, src->gzip ? "Packages.gz" : "Packages");
 
 	  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(url, tmp_file_name, NULL, NULL);
-	      if (err == 0) {
-		   opkg_msg(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(url, list_file_name, NULL, NULL);
-	  if (err) {
+	  if (opkg_download(url, list_file_name, NULL, NULL, 0)) {
 	       failures++;
 	  } else {
 	       opkg_msg(NOTICE, "Updated list of available packages in %s.\n",
 			    list_file_name);
 	  }
 	  free(url);
-#if defined(HAVE_GPGME) || defined(HAVE_OPENSSL)
+#if defined(HAVE_GPGME) || defined(HAVE_OPENSSL) || defined(HAVE_USIGN)
           if (conf->check_signature) {
               /* download detached signitures to verify the package lists */
               /* get the url for the sig file */
@@ -169,7 +185,7 @@ opkg_update_cmd(int argc, char **argv)
               /* Put the signature in the right place */
               sprintf_alloc (&tmp_file_name, "%s/%s.sig", lists_dir, src->name);
 
-              err = opkg_download(url, tmp_file_name, NULL, NULL);
+              err = opkg_download(url, tmp_file_name, NULL, NULL, 0);
               if (err) {
                   failures++;
                   opkg_msg(NOTICE, "Signature check failed.\n");
@@ -180,6 +196,12 @@ opkg_update_cmd(int argc, char **argv)
                   else
                       opkg_msg(NOTICE, "Signature check failed.\n");
               }
+              if (err) {
+                  /* The signature was wrong so delete it */
+                  opkg_msg(NOTICE, "Remove wrong Signature file.\n");
+                  unlink (tmp_file_name);
+                  unlink (list_file_name);
+              }
               /* We shouldn't unlink the signature ! */
               // unlink (tmp_file_name);
               free (tmp_file_name);
@@ -250,7 +272,7 @@ opkg_finalize_intercepts(opkg_intercept_t ctx)
 
 	    if (de->d_name[0] == '.')
 		continue;
-	    
+
 	    sprintf_alloc (&path, "%s/%s", ctx->statedir, de->d_name);
 	    if (access (path, X_OK) == 0) {
 		const char *argv[] = {"sh", "-c", path, NULL};
@@ -261,7 +283,7 @@ opkg_finalize_intercepts(opkg_intercept_t ctx)
         closedir(dir);
     } else
 	opkg_perror(ERROR, "Failed to open dir %s", ctx->statedir);
-	
+
     rm_r(ctx->statedir);
     free (ctx->statedir);
     free (ctx);
@@ -270,10 +292,10 @@ opkg_finalize_intercepts(opkg_intercept_t ctx)
 }
 
 /* For package pkg do the following: If it is already visited, return. If not,
-   add it in visited list and recurse to its deps. Finally, add it to ordered 
+   add it in visited list and recurse to its deps. Finally, add it to ordered
    list.
    pkg_vec all contains all available packages in repos.
-   pkg_vec visited contains packages already visited by this function, and is 
+   pkg_vec visited contains packages already visited by this function, and is
    used to end recursion and avoid an infinite loop on graph cycles.
    pkg_vec ordered will finally contain the ordered set of packages.
 */
@@ -291,31 +313,31 @@ opkg_recurse_pkgs_in_order(pkg_t *pkg, pkg_vec_t *all,
 
     /* If it's just an available package, that is, not installed and not even
        unpacked, skip it */
-    /* XXX: This is probably an overkill, since a state_status != SS_UNPACKED 
-       would do here. However, if there is an intermediate node (pkg) that is 
-       configured and installed between two unpacked packages, the latter 
+    /* XXX: This is probably an overkill, since a state_status != SS_UNPACKED
+       would do here. However, if there is an intermediate node (pkg) that is
+       configured and installed between two unpacked packages, the latter
        won't be properly reordered, unless all installed/unpacked pkgs are
        checked */
-    if (pkg->state_status == SS_NOT_INSTALLED) 
+    if (pkg->state_status == SS_NOT_INSTALLED)
         return 0;
 
     /* If the  package has already been visited (by this function), skip it */
-    for(j = 0; j < visited->len; j++) 
+    for(j = 0; j < visited->len; j++)
         if ( ! strcmp(visited->pkgs[j]->name, pkg->name)) {
-            opkg_msg(INFO, "pkg %s already visited, skipping.\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_msg(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];
@@ -326,16 +348,16 @@ opkg_recurse_pkgs_in_order(pkg_t *pkg, pkg_vec_t *all,
             l = 0;
             if (dependents != NULL)
                 while (l < abpkg->provided_by->len && dependents[l] != NULL) {
-                    opkg_msg(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(dep, all, 
+                                opkg_recurse_pkgs_in_order(dep, all,
                                                            visited, ordered);
                                 /* Stop the outer loop */
                                 l = abpkg->provided_by->len;
@@ -348,7 +370,7 @@ opkg_recurse_pkgs_in_order(pkg_t *pkg, pkg_vec_t *all,
         }
     }
 
-    /* When all recursions from this node down, are over, and all 
+    /* When all recursions from this node down, are over, and all
        dependencies have been added in proper order in the ordered array, add
        also the package pkg to ordered array */
     pkg_vec_insert(ordered, pkg);
@@ -387,11 +409,11 @@ opkg_configure_packages(char *pkg_name)
 	     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) {
@@ -401,16 +423,15 @@ opkg_configure_packages(char *pkg_name)
 		    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);
@@ -420,12 +441,23 @@ error:
      return err;
 }
 
+static int
+opkg_remove_cmd(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;
+     }
 
      signal(SIGINT, sigint_handler);
 
@@ -436,21 +468,21 @@ opkg_install_cmd(int argc, char **argv)
 	  arg = argv[i];
 
           opkg_msg(DEBUG2, "%s\n", arg);
-          err = opkg_prepare_url_for_install(arg, &argv[i]);
-          if (err)
-              return err;
+          if (opkg_prepare_url_for_install(arg, &argv[i]))
+              return -1;
      }
      pkg_info_preinstall_check();
 
      for (i=0; i < argc; i++) {
 	  arg = argv[i];
-          err = opkg_install_by_name(arg);
-	  if (err) {
+          if (opkg_install_by_name(arg)) {
 	       opkg_msg(ERROR, "Cannot install package %s.\n", arg);
+	       err = -1;
 	  }
      }
 
-     opkg_configure_packages(NULL);
+     if (opkg_configure_packages(NULL))
+	  err = -1;
 
      write_status_files_if_changed();
 
@@ -462,7 +494,7 @@ opkg_upgrade_cmd(int argc, char **argv)
 {
      int i;
      pkg_t *pkg;
-     int err;
+     int err = 0;
 
      signal(SIGINT, sigint_handler);
 
@@ -470,9 +502,8 @@ opkg_upgrade_cmd(int argc, char **argv)
 	  for (i=0; i < argc; i++) {
 	       char *arg = argv[i];
 
-               err = opkg_prepare_url_for_install(arg, &arg);
-               if (err)
-                   return err;
+               if (opkg_prepare_url_for_install(arg, &arg))
+                   return -1;
 	  }
 	  pkg_info_preinstall_check();
 
@@ -489,36 +520,28 @@ opkg_upgrade_cmd(int argc, char **argv)
 	       } else {
 		    pkg = pkg_hash_fetch_installed_by_name(argv[i]);
 	       }
-	       if (pkg)
-		    opkg_upgrade_pkg(pkg);
-	       else {
-		    opkg_install_by_name(arg);
+	       if (pkg) {
+		    if (opkg_upgrade_pkg(pkg))
+			    err = -1;
+	       } else {
+		    if (opkg_install_by_name(arg))
+			    err = -1;
                }
 	  }
-     } else {
-	  pkg_vec_t *installed = pkg_vec_alloc();
-
-	  pkg_info_preinstall_check();
-
-	  pkg_hash_fetch_all_installed(installed);
-	  for (i = 0; i < installed->len; i++) {
-	       pkg = installed->pkgs[i];
-	       opkg_upgrade_pkg(pkg);
-	  }
-	  pkg_vec_free(installed);
      }
 
-     opkg_configure_packages(NULL);
+     if (opkg_configure_packages(NULL))
+	  err = -1;
 
      write_status_files_if_changed();
 
-     return 0;
+     return err;
 }
 
 static int
 opkg_download_cmd(int argc, char **argv)
 {
-     int i, err;
+     int i, err = 0;
      char *arg;
      pkg_t *pkg;
 
@@ -532,7 +555,8 @@ opkg_download_cmd(int argc, char **argv)
 	       continue;
 	  }
 
-	  err = opkg_download_pkg(pkg, ".");
+	  if (opkg_download_pkg(pkg, "."))
+		  err = -1;
 
 	  if (err) {
 	       opkg_msg(ERROR, "Failed to download %s.\n", pkg->name);
@@ -542,12 +566,12 @@ opkg_download_cmd(int argc, char **argv)
 	  }
      }
 
-     return 0;
+     return err;
 }
 
 
 static int
-opkg_list_cmd(int argc, char **argv)
+opkg_list_find_cmd(int argc, char **argv, int use_desc)
 {
      int i;
      pkg_vec_t *available;
@@ -563,7 +587,8 @@ opkg_list_cmd(int argc, char **argv)
      for (i=0; i < available->len; i++) {
 	  pkg = available->pkgs[i];
 	  /* if we have package name or pattern and pkg does not match, then skip it */
-	  if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) 
+	  if (pkg_name && fnmatch(pkg_name, pkg->name, conf->nocase) &&
+	      (!use_desc || !pkg->description || fnmatch(pkg_name, pkg->description, conf->nocase)))
 	       continue;
           print_pkg(pkg);
      }
@@ -572,6 +597,18 @@ opkg_list_cmd(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_find_cmd(int argc, char **argv)
+{
+	return opkg_list_find_cmd(argc, argv, 1);
+}
+
 
 static int
 opkg_list_installed_cmd(int argc, char **argv)
@@ -590,7 +627,7 @@ opkg_list_installed_cmd(int argc, char **argv)
      for (i=0; i < available->len; i++) {
 	  pkg = available->pkgs[i];
 	  /* if we have package name or pattern and pkg does not match, then skip it */
-	  if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) 
+	  if (pkg_name && fnmatch(pkg_name, pkg->name, conf->nocase))
 	       continue;
           print_pkg(pkg);
      }
@@ -600,6 +637,39 @@ opkg_list_installed_cmd(int argc, char **argv)
      return 0;
 }
 
+static int
+opkg_list_changed_conffiles_cmd(int argc, char **argv)
+{
+     int i ;
+     pkg_vec_t *available;
+     pkg_t *pkg;
+     char *pkg_name = NULL;
+     conffile_list_elt_t *iter;
+     conffile_t *cf;
+
+     if (argc > 0) {
+	  pkg_name = argv[0];
+     }
+     available = pkg_vec_alloc();
+     pkg_hash_fetch_all_installed(available);
+     pkg_vec_sort(available, pkg_compare_names);
+     for (i=0; i < available->len; i++) {
+	  pkg = available->pkgs[i];
+	  /* if we have package name or pattern and pkg does not match, then skip it */
+	  if (pkg_name && fnmatch(pkg_name, pkg->name, 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)
 {
@@ -642,7 +712,7 @@ opkg_info_status_cmd(int argc, char **argv, int installed_only)
 
      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;
 	  }
 
@@ -695,7 +765,7 @@ opkg_configure_cmd(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;
@@ -712,7 +782,7 @@ opkg_remove_cmd(int argc, char **argv)
      for (i=0; i<argc; i++) {
         for (a=0; a<available->len; 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) {
@@ -722,17 +792,20 @@ opkg_remove_cmd(int argc, char **argv)
             } else {
 	         pkg_to_remove = pkg_hash_fetch_installed_by_name(pkg->name);
             }
-        
+
             if (pkg_to_remove == NULL) {
 	         opkg_msg(ERROR, "Package %s is not installed.\n", pkg->name);
 	         continue;
             }
-            if (pkg->state_status == SS_NOT_INSTALLED) {    // Added the control, so every already removed package could be skipped
+            if (pkg->state_status == SS_NOT_INSTALLED) {
 	         opkg_msg(ERROR, "Package %s not installed.\n", pkg->name);
                  continue;
             }
-            opkg_remove_pkg(pkg_to_remove, 0);
-            done = 1;
+
+            if (opkg_remove_pkg(pkg_to_remove, 0))
+	         err = -1;
+	    else
+                 done = 1;
         }
      }
 
@@ -742,7 +815,7 @@ opkg_remove_cmd(int argc, char **argv)
         opkg_msg(NOTICE, "No packages removed.\n");
 
      write_status_files_if_changed();
-     return 0;
+     return err;
 }
 
 static int
@@ -751,7 +824,7 @@ opkg_flag_cmd(int argc, char **argv)
      int i;
      pkg_t *pkg;
      const char *flags = argv[0];
-    
+
      signal(SIGINT, sigint_handler);
 
      for (i=1; i < argc; i++) {
@@ -771,7 +844,7 @@ opkg_flag_cmd(int argc, char **argv)
 	      pkg->state_flag = pkg_state_flag_from_str(flags);
           }
 
-	  /* 
+	  /*
 	   * Useful if a package is installed in an offline_root, and
 	   * should be configured by opkg-cl configure at a later date.
 	   */
@@ -843,7 +916,7 @@ opkg_depends_cmd(int argc, char **argv)
 		for (j=0; j<available_pkgs->len; 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 +
@@ -912,7 +985,7 @@ opkg_what_depends_conflicts_cmd(enum depend_type what_field_type, int recursive,
 	case RECOMMEND: rel_str = "recommends"; break;
 	default: return -1;
 	}
-     
+
 	available_pkgs = pkg_vec_alloc();
 
 	if (conf->query_all)
@@ -968,14 +1041,14 @@ opkg_what_depends_conflicts_cmd(enum depend_type what_field_type, int recursive,
 								& SF_MARKED)
 							!= SF_MARKED)
 						continue;
-					
+
 					/* mark the depending package so we
 					* won't visit it again */
 					pkg->state_flag |= SF_MARKED;
 					pkg_mark_provides(pkg);
 					changed++;
 
-					ver = pkg_version_str_alloc(pkg); 
+					ver = pkg_version_str_alloc(pkg);
 				        opkg_msg(NOTICE, "\t%s %s\t%s %s",
 							pkg->name,
 							ver,
@@ -990,7 +1063,7 @@ opkg_what_depends_conflicts_cmd(enum depend_type what_field_type, int recursive,
 					if (!pkg_dependence_satisfiable(possibility))
 						opkg_msg(NOTICE,
 							" unsatisfiable");
-					opkg_msg(NOTICE, "\n");
+					opkg_message(NOTICE, "\n");
 					goto next_package;
 				}
 			}
@@ -1042,7 +1115,7 @@ opkg_what_provides_replaces_cmd(enum what_field_type what_field_type, int argc,
 	  pkg_vec_t *available_pkgs = pkg_vec_alloc();
 	  const char *rel_str = (what_field_type == WHATPROVIDES ? "provides" : "replaces");
 	  int i;
-     
+
 	  pkg_info_preinstall_check();
 
 	  if (conf->query_all)
@@ -1060,16 +1133,16 @@ opkg_what_provides_replaces_cmd(enum what_field_type what_field_type, int argc,
 		    int k;
 		    int count = (what_field_type == WHATPROVIDES) ? pkg->provides_count : pkg->replaces_count;
 		    for (k = 0; k < count; k++) {
-			 abstract_pkg_t *apkg = 
-			      ((what_field_type == WHATPROVIDES) 
+			 abstract_pkg_t *apkg =
+			      ((what_field_type == WHATPROVIDES)
 			       ? pkg->provides[k]
 			       : pkg->replaces[k]);
-			 if (fnmatch(target, apkg->name, 0) == 0) {
+			 if (fnmatch(target, apkg->name, conf->nocase) == 0) {
 			      opkg_msg(NOTICE, "    %s", pkg->name);
-			      if (strcmp(target, apkg->name) != 0)
+			      if ((conf->nocase ? strcasecmp(target, apkg->name) : strcmp(target, apkg->name)) != 0)
 				   opkg_msg(NOTICE, "\t%s %s\n",
 						   rel_str, apkg->name);
-			      opkg_msg(NOTICE, "\n");
+			      opkg_message(NOTICE, "\n");
 			 }
 		    }
 	       }
@@ -1105,7 +1178,7 @@ opkg_search_cmd(int argc, char **argv)
      if (argc < 1) {
 	  return -1;
      }
- 
+
      installed = pkg_vec_alloc();
      pkg_hash_fetch_all_installed(installed);
      pkg_vec_sort(installed, pkg_compare_names);
@@ -1117,7 +1190,7 @@ opkg_search_cmd(int argc, char **argv)
 
 	  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);
 	  }
 
@@ -1135,8 +1208,8 @@ opkg_compare_versions_cmd(int argc, char **argv)
      if (argc == 3) {
 	  /* this is a bit gross */
 	  struct pkg p1, p2;
-	  parse_version(&p1, argv[0]); 
-	  parse_version(&p2, argv[2]); 
+	  parse_version(&p1, argv[0]);
+	  parse_version(&p2, argv[2]);
 	  return pkg_version_satisfied(&p1, &p2, argv[1]);
      } else {
 	  opkg_msg(ERROR,
@@ -1163,12 +1236,14 @@ opkg_print_architecture_cmd(int argc, char **argv)
    array for easier maintenance */
 static opkg_cmd_t cmds[] = {
      {"update", 0, (opkg_cmd_fun_t)opkg_update_cmd, PFM_DESCRIPTION|PFM_SOURCE},
-     {"upgrade", 0, (opkg_cmd_fun_t)opkg_upgrade_cmd, PFM_DESCRIPTION|PFM_SOURCE},
+     {"upgrade", 1, (opkg_cmd_fun_t)opkg_upgrade_cmd, PFM_DESCRIPTION|PFM_SOURCE},
      {"list", 0, (opkg_cmd_fun_t)opkg_list_cmd, PFM_SOURCE},
      {"list_installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd, PFM_SOURCE},
      {"list-installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd, PFM_SOURCE},
      {"list_upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd, PFM_SOURCE},
      {"list-upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd, PFM_SOURCE},
+     {"list_changed_conffiles", 0, (opkg_cmd_fun_t)opkg_list_changed_conffiles_cmd, PFM_SOURCE},
+     {"list-changed-conffiles", 0, (opkg_cmd_fun_t)opkg_list_changed_conffiles_cmd, PFM_SOURCE},
      {"info", 0, (opkg_cmd_fun_t)opkg_info_cmd, 0},
      {"flag", 1, (opkg_cmd_fun_t)opkg_flag_cmd, PFM_DESCRIPTION|PFM_SOURCE},
      {"status", 0, (opkg_cmd_fun_t)opkg_status_cmd, PFM_DESCRIPTION|PFM_SOURCE},
@@ -1177,6 +1252,7 @@ static opkg_cmd_t cmds[] = {
      {"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},
@@ -1213,12 +1289,5 @@ opkg_cmd_find(const char *name)
 int
 opkg_cmd_exec(opkg_cmd_t *cmd, int argc, const char **argv)
 {
-	int result;
-
-	result = (cmd->fun)(argc, argv);
-
-	print_error_list();
-	free_error_list();
-
-	return result;
+	return (cmd->fun)(argc, argv);
 }