libopkg/opkg_cmd.c

   1 /* opkg_cmd.c - the opkg package management system
   2
   3    Carl D. Worth
   4
   5    Copyright (C) 2001 University of Southern California
   6
   7    This program is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU General Public License as
   9    published by the Free Software Foundation; either version 2, or (at
  10    your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    General Public License for more details.
  16 */
  17
  18
  19 #include "includes.h"
  20 #include <dirent.h>
  21 #include <glob.h>
  22 #include <fnmatch.h>
  23
  24 #include "opkg_conf.h"
  25 #include "opkg_cmd.h"
  26 #include "opkg_message.h"
  27 #include "pkg.h"
  28 #include "pkg_dest.h"
  29 #include "pkg_parse.h"
  30 #include "sprintf_alloc.h"
  31 #include "pkg.h"
  32 #include "file_util.h"
  33 #include "str_util.h"
  34 #include "libbb/libbb.h"
  35 #include "opkg_utils.h"
  36 #include "opkg_defines.h"
  37 #include "opkg_download.h"
  38 #include "opkg_install.h"
  39 #include "opkg_upgrade.h"
  40 #include "opkg_remove.h"
  41 #include "opkg_configure.h"
  42 #include "opkg_message.h"
  43 #include "libopkg.h"
  44 #include "xsystem.h"
  45
  46 static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv);
  47 static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv);
  48 static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv);
  49 static int opkg_info_cmd(opkg_conf_t *conf, int argc, char **argv);
  50 static int opkg_status_cmd(opkg_conf_t *conf, int argc, char **argv);
  51 static int opkg_install_pending_cmd(opkg_conf_t *conf, int argc, char **argv);
  52 static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv);
  53 static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv);
  54 static int opkg_list_upgradable_cmd(opkg_conf_t *conf, int argc, char **argv);
  55 static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv);
  56 static int opkg_purge_cmd(opkg_conf_t *conf, int argc, char **argv);
  57 static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv);
  58 static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv);
  59 static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv);
  60 static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv);
  61 static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv);
  62 static int opkg_whatdepends_cmd(opkg_conf_t *conf, int argc, char **argv);
  63 static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv);
  64 static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv);
  65 static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv);
  66 static int opkg_whatprovides_cmd(opkg_conf_t *conf, int argc, char **argv);
  67 static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv);
  68 static int opkg_whatreplaces_cmd(opkg_conf_t *conf, int argc, char **argv);
  69 static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv);
  70 static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv);
  71 static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv);
  72 static int pkg_mark_provides(pkg_t *pkg);
  73
  74 /* XXX: CLEANUP: The usage strings should be incorporated into this
  75    array for easier maintenance */
  76 static opkg_cmd_t cmds[] = {
  77      {"update", 0, (opkg_cmd_fun_t)opkg_update_cmd},
  78      {"upgrade", 0, (opkg_cmd_fun_t)opkg_upgrade_cmd},
  79      {"list", 0, (opkg_cmd_fun_t)opkg_list_cmd},
  80      {"list_installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd},
  81      {"list-installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd},
  82      {"list_upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd},
  83      {"list-upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd},
  84      {"info", 0, (opkg_cmd_fun_t)opkg_info_cmd},
  85      {"flag", 1, (opkg_cmd_fun_t)opkg_flag_cmd},
  86      {"status", 0, (opkg_cmd_fun_t)opkg_status_cmd},
  87      {"install_pending", 0, (opkg_cmd_fun_t)opkg_install_pending_cmd},
  88      {"install-pending", 0, (opkg_cmd_fun_t)opkg_install_pending_cmd},
  89      {"install", 1, (opkg_cmd_fun_t)opkg_install_cmd},
  90      {"remove", 1, (opkg_cmd_fun_t)opkg_remove_cmd},
  91      {"purge", 1, (opkg_cmd_fun_t)opkg_purge_cmd},
  92      {"configure", 0, (opkg_cmd_fun_t)opkg_configure_cmd},
  93      {"files", 1, (opkg_cmd_fun_t)opkg_files_cmd},
  94      {"search", 1, (opkg_cmd_fun_t)opkg_search_cmd},
  95      {"download", 1, (opkg_cmd_fun_t)opkg_download_cmd},
  96      {"compare_versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd},
  97      {"compare-versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd},
  98      {"print-architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
  99      {"print_architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
 100      {"print-installation-architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
 101      {"print_installation_architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
 102      {"depends", 1, (opkg_cmd_fun_t)opkg_depends_cmd},
 103      {"whatdepends", 1, (opkg_cmd_fun_t)opkg_whatdepends_cmd},
 104      {"whatdependsrec", 1, (opkg_cmd_fun_t)opkg_whatdepends_recursively_cmd},
 105      {"whatrecommends", 1, (opkg_cmd_fun_t)opkg_whatrecommends_cmd},
 106      {"whatsuggests", 1, (opkg_cmd_fun_t)opkg_whatsuggests_cmd},
 107      {"whatprovides", 1, (opkg_cmd_fun_t)opkg_whatprovides_cmd},
 108      {"whatreplaces", 1, (opkg_cmd_fun_t)opkg_whatreplaces_cmd},
 109      {"whatconflicts", 1, (opkg_cmd_fun_t)opkg_whatconflicts_cmd},
 110 };
 111
 112 static void print_pkg(pkg_t *pkg)
 113 {
 114         char *version = pkg_version_str_alloc(pkg);
 115         if (pkg->description)
 116                 printf("%s - %s - %s\n", pkg->name, version, pkg->description);
 117         else
 118                 printf("%s - %s\n", pkg->name, version);
 119         free(version);
 120 }
 121
 122 int opkg_state_changed;
 123 static void write_status_files_if_changed(opkg_conf_t *conf)
 124 {
 125      if (opkg_state_changed && !conf->noaction) {
 126           opkg_message(conf, OPKG_INFO,
 127                        "  writing status file\n");
 128           opkg_conf_write_status_files(conf);
 129           pkg_write_changed_filelists(conf);
 130      } else {
 131           opkg_message(conf, OPKG_DEBUG, "Nothing to be done\n");
 132      }
 133 }
 134
 135
 136 static int num_cmds = sizeof(cmds) / sizeof(opkg_cmd_t);
 137
 138 opkg_cmd_t *opkg_cmd_find(const char *name)
 139 {
 140      int i;
 141      opkg_cmd_t *cmd;
 142
 143      for (i=0; i < num_cmds; i++) {
 144           cmd = &cmds[i];
 145           if (strcmp(name, cmd->name) == 0) {
 146                return cmd;
 147           }
 148      }
 149
 150      return NULL;
 151 }
 152
 153 int opkg_cmd_exec(opkg_cmd_t *cmd, opkg_conf_t *conf, int argc, const char **argv, void *userdata)
 154 {
 155         int result;
 156
 157         result = (cmd->fun)(conf, argc, argv);
 158
 159         print_error_list();
 160         free_error_list();
 161
 162         return result;
 163 }
 164
 165 static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv)
 166 {
 167      char *tmp;
 168      int err;
 169      int failures;
 170      char *lists_dir;
 171      pkg_src_list_elt_t *iter;
 172      pkg_src_t *src;
 173
 174
 175     sprintf_alloc(&lists_dir, "%s", conf->restrict_to_default_dest ? conf->default_dest->lists_dir : conf->lists_dir);
 176
 177     if (! file_is_dir(lists_dir)) {
 178           if (file_exists(lists_dir)) {
 179                opkg_message(conf, OPKG_ERROR,
 180                             "%s: ERROR: %s exists, but is not a directory\n",
 181                             __FUNCTION__, lists_dir);
 182                free(lists_dir);
 183                return -1;
 184           }
 185           err = file_mkdir_hier(lists_dir, 0755);
 186           if (err) {
 187                opkg_message(conf, OPKG_ERROR,
 188                             "%s: ERROR: failed to make directory %s: %s\n",
 189                             __FUNCTION__, lists_dir, strerror(errno));
 190                free(lists_dir);
 191                return -1;
 192           }
 193      }
 194
 195      failures = 0;
 196
 197      sprintf_alloc(&tmp, "%s/update-XXXXXX", conf->tmp_dir);
 198      if (mkdtemp (tmp) == NULL) {
 199          perror ("mkdtemp");
 200          return -1;
 201      }
 202
 203
 204      for (iter = void_list_first(&conf->pkg_src_list); iter; iter = void_list_next(&conf->pkg_src_list, iter)) {
 205           char *url, *list_file_name;
 206
 207           src = (pkg_src_t *)iter->data;
 208
 209           if (src->extra_data)  /* debian style? */
 210               sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
 211                             src->gzip ? "Packages.gz" : "Packages");
 212           else
 213               sprintf_alloc(&url, "%s/%s", src->value, src->gzip ? "Packages.gz" : "Packages");
 214
 215           sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name);
 216           if (src->gzip) {
 217               char *tmp_file_name;
 218               FILE *in, *out;
 219
 220               sprintf_alloc (&tmp_file_name, "%s/%s.gz", tmp, src->name);
 221               err = opkg_download(conf, url, tmp_file_name, NULL, NULL);
 222               if (err == 0) {
 223                    opkg_message (conf, OPKG_NOTICE, "Inflating %s\n", url);
 224                    in = fopen (tmp_file_name, "r");
 225                    out = fopen (list_file_name, "w");
 226                    if (in && out)
 227                         unzip (in, out);
 228                    else
 229                         err = 1;
 230                    if (in)
 231                         fclose (in);
 232                    if (out)
 233                         fclose (out);
 234                    unlink (tmp_file_name);
 235               }
 236               free(tmp_file_name);
 237           } else
 238               err = opkg_download(conf, url, list_file_name, NULL, NULL);
 239           if (err) {
 240                failures++;
 241           } else {
 242                opkg_message(conf, OPKG_NOTICE,
 243                             "Updated list of available packages in %s\n",
 244                             list_file_name);
 245           }
 246           free(url);
 247 #if defined(HAVE_GPGME) || defined(HAVE_OPENSSL)
 248           if (conf->check_signature) {
 249               /* download detached signitures to verify the package lists */
 250               /* get the url for the sig file */
 251               if (src->extra_data)      /* debian style? */
 252                   sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
 253                           "Packages.sig");
 254               else
 255                   sprintf_alloc(&url, "%s/%s", src->value, "Packages.sig");
 256
 257               /* create temporary file for it */
 258               char *tmp_file_name;
 259
 260               /* Put the signature in the right place */
 261               sprintf_alloc (&tmp_file_name, "%s/%s.sig", lists_dir, src->name);
 262
 263               err = opkg_download(conf, url, tmp_file_name, NULL, NULL);
 264               if (err) {
 265                   failures++;
 266                   opkg_message (conf, OPKG_NOTICE, "Signature check failed\n");
 267               } else {
 268                   int err;
 269                   err = opkg_verify_file (conf, list_file_name, tmp_file_name);
 270                   if (err == 0)
 271                       opkg_message (conf, OPKG_NOTICE, "Signature check passed\n");
 272                   else
 273                       opkg_message (conf, OPKG_NOTICE, "Signature check failed\n");
 274               }
 275               /* We shouldn't unlink the signature ! */
 276               // unlink (tmp_file_name);
 277               free (tmp_file_name);
 278               free (url);
 279           }
 280 #else
 281           // Do nothing
 282 #endif
 283           free(list_file_name);
 284      }
 285      rmdir (tmp);
 286      free (tmp);
 287      free(lists_dir);
 288
 289      return failures;
 290 }
 291
 292
 293 struct opkg_intercept
 294 {
 295     char *oldpath;
 296     char *statedir;
 297 };
 298
 299 typedef struct opkg_intercept *opkg_intercept_t;
 300
 301 static opkg_intercept_t opkg_prep_intercepts(opkg_conf_t *conf)
 302 {
 303     opkg_intercept_t ctx;
 304     char *newpath;
 305
 306     ctx = xcalloc(1, sizeof (*ctx));
 307     ctx->oldpath = xstrdup(getenv("PATH"));
 308     sprintf_alloc(&newpath, "%s/opkg/intercept:%s", DATADIR, ctx->oldpath);
 309     sprintf_alloc(&ctx->statedir, "%s/opkg-intercept-XXXXXX", conf->tmp_dir);
 310
 311     if (mkdtemp(ctx->statedir) == NULL) {
 312         fprintf(stderr, "%s: mkdtemp: %s\n", __FUNCTION__, strerror(errno));
 313         free(ctx->oldpath);
 314         free(ctx->statedir);
 315         free(newpath);
 316         free(ctx);
 317         return NULL;
 318     }
 319
 320     setenv("OPKG_INTERCEPT_DIR", ctx->statedir, 1);
 321     setenv("PATH", newpath, 1);
 322     free(newpath);
 323
 324     return ctx;
 325 }
 326
 327 static int opkg_finalize_intercepts(opkg_intercept_t ctx)
 328 {
 329     DIR *dir;
 330     int err = 0;
 331
 332     setenv ("PATH", ctx->oldpath, 1);
 333     free (ctx->oldpath);
 334
 335     dir = opendir (ctx->statedir);
 336     if (dir) {
 337         struct dirent *de;
 338         while (de = readdir (dir), de != NULL) {
 339             char *path;
 340
 341             if (de->d_name[0] == '.')
 342                 continue;
 343
 344             sprintf_alloc (&path, "%s/%s", ctx->statedir, de->d_name);
 345             if (access (path, X_OK) == 0) {
 346                 const char *argv[] = {"sh", "-c", path, NULL};
 347                 xsystem (argv);
 348             }
 349             free (path);
 350         }
 351         closedir(dir);
 352     } else
 353         perror (ctx->statedir);
 354
 355     rm_r(ctx->statedir);
 356     free (ctx->statedir);
 357     free (ctx);
 358
 359     return err;
 360 }
 361
 362 /* For package pkg do the following: If it is already visited, return. If not,
 363    add it in visited list and recurse to its deps. Finally, add it to ordered
 364    list.
 365    pkg_vec all contains all available packages in repos.
 366    pkg_vec visited contains packages already visited by this function, and is
 367    used to end recursion and avoid an infinite loop on graph cycles.
 368    pkg_vec ordered will finally contain the ordered set of packages.
 369 */
 370 static int opkg_recurse_pkgs_in_order(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *all,
 371                                pkg_vec_t *visited, pkg_vec_t *ordered)
 372 {
 373     int j,k,l,m;
 374     int count;
 375     pkg_t *dep;
 376     compound_depend_t * compound_depend;
 377     depend_t ** possible_satisfiers;
 378     abstract_pkg_t *abpkg;
 379     abstract_pkg_t **dependents;
 380
 381     /* If it's just an available package, that is, not installed and not even
 382        unpacked, skip it */
 383     /* XXX: This is probably an overkill, since a state_status != SS_UNPACKED
 384        would do here. However, if there is an intermediate node (pkg) that is
 385        configured and installed between two unpacked packages, the latter
 386        won't be properly reordered, unless all installed/unpacked pkgs are
 387        checked */
 388     if (pkg->state_status == SS_NOT_INSTALLED)
 389         return 0;
 390
 391     /* If the  package has already been visited (by this function), skip it */
 392     for(j = 0; j < visited->len; j++)
 393         if ( ! strcmp(visited->pkgs[j]->name, pkg->name)) {
 394             opkg_message(conf, OPKG_INFO,
 395                          "  pkg: %s already visited\n", pkg->name);
 396             return 0;
 397         }
 398
 399     pkg_vec_insert(visited, pkg);
 400
 401     count = pkg->pre_depends_count + pkg->depends_count + \
 402         pkg->recommends_count + pkg->suggests_count;
 403
 404     opkg_message(conf, OPKG_INFO,
 405                  "  pkg: %s\n", pkg->name);
 406
 407     /* Iterate over all the dependencies of pkg. For each one, find a package
 408        that is either installed or unpacked and satisfies this dependency.
 409        (there should only be one such package per dependency installed or
 410        unpacked). Then recurse to the dependency package */
 411     for (j=0; j < count ; j++) {
 412         compound_depend = &pkg->depends[j];
 413         possible_satisfiers = compound_depend->possibilities;
 414         for (k=0; k < compound_depend->possibility_count ; k++) {
 415             abpkg = possible_satisfiers[k]->pkg;
 416             dependents = abpkg->provided_by->pkgs;
 417             l = 0;
 418             if (dependents != NULL)
 419                 while (l < abpkg->provided_by->len && dependents[l] != NULL) {
 420                     opkg_message(conf, OPKG_INFO,
 421                                  "  Descending on pkg: %s\n",
 422                                  dependents [l]->name);
 423
 424                     /* find whether dependent l is installed or unpacked,
 425                      * and then find which package in the list satisfies it */
 426                     for(m = 0; m < all->len; m++) {
 427                         dep = all->pkgs[m];
 428                         if ( dep->state_status != SS_NOT_INSTALLED)
 429                             if ( ! strcmp(dep->name, dependents[l]->name)) {
 430                                 opkg_recurse_pkgs_in_order(conf, dep, all,
 431                                                            visited, ordered);
 432                                 /* Stop the outer loop */
 433                                 l = abpkg->provided_by->len;
 434                                 /* break from the inner loop */
 435                                 break;
 436                             }
 437                     }
 438                     l++;
 439                 }
 440         }
 441     }
 442
 443     /* When all recursions from this node down, are over, and all
 444        dependencies have been added in proper order in the ordered array, add
 445        also the package pkg to ordered array */
 446     pkg_vec_insert(ordered, pkg);
 447
 448     return 0;
 449
 450 }
 451
 452 static int opkg_configure_packages(opkg_conf_t *conf, char *pkg_name)
 453 {
 454      pkg_vec_t *all, *ordered, *visited;
 455      int i;
 456      pkg_t *pkg;
 457      opkg_intercept_t ic;
 458      int r, err = 0;
 459
 460      opkg_message(conf, OPKG_INFO,
 461                   "Configuring unpacked packages\n");
 462      fflush( stdout );
 463
 464      all = pkg_vec_alloc();
 465
 466      pkg_hash_fetch_available(&conf->pkg_hash, all);
 467
 468      /* Reorder pkgs in order to be configured according to the Depends: tag
 469         order */
 470      opkg_message(conf, OPKG_INFO,
 471                   "Reordering packages before configuring them...\n");
 472      ordered = pkg_vec_alloc();
 473      visited = pkg_vec_alloc();
 474      for(i = 0; i < all->len; i++) {
 475          pkg = all->pkgs[i];
 476          opkg_recurse_pkgs_in_order(conf, pkg, all, visited, ordered);
 477      }
 478
 479      ic = opkg_prep_intercepts (conf);
 480      if (ic == NULL) {
 481              err = -1;
 482              goto error;
 483      }
 484
 485      for(i = 0; i < all->len; i++) {
 486           pkg = all->pkgs[i];
 487
 488           if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
 489                continue;
 490
 491           if (pkg->state_status == SS_UNPACKED) {
 492                opkg_message(conf, OPKG_NOTICE,
 493                             "Configuring %s\n", pkg->name);
 494                fflush( stdout );
 495                r = opkg_configure(conf, pkg);
 496                if (r == 0) {
 497                     pkg->state_status = SS_INSTALLED;
 498                     pkg->parent->state_status = SS_INSTALLED;
 499                     pkg->state_flag &= ~SF_PREFER;
 500                } else {
 501                     if (!err)
 502                         err = r;
 503                }
 504           }
 505      }
 506
 507      r = opkg_finalize_intercepts (ic);
 508      if (r && !err)
 509          err = r;
 510
 511 error:
 512      pkg_vec_free(all);
 513      pkg_vec_free(ordered);
 514      pkg_vec_free(visited);
 515
 516      return err;
 517 }
 518
 519 static opkg_conf_t *global_conf;
 520
 521 static void sigint_handler(int sig)
 522 {
 523      signal(sig, SIG_DFL);
 524      opkg_message(NULL, OPKG_NOTICE,
 525                   "opkg: interrupted. writing out status database\n");
 526      write_status_files_if_changed(global_conf);
 527      exit(128 + sig);
 528 }
 529
 530 static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv)
 531 {
 532      int i;
 533      char *arg;
 534      int err=0;
 535
 536      global_conf = conf;
 537      signal(SIGINT, sigint_handler);
 538
 539      /*
 540       * Now scan through package names and install
 541       */
 542      for (i=0; i < argc; i++) {
 543           arg = argv[i];
 544
 545           opkg_message(conf, OPKG_DEBUG2, "Debug install_cmd: %s  \n",arg );
 546           err = opkg_prepare_url_for_install(conf, arg, &argv[i]);
 547           if (err != EINVAL && err != 0)
 548               return err;
 549      }
 550      pkg_info_preinstall_check(conf);
 551
 552      for (i=0; i < argc; i++) {
 553           arg = argv[i];
 554           err = opkg_install_by_name(conf, arg);
 555           if (err == OPKG_PKG_HAS_NO_CANDIDATE) {
 556                opkg_message(conf, OPKG_ERROR,
 557                             "Cannot find package %s.\n",
 558                             arg);
 559           }
 560      }
 561
 562      opkg_configure_packages(conf, NULL);
 563
 564      write_status_files_if_changed(conf);
 565
 566      return err;
 567 }
 568
 569 static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv)
 570 {
 571      int i;
 572      pkg_t *pkg;
 573      int err;
 574
 575      global_conf = conf;
 576      signal(SIGINT, sigint_handler);
 577
 578      if (argc) {
 579           for (i=0; i < argc; i++) {
 580                char *arg = argv[i];
 581
 582                err = opkg_prepare_url_for_install(conf, arg, &arg);
 583                if (err != EINVAL && err != 0)
 584                    return err;
 585           }
 586           pkg_info_preinstall_check(conf);
 587
 588           for (i=0; i < argc; i++) {
 589                char *arg = argv[i];
 590                if (conf->restrict_to_default_dest) {
 591                     pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
 592                                                                 argv[i],
 593                                                                 conf->default_dest);
 594                     if (pkg == NULL) {
 595                          opkg_message(conf, OPKG_NOTICE,
 596                                       "Package %s not installed in %s\n",
 597                                       argv[i], conf->default_dest->name);
 598                          continue;
 599                     }
 600                } else {
 601                     pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
 602                                                            argv[i]);
 603                }
 604                if (pkg)
 605                     opkg_upgrade_pkg(conf, pkg);
 606                else {
 607                     opkg_install_by_name(conf, arg);
 608                }
 609           }
 610      } else {
 611           pkg_vec_t *installed = pkg_vec_alloc();
 612
 613           pkg_info_preinstall_check(conf);
 614
 615           pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
 616           for (i = 0; i < installed->len; i++) {
 617                pkg = installed->pkgs[i];
 618                opkg_upgrade_pkg(conf, pkg);
 619           }
 620           pkg_vec_free(installed);
 621      }
 622
 623      opkg_configure_packages(conf, NULL);
 624
 625      write_status_files_if_changed(conf);
 626
 627      return 0;
 628 }
 629
 630 static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv)
 631 {
 632      int i, err;
 633      char *arg;
 634      pkg_t *pkg;
 635
 636      pkg_info_preinstall_check(conf);
 637      for (i = 0; i < argc; i++) {
 638           arg = argv[i];
 639
 640           pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, arg, &err);
 641           if (pkg == NULL) {
 642                opkg_message(conf, OPKG_ERROR,
 643                             "Cannot find package %s.\n"
 644                             "Check the spelling or perhaps run 'opkg update'\n",
 645                             arg);
 646                continue;
 647           }
 648
 649           err = opkg_download_pkg(conf, pkg, ".");
 650
 651           if (err) {
 652                opkg_message(conf, OPKG_ERROR,
 653                             "Failed to download %s\n", pkg->name);
 654           } else {
 655                opkg_message(conf, OPKG_NOTICE,
 656                             "Downloaded %s as %s\n",
 657                             pkg->name, pkg->local_filename);
 658           }
 659      }
 660
 661      return 0;
 662 }
 663
 664
 665 static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv)
 666 {
 667      int i;
 668      pkg_vec_t *available;
 669      pkg_t *pkg;
 670      char *pkg_name = NULL;
 671
 672      if (argc > 0) {
 673           pkg_name = argv[0];
 674      }
 675      available = pkg_vec_alloc();
 676      pkg_hash_fetch_available(&conf->pkg_hash, available);
 677      pkg_vec_sort(available, pkg_compare_names);
 678      for (i=0; i < available->len; i++) {
 679           pkg = available->pkgs[i];
 680           /* if we have package name or pattern and pkg does not match, then skip it */
 681           if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
 682                continue;
 683           print_pkg(pkg);
 684      }
 685      pkg_vec_free(available);
 686
 687      return 0;
 688 }
 689
 690
 691 static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv)
 692 {
 693      int i ;
 694      pkg_vec_t *available;
 695      pkg_t *pkg;
 696      char *pkg_name = NULL;
 697
 698      if (argc > 0) {
 699           pkg_name = argv[0];
 700      }
 701      available = pkg_vec_alloc();
 702      pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
 703      pkg_vec_sort(available, pkg_compare_names);
 704      for (i=0; i < available->len; i++) {
 705           pkg = available->pkgs[i];
 706           /* if we have package name or pattern and pkg does not match, then skip it */
 707           if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
 708                continue;
 709           print_pkg(pkg);
 710      }
 711
 712      pkg_vec_free(available);
 713
 714      return 0;
 715 }
 716
 717 static int opkg_list_upgradable_cmd(opkg_conf_t *conf, int argc, char **argv)
 718 {
 719     struct active_list *head = prepare_upgrade_list(conf);
 720     struct active_list *node=NULL;
 721     pkg_t *_old_pkg, *_new_pkg;
 722     char *old_v, *new_v;
 723     for (node = active_list_next(head, head); node;node = active_list_next(head,node)) {
 724         _old_pkg = list_entry(node, pkg_t, list);
 725         _new_pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, _old_pkg->name, NULL);
 726         old_v = pkg_version_str_alloc(_old_pkg);
 727         new_v = pkg_version_str_alloc(_new_pkg);
 728         printf("%s - %s - %s\n", _old_pkg->name, old_v, new_v);
 729         free(old_v);
 730         free(new_v);
 731     }
 732     active_list_head_delete(head);
 733     return 0;
 734 }
 735
 736 static int opkg_info_status_cmd(opkg_conf_t *conf, int argc, char **argv, int installed_only)
 737 {
 738      int i;
 739      pkg_vec_t *available;
 740      pkg_t *pkg;
 741      char *pkg_name = NULL;
 742
 743      if (argc > 0) {
 744           pkg_name = argv[0];
 745      }
 746
 747      available = pkg_vec_alloc();
 748      if (installed_only)
 749           pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
 750      else
 751           pkg_hash_fetch_available(&conf->pkg_hash, available);
 752
 753      for (i=0; i < available->len; i++) {
 754           pkg = available->pkgs[i];
 755           if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
 756                continue;
 757           }
 758
 759           pkg_formatted_info(stdout, pkg);
 760
 761           if (conf->verbosity >= OPKG_NOTICE) {
 762                conffile_list_elt_t *iter;
 763                for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
 764                     conffile_t *cf = (conffile_t *)iter->data;
 765                     int modified = conffile_has_been_modified(conf, cf);
 766                     if (cf->value)
 767                         opkg_message(conf, OPKG_NOTICE,
 768                                 "conffile=%s md5sum=%s modified=%d\n",
 769                                  cf->name, cf->value, modified);
 770                }
 771           }
 772      }
 773      pkg_vec_free(available);
 774
 775      return 0;
 776 }
 777
 778 static int opkg_info_cmd(opkg_conf_t *conf, int argc, char **argv)
 779 {
 780      return opkg_info_status_cmd(conf, argc, argv, 0);
 781 }
 782
 783 static int opkg_status_cmd(opkg_conf_t *conf, int argc, char **argv)
 784 {
 785      return opkg_info_status_cmd(conf, argc, argv, 1);
 786 }
 787
 788 static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv)
 789 {
 790
 791      int err;
 792      if (argc > 0) {
 793           char *pkg_name = NULL;
 794
 795           pkg_name = argv[0];
 796
 797           err = opkg_configure_packages (conf, pkg_name);
 798
 799      } else {
 800           err = opkg_configure_packages (conf, NULL);
 801      }
 802
 803      write_status_files_if_changed(conf);
 804
 805      return err;
 806 }
 807
 808 static int opkg_install_pending_cmd(opkg_conf_t *conf, int argc, char **argv)
 809 {
 810      int i, err;
 811      char *globpattern;
 812      glob_t globbuf;
 813
 814      sprintf_alloc(&globpattern, "%s/*" OPKG_PKG_EXTENSION, conf->pending_dir);
 815      err = glob(globpattern, 0, NULL, &globbuf);
 816      free(globpattern);
 817      if (err) {
 818           return 0;
 819      }
 820
 821      opkg_message(conf, OPKG_NOTICE,
 822                   "The following packages in %s will now be installed.\n",
 823                   conf->pending_dir);
 824      for (i = 0; i < globbuf.gl_pathc; i++) {
 825           opkg_message(conf, OPKG_NOTICE,
 826                        "%s%s", i == 0 ? "" : " ", globbuf.gl_pathv[i]);
 827      }
 828      opkg_message(conf, OPKG_NOTICE, "\n");
 829      for (i = 0; i < globbuf.gl_pathc; i++) {
 830           err = opkg_install_from_file(conf, globbuf.gl_pathv[i]);
 831           if (err == 0) {
 832                err = unlink(globbuf.gl_pathv[i]);
 833                if (err) {
 834                     opkg_message(conf, OPKG_ERROR,
 835                                  "%s: ERROR: failed to unlink %s: %s\n",
 836                                  __FUNCTION__, globbuf.gl_pathv[i], strerror(err));
 837                     return err;
 838                }
 839           }
 840      }
 841      globfree(&globbuf);
 842
 843      return err;
 844 }
 845
 846 static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv)
 847 {
 848      int i,a,done;
 849      pkg_t *pkg;
 850      pkg_t *pkg_to_remove;
 851      pkg_vec_t *available;
 852      global_conf = conf;
 853      signal(SIGINT, sigint_handler);
 854
 855 // ENH: Add the "no pkg removed" just in case.
 856
 857     done = 0;
 858
 859      pkg_info_preinstall_check(conf);
 860      if ( argc > 0 ) {
 861         available = pkg_vec_alloc();
 862         pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
 863         for (i=0; i < argc; i++) {
 864            for (a=0; a < available->len; a++) {
 865                pkg = available->pkgs[a];
 866                if (fnmatch(argv[i], pkg->name, 0)) {
 867                   continue;
 868                }
 869                if (conf->restrict_to_default_dest) {
 870                     pkg_to_remove = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
 871                                                                 pkg->name,
 872                                                                 conf->default_dest);
 873                } else {
 874                     pkg_to_remove = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name );
 875                }
 876
 877                if (pkg_to_remove == NULL) {
 878                     opkg_message(conf, OPKG_ERROR, "Package %s is not installed.\n", pkg->name);
 879                     continue;
 880                }
 881                if (pkg->state_status == SS_NOT_INSTALLED) {    // Added the control, so every already removed package could be skipped
 882                     opkg_message(conf, OPKG_ERROR, "Package seems to be %s not installed (STATUS = NOT_INSTALLED).\n", pkg->name);
 883                     continue;
 884                }
 885                opkg_remove_pkg(conf, pkg_to_remove,0);
 886                done = 1;
 887            }
 888         }
 889         pkg_vec_free(available);
 890      } else {
 891           pkg_vec_t *installed_pkgs = pkg_vec_alloc();
 892           int i;
 893           int flagged_pkg_count = 0;
 894           int removed;
 895
 896           pkg_hash_fetch_all_installed(&conf->pkg_hash, installed_pkgs);
 897
 898           for (i = 0; i < installed_pkgs->len; i++) {
 899                pkg_t *pkg = installed_pkgs->pkgs[i];
 900                if (pkg->state_flag & SF_USER) {
 901                     flagged_pkg_count++;
 902                } else {
 903                     if (!pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL))
 904                          opkg_message(conf, OPKG_NOTICE, "Non-user leaf package: %s\n", pkg->name);
 905                }
 906           }
 907           if (!flagged_pkg_count) {
 908                opkg_message(conf, OPKG_NOTICE, "No packages flagged as installed by user, \n"
 909                             "so refusing to uninstall unflagged non-leaf packages\n");
 910                return 0;
 911           }
 912
 913           /* find packages not flagged SF_USER (i.e., installed to
 914            * satisfy a dependence) and not having any dependents, and
 915            * remove them */
 916           do {
 917                removed = 0;
 918                for (i = 0; i < installed_pkgs->len; i++) {
 919                     pkg_t *pkg = installed_pkgs->pkgs[i];
 920                     if (!(pkg->state_flag & SF_USER)
 921                         && !pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL)) {
 922                          removed++;
 923                          opkg_message(conf, OPKG_NOTICE, "Removing non-user leaf package %s\n");
 924                          opkg_remove_pkg(conf, pkg,0);
 925                          done = 1;
 926                     }
 927                }
 928           } while (removed);
 929           pkg_vec_free(installed_pkgs);
 930      }
 931
 932      if ( done == 0 )
 933         opkg_message(conf, OPKG_NOTICE, "No packages removed.\n");
 934
 935      write_status_files_if_changed(conf);
 936      return 0;
 937 }
 938
 939 static int opkg_purge_cmd(opkg_conf_t *conf, int argc, char **argv)
 940 {
 941      int i;
 942      pkg_t *pkg;
 943
 944      global_conf = conf;
 945      signal(SIGINT, sigint_handler);
 946
 947      pkg_info_preinstall_check(conf);
 948
 949      for (i=0; i < argc; i++) {
 950           if (conf->restrict_to_default_dest) {
 951                pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
 952                                                            argv[i],
 953                                                            conf->default_dest);
 954           } else {
 955                pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
 956           }
 957
 958           if (pkg == NULL) {
 959                opkg_message(conf, OPKG_ERROR,
 960                             "Package %s is not installed.\n", argv[i]);
 961                continue;
 962           }
 963           opkg_purge_pkg(conf, pkg);
 964      }
 965
 966      write_status_files_if_changed(conf);
 967      return 0;
 968 }
 969
 970 static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv)
 971 {
 972      int i;
 973      pkg_t *pkg;
 974      const char *flags = argv[0];
 975
 976      global_conf = conf;
 977      signal(SIGINT, sigint_handler);
 978
 979      for (i=1; i < argc; i++) {
 980           if (conf->restrict_to_default_dest) {
 981                pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
 982                                                            argv[i],
 983                                                            conf->default_dest);
 984           } else {
 985                pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
 986           }
 987
 988           if (pkg == NULL) {
 989                opkg_message(conf, OPKG_ERROR,
 990                             "Package %s is not installed.\n", argv[i]);
 991                continue;
 992           }
 993           if (( strcmp(flags,"hold")==0)||( strcmp(flags,"noprune")==0)||
 994               ( strcmp(flags,"user")==0)||( strcmp(flags,"ok")==0)) {
 995               pkg->state_flag = pkg_state_flag_from_str(flags);
 996           }
 997 /* pb_ asked this feature 03292004 */
 998 /* Actually I will use only this two, but this is an open for various status */
 999           if (( strcmp(flags,"installed")==0)||( strcmp(flags,"unpacked")==0)){
1000               pkg->state_status = pkg_state_status_from_str(flags);
1001           }
1002           opkg_state_changed++;
1003           opkg_message(conf, OPKG_NOTICE,
1004                        "Setting flags for package %s to %s\n",
1005                        pkg->name, flags);
1006      }
1007
1008      write_status_files_if_changed(conf);
1009      return 0;
1010 }
1011
1012 static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv)
1013 {
1014      pkg_t *pkg;
1015      str_list_t *files;
1016      str_list_elt_t *iter;
1017      char *pkg_version;
1018
1019      if (argc < 1) {
1020           return EINVAL;
1021      }
1022
1023      pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
1024                                             argv[0]);
1025      if (pkg == NULL) {
1026           opkg_message(conf, OPKG_ERROR,
1027                        "Package %s not installed.\n", argv[0]);
1028           return 0;
1029      }
1030
1031      files = pkg_get_installed_files(conf, pkg);
1032      pkg_version = pkg_version_str_alloc(pkg);
1033
1034      printf("Package %s (%s) is installed on %s and has the following files:\n",
1035                 pkg->name, pkg_version, pkg->dest->name);
1036
1037      for (iter=str_list_first(files); iter; iter=str_list_next(files, iter))
1038           printf("%s\n", (char *)iter->data);
1039
1040      free(pkg_version);
1041      pkg_free_installed_files(pkg);
1042
1043      return 0;
1044 }
1045
1046 static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv)
1047 {
1048
1049      if (argc > 0) {
1050           pkg_vec_t *available_pkgs = pkg_vec_alloc();
1051           const char *rel_str = "depends on";
1052           int i;
1053
1054           pkg_info_preinstall_check(conf);
1055
1056           if (conf->query_all)
1057                pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1058           else
1059                pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1060           for (i = 0; i < argc; i++) {
1061                const char *target = argv[i];
1062                int j;
1063
1064                opkg_message(conf, OPKG_NOTICE, "target=%s\n", target);
1065
1066                for (j = 0; j < available_pkgs->len; j++) {
1067                     pkg_t *pkg = available_pkgs->pkgs[j];
1068                     if (fnmatch(target, pkg->name, 0) == 0) {
1069                          int k;
1070                          int count = pkg->depends_count + pkg->pre_depends_count;
1071                          opkg_message(conf, OPKG_NOTICE, "What %s (arch=%s) %s\n",
1072                                       target, pkg->architecture, rel_str);
1073                          for (k = 0; k < count; k++) {
1074                               compound_depend_t *cdepend = &pkg->depends[k];
1075                               int l;
1076                               for (l = 0; l < cdepend->possibility_count; l++) {
1077                                    depend_t *possibility = cdepend->possibilities[l];
1078                                    opkg_message(conf, OPKG_NOTICE, "    %s", possibility->pkg->name);
1079                                    if (conf->verbosity >= OPKG_NOTICE) {
1080                                         if (possibility->version) {
1081                                              char *typestr = NULL;
1082                                              opkg_message(conf, OPKG_NOTICE, " %s", possibility->version);
1083                                              switch (possibility->constraint) {
1084                                              case NONE: typestr = "none"; break;
1085                                              case EARLIER: typestr = "<"; break;
1086                                              case EARLIER_EQUAL: typestr = "<="; break;
1087                                              case EQUAL: typestr = "="; break;
1088                                              case LATER_EQUAL: typestr = ">="; break;
1089                                              case LATER: typestr = ">"; break;
1090                                              }
1091                                              opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
1092                                         }
1093                                    }
1094                                    opkg_message(conf, OPKG_NOTICE, "\n");
1095                               }
1096                          }
1097                     }
1098                }
1099           }
1100           pkg_vec_free(available_pkgs);
1101      }
1102      return 0;
1103 }
1104
1105 enum what_field_type {
1106   WHATDEPENDS,
1107   WHATCONFLICTS,
1108   WHATPROVIDES,
1109   WHATREPLACES,
1110   WHATRECOMMENDS,
1111   WHATSUGGESTS
1112 };
1113
1114 static int opkg_what_depends_conflicts_cmd(opkg_conf_t *conf, enum depend_type what_field_type, int recursive, int argc, char **argv)
1115 {
1116
1117      if (argc > 0) {
1118           pkg_vec_t *available_pkgs = pkg_vec_alloc();
1119           const char *rel_str = NULL;
1120           int i;
1121           int changed;
1122
1123           switch (what_field_type) {
1124           case DEPEND: rel_str = "depends on"; break;
1125           case CONFLICTS: rel_str = "conflicts with"; break;
1126           case SUGGEST: rel_str = "suggests"; break;
1127           case RECOMMEND: rel_str = "recommends"; break;
1128           default: return -1;
1129           }
1130
1131           if (conf->query_all)
1132                pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1133           else
1134                pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1135
1136           /* mark the root set */
1137           pkg_vec_clear_marks(available_pkgs);
1138           opkg_message(conf, OPKG_NOTICE, "Root set:\n");
1139           for (i = 0; i < argc; i++) {
1140                const char *dependee_pattern = argv[i];
1141                pkg_vec_mark_if_matches(available_pkgs, dependee_pattern);
1142           }
1143           for (i = 0; i < available_pkgs->len; i++) {
1144                pkg_t *pkg = available_pkgs->pkgs[i];
1145                if (pkg->state_flag & SF_MARKED) {
1146                     /* mark the parent (abstract) package */
1147                     pkg_mark_provides(pkg);
1148                     opkg_message(conf, OPKG_NOTICE, "  %s\n", pkg->name);
1149                }
1150           }
1151
1152           opkg_message(conf, OPKG_NOTICE, "What %s root set\n", rel_str);
1153           do {
1154                int j;
1155                changed = 0;
1156
1157                for (j = 0; j < available_pkgs->len; j++) {
1158                     pkg_t *pkg = available_pkgs->pkgs[j];
1159                     int k;
1160                     int count = ((what_field_type == CONFLICTS)
1161                                  ? pkg->conflicts_count
1162                                  : pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count);
1163                     /* skip this package if it is already marked */
1164                     if (pkg->parent->state_flag & SF_MARKED) {
1165                          continue;
1166                     }
1167                     for (k = 0; k < count; k++) {
1168                          compound_depend_t *cdepend =
1169                               (what_field_type == CONFLICTS) ? &pkg->conflicts[k] : &pkg->depends[k];
1170                          int l;
1171                          if (what_field_type != cdepend->type)
1172                                  continue;
1173                          for (l = 0; l < cdepend->possibility_count; l++) {
1174                               depend_t *possibility = cdepend->possibilities[l];
1175                               if (possibility->pkg->state_flag & SF_MARKED) {
1176                                    /* mark the depending package so we won't visit it again */
1177                                    pkg->state_flag |= SF_MARKED;
1178                                    pkg_mark_provides(pkg);
1179                                    changed++;
1180
1181                                    if (conf->verbosity >= OPKG_NOTICE) {
1182                                         char *ver = pkg_version_str_alloc(pkg);
1183                                         opkg_message(conf, OPKG_NOTICE, "    %s", pkg->name);
1184                                         opkg_message(conf, OPKG_NOTICE, " %s", ver);
1185                                         opkg_message(conf, OPKG_NOTICE, "\t%s %s", rel_str, possibility->pkg->name);
1186                                         if (possibility->version) {
1187                                              char *typestr = NULL;
1188                                              switch (possibility->constraint) {
1189                                              case NONE: typestr = "none"; break;
1190                                              case EARLIER: typestr = "<"; break;
1191                                              case EARLIER_EQUAL: typestr = "<="; break;
1192                                              case EQUAL: typestr = "="; break;
1193                                              case LATER_EQUAL: typestr = ">="; break;
1194                                              case LATER: typestr = ">"; break;
1195                                              }
1196                                              opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
1197                                         }
1198                                         free(ver);
1199                                         if (!pkg_dependence_satisfiable(conf, possibility))
1200                                              opkg_message(conf, OPKG_NOTICE, " unsatisfiable");
1201                                    }
1202                                    opkg_message(conf, OPKG_NOTICE, "\n");
1203                                    goto next_package;
1204                               }
1205                          }
1206                     }
1207                next_package:
1208                     ;
1209                }
1210           } while (changed && recursive);
1211           pkg_vec_free(available_pkgs);
1212      }
1213
1214      return 0;
1215 }
1216
1217 static int pkg_mark_provides(pkg_t *pkg)
1218 {
1219      int provides_count = pkg->provides_count;
1220      abstract_pkg_t **provides = pkg->provides;
1221      int i;
1222      pkg->parent->state_flag |= SF_MARKED;
1223      for (i = 0; i < provides_count; i++) {
1224           provides[i]->state_flag |= SF_MARKED;
1225      }
1226      return 0;
1227 }
1228
1229 static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv)
1230 {
1231      return opkg_what_depends_conflicts_cmd(conf, DEPEND, 1, argc, argv);
1232 }
1233 static int opkg_whatdepends_cmd(opkg_conf_t *conf, int argc, char **argv)
1234 {
1235      return opkg_what_depends_conflicts_cmd(conf, DEPEND, 0, argc, argv);
1236 }
1237
1238 static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv)
1239 {
1240      return opkg_what_depends_conflicts_cmd(conf, SUGGEST, 0, argc, argv);
1241 }
1242
1243 static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv)
1244 {
1245      return opkg_what_depends_conflicts_cmd(conf, RECOMMEND, 0, argc, argv);
1246 }
1247
1248 static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv)
1249 {
1250      return opkg_what_depends_conflicts_cmd(conf, CONFLICTS, 0, argc, argv);
1251 }
1252
1253 static int opkg_what_provides_replaces_cmd(opkg_conf_t *conf, enum what_field_type what_field_type, int argc, char **argv)
1254 {
1255
1256      if (argc > 0) {
1257           pkg_vec_t *available_pkgs = pkg_vec_alloc();
1258           const char *rel_str = (what_field_type == WHATPROVIDES ? "provides" : "replaces");
1259           int i;
1260
1261           pkg_info_preinstall_check(conf);
1262
1263           if (conf->query_all)
1264                pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1265           else
1266                pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1267           for (i = 0; i < argc; i++) {
1268                const char *target = argv[i];
1269                int j;
1270
1271                opkg_message(conf, OPKG_ERROR, "What %s %s\n",
1272                             rel_str, target);
1273                for (j = 0; j < available_pkgs->len; j++) {
1274                     pkg_t *pkg = available_pkgs->pkgs[j];
1275                     int k;
1276                     int count = (what_field_type == WHATPROVIDES) ? pkg->provides_count : pkg->replaces_count;
1277                     for (k = 0; k < count; k++) {
1278                          abstract_pkg_t *apkg =
1279                               ((what_field_type == WHATPROVIDES)
1280                                ? pkg->provides[k]
1281                                : pkg->replaces[k]);
1282                          if (fnmatch(target, apkg->name, 0) == 0) {
1283                               opkg_message(conf, OPKG_ERROR, "    %s", pkg->name);
1284                               if (strcmp(target, apkg->name) != 0)
1285                                    opkg_message(conf, OPKG_ERROR, "\t%s %s\n", rel_str, apkg->name);
1286                               opkg_message(conf, OPKG_ERROR, "\n");
1287                          }
1288                     }
1289                }
1290           }
1291           pkg_vec_free(available_pkgs);
1292      }
1293      return 0;
1294 }
1295
1296 static int opkg_whatprovides_cmd(opkg_conf_t *conf, int argc, char **argv)
1297 {
1298      return opkg_what_provides_replaces_cmd(conf, WHATPROVIDES, argc, argv);
1299 }
1300
1301 static int opkg_whatreplaces_cmd(opkg_conf_t *conf, int argc, char **argv)
1302 {
1303      return opkg_what_provides_replaces_cmd(conf, WHATREPLACES, argc, argv);
1304 }
1305
1306 static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv)
1307 {
1308      int i;
1309
1310      pkg_vec_t *installed;
1311      pkg_t *pkg;
1312      str_list_t *installed_files;
1313      str_list_elt_t *iter;
1314      char *installed_file;
1315
1316      if (argc < 1) {
1317           return EINVAL;
1318      }
1319
1320      installed = pkg_vec_alloc();
1321      pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
1322      pkg_vec_sort(installed, pkg_compare_names);
1323
1324      for (i=0; i < installed->len; i++) {
1325           pkg = installed->pkgs[i];
1326
1327           installed_files = pkg_get_installed_files(conf, pkg);
1328
1329           for (iter = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) {
1330                installed_file = (char *)iter->data;
1331                if (fnmatch(argv[0], installed_file, 0)==0)
1332                     print_pkg(pkg);
1333           }
1334
1335           pkg_free_installed_files(pkg);
1336      }
1337
1338      pkg_vec_free(installed);
1339
1340      return 0;
1341 }
1342
1343 static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv)
1344 {
1345      if (argc == 3) {
1346           /* this is a bit gross */
1347           struct pkg p1, p2;
1348           parse_version(&p1, argv[0]);
1349           parse_version(&p2, argv[2]);
1350           return pkg_version_satisfied(&p1, &p2, argv[1]);
1351      } else {
1352           opkg_message(conf, OPKG_ERROR,
1353                        "opkg compare_versions <v1> <op> <v2>\n"
1354                        "<op> is one of <= >= << >> =\n");
1355           return -1;
1356      }
1357 }
1358
1359 static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv)
1360 {
1361      nv_pair_list_elt_t *l;
1362
1363      list_for_each_entry(l, &conf->arch_list.head, node) {
1364           nv_pair_t *nv = (nv_pair_t *)l->data;
1365           printf("arch %s %s\n", nv->name, nv->value);
1366      }
1367      return 0;
1368 }