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 occurred, 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         closedir(dir);
 383     } else
 384         perror (ctx->statedir);
 385
 386     sprintf_alloc (&cmd, "rm -rf %s", ctx->statedir);
 387     err = system (cmd);
 388     free (cmd);
 389
 390     free (ctx->statedir);
 391     free (ctx);
 392
 393     return err;
 394 }
 395
 396 /* For package pkg do the following: If it is already visited, return. If not,
 397    add it in visited list and recurse to its deps. Finally, add it to ordered
 398    list.
 399    pkg_vec all contains all available packages in repos.
 400    pkg_vec visited contains packages already visited by this function, and is
 401    used to end recursion and avoid an infinite loop on graph cycles.
 402    pkg_vec ordered will finally contain the ordered set of packages.
 403 */
 404 static int opkg_recurse_pkgs_in_order(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *all,
 405                                pkg_vec_t *visited, pkg_vec_t *ordered)
 406 {
 407     int j,k,l,m;
 408     int count;
 409     pkg_t *dep;
 410     compound_depend_t * compound_depend;
 411     depend_t ** possible_satisfiers;
 412     abstract_pkg_t *abpkg;
 413     abstract_pkg_t **dependents;
 414
 415     /* If it's just an available package, that is, not installed and not even
 416        unpacked, skip it */
 417     /* XXX: This is probably an overkill, since a state_status != SS_UNPACKED
 418        would do here. However, if there is an intermediate node (pkg) that is
 419        configured and installed between two unpacked packages, the latter
 420        won't be properly reordered, unless all installed/unpacked pkgs are
 421        checked */
 422     if (pkg->state_status == SS_NOT_INSTALLED)
 423         return 0;
 424
 425     /* If the  package has already been visited (by this function), skip it */
 426     for(j = 0; j < visited->len; j++)
 427         if ( ! strcmp(visited->pkgs[j]->name, pkg->name)) {
 428             opkg_message(conf, OPKG_INFO,
 429                          "  pkg: %s already visited\n", pkg->name);
 430             return 0;
 431         }
 432
 433     pkg_vec_insert(visited, pkg);
 434
 435     count = pkg->pre_depends_count + pkg->depends_count + \
 436         pkg->recommends_count + pkg->suggests_count;
 437
 438     opkg_message(conf, OPKG_INFO,
 439                  "  pkg: %s\n", pkg->name);
 440
 441     /* Iterate over all the dependencies of pkg. For each one, find a package
 442        that is either installed or unpacked and satisfies this dependency.
 443        (there should only be one such package per dependency installed or
 444        unpacked). Then recurse to the dependency package */
 445     for (j=0; j < count ; j++) {
 446         compound_depend = &pkg->depends[j];
 447         possible_satisfiers = compound_depend->possibilities;
 448         for (k=0; k < compound_depend->possibility_count ; k++) {
 449             abpkg = possible_satisfiers[k]->pkg;
 450             dependents = abpkg->provided_by->pkgs;
 451             l = 0;
 452             if (dependents != NULL)
 453                 while (dependents [l] != NULL && l < abpkg->provided_by->len) {
 454                     opkg_message(conf, OPKG_INFO,
 455                                  "  Descending on pkg: %s\n",
 456                                  dependents [l]->name);
 457
 458                     /* find whether dependent l is installed or unpacked,
 459                      * and then find which package in the list satisfies it */
 460                     for(m = 0; m < all->len; m++) {
 461                         dep = all->pkgs[m];
 462                         if ( dep->state_status != SS_NOT_INSTALLED)
 463                             if ( ! strcmp(dep->name, dependents[l]->name)) {
 464                                 opkg_recurse_pkgs_in_order(conf, dep, all,
 465                                                            visited, ordered);
 466                                 /* Stop the outer loop */
 467                                 l = abpkg->provided_by->len;
 468                                 /* break from the inner loop */
 469                                 break;
 470                             }
 471                     }
 472                     l++;
 473                 }
 474         }
 475     }
 476
 477     /* When all recursions from this node down, are over, and all
 478        dependencies have been added in proper order in the ordered array, add
 479        also the package pkg to ordered array */
 480     pkg_vec_insert(ordered, pkg);
 481
 482     return 0;
 483
 484 }
 485
 486 static int opkg_configure_packages(opkg_conf_t *conf, char *pkg_name)
 487 {
 488     pkg_vec_t *all, *ordered, *visited;
 489      int i;
 490      pkg_t *pkg;
 491      opkg_intercept_t ic;
 492      int r, err = 0;
 493
 494      opkg_message(conf, OPKG_INFO,
 495                   "Configuring unpacked packages\n");
 496      fflush( stdout );
 497
 498      all = pkg_vec_alloc();
 499
 500      pkg_hash_fetch_available(&conf->pkg_hash, all);
 501
 502      /* Reorder pkgs in order to be configured according to the Depends: tag
 503         order */
 504      opkg_message(conf, OPKG_INFO,
 505                   "Reordering packages before configuring them...\n");
 506      ordered = pkg_vec_alloc();
 507      visited = pkg_vec_alloc();
 508      for(i = 0; i < all->len; i++) {
 509          pkg = all->pkgs[i];
 510          opkg_recurse_pkgs_in_order(conf, pkg, all, visited, ordered);
 511      }
 512
 513
 514      ic = opkg_prep_intercepts (conf);
 515
 516      for(i = 0; i < all->len; i++) {
 517           pkg = all->pkgs[i];
 518
 519           if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
 520                continue;
 521
 522           if (pkg->state_status == SS_UNPACKED) {
 523                opkg_message(conf, OPKG_NOTICE,
 524                             "Configuring %s\n", pkg->name);
 525                fflush( stdout );
 526                r = opkg_configure(conf, pkg);
 527                if (r == 0) {
 528                     pkg->state_status = SS_INSTALLED;
 529                     pkg->parent->state_status = SS_INSTALLED;
 530                     pkg->state_flag &= ~SF_PREFER;
 531                } else {
 532                     if (!err)
 533                         err = r;
 534                }
 535           }
 536      }
 537
 538      r = opkg_finalize_intercepts (ic);
 539      if (r && !err)
 540          err = r;
 541
 542      pkg_vec_free(all);
 543      pkg_vec_free(ordered);
 544      pkg_vec_free(visited);
 545
 546      return err;
 547 }
 548
 549 static opkg_conf_t *global_conf;
 550
 551 static void sigint_handler(int sig)
 552 {
 553      signal(sig, SIG_DFL);
 554      opkg_message(NULL, OPKG_NOTICE,
 555                   "opkg: interrupted. writing out status database\n");
 556      write_status_files_if_changed(global_conf);
 557      exit(128 + sig);
 558 }
 559
 560 static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv)
 561 {
 562      int i;
 563      char *arg;
 564      int err=0;
 565
 566      global_conf = conf;
 567      signal(SIGINT, sigint_handler);
 568
 569      /*
 570       * Now scan through package names and install
 571       */
 572      for (i=0; i < argc; i++) {
 573           arg = argv[i];
 574
 575           opkg_message(conf, OPKG_DEBUG2, "Debug install_cmd: %s  \n",arg );
 576           err = opkg_prepare_url_for_install(conf, arg, &argv[i]);
 577           if (err != EINVAL && err != 0)
 578               return err;
 579      }
 580      pkg_info_preinstall_check(conf);
 581
 582      for (i=0; i < argc; i++) {
 583           arg = argv[i];
 584           err = opkg_install_by_name(conf, arg);
 585           if (err == OPKG_PKG_HAS_NO_CANDIDATE) {
 586                opkg_message(conf, OPKG_ERROR,
 587                             "Cannot find package %s.\n",
 588                             arg);
 589           }
 590      }
 591
 592      /* recheck to verify that all dependences are satisfied */
 593      if (0) opkg_satisfy_all_dependences(conf);
 594
 595      opkg_configure_packages(conf, NULL);
 596
 597      write_status_files_if_changed(conf);
 598
 599      return err;
 600 }
 601
 602 static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv)
 603 {
 604      int i;
 605      pkg_t *pkg;
 606      int err;
 607
 608      global_conf = conf;
 609      signal(SIGINT, sigint_handler);
 610
 611      if (argc) {
 612           for (i=0; i < argc; i++) {
 613                char *arg = argv[i];
 614
 615                err = opkg_prepare_url_for_install(conf, arg, &arg);
 616                if (err != EINVAL && err != 0)
 617                    return err;
 618           }
 619           pkg_info_preinstall_check(conf);
 620
 621           for (i=0; i < argc; i++) {
 622                char *arg = argv[i];
 623                if (conf->restrict_to_default_dest) {
 624                     pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
 625                                                                 argv[i],
 626                                                                 conf->default_dest);
 627                     if (pkg == NULL) {
 628                          opkg_message(conf, OPKG_NOTICE,
 629                                       "Package %s not installed in %s\n",
 630                                       argv[i], conf->default_dest->name);
 631                          continue;
 632                     }
 633                } else {
 634                     pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
 635                                                            argv[i]);
 636                }
 637                if (pkg)
 638                     opkg_upgrade_pkg(conf, pkg);
 639                else {
 640                     opkg_install_by_name(conf, arg);
 641                }
 642           }
 643      } else {
 644           pkg_vec_t *installed = pkg_vec_alloc();
 645
 646           pkg_info_preinstall_check(conf);
 647
 648           pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
 649           for (i = 0; i < installed->len; i++) {
 650                pkg = installed->pkgs[i];
 651                opkg_upgrade_pkg(conf, pkg);
 652           }
 653           pkg_vec_free(installed);
 654      }
 655
 656      /* recheck to verify that all dependences are satisfied */
 657      if (0) opkg_satisfy_all_dependences(conf);
 658
 659      opkg_configure_packages(conf, NULL);
 660
 661      write_status_files_if_changed(conf);
 662
 663      return 0;
 664 }
 665
 666 static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv)
 667 {
 668      int i, err;
 669      char *arg;
 670      pkg_t *pkg;
 671
 672      pkg_info_preinstall_check(conf);
 673      for (i = 0; i < argc; i++) {
 674           arg = argv[i];
 675
 676           pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, arg, &err);
 677           if (pkg == NULL) {
 678                opkg_message(conf, OPKG_ERROR,
 679                             "Cannot find package %s.\n"
 680                             "Check the spelling or perhaps run 'opkg update'\n",
 681                             arg);
 682                continue;
 683           }
 684
 685           err = opkg_download_pkg(conf, pkg, ".");
 686
 687           if (err) {
 688                opkg_message(conf, OPKG_ERROR,
 689                             "Failed to download %s\n", pkg->name);
 690           } else {
 691                opkg_message(conf, OPKG_NOTICE,
 692                             "Downloaded %s as %s\n",
 693                             pkg->name, pkg->local_filename);
 694           }
 695      }
 696
 697      return 0;
 698 }
 699
 700
 701 static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv)
 702 {
 703      int i ;
 704      pkg_vec_t *available;
 705      pkg_t *pkg;
 706      char desc_short[OPKG_LIST_DESCRIPTION_LENGTH];
 707      char *newline;
 708      char *pkg_name = NULL;
 709      char *version_str;
 710
 711      if (argc > 0) {
 712           pkg_name = argv[0];
 713      }
 714      available = pkg_vec_alloc();
 715      pkg_hash_fetch_available(&conf->pkg_hash, available);
 716      pkg_vec_sort(available, pkg_compare_names);
 717      for (i=0; i < available->len; i++) {
 718           pkg = available->pkgs[i];
 719           /* if we have package name or pattern and pkg does not match, then skip it */
 720           if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
 721                continue;
 722           if (pkg->description) {
 723                strncpy(desc_short, pkg->description, OPKG_LIST_DESCRIPTION_LENGTH);
 724           } else {
 725                desc_short[0] = '\0';
 726           }
 727           desc_short[OPKG_LIST_DESCRIPTION_LENGTH - 1] = '\0';
 728           newline = strchr(desc_short, '\n');
 729           if (newline) {
 730                *newline = '\0';
 731           }
 732           if (opkg_cb_list) {
 733                 version_str = pkg_version_str_alloc(pkg);
 734                 opkg_cb_list(pkg->name,desc_short,
 735                                              version_str,
 736                                          pkg->state_status,
 737                                          p_userdata);
 738                 free(version_str);
 739           }
 740      }
 741      pkg_vec_free(available);
 742
 743      return 0;
 744 }
 745
 746
 747 static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv)
 748 {
 749      int i ;
 750      pkg_vec_t *available;
 751      pkg_t *pkg;
 752      char desc_short[OPKG_LIST_DESCRIPTION_LENGTH];
 753      char *newline;
 754      char *pkg_name = NULL;
 755      char *version_str;
 756
 757      if (argc > 0) {
 758           pkg_name = argv[0];
 759      }
 760      available = pkg_vec_alloc();
 761      pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
 762      pkg_vec_sort(available, pkg_compare_names);
 763      for (i=0; i < available->len; i++) {
 764           pkg = available->pkgs[i];
 765           /* if we have package name or pattern and pkg does not match, then skip it */
 766           if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
 767                continue;
 768           if (pkg->description) {
 769                strncpy(desc_short, pkg->description, OPKG_LIST_DESCRIPTION_LENGTH);
 770           } else {
 771                desc_short[0] = '\0';
 772           }
 773           desc_short[OPKG_LIST_DESCRIPTION_LENGTH - 1] = '\0';
 774           newline = strchr(desc_short, '\n');
 775           if (newline) {
 776                *newline = '\0';
 777           }
 778           if (opkg_cb_list) {
 779                 version_str = pkg_version_str_alloc(pkg);
 780                 opkg_cb_list(pkg->name,desc_short,
 781                                              version_str,
 782                                          pkg->state_status,
 783                                          p_userdata);
 784                 free(version_str);
 785           }
 786      }
 787
 788      return 0;
 789 }
 790
 791 static int opkg_list_upgradable_cmd(opkg_conf_t *conf, int argc, char **argv)
 792 {
 793     struct active_list *head = prepare_upgrade_list(conf);
 794     struct active_list *node=NULL;
 795     pkg_t *_old_pkg, *_new_pkg;
 796     char *old_v, *new_v;
 797     for (node = active_list_next(head, head); node;node = active_list_next(head,node)) {
 798         _old_pkg = list_entry(node, pkg_t, list);
 799         _new_pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, _old_pkg->name, NULL);
 800         old_v = pkg_version_str_alloc(_old_pkg);
 801         new_v = pkg_version_str_alloc(_new_pkg);
 802         if (opkg_cb_list)
 803             opkg_cb_list(_old_pkg->name, new_v, old_v, _old_pkg->state_status, p_userdata);
 804         free(old_v);
 805         free(new_v);
 806     }
 807     active_list_head_delete(head);
 808     return 0;
 809 }
 810
 811 static int opkg_info_status_cmd(opkg_conf_t *conf, int argc, char **argv, int installed_only)
 812 {
 813      int i;
 814      pkg_vec_t *available;
 815      pkg_t *pkg;
 816      char *pkg_name = NULL;
 817      char **pkg_fields = NULL;
 818      int n_fields = 0;
 819      char *buff = NULL;
 820
 821      if (argc > 0) {
 822           pkg_name = argv[0];
 823      }
 824      if (argc > 1) {
 825           pkg_fields = &argv[1];
 826           n_fields = argc - 1;
 827      }
 828
 829      available = pkg_vec_alloc();
 830      if (installed_only)
 831           pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
 832      else
 833           pkg_hash_fetch_available(&conf->pkg_hash, available);
 834      for (i=0; i < available->len; i++) {
 835           pkg = available->pkgs[i];
 836           if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
 837                continue;
 838           }
 839
 840           buff = pkg_formatted_info(pkg);
 841           if ( buff ) {
 842                if (opkg_cb_status) opkg_cb_status(pkg->name,
 843                                                   pkg->state_status,
 844                                                   buff,
 845                                                   p_userdata);
 846 /*
 847    We should not forget that actually the pointer is allocated.
 848    We need to free it :)  ( Thanks florian for seeing the error )
 849 */
 850                free(buff);
 851                buff = NULL;
 852           }
 853           if (conf->verbosity > 1) {
 854                conffile_list_elt_t *iter;
 855                for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
 856                     conffile_t *cf = (conffile_t *)iter->data;
 857                     int modified = conffile_has_been_modified(conf, cf);
 858                     opkg_message(conf, OPKG_NOTICE, "conffile=%s md5sum=%s modified=%d\n",
 859                                  cf->name, cf->value, modified);
 860                }
 861           }
 862      }
 863      pkg_vec_free(available);
 864
 865      return 0;
 866 }
 867
 868 static int opkg_info_cmd(opkg_conf_t *conf, int argc, char **argv)
 869 {
 870      return opkg_info_status_cmd(conf, argc, argv, 0);
 871 }
 872
 873 static int opkg_status_cmd(opkg_conf_t *conf, int argc, char **argv)
 874 {
 875      return opkg_info_status_cmd(conf, argc, argv, 1);
 876 }
 877
 878 static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv)
 879 {
 880
 881      int err;
 882      if (argc > 0) {
 883           char *pkg_name = NULL;
 884
 885           pkg_name = argv[0];
 886
 887           err = opkg_configure_packages (conf, pkg_name);
 888
 889      } else {
 890           err = opkg_configure_packages (conf, NULL);
 891      }
 892
 893      write_status_files_if_changed(conf);
 894
 895      return err;
 896 }
 897
 898 static int opkg_install_pending_cmd(opkg_conf_t *conf, int argc, char **argv)
 899 {
 900      int i, err;
 901      char *globpattern;
 902      glob_t globbuf;
 903
 904      sprintf_alloc(&globpattern, "%s/*" OPKG_PKG_EXTENSION, conf->pending_dir);
 905      err = glob(globpattern, 0, NULL, &globbuf);
 906      free(globpattern);
 907      if (err) {
 908           return 0;
 909      }
 910
 911      opkg_message(conf, OPKG_NOTICE,
 912                   "The following packages in %s will now be installed.\n",
 913                   conf->pending_dir);
 914      for (i = 0; i < globbuf.gl_pathc; i++) {
 915           opkg_message(conf, OPKG_NOTICE,
 916                        "%s%s", i == 0 ? "" : " ", globbuf.gl_pathv[i]);
 917      }
 918      opkg_message(conf, OPKG_NOTICE, "\n");
 919      for (i = 0; i < globbuf.gl_pathc; i++) {
 920           err = opkg_install_from_file(conf, globbuf.gl_pathv[i]);
 921           if (err == 0) {
 922                err = unlink(globbuf.gl_pathv[i]);
 923                if (err) {
 924                     opkg_message(conf, OPKG_ERROR,
 925                                  "%s: ERROR: failed to unlink %s: %s\n",
 926                                  __FUNCTION__, globbuf.gl_pathv[i], strerror(err));
 927                     return err;
 928                }
 929           }
 930      }
 931      globfree(&globbuf);
 932
 933      return err;
 934 }
 935
 936 static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv)
 937 {
 938      int i,a,done;
 939      pkg_t *pkg;
 940      pkg_t *pkg_to_remove;
 941      pkg_vec_t *available;
 942      char *pkg_name = NULL;
 943      global_conf = conf;
 944      signal(SIGINT, sigint_handler);
 945
 946 // ENH: Add the "no pkg removed" just in case.
 947
 948     done = 0;
 949
 950      pkg_info_preinstall_check(conf);
 951      if ( argc > 0 ) {
 952         available = pkg_vec_alloc();
 953         pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
 954         for (i=0; i < argc; i++) {
 955            pkg_name = calloc(1, strlen(argv[i])+2);
 956            strcpy(pkg_name,argv[i]);
 957            for (a=0; a < available->len; a++) {
 958                pkg = available->pkgs[a];
 959                if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
 960                   continue;
 961                }
 962                if (conf->restrict_to_default_dest) {
 963                     pkg_to_remove = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
 964                                                                 pkg->name,
 965                                                                 conf->default_dest);
 966                } else {
 967                     pkg_to_remove = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name );
 968                }
 969
 970                if (pkg == NULL) {
 971                     opkg_message(conf, OPKG_ERROR, "Package %s is not installed.\n", pkg->name);
 972                     continue;
 973                }
 974                if (pkg->state_status == SS_NOT_INSTALLED) {    // Added the control, so every already removed package could be skipped
 975                     opkg_message(conf, OPKG_ERROR, "Package seems to be %s not installed (STATUS = NOT_INSTALLED).\n", pkg->name);
 976                     continue;
 977                }
 978                opkg_remove_pkg(conf, pkg_to_remove,0);
 979                done = 1;
 980            }
 981            free (pkg_name);
 982         }
 983         pkg_vec_free(available);
 984      } else {
 985           pkg_vec_t *installed_pkgs = pkg_vec_alloc();
 986           int i;
 987           int flagged_pkg_count = 0;
 988           int removed;
 989
 990           pkg_hash_fetch_all_installed(&conf->pkg_hash, installed_pkgs);
 991
 992           for (i = 0; i < installed_pkgs->len; i++) {
 993                pkg_t *pkg = installed_pkgs->pkgs[i];
 994                if (pkg->state_flag & SF_USER) {
 995                     flagged_pkg_count++;
 996                } else {
 997                     if (!pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL))
 998                          opkg_message(conf, OPKG_NOTICE, "Non-user leaf package: %s\n", pkg->name);
 999                }
1000           }
1001           if (!flagged_pkg_count) {
1002                opkg_message(conf, OPKG_NOTICE, "No packages flagged as installed by user, \n"
1003                             "so refusing to uninstall unflagged non-leaf packages\n");
1004                return 0;
1005           }
1006
1007           /* find packages not flagged SF_USER (i.e., installed to
1008            * satisfy a dependence) and not having any dependents, and
1009            * remove them */
1010           do {
1011                removed = 0;
1012                for (i = 0; i < installed_pkgs->len; i++) {
1013                     pkg_t *pkg = installed_pkgs->pkgs[i];
1014                     if (!(pkg->state_flag & SF_USER)
1015                         && !pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL)) {
1016                          removed++;
1017                          opkg_message(conf, OPKG_NOTICE, "Removing non-user leaf package %s\n");
1018                          opkg_remove_pkg(conf, pkg,0);
1019                          done = 1;
1020                     }
1021                }
1022           } while (removed);
1023           pkg_vec_free(installed_pkgs);
1024      }
1025
1026      if ( done == 0 )
1027         opkg_message(conf, OPKG_NOTICE, "No packages removed.\n");
1028
1029      write_status_files_if_changed(conf);
1030      return 0;
1031 }
1032
1033 static int opkg_purge_cmd(opkg_conf_t *conf, int argc, char **argv)
1034 {
1035      int i;
1036      pkg_t *pkg;
1037
1038      global_conf = conf;
1039      signal(SIGINT, sigint_handler);
1040
1041      pkg_info_preinstall_check(conf);
1042
1043      for (i=0; i < argc; i++) {
1044           if (conf->restrict_to_default_dest) {
1045                pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
1046                                                            argv[i],
1047                                                            conf->default_dest);
1048           } else {
1049                pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
1050           }
1051
1052           if (pkg == NULL) {
1053                opkg_message(conf, OPKG_ERROR,
1054                             "Package %s is not installed.\n", argv[i]);
1055                continue;
1056           }
1057           opkg_purge_pkg(conf, pkg);
1058      }
1059
1060      write_status_files_if_changed(conf);
1061      return 0;
1062 }
1063
1064 static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv)
1065 {
1066      int i;
1067      pkg_t *pkg;
1068      const char *flags = argv[0];
1069
1070      global_conf = conf;
1071      signal(SIGINT, sigint_handler);
1072
1073      for (i=1; i < argc; i++) {
1074           if (conf->restrict_to_default_dest) {
1075                pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
1076                                                            argv[i],
1077                                                            conf->default_dest);
1078           } else {
1079                pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
1080           }
1081
1082           if (pkg == NULL) {
1083                opkg_message(conf, OPKG_ERROR,
1084                             "Package %s is not installed.\n", argv[i]);
1085                continue;
1086           }
1087           if (( strcmp(flags,"hold")==0)||( strcmp(flags,"noprune")==0)||
1088               ( strcmp(flags,"user")==0)||( strcmp(flags,"ok")==0)) {
1089               pkg->state_flag = pkg_state_flag_from_str(flags);
1090           }
1091 /* pb_ asked this feature 03292004 */
1092 /* Actually I will use only this two, but this is an open for various status */
1093           if (( strcmp(flags,"installed")==0)||( strcmp(flags,"unpacked")==0)){
1094               pkg->state_status = pkg_state_status_from_str(flags);
1095           }
1096           opkg_state_changed++;
1097           opkg_message(conf, OPKG_NOTICE,
1098                        "Setting flags for package %s to %s\n",
1099                        pkg->name, flags);
1100      }
1101
1102      write_status_files_if_changed(conf);
1103      return 0;
1104 }
1105
1106 static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv)
1107 {
1108      pkg_t *pkg;
1109      str_list_t *installed_files;
1110      str_list_elt_t *iter;
1111      char *pkg_version;
1112      size_t buff_len = 8192;
1113      size_t used_len;
1114      char *buff ;
1115
1116      buff = (char *)calloc(1, buff_len);
1117      if ( buff == NULL ) {
1118         fprintf( stderr,"%s: Unable to allocate memory \n",__FUNCTION__);
1119         return ENOMEM;
1120      }
1121
1122      if (argc < 1) {
1123           return EINVAL;
1124      }
1125
1126      pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
1127                                             argv[0]);
1128      if (pkg == NULL) {
1129           opkg_message(conf, OPKG_ERROR,
1130                        "Package %s not installed.\n", argv[0]);
1131           return 0;
1132      }
1133
1134      installed_files = pkg_get_installed_files(pkg);
1135      pkg_version = pkg_version_str_alloc(pkg);
1136
1137      if (buff) {
1138      try_again:
1139           used_len = snprintf(buff, buff_len, "Package %s (%s) is installed on %s and has the following files:\n",
1140                               pkg->name, pkg_version, pkg->dest->name) + 1;
1141           if (used_len > buff_len) {
1142                buff_len *= 2;
1143                buff = realloc (buff, buff_len);
1144                goto try_again;
1145           }
1146           for (iter = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) {
1147                used_len += strlen (iter->data) + 1;
1148                while (buff_len <= used_len) {
1149                     buff_len *= 2;
1150                     buff = realloc (buff, buff_len);
1151                }
1152                strncat(buff, iter->data, buff_len);
1153                strncat(buff, "\n", buff_len);
1154           }
1155           if (opkg_cb_list) opkg_cb_list(pkg->name,
1156                                          buff,
1157                                          pkg_version_str_alloc(pkg),
1158                                          pkg->state_status,
1159                                          p_userdata);
1160           free(buff);
1161      }
1162
1163      free(pkg_version);
1164      pkg_free_installed_files(pkg);
1165
1166      return 0;
1167 }
1168
1169 static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv)
1170 {
1171
1172      if (argc > 0) {
1173           pkg_vec_t *available_pkgs = pkg_vec_alloc();
1174           const char *rel_str = "depends on";
1175           int i;
1176
1177           pkg_info_preinstall_check(conf);
1178
1179           if (conf->query_all)
1180                pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1181           else
1182                pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1183           for (i = 0; i < argc; i++) {
1184                const char *target = argv[i];
1185                int j;
1186
1187                opkg_message(conf, OPKG_ERROR, "target=%s\n", target);
1188
1189                for (j = 0; j < available_pkgs->len; j++) {
1190                     pkg_t *pkg = available_pkgs->pkgs[j];
1191                     if (fnmatch(target, pkg->name, 0) == 0) {
1192                          int k;
1193                          int count = pkg->depends_count + pkg->pre_depends_count;
1194                          opkg_message(conf, OPKG_ERROR, "What %s (arch=%s) %s\n",
1195                                       target, pkg->architecture, rel_str);
1196                          for (k = 0; k < count; k++) {
1197                               compound_depend_t *cdepend = &pkg->depends[k];
1198                               int l;
1199                               for (l = 0; l < cdepend->possibility_count; l++) {
1200                                    depend_t *possibility = cdepend->possibilities[l];
1201                                    opkg_message(conf, OPKG_ERROR, "    %s", possibility->pkg->name);
1202                                    if (conf->verbosity > 0) {
1203                                         // char *ver = abstract_pkg_version_str_alloc(possibility->pkg);
1204                                         opkg_message(conf, OPKG_NOTICE, " %s", possibility->version);
1205                                         if (possibility->version) {
1206                                              char *typestr = NULL;
1207                                              switch (possibility->constraint) {
1208                                              case NONE: typestr = "none"; break;
1209                                              case EARLIER: typestr = "<"; break;
1210                                              case EARLIER_EQUAL: typestr = "<="; break;
1211                                              case EQUAL: typestr = "="; break;
1212                                              case LATER_EQUAL: typestr = ">="; break;
1213                                              case LATER: typestr = ">"; break;
1214                                              }
1215                                              opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
1216                                         }
1217                                         // free(ver);
1218                                    }
1219                                    opkg_message(conf, OPKG_ERROR, "\n");
1220                               }
1221                          }
1222                     }
1223                }
1224           }
1225           pkg_vec_free(available_pkgs);
1226      }
1227      return 0;
1228 }
1229
1230 enum what_field_type {
1231   WHATDEPENDS,
1232   WHATCONFLICTS,
1233   WHATPROVIDES,
1234   WHATREPLACES,
1235   WHATRECOMMENDS,
1236   WHATSUGGESTS
1237 };
1238
1239 static int opkg_what_depends_conflicts_cmd(opkg_conf_t *conf, enum what_field_type what_field_type, int recursive, int argc, char **argv)
1240 {
1241
1242      if (argc > 0) {
1243           pkg_vec_t *available_pkgs = pkg_vec_alloc();
1244           const char *rel_str = NULL;
1245           int i;
1246           int changed;
1247
1248           switch (what_field_type) {
1249           case WHATDEPENDS: rel_str = "depends on"; break;
1250           case WHATCONFLICTS: rel_str = "conflicts with"; break;
1251           case WHATSUGGESTS: rel_str = "suggests"; break;
1252           case WHATRECOMMENDS: rel_str = "recommends"; break;
1253           case WHATPROVIDES: rel_str = "provides"; break;
1254           case WHATREPLACES: rel_str = "replaces"; break;
1255           }
1256
1257           if (conf->query_all)
1258                pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1259           else
1260                pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1261
1262           /* mark the root set */
1263           pkg_vec_clear_marks(available_pkgs);
1264           opkg_message(conf, OPKG_NOTICE, "Root set:\n");
1265           for (i = 0; i < argc; i++) {
1266                const char *dependee_pattern = argv[i];
1267                pkg_vec_mark_if_matches(available_pkgs, dependee_pattern);
1268           }
1269           for (i = 0; i < available_pkgs->len; i++) {
1270                pkg_t *pkg = available_pkgs->pkgs[i];
1271                if (pkg->state_flag & SF_MARKED) {
1272                     /* mark the parent (abstract) package */
1273                     pkg_mark_provides(pkg);
1274                     opkg_message(conf, OPKG_NOTICE, "  %s\n", pkg->name);
1275                }
1276           }
1277
1278           opkg_message(conf, OPKG_NOTICE, "What %s root set\n", rel_str);
1279           do {
1280                int j;
1281                changed = 0;
1282
1283                for (j = 0; j < available_pkgs->len; j++) {
1284                     pkg_t *pkg = available_pkgs->pkgs[j];
1285                     int k;
1286                     int count = ((what_field_type == WHATCONFLICTS)
1287                                  ? pkg->conflicts_count
1288                                  : pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count);
1289                     /* skip this package if it is already marked */
1290                     if (pkg->parent->state_flag & SF_MARKED) {
1291                          continue;
1292                     }
1293                     for (k = 0; k < count; k++) {
1294                          compound_depend_t *cdepend =
1295                               (what_field_type == WHATCONFLICTS) ? &pkg->conflicts[k] : &pkg->depends[k];
1296                          int l;
1297                          for (l = 0; l < cdepend->possibility_count; l++) {
1298                               depend_t *possibility = cdepend->possibilities[l];
1299                               if (possibility->pkg->state_flag & SF_MARKED) {
1300                                    /* mark the depending package so we won't visit it again */
1301                                    pkg->state_flag |= SF_MARKED;
1302                                    pkg_mark_provides(pkg);
1303                                    changed++;
1304
1305                                    opkg_message(conf, OPKG_NOTICE, "    %s", pkg->name);
1306                                    if (conf->verbosity > 0) {
1307                                         char *ver = pkg_version_str_alloc(pkg);
1308                                         opkg_message(conf, OPKG_NOTICE, " %s", ver);
1309                                         opkg_message(conf, OPKG_NOTICE, "\t%s %s", rel_str, possibility->pkg->name);
1310                                         if (possibility->version) {
1311                                              char *typestr = NULL;
1312                                              switch (possibility->constraint) {
1313                                              case NONE: typestr = "none"; break;
1314                                              case EARLIER: typestr = "<"; break;
1315                                              case EARLIER_EQUAL: typestr = "<="; break;
1316                                              case EQUAL: typestr = "="; break;
1317                                              case LATER_EQUAL: typestr = ">="; break;
1318                                              case LATER: typestr = ">"; break;
1319                                              }
1320                                              opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
1321                                         }
1322                                         free(ver);
1323                                         if (!pkg_dependence_satisfiable(conf, possibility))
1324                                              opkg_message(conf, OPKG_NOTICE, " unsatisfiable");
1325                                    }
1326                                    opkg_message(conf, OPKG_NOTICE, "\n");
1327                                    goto next_package;
1328                               }
1329                          }
1330                     }
1331                next_package:
1332                     ;
1333                }
1334           } while (changed && recursive);
1335           pkg_vec_free(available_pkgs);
1336      }
1337
1338      return 0;
1339 }
1340
1341 static int pkg_mark_provides(pkg_t *pkg)
1342 {
1343      int provides_count = pkg->provides_count;
1344      abstract_pkg_t **provides = pkg->provides;
1345      int i;
1346      pkg->parent->state_flag |= SF_MARKED;
1347      for (i = 0; i < provides_count; i++) {
1348           provides[i]->state_flag |= SF_MARKED;
1349      }
1350      return 0;
1351 }
1352
1353 static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv)
1354 {
1355      return opkg_what_depends_conflicts_cmd(conf, WHATDEPENDS, 1, argc, argv);
1356 }
1357 static int opkg_whatdepends_cmd(opkg_conf_t *conf, int argc, char **argv)
1358 {
1359      return opkg_what_depends_conflicts_cmd(conf, WHATDEPENDS, 0, argc, argv);
1360 }
1361
1362 static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv)
1363 {
1364      return opkg_what_depends_conflicts_cmd(conf, WHATSUGGESTS, 0, argc, argv);
1365 }
1366
1367 static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv)
1368 {
1369      return opkg_what_depends_conflicts_cmd(conf, WHATRECOMMENDS, 0, argc, argv);
1370 }
1371
1372 static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv)
1373 {
1374      return opkg_what_depends_conflicts_cmd(conf, WHATCONFLICTS, 0, argc, argv);
1375 }
1376
1377 static int opkg_what_provides_replaces_cmd(opkg_conf_t *conf, enum what_field_type what_field_type, int argc, char **argv)
1378 {
1379
1380      if (argc > 0) {
1381           pkg_vec_t *available_pkgs = pkg_vec_alloc();
1382           const char *rel_str = (what_field_type == WHATPROVIDES ? "provides" : "replaces");
1383           int i;
1384
1385           pkg_info_preinstall_check(conf);
1386
1387           if (conf->query_all)
1388                pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1389           else
1390                pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1391           for (i = 0; i < argc; i++) {
1392                const char *target = argv[i];
1393                int j;
1394
1395                opkg_message(conf, OPKG_ERROR, "What %s %s\n",
1396                             rel_str, target);
1397                for (j = 0; j < available_pkgs->len; j++) {
1398                     pkg_t *pkg = available_pkgs->pkgs[j];
1399                     int k;
1400                     int count = (what_field_type == WHATPROVIDES) ? pkg->provides_count : pkg->replaces_count;
1401                     for (k = 0; k < count; k++) {
1402                          abstract_pkg_t *apkg =
1403                               ((what_field_type == WHATPROVIDES)
1404                                ? pkg->provides[k]
1405                                : pkg->replaces[k]);
1406                          if (fnmatch(target, apkg->name, 0) == 0) {
1407                               opkg_message(conf, OPKG_ERROR, "    %s", pkg->name);
1408                               if (strcmp(target, apkg->name) != 0)
1409                                    opkg_message(conf, OPKG_ERROR, "\t%s %s\n", rel_str, apkg->name);
1410                               opkg_message(conf, OPKG_ERROR, "\n");
1411                          }
1412                     }
1413                }
1414           }
1415           pkg_vec_free(available_pkgs);
1416      }
1417      return 0;
1418 }
1419
1420 static int opkg_whatprovides_cmd(opkg_conf_t *conf, int argc, char **argv)
1421 {
1422      return opkg_what_provides_replaces_cmd(conf, WHATPROVIDES, argc, argv);
1423 }
1424
1425 static int opkg_whatreplaces_cmd(opkg_conf_t *conf, int argc, char **argv)
1426 {
1427      return opkg_what_provides_replaces_cmd(conf, WHATREPLACES, argc, argv);
1428 }
1429
1430 static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv)
1431 {
1432      int i;
1433
1434      pkg_vec_t *installed;
1435      pkg_t *pkg;
1436      str_list_t *installed_files;
1437      str_list_elt_t *iter;
1438      char *installed_file;
1439
1440      if (argc < 1) {
1441           return EINVAL;
1442      }
1443
1444      installed = pkg_vec_alloc();
1445      pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
1446      pkg_vec_sort(installed, pkg_compare_names);
1447
1448      for (i=0; i < installed->len; i++) {
1449           pkg = installed->pkgs[i];
1450
1451           installed_files = pkg_get_installed_files(pkg);
1452
1453           for (iter = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) {
1454                installed_file = (char *)iter->data;
1455                if (fnmatch(argv[0], installed_file, 0)==0)  {
1456                         if (opkg_cb_list) opkg_cb_list(pkg->name,
1457                                                        installed_file,
1458                                                        pkg_version_str_alloc(pkg),
1459                                                        pkg->state_status, p_userdata);
1460                }
1461           }
1462
1463           pkg_free_installed_files(pkg);
1464      }
1465
1466      pkg_vec_free(installed);
1467
1468      return 0;
1469 }
1470
1471 static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv)
1472 {
1473      if (argc == 3) {
1474           /* this is a bit gross */
1475           struct pkg p1, p2;
1476           parseVersion(&p1, argv[0]);
1477           parseVersion(&p2, argv[2]);
1478           return pkg_version_satisfied(&p1, &p2, argv[1]);
1479      } else {
1480           opkg_message(conf, OPKG_ERROR,
1481                        "opkg compare_versions <v1> <op> <v2>\n"
1482                        "<op> is one of <= >= << >> =\n");
1483           return -1;
1484      }
1485 }
1486
1487 #ifndef HOST_CPU_STR
1488 #define HOST_CPU_STR__(X) #X
1489 #define HOST_CPU_STR_(X) HOST_CPU_STR__(X)
1490 #define HOST_CPU_STR HOST_CPU_STR_(HOST_CPU_FOO)
1491 #endif
1492
1493 static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv)
1494 {
1495      nv_pair_list_elt_t *l;
1496
1497      list_for_each_entry(l, &conf->arch_list.head, node) {
1498           nv_pair_t *nv = (nv_pair_t *)l->data;
1499           printf("arch %s %s\n", nv->name, nv->value);
1500      }
1501      return 0;
1502 }
1503
1504