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