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