libopkg/pkg_hash.c

   1 /* opkg_hash.c - the opkg package management system
   2
   3    Steven M. Ayer
   4
   5    Copyright (C) 2002 Compaq Computer Corporation
   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 #include <stdio.h>
  19
  20 #include "hash_table.h"
  21 #include "pkg.h"
  22 #include "opkg_message.h"
  23 #include "pkg_vec.h"
  24 #include "pkg_hash.h"
  25 #include "parse_util.h"
  26 #include "pkg_parse.h"
  27 #include "opkg_utils.h"
  28 #include "sprintf_alloc.h"
  29 #include "file_util.h"
  30 #include "libbb/libbb.h"
  31 #include "libbb/gzip.h"
  32
  33 void pkg_hash_init(void)
  34 {
  35         hash_table_init("pkg-hash", &conf->pkg_hash,
  36                         OPKG_CONF_DEFAULT_HASH_LEN);
  37 }
  38
  39 static void free_pkgs(const char *key, void *entry, void *data)
  40 {
  41         int i;
  42         abstract_pkg_t *ab_pkg;
  43
  44         /* Each entry in the hash table is an abstract package, which contains
  45          * a list of packages that provide the abstract package.
  46          */
  47
  48         ab_pkg = (abstract_pkg_t *) entry;
  49
  50         if (ab_pkg->pkgs) {
  51                 for (i = 0; i < ab_pkg->pkgs->len; i++) {
  52                         pkg_deinit(ab_pkg->pkgs->pkgs[i]);
  53                         free(ab_pkg->pkgs->pkgs[i]);
  54                 }
  55         }
  56
  57         abstract_pkg_vec_free(ab_pkg->provided_by);
  58         abstract_pkg_vec_free(ab_pkg->replaced_by);
  59         pkg_vec_free(ab_pkg->pkgs);
  60         free(ab_pkg->depended_upon_by);
  61         free(ab_pkg->name);
  62         free(ab_pkg);
  63 }
  64
  65 void pkg_hash_deinit(void)
  66 {
  67         hash_table_foreach(&conf->pkg_hash, free_pkgs, NULL);
  68         hash_table_deinit(&conf->pkg_hash);
  69 }
  70
  71 int dist_hash_add_from_file(const char *lists_dir, pkg_src_t * dist)
  72 {
  73         nv_pair_list_elt_t *l;
  74         char *list_file, *subname;
  75
  76         list_for_each_entry(l, &conf->arch_list.head, node) {
  77                 nv_pair_t *nv = (nv_pair_t *) l->data;
  78                 sprintf_alloc(&subname, "%s-%s", dist->name, nv->name);
  79                 sprintf_alloc(&list_file, "%s/%s", lists_dir, subname);
  80
  81                 if (file_exists(list_file)) {
  82                         if (pkg_hash_add_from_file(list_file, dist, NULL, 0, 0)) {
  83                                 free(list_file);
  84                                 return -1;
  85                         }
  86                         pkg_src_list_append(&conf->pkg_src_list, subname,
  87                                             dist->value, "__dummy__", 0);
  88                 }
  89
  90                 free(list_file);
  91         }
  92
  93         return 0;
  94 }
  95
  96 int
  97 pkg_hash_add_from_file(const char *file_name,
  98                        pkg_src_t * src, pkg_dest_t * dest, int is_status_file, int state_flags)
  99 {
 100         pkg_t *pkg;
 101         FILE *fp;
 102         char *buf;
 103         const size_t len = 4096;
 104         int ret = 0;
 105         struct gzip_handle zh;
 106
 107         if (src && src->gzip) {
 108                 fp = gzip_fdopen(&zh, file_name);
 109         } else {
 110                 fp = fopen(file_name, "r");
 111         }
 112
 113         if (fp == NULL) {
 114                 opkg_perror(ERROR, "Failed to open %s", file_name);
 115                 return -1;
 116         }
 117
 118         buf = xmalloc(len);
 119
 120         do {
 121                 pkg = pkg_new();
 122                 pkg->src = src;
 123                 pkg->dest = dest;
 124                 pkg->state_flag |= state_flags;
 125
 126                 ret = parse_from_stream_nomalloc(pkg_parse_line, pkg, fp, 0,
 127                                                  &buf, len);
 128
 129                 if (pkg->name == NULL) {
 130                         /* probably just a blank line */
 131                         ret = 1;
 132                 }
 133
 134                 if (ret) {
 135                         pkg_deinit(pkg);
 136                         free(pkg);
 137                         if (ret == -1)
 138                                 break;
 139                         if (ret == 1)
 140                                 /* Probably a blank line, continue parsing. */
 141                                 ret = 0;
 142                         continue;
 143                 }
 144
 145                 if (!(pkg->state_flag & SF_NEED_DETAIL)) {
 146                         //opkg_msg(DEBUG, "Package %s is unrelated, ignoring.\n", pkg->name);
 147                         pkg_deinit(pkg);
 148                         free(pkg);
 149                         continue;
 150                 }
 151
 152                 if (!pkg_get_architecture(pkg) || !pkg_get_arch_priority(pkg)) {
 153                         char *version_str = pkg_version_str_alloc(pkg);
 154                         opkg_msg(NOTICE, "Package %s version %s has no "
 155                                  "valid architecture, ignoring.\n",
 156                                  pkg->name, version_str);
 157                         free(version_str);
 158                         continue;
 159                 }
 160
 161                 hash_insert_pkg(pkg, is_status_file);
 162
 163         } while (!feof(fp));
 164
 165         free(buf);
 166         fclose(fp);
 167
 168         if (src && src->gzip)
 169                 gzip_close(&zh);
 170
 171         return ret;
 172 }
 173
 174 /*
 175  * Load in feed files from the cached "src" and/or "src/gz" locations.
 176  */
 177 int pkg_hash_load_feeds(int state_flags)
 178 {
 179         pkg_src_list_elt_t *iter;
 180         pkg_src_t *src;
 181         char *list_file, *lists_dir;
 182
 183         opkg_msg(INFO, "\n");
 184
 185         lists_dir = conf->restrict_to_default_dest ?
 186             conf->default_dest->lists_dir : conf->lists_dir;
 187
 188         for (iter = void_list_first(&conf->pkg_src_list); iter;
 189              iter = void_list_next(&conf->pkg_src_list, iter)) {
 190
 191                 src = (pkg_src_t *) iter->data;
 192
 193                 sprintf_alloc(&list_file, "%s/%s", lists_dir, src->name);
 194
 195                 if (file_exists(list_file)) {
 196                         if (pkg_hash_add_from_file(list_file, src, NULL, 0, state_flags)) {
 197                                 free(list_file);
 198                                 return -1;
 199                         }
 200                 }
 201                 free(list_file);
 202         }
 203
 204         return 0;
 205 }
 206
 207 /*
 208  * Load in status files from the configured "dest"s.
 209  */
 210 int pkg_hash_load_status_files(void)
 211 {
 212         pkg_dest_list_elt_t *iter;
 213         pkg_dest_t *dest;
 214
 215         opkg_msg(INFO, "\n");
 216
 217         for (iter = void_list_first(&conf->pkg_dest_list); iter;
 218              iter = void_list_next(&conf->pkg_dest_list, iter)) {
 219
 220                 dest = (pkg_dest_t *) iter->data;
 221
 222                 if (file_exists(dest->status_file_name)) {
 223                         if (pkg_hash_add_from_file
 224                             (dest->status_file_name, NULL, dest, 1, SF_NEED_DETAIL))
 225                                 return -1;
 226                 }
 227         }
 228
 229         return 0;
 230 }
 231
 232 static void
 233 pkg_hash_load_package_details_helper(const char *pkg_name, void *entry, void *data)
 234 {
 235         int *count = data;
 236         abstract_pkg_t *ab_pkg = (abstract_pkg_t *) entry;
 237
 238         if (ab_pkg->state_flag & SF_NEED_DETAIL) {
 239                 if (ab_pkg->state_flag & SF_MARKED) {
 240                         opkg_msg(DEBUG, "skipping already seen flagged abpkg %s\n",
 241                                  ab_pkg->name);
 242                         return;
 243                 }
 244
 245                 opkg_msg(DEBUG, "found yet incomplete flagged abpkg %s\n",
 246                          ab_pkg->name);
 247
 248                 (*count)++;
 249                 ab_pkg->state_flag |= SF_MARKED;
 250         }
 251 }
 252
 253 int pkg_hash_load_package_details(void)
 254 {
 255         int n_need_detail;
 256
 257         while (1) {
 258                 pkg_hash_load_feeds(0);
 259
 260                 n_need_detail = 0;
 261                 hash_table_foreach(&conf->pkg_hash, pkg_hash_load_package_details_helper, &n_need_detail);
 262
 263                 if (n_need_detail > 0)
 264                         opkg_msg(DEBUG, "Found %d packages requiring details, reloading feeds\n", n_need_detail);
 265                 else
 266                         break;
 267         }
 268
 269         return 0;
 270 }
 271
 272 pkg_t *pkg_hash_fetch_best_installation_candidate(abstract_pkg_t * apkg,
 273                                                   int (*constraint_fcn) (pkg_t *
 274                                                                          pkg,
 275                                                                          void
 276                                                                          *cdata),
 277                                                   void *cdata, int quiet)
 278 {
 279         int i, j;
 280         int nprovides = 0;
 281         int nmatching = 0;
 282         int wrong_arch_found = 0;
 283         int arch_priority;
 284         pkg_vec_t *matching_pkgs;
 285         abstract_pkg_vec_t *matching_apkgs;
 286         abstract_pkg_vec_t *provided_apkg_vec;
 287         abstract_pkg_t **provided_apkgs;
 288         abstract_pkg_vec_t *providers;
 289         pkg_t *latest_installed_parent = NULL;
 290         pkg_t *latest_matching = NULL;
 291         pkg_t *priorized_matching = NULL;
 292         pkg_t *held_pkg = NULL;
 293         pkg_t *good_pkg_by_name = NULL;
 294
 295         if (apkg == NULL || apkg->provided_by == NULL
 296             || (apkg->provided_by->len == 0))
 297                 return NULL;
 298
 299         matching_pkgs = pkg_vec_alloc();
 300         matching_apkgs = abstract_pkg_vec_alloc();
 301         providers = abstract_pkg_vec_alloc();
 302
 303         opkg_msg(DEBUG, "Best installation candidate for %s:\n", apkg->name);
 304
 305         provided_apkg_vec = apkg->provided_by;
 306         nprovides = provided_apkg_vec->len;
 307         provided_apkgs = provided_apkg_vec->pkgs;
 308         if (nprovides > 1)
 309                 opkg_msg(DEBUG, "apkg=%s nprovides=%d.\n", apkg->name,
 310                          nprovides);
 311
 312         /* accumulate all the providers */
 313         for (i = 0; i < nprovides; i++) {
 314                 abstract_pkg_t *provider_apkg = provided_apkgs[i];
 315                 opkg_msg(DEBUG, "Adding %s to providers.\n",
 316                          provider_apkg->name);
 317                 abstract_pkg_vec_insert(providers, provider_apkg);
 318         }
 319         nprovides = providers->len;
 320
 321         for (i = 0; i < nprovides; i++) {
 322                 abstract_pkg_t *provider_apkg =
 323                     abstract_pkg_vec_get(providers, i);
 324                 abstract_pkg_t *replacement_apkg = NULL;
 325                 pkg_vec_t *vec;
 326
 327                 if (provider_apkg->replaced_by
 328                     && provider_apkg->replaced_by->len) {
 329                         replacement_apkg = provider_apkg->replaced_by->pkgs[0];
 330                         if (provider_apkg->replaced_by->len > 1) {
 331                                 opkg_msg(NOTICE, "Multiple replacers for %s, "
 332                                          "using first one (%s).\n",
 333                                          provider_apkg->name,
 334                                          replacement_apkg->name);
 335                         }
 336                 }
 337
 338                 if (replacement_apkg)
 339                         opkg_msg(DEBUG,
 340                                  "replacement_apkg=%s for provider_apkg=%s.\n",
 341                                  replacement_apkg->name, provider_apkg->name);
 342
 343                 if (replacement_apkg && (replacement_apkg != provider_apkg)) {
 344                         if (abstract_pkg_vec_contains
 345                             (providers, replacement_apkg))
 346                                 continue;
 347                         else
 348                                 provider_apkg = replacement_apkg;
 349                 }
 350
 351                 if (!(vec = provider_apkg->pkgs)) {
 352                         opkg_msg(DEBUG, "No pkgs for provider_apkg %s.\n",
 353                                  provider_apkg->name);
 354                         continue;
 355                 }
 356
 357                 /* now check for supported architecture */
 358                 {
 359                         int max_count = 0;
 360                         int found_apkg = 0;
 361
 362                         /* count packages matching max arch priority and keep track of last one */
 363                         for (j = 0; j < vec->len; j++) {
 364                                 pkg_t *maybe = vec->pkgs[j];
 365                                 arch_priority = pkg_get_arch_priority(maybe);
 366
 367                                 /* check if this package actually provides the requested
 368                                    abstract package */
 369                                 found_apkg = 0;
 370                                 provided_apkgs = pkg_get_ptr(maybe, PKG_PROVIDES);
 371
 372                                 while (provided_apkgs && *provided_apkgs) {
 373                                         if (!strcmp((*provided_apkgs)->name, apkg->name)) {
 374                                                 found_apkg = 1;
 375                                                 break;
 376                                         }
 377                                         provided_apkgs++;
 378                                 }
 379
 380                                 if (found_apkg == 0) {
 381                                         opkg_msg(DEBUG,
 382                                                 "%s version=%s skipped since it does not provide %s\n",
 383                                                 maybe->name, pkg_get_string(maybe, PKG_VERSION), apkg->name);
 384                                         continue;
 385                                 }
 386
 387                                 opkg_msg(DEBUG,
 388                                          "%s arch=%s arch_priority=%d version=%s.\n",
 389                                          maybe->name, pkg_get_architecture(maybe),
 390                                          arch_priority, pkg_get_string(maybe, PKG_VERSION));
 391                                 /* We make sure not to add the same package twice. Need to search for the reason why
 392                                    they show up twice sometimes. */
 393                                 if ((arch_priority > 0)
 394                                     &&
 395                                     (!pkg_vec_contains(matching_pkgs, maybe))) {
 396                                         max_count++;
 397                                         abstract_pkg_vec_insert(matching_apkgs,
 398                                                                 maybe->parent);
 399                                         pkg_vec_insert(matching_pkgs, maybe);
 400                                 }
 401                         }
 402
 403                         if (vec->len > 0 && matching_pkgs->len < 1)
 404                                 wrong_arch_found = 1;
 405                 }
 406         }
 407
 408         if (matching_pkgs->len < 1) {
 409                 if (wrong_arch_found)
 410                         opkg_msg(ERROR, "Packages for %s found, but"
 411                                  " incompatible with the architectures configured\n",
 412                                  apkg->name);
 413                 pkg_vec_free(matching_pkgs);
 414                 abstract_pkg_vec_free(matching_apkgs);
 415                 abstract_pkg_vec_free(providers);
 416                 return NULL;
 417         }
 418
 419         if (matching_pkgs->len > 1)
 420                 pkg_vec_sort(matching_pkgs,
 421                              pkg_name_version_and_architecture_compare);
 422         if (matching_apkgs->len > 1)
 423                 abstract_pkg_vec_sort(matching_apkgs, abstract_pkg_name_compare);
 424
 425         for (i = 0; i < matching_pkgs->len; i++) {
 426                 pkg_t *matching = matching_pkgs->pkgs[i];
 427                 if (constraint_fcn(matching, cdata)) {
 428                         opkg_msg(DEBUG, "Candidate: %s %s.\n",
 429                                  matching->name, pkg_get_string(matching, PKG_VERSION));
 430                         good_pkg_by_name = matching;
 431                         /* It has been provided by hand, so it is what user want */
 432                         if (matching->provided_by_hand == 1)
 433                                 break;
 434                 }
 435         }
 436
 437         for (i = 0; i < matching_pkgs->len; i++) {
 438                 pkg_t *matching = matching_pkgs->pkgs[i];
 439                 latest_matching = matching;
 440                 if (matching->parent->state_status == SS_INSTALLED
 441                     || matching->parent->state_status == SS_UNPACKED)
 442                         latest_installed_parent = matching;
 443                 if (matching->state_flag & (SF_HOLD | SF_PREFER)) {
 444                         if (held_pkg)
 445                                 opkg_msg(NOTICE,
 446                                          "Multiple packages (%s and %s) providing"
 447                                          " same name marked HOLD or PREFER. "
 448                                          "Using latest.\n", held_pkg->name,
 449                                          matching->name);
 450                         held_pkg = matching;
 451                 }
 452         }
 453
 454         if (!good_pkg_by_name && !held_pkg && !latest_installed_parent
 455             && matching_apkgs->len > 1 && !quiet) {
 456                 int prio = 0;
 457                 for (i = 0; i < matching_pkgs->len; i++) {
 458                         pkg_t *matching = matching_pkgs->pkgs[i];
 459                         arch_priority = pkg_get_arch_priority(matching);
 460                         if (arch_priority > prio) {
 461                                 priorized_matching = matching;
 462                                 prio = arch_priority;
 463                                 opkg_msg(DEBUG, "Match %s with priority %i.\n",
 464                                          matching->name, prio);
 465                         }
 466                 }
 467
 468         }
 469
 470         if (conf->verbosity >= INFO && matching_apkgs->len > 1) {
 471                 opkg_msg(INFO, "%d matching pkgs for apkg=%s:\n",
 472                          matching_pkgs->len, apkg->name);
 473                 for (i = 0; i < matching_pkgs->len; i++) {
 474                         pkg_t *matching = matching_pkgs->pkgs[i];
 475                         opkg_msg(INFO, "%s %s %s\n",
 476                                  matching->name, pkg_get_string(matching, PKG_VERSION),
 477                                  pkg_get_architecture(matching));
 478                 }
 479         }
 480
 481         nmatching = matching_apkgs->len;
 482
 483         pkg_vec_free(matching_pkgs);
 484         abstract_pkg_vec_free(matching_apkgs);
 485         abstract_pkg_vec_free(providers);
 486
 487         if (good_pkg_by_name) { /* We found a good candidate, we will install it */
 488                 return good_pkg_by_name;
 489         }
 490         if (held_pkg) {
 491                 opkg_msg(INFO, "Using held package %s.\n", held_pkg->name);
 492                 return held_pkg;
 493         }
 494         if (latest_installed_parent) {
 495                 opkg_msg(INFO,
 496                          "Using latest version of installed package %s.\n",
 497                          latest_installed_parent->name);
 498                 return latest_installed_parent;
 499         }
 500         if (priorized_matching) {
 501                 opkg_msg(INFO, "Using priorized matching %s %s %s.\n",
 502                          priorized_matching->name, pkg_get_string(priorized_matching, PKG_VERSION),
 503                          pkg_get_architecture(priorized_matching));
 504                 return priorized_matching;
 505         }
 506         if (nmatching > 1) {
 507                 opkg_msg(INFO, "No matching pkg out of %d matching_apkgs.\n",
 508                          nmatching);
 509                 return NULL;
 510         }
 511         if (latest_matching) {
 512                 opkg_msg(INFO, "Using latest matching %s %s %s.\n",
 513                          latest_matching->name, pkg_get_string(latest_matching, PKG_VERSION),
 514                          pkg_get_architecture(latest_matching));
 515                 return latest_matching;
 516         }
 517         return NULL;
 518 }
 519
 520 static int pkg_name_constraint_fcn(pkg_t * pkg, void *cdata)
 521 {
 522         const char *name = (const char *)cdata;
 523
 524         if (strcmp(pkg->name, name) == 0)
 525                 return 1;
 526         else
 527                 return 0;
 528 }
 529
 530 static pkg_vec_t *pkg_vec_fetch_by_name(const char *pkg_name)
 531 {
 532         abstract_pkg_t *ab_pkg;
 533
 534         if (!(ab_pkg = abstract_pkg_fetch_by_name(pkg_name)))
 535                 return NULL;
 536
 537         if (ab_pkg->pkgs)
 538                 return ab_pkg->pkgs;
 539
 540         if (ab_pkg->provided_by) {
 541                 abstract_pkg_t *abpkg =
 542                     abstract_pkg_vec_get(ab_pkg->provided_by, 0);
 543                 if (abpkg != NULL)
 544                         return abpkg->pkgs;
 545                 else
 546                         return ab_pkg->pkgs;
 547         }
 548
 549         return NULL;
 550 }
 551
 552 pkg_t *pkg_hash_fetch_best_installation_candidate_by_name(const char *name)
 553 {
 554         abstract_pkg_t *apkg = NULL;
 555
 556         if (!(apkg = abstract_pkg_fetch_by_name(name)))
 557                 return NULL;
 558
 559         return pkg_hash_fetch_best_installation_candidate(apkg,
 560                                                           pkg_name_constraint_fcn,
 561                                                           apkg->name, 0);
 562 }
 563
 564 pkg_t *pkg_hash_fetch_by_name_version(const char *pkg_name, const char *version)
 565 {
 566         pkg_vec_t *vec;
 567         int i;
 568         char *version_str = NULL;
 569
 570         if (!(vec = pkg_vec_fetch_by_name(pkg_name)))
 571                 return NULL;
 572
 573         for (i = 0; i < vec->len; i++) {
 574                 version_str = pkg_version_str_alloc(vec->pkgs[i]);
 575                 if (!strcmp(version_str, version)) {
 576                         free(version_str);
 577                         break;
 578                 }
 579                 free(version_str);
 580         }
 581
 582         if (i == vec->len)
 583                 return NULL;
 584
 585         return vec->pkgs[i];
 586 }
 587
 588 pkg_t *pkg_hash_fetch_installed_by_name_dest(const char *pkg_name,
 589                                              pkg_dest_t * dest)
 590 {
 591         pkg_vec_t *vec;
 592         int i;
 593
 594         if (!(vec = pkg_vec_fetch_by_name(pkg_name))) {
 595                 return NULL;
 596         }
 597
 598         for (i = 0; i < vec->len; i++)
 599                 if ((vec->pkgs[i]->state_status == SS_INSTALLED
 600                      || vec->pkgs[i]->state_status == SS_UNPACKED)
 601                     && vec->pkgs[i]->dest == dest) {
 602                         return vec->pkgs[i];
 603                 }
 604
 605         return NULL;
 606 }
 607
 608 pkg_t *pkg_hash_fetch_installed_by_name(const char *pkg_name)
 609 {
 610         pkg_vec_t *vec;
 611         int i;
 612
 613         if (!(vec = pkg_vec_fetch_by_name(pkg_name))) {
 614                 return NULL;
 615         }
 616
 617         for (i = 0; i < vec->len; i++) {
 618                 if (vec->pkgs[i]->state_status == SS_INSTALLED
 619                     || vec->pkgs[i]->state_status == SS_UNPACKED) {
 620                         return vec->pkgs[i];
 621                 }
 622         }
 623
 624         return NULL;
 625 }
 626
 627 static void
 628 pkg_hash_fetch_available_helper(const char *pkg_name, void *entry, void *data)
 629 {
 630         int j;
 631         abstract_pkg_t *ab_pkg = (abstract_pkg_t *) entry;
 632         pkg_vec_t *all = (pkg_vec_t *) data;
 633         pkg_vec_t *pkg_vec = ab_pkg->pkgs;
 634
 635         if (!pkg_vec)
 636                 return;
 637
 638         for (j = 0; j < pkg_vec->len; j++) {
 639                 pkg_t *pkg = pkg_vec->pkgs[j];
 640                 pkg_vec_insert(all, pkg);
 641         }
 642 }
 643
 644 void pkg_hash_fetch_available(pkg_vec_t * all)
 645 {
 646         hash_table_foreach(&conf->pkg_hash, pkg_hash_fetch_available_helper,
 647                            all);
 648 }
 649
 650 static void
 651 pkg_hash_fetch_all_installed_helper(const char *pkg_name, void *entry,
 652                                     void *data)
 653 {
 654         abstract_pkg_t *ab_pkg = (abstract_pkg_t *) entry;
 655         pkg_vec_t *all = (pkg_vec_t *) data;
 656         pkg_vec_t *pkg_vec = ab_pkg->pkgs;
 657         int j;
 658
 659         if (!pkg_vec)
 660                 return;
 661
 662         for (j = 0; j < pkg_vec->len; j++) {
 663                 pkg_t *pkg = pkg_vec->pkgs[j];
 664                 if (pkg->state_status == SS_INSTALLED
 665                     || pkg->state_status == SS_UNPACKED)
 666                         pkg_vec_insert(all, pkg);
 667         }
 668 }
 669
 670 void pkg_hash_fetch_all_installed(pkg_vec_t * all)
 671 {
 672         hash_table_foreach(&conf->pkg_hash, pkg_hash_fetch_all_installed_helper,
 673                            all);
 674 }
 675
 676 /*
 677  * This assumes that the abstract pkg doesn't exist.
 678  */
 679 static abstract_pkg_t *add_new_abstract_pkg_by_name(const char *pkg_name)
 680 {
 681         abstract_pkg_t *ab_pkg;
 682
 683         ab_pkg = abstract_pkg_new();
 684
 685         ab_pkg->name = xstrdup(pkg_name);
 686         hash_table_insert(&conf->pkg_hash, pkg_name, ab_pkg);
 687
 688         return ab_pkg;
 689 }
 690
 691 abstract_pkg_t *ensure_abstract_pkg_by_name(const char *pkg_name)
 692 {
 693         abstract_pkg_t *ab_pkg;
 694
 695         if (!(ab_pkg = abstract_pkg_fetch_by_name(pkg_name)))
 696                 ab_pkg = add_new_abstract_pkg_by_name(pkg_name);
 697
 698         return ab_pkg;
 699 }
 700
 701 void hash_insert_pkg(pkg_t * pkg, int set_status)
 702 {
 703         abstract_pkg_t *ab_pkg;
 704
 705         ab_pkg = ensure_abstract_pkg_by_name(pkg->name);
 706         if (!ab_pkg->pkgs)
 707                 ab_pkg->pkgs = pkg_vec_alloc();
 708
 709         if (pkg->state_status == SS_INSTALLED) {
 710                 ab_pkg->state_status = SS_INSTALLED;
 711         } else if (pkg->state_status == SS_UNPACKED) {
 712                 ab_pkg->state_status = SS_UNPACKED;
 713         }
 714
 715         buildDepends(pkg);
 716
 717         buildProvides(ab_pkg, pkg);
 718
 719         init_providelist(pkg, NULL);
 720
 721         /* Need to build the conflicts graph before replaces for correct
 722          * calculation of replaced_by relation.
 723          */
 724         buildConflicts(pkg);
 725
 726         buildReplaces(ab_pkg, pkg);
 727
 728         buildDependedUponBy(pkg, ab_pkg);
 729
 730         pkg_vec_insert_merge(ab_pkg->pkgs, pkg, set_status);
 731         pkg->parent = ab_pkg;
 732 }
 733
 734 static const char *strip_offline_root(const char *file_name)
 735 {
 736         unsigned int len;
 737
 738         if (conf->offline_root) {
 739                 len = strlen(conf->offline_root);
 740                 if (strncmp(file_name, conf->offline_root, len) == 0)
 741                         file_name += len;
 742         }
 743
 744         return file_name;
 745 }
 746
 747 void file_hash_remove(const char *file_name)
 748 {
 749         file_name = strip_offline_root(file_name);
 750         hash_table_remove(&conf->file_hash, file_name);
 751 }
 752
 753 pkg_t *file_hash_get_file_owner(const char *file_name)
 754 {
 755         file_name = strip_offline_root(file_name);
 756         return hash_table_get(&conf->file_hash, file_name);
 757 }
 758
 759 void file_hash_set_file_owner(const char *file_name, pkg_t * owning_pkg)
 760 {
 761         pkg_t *old_owning_pkg;
 762         int file_name_len = strlen(file_name);
 763
 764         if (file_name[file_name_len - 1] == '/')
 765                 return;
 766
 767         file_name = strip_offline_root(file_name);
 768
 769         old_owning_pkg = hash_table_get(&conf->file_hash, file_name);
 770         hash_table_insert(&conf->file_hash, file_name, owning_pkg);
 771
 772         if (old_owning_pkg) {
 773                 pkg_get_installed_files(old_owning_pkg);
 774                 str_list_remove_elt(old_owning_pkg->installed_files, file_name);
 775                 pkg_free_installed_files(old_owning_pkg);
 776
 777                 /* mark this package to have its filelist written */
 778                 old_owning_pkg->state_flag |= SF_FILELIST_CHANGED;
 779                 owning_pkg->state_flag |= SF_FILELIST_CHANGED;
 780         }
 781 }