src/pool.c

   1 /*
   2  * Copyright (c) 2007, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * pool.c
  10  *
  11  * The pool contains information about solvables
  12  * stored optimized for memory consumption and fast retrieval.
  13  */
  14
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <stdarg.h>
  18 #include <unistd.h>
  19 #include <string.h>
  20
  21 #include "pool.h"
  22 #include "repo.h"
  23 #include "poolid.h"
  24 #include "poolid_private.h"
  25 #include "poolarch.h"
  26 #include "util.h"
  27 #include "bitmap.h"
  28 #include "evr.h"
  29
  30 #define SOLVABLE_BLOCK  255
  31
  32 /*
  33  * list of string constants, so we can do pointer/Id instead of string comparison
  34  * index into array matches ID_xxx constants in pool.h
  35  */
  36
  37 static const char *initpool_data[] = {
  38   "<NULL>",                   // ID_NULL
  39   "",                         // ID_EMPTY
  40   "solvable:name",
  41   "solvable:arch",
  42   "solvable:evr",
  43   "solvable:vendor",
  44   "solvable:provides",
  45   "solvable:obsoletes",
  46   "solvable:conflicts",
  47   "solvable:requires",
  48   "solvable:recommends",
  49   "solvable:suggests",
  50   "solvable:supplements",
  51   "solvable:enhances",
  52   "solvable:freshens",
  53   "rpm:dbid",                          /* direct key into rpmdb */
  54   "solvable:prereqmarker",
  55   "solvable:filemarker",
  56   "namespace:installed",
  57   "namespace:modalias",
  58   "namespace:splitprovides",
  59   "namespace:language",
  60   "system:system",
  61   "src",
  62   "nosrc",
  63   "noarch",
  64   "repodata:external",
  65   "repodata:keys",
  66   "repodata:location",
  67   "repokey:type:void",
  68   "repokey:type:constant",
  69   "repokey:type:constantid",
  70   "repokey:type:id",
  71   "repokey:type:num",
  72   "repokey:type:num32",
  73   "repokey:type:dir",
  74   "repokey:type:str",
  75   "repokey:type:idarray",
  76   "repokey:type:relidarray",
  77   "repokey:type:dirstrarray",
  78   "repokey:type:dirnumnumarray",
  79
  80   "solvable:summary",
  81   "solvable:description",
  82   "solvable:authors",
  83   "solvable:group",
  84   "solvable:keywords",
  85   "solvable:license",
  86   "solvable:buildtime",
  87
  88   "solvable:eula",
  89   "solvable:messageins",
  90   "solvable:messagedel",
  91
  92   "solvable:installsize",
  93   "solvable:diskusage",
  94   "solvable:filelist",
  95
  96   "solvable:installtime",
  97
  98   "solvable:mediadir",
  99   "solvable:mediafile",
 100   "solvable:medianr",
 101   "solvable:downloadsize",
 102
 103   "solvable:sourcearch",
 104   "solvable:sourcename",
 105   "solvable:sourceevr",
 106
 107   "solvable:isvisible",                 /* from susetags */
 108
 109   "solvable:patchcategory",
 110
 111   0
 112 };
 113
 114 /* create pool */
 115 Pool *
 116 pool_create(void)
 117 {
 118   Pool *pool;
 119   Solvable *s;
 120
 121   pool = (Pool *)sat_calloc(1, sizeof(*pool));
 122
 123   stringpool_init (&pool->ss, initpool_data);
 124
 125   /* alloc space for ReDep 0 */
 126   pool->rels = sat_extend_resize(0, 1, sizeof(Reldep), REL_BLOCK);
 127   pool->nrels = 1;
 128   memset(pool->rels, 0, sizeof(Reldep));
 129
 130   /* alloc space for Solvable 0 and system solvable */
 131   pool->solvables = sat_extend_resize(0, 2, sizeof(Solvable), SOLVABLE_BLOCK);
 132   pool->nsolvables = 2;
 133   memset(pool->solvables, 0, 2 * sizeof(Solvable));
 134   s = pool->solvables + SYSTEMSOLVABLE;
 135   s->name = SYSTEM_SYSTEM;
 136   s->arch = ARCH_NOARCH;
 137   s->evr = ID_EMPTY;
 138
 139   queue_init(&pool->vendormap);
 140
 141   pool->debugmask = SAT_DEBUG_RESULT;   /* FIXME */
 142   return pool;
 143 }
 144
 145
 146 /* free all the resources of our pool */
 147 void
 148 pool_free(Pool *pool)
 149 {
 150   int i;
 151
 152   pool_freewhatprovides(pool);
 153   pool_freeidhashes(pool);
 154   repo_freeallrepos(pool, 1);
 155   sat_free(pool->id2arch);
 156   sat_free(pool->solvables);
 157   sat_free(pool->ss.stringspace);
 158   sat_free(pool->ss.strings);
 159   sat_free(pool->rels);
 160   queue_free(&pool->vendormap);
 161   for (i = 0; i < DEP2STRBUF; i++)
 162     sat_free(pool->dep2strbuf[i]);
 163   for (i = 0; i < pool->nlanguages; i++)
 164     free((char *)pool->languages[i]);
 165   sat_free(pool->languages);
 166   sat_free(pool->languagecache);
 167   sat_free(pool);
 168 }
 169
 170 Id
 171 pool_add_solvable(Pool *pool)
 172 {
 173   pool->solvables = sat_extend(pool->solvables, pool->nsolvables, 1, sizeof(Solvable), SOLVABLE_BLOCK);
 174   memset(pool->solvables + pool->nsolvables, 0, sizeof(Solvable));
 175   return pool->nsolvables++;
 176 }
 177
 178 Id
 179 pool_add_solvable_block(Pool *pool, int count)
 180 {
 181   Id nsolvables = pool->nsolvables;
 182   if (!count)
 183     return nsolvables;
 184   pool->solvables = sat_extend(pool->solvables, pool->nsolvables, count, sizeof(Solvable), SOLVABLE_BLOCK);
 185   memset(pool->solvables + nsolvables, 0, sizeof(Solvable) * count);
 186   pool->nsolvables += count;
 187   return nsolvables;
 188 }
 189
 190 void
 191 pool_free_solvable_block(Pool *pool, Id start, int count, int reuseids)
 192 {
 193   if (!count)
 194     return;
 195   if (reuseids && start + count == pool->nsolvables)
 196     {
 197       /* might want to shrink solvable array */
 198       pool->nsolvables = start;
 199       return;
 200     }
 201   memset(pool->solvables + start, 0, sizeof(Solvable) * count);
 202 }
 203
 204
 205 const char *
 206 solvable2str(Pool *pool, Solvable *s)
 207 {
 208   int l, nn = pool->dep2strn;
 209   const char *n, *e, *a;
 210   n = id2str(pool, s->name);
 211   e = id2str(pool, s->evr);
 212   a = id2str(pool, s->arch);
 213   l = strlen(n) + strlen(e) + strlen(a) + 3;
 214   if (l > pool->dep2strlen[nn])
 215     {
 216       pool->dep2strbuf[nn] = sat_realloc(pool->dep2strbuf[nn], l + 32);
 217       pool->dep2strlen[nn] = l + 32;
 218     }
 219   sprintf(pool->dep2strbuf[nn], "%s-%s.%s", n, e, a);
 220   pool->dep2strn = (nn + 1) % DEP2STRBUF;
 221   return pool->dep2strbuf[nn];
 222 }
 223
 224 static Pool *pool_shrink_whatprovides_sortcmp_data;
 225
 226 static int
 227 pool_shrink_whatprovides_sortcmp(const void *ap, const void *bp)
 228 {
 229   int r;
 230   Pool *pool = pool_shrink_whatprovides_sortcmp_data;
 231   Id oa, ob, *da, *db;
 232   oa = pool->whatprovides[*(Id *)ap];
 233   ob = pool->whatprovides[*(Id *)bp];
 234   if (oa == ob)
 235     return *(Id *)ap - *(Id *)bp;
 236   if (!oa)
 237     return -1;
 238   if (!ob)
 239     return 1;
 240   da = pool->whatprovidesdata + oa;
 241   db = pool->whatprovidesdata + ob;
 242   while (*db)
 243     if ((r = (*da++ - *db++)) != 0)
 244       return r;
 245   if (*da)
 246     return *da;
 247   return *(Id *)ap - *(Id *)bp;
 248 }
 249
 250 /*
 251  * pool_shrink_whatprovides  - unify whatprovides data
 252  *
 253  * whatprovides_rel must be empty for this to work!
 254  *
 255  */
 256 static void
 257 pool_shrink_whatprovides(Pool *pool)
 258 {
 259   Id i, id;
 260   Id *sorted;
 261   Id lastid, *last, *dp, *lp;
 262   Offset o;
 263   int r;
 264
 265   if (pool->ss.nstrings < 3)
 266     return;
 267   sorted = sat_malloc2(pool->ss.nstrings, sizeof(Id));
 268   for (id = 0; id < pool->ss.nstrings; id++)
 269     sorted[id] = id;
 270   pool_shrink_whatprovides_sortcmp_data = pool;
 271   qsort(sorted + 1, pool->ss.nstrings - 1, sizeof(Id), pool_shrink_whatprovides_sortcmp);
 272   last = 0;
 273   lastid = 0;
 274   for (i = 1; i < pool->ss.nstrings; i++)
 275     {
 276       id = sorted[i];
 277       o = pool->whatprovides[id];
 278       if (o == 0 || o == 1)
 279         continue;
 280       dp = pool->whatprovidesdata + o;
 281       if (last)
 282         {
 283           lp = last;
 284           while (*dp)
 285             if (*dp++ != *lp++)
 286               {
 287                 last = 0;
 288                 break;
 289               }
 290           if (last && *lp)
 291             last = 0;
 292           if (last)
 293             {
 294               pool->whatprovides[id] = -lastid;
 295               continue;
 296             }
 297         }
 298       last = pool->whatprovidesdata + o;
 299       lastid = id;
 300     }
 301   sat_free(sorted);
 302   dp = pool->whatprovidesdata + 2;
 303   for (id = 1; id < pool->ss.nstrings; id++)
 304     {
 305       o = pool->whatprovides[id];
 306       if (o == 0 || o == 1)
 307         continue;
 308       if ((Id)o < 0)
 309         {
 310           i = -(Id)o;
 311           if (i >= id)
 312             abort();
 313           pool->whatprovides[id] = pool->whatprovides[i];
 314           continue;
 315         }
 316       lp = pool->whatprovidesdata + o;
 317       if (lp < dp)
 318         abort();
 319       pool->whatprovides[id] = dp - pool->whatprovidesdata;
 320       while ((*dp++ = *lp++) != 0)
 321         ;
 322     }
 323   o = dp - pool->whatprovidesdata;
 324   POOL_DEBUG(SAT_DEBUG_STATS, "shrunk whatprovidesdata from %d to %d\n", pool->whatprovidesdataoff, o);
 325   if (pool->whatprovidesdataoff == o)
 326     return;
 327   r = pool->whatprovidesdataoff - o;
 328   pool->whatprovidesdataoff = o;
 329   pool->whatprovidesdata = sat_realloc(pool->whatprovidesdata, (o + pool->whatprovidesdataleft) * sizeof(Id));
 330   if (r > pool->whatprovidesdataleft)
 331     r = pool->whatprovidesdataleft;
 332   memset(pool->whatprovidesdata + o, 0, r * sizeof(Id));
 333 }
 334
 335
 336 /*
 337  * pool_createwhatprovides()
 338  *
 339  * create hashes over pool of solvables to ease provide lookups
 340  *
 341  */
 342 void
 343 pool_createwhatprovides(Pool *pool)
 344 {
 345   int i, num, np, extra;
 346   Offset off;
 347   Solvable *s;
 348   Id id;
 349   Offset *idp, n;
 350   Offset *whatprovides;
 351   Id *whatprovidesdata, *d;
 352
 353   POOL_DEBUG(SAT_DEBUG_STATS, "number of solvables: %d\n", pool->nsolvables);
 354   POOL_DEBUG(SAT_DEBUG_STATS, "number of ids: %d + %d\n", pool->ss.nstrings, pool->nrels);
 355
 356   pool_freeidhashes(pool);      /* XXX: should not be here! */
 357   pool_freewhatprovides(pool);
 358   num = pool->ss.nstrings;
 359   pool->whatprovides = whatprovides = sat_extend_resize(0, num, sizeof(Offset), WHATPROVIDES_BLOCK);
 360   memset(whatprovides, 0, num * sizeof(Offset));
 361   pool->whatprovides_rel = sat_extend_resize(0, pool->nrels, sizeof(Offset), WHATPROVIDES_BLOCK);
 362   memset(pool->whatprovides_rel, 0, pool->nrels * sizeof(Offset));
 363
 364   /* count providers for each name */
 365   for (i = 1; i < pool->nsolvables; i++)
 366     {
 367       Id *pp;
 368       s = pool->solvables + i;
 369       if (!s->provides)
 370         continue;
 371       if (!pool_installable(pool, s))
 372         continue;
 373       pp = s->repo->idarraydata + s->provides;
 374       while ((id = *pp++) != ID_NULL)
 375         {
 376           while (ISRELDEP(id))
 377             {
 378               Reldep *rd = GETRELDEP(pool, id);
 379               id = rd->name;
 380             }
 381           whatprovides[id]++;          /* inc count of providers */
 382         }
 383     }
 384
 385   off = 2;      /* first entry is undef, second is empty list */
 386   idp = whatprovides;
 387   np = 0;                              /* number of names provided */
 388   for (i = 0; i < num; i++, idp++)
 389     {
 390       n = *idp;
 391       if (!n)                          /* no providers */
 392         continue;
 393       *idp = off;                      /* move from counts to offsets into whatprovidesdata */
 394       off += n + 1;                    /* make space for all providers + terminating ID_NULL */
 395       np++;                            /* inc # of provider 'slots' */
 396     }
 397
 398   POOL_DEBUG(SAT_DEBUG_STATS, "provide ids: %d\n", np);
 399
 400   /* reserve some space for relation data */
 401   extra = 2 * pool->nrels;
 402   if (extra < 256)
 403     extra = 256;
 404
 405   POOL_DEBUG(SAT_DEBUG_STATS, "provide space needed: %d + %d\n", off, extra);
 406
 407   /* alloc space for all providers + extra */
 408   whatprovidesdata = sat_calloc(off + extra, sizeof(Id));
 409
 410   /* now fill data for all provides */
 411   for (i = 1; i < pool->nsolvables; i++)
 412     {
 413       Id *pp;
 414       s = pool->solvables + i;
 415       if (!s->provides)
 416         continue;
 417       if (!pool_installable(pool, s))
 418         continue;
 419
 420       /* for all provides of this solvable */
 421       pp = s->repo->idarraydata + s->provides;
 422       while ((id = *pp++) != 0)
 423         {
 424           while (ISRELDEP(id))
 425             {
 426               Reldep *rd = GETRELDEP(pool, id);
 427               id = rd->name;
 428             }
 429           d = whatprovidesdata + whatprovides[id];   /* offset into whatprovidesdata */
 430           if (*d)
 431             {
 432               d++;
 433               while (*d)               /* find free slot */
 434                 d++;
 435               if (d[-1] == i)
 436                 continue;
 437             }
 438           *d = i;                      /* put solvable Id into data */
 439         }
 440     }
 441   pool->whatprovidesdata = whatprovidesdata;
 442   pool->whatprovidesdataoff = off;
 443   pool->whatprovidesdataleft = extra;
 444   pool_shrink_whatprovides(pool);
 445 }
 446
 447 /*
 448  * free all of our whatprovides data
 449  * be careful, everything internalized with pool_queuetowhatprovides is gone, too
 450  */
 451 void
 452 pool_freewhatprovides(Pool *pool)
 453 {
 454   pool->whatprovides = sat_free(pool->whatprovides);
 455   pool->whatprovides_rel = sat_free(pool->whatprovides_rel);
 456   pool->whatprovidesdata = sat_free(pool->whatprovidesdata);
 457   pool->whatprovidesdataoff = 0;
 458   pool->whatprovidesdataleft = 0;
 459 }
 460
 461
 462 /******************************************************************************/
 463
 464 /*
 465  * pool_queuetowhatprovides  - add queue contents to whatprovidesdata
 466  *
 467  * on-demand filling of provider information
 468  * move queue data into whatprovidesdata
 469  * q: queue of Ids
 470  * returns: Offset into whatprovides
 471  *
 472  */
 473 Id
 474 pool_queuetowhatprovides(Pool *pool, Queue *q)
 475 {
 476   Offset off;
 477   int count = q->count;
 478
 479   if (count == 0)                      /* queue empty -> ID_EMPTY */
 480     return ID_EMPTY;
 481
 482   /* extend whatprovidesdata if needed, +1 for ID_NULL-termination */
 483   if (pool->whatprovidesdataleft < count + 1)
 484     {
 485       POOL_DEBUG(SAT_DEBUG_STATS, "growing provides hash data...\n");
 486       pool->whatprovidesdata = sat_realloc(pool->whatprovidesdata, (pool->whatprovidesdataoff + count + 4096) * sizeof(Id));
 487       pool->whatprovidesdataleft = count + 4096;
 488     }
 489
 490   /* copy queue to next free slot */
 491   off = pool->whatprovidesdataoff;
 492   memcpy(pool->whatprovidesdata + pool->whatprovidesdataoff, q->elements, count * sizeof(Id));
 493
 494   /* adapt count and ID_NULL-terminate */
 495   pool->whatprovidesdataoff += count;
 496   pool->whatprovidesdata[pool->whatprovidesdataoff++] = ID_NULL;
 497   pool->whatprovidesdataleft -= count + 1;
 498
 499   return (Id)off;
 500 }
 501
 502
 503 /*************************************************************************/
 504
 505 /*
 506  * addrelproviders
 507  *
 508  * add packages fulfilling the relation to whatprovides array
 509  * no exact providers, do range match
 510  *
 511  */
 512
 513 Id *
 514 pool_addrelproviders(Pool *pool, Id d)
 515 {
 516   Reldep *rd = GETRELDEP(pool, d);
 517   Reldep *prd;
 518   Queue plist;
 519   Id buf[16];
 520   Id name = rd->name;
 521   Id evr = rd->evr;
 522   int flags = rd->flags;
 523   Id pid, *pidp;
 524   Id p, *pp, *pp2, *pp3;
 525
 526   d = GETRELID(d);
 527   queue_init_buffer(&plist, buf, sizeof(buf)/sizeof(*buf));
 528   switch (flags)
 529     {
 530     case REL_AND:
 531     case REL_WITH:
 532       pp = pool_whatprovides(pool, name);
 533       pp2 = pool_whatprovides(pool, evr);
 534       while ((p = *pp++) != 0)
 535         {
 536           for (pp3 = pp2; *pp3;)
 537             if (*pp3++ == p)
 538               {
 539                 queue_push(&plist, p);
 540                 break;
 541               }
 542         }
 543       break;
 544     case REL_OR:
 545       pp = pool_whatprovides(pool, name);
 546       while ((p = *pp++) != 0)
 547         queue_push(&plist, p);
 548       pp = pool_whatprovides(pool, evr);
 549       while ((p = *pp++) != 0)
 550         queue_pushunique(&plist, p);
 551       break;
 552     case REL_NAMESPACE:
 553       if (pool->nscallback)
 554         {
 555           p = pool->nscallback(pool, pool->nscallbackdata, name, evr);
 556           if (p > 1)
 557             {
 558               queue_free(&plist);
 559               pool->whatprovides_rel[d] = p;
 560               return pool->whatprovidesdata + p;
 561             }
 562           if (p == 1)
 563             queue_push(&plist, SYSTEMSOLVABLE);
 564         }
 565       break;
 566     default:
 567       break;
 568     }
 569
 570   /* convert to whatprovides id */
 571 #if 0
 572   POOL_DEBUG(SAT_DEBUG_STATS, "addrelproviders: what provides %s?\n", dep2str(pool, name));
 573 #endif
 574   if (flags && flags < 8)
 575     {
 576       FOR_PROVIDES(p, pp, name)
 577         {
 578 #if 0
 579           POOL_DEBUG(DEBUG_1, "addrelproviders: checking package %s\n", id2str(pool, pool->p[p].name));
 580 #endif
 581           /* solvable p provides name in some rels */
 582           pidp = pool->solvables[p].repo->idarraydata + pool->solvables[p].provides;
 583           while ((pid = *pidp++) != 0)
 584             {
 585               int pflags;
 586               Id pevr;
 587
 588               if (pid == name)
 589                 {
 590 #ifdef DEBIAN_SEMANTICS
 591                   continue;             /* unversioned provides can
 592                                          * never match versioned deps */
 593 #else
 594                   break;                /* yes, provides all versions */
 595 #endif
 596                 }
 597               if (!ISRELDEP(pid))
 598                 continue;               /* wrong provides name */
 599               prd = GETRELDEP(pool, pid);
 600               if (prd->name != name)
 601                 continue;               /* wrong provides name */
 602               /* right package, both deps are rels */
 603               pflags = prd->flags;
 604               if (!pflags)
 605                 continue;
 606               if (flags == 7 || pflags == 7)
 607                 break; /* included */
 608               if ((pflags & flags & 5) != 0)
 609                 break; /* same direction, match */
 610               pevr = prd->evr;
 611               if (pevr == evr)
 612                 {
 613                   if ((pflags & flags & 2) != 0)
 614                     break; /* both have =, match */
 615                 }
 616               else
 617                 {
 618                   int f = flags == 5 ? 5 : flags == 2 ? pflags : (flags ^ 5) & (pflags | 5);
 619                   if ((f & (1 << (1 + evrcmp(pool, pevr, evr, EVRCMP_MATCH_RELEASE)))) != 0)
 620                     break;
 621                 }
 622             }
 623           if (!pid)
 624             continue;   /* no rel match */
 625           queue_push(&plist, p);
 626         }
 627       /* make our system solvable provide all unknown rpmlib() stuff */
 628       if (plist.count == 0 && !strncmp(id2str(pool, name), "rpmlib(", 7))
 629         queue_push(&plist, SYSTEMSOLVABLE);
 630     }
 631   /* add providers to whatprovides */
 632 #if 0
 633   POOL_DEBUG(SAT_DEBUG_STATS, "addrelproviders: adding %d packages to %d\n", plist.count, d);
 634 #endif
 635   pool->whatprovides_rel[d] = pool_queuetowhatprovides(pool, &plist);
 636   queue_free(&plist);
 637
 638   return pool->whatprovidesdata + pool->whatprovides_rel[d];
 639 }
 640
 641 /*************************************************************************/
 642
 643 void
 644 pool_debug(Pool *pool, int type, const char *format, ...)
 645 {
 646   va_list args;
 647   char buf[1024];
 648
 649   if ((type & (SAT_FATAL|SAT_ERROR)) == 0)
 650     {
 651       if ((pool->debugmask & type) == 0)
 652         return;
 653     }
 654   va_start(args, format);
 655   if (!pool->debugcallback)
 656     {
 657       if ((type & (SAT_FATAL|SAT_ERROR)) == 0)
 658         vprintf(format, args);
 659       else
 660         vfprintf(stderr, format, args);
 661       return;
 662     }
 663   vsnprintf(buf, sizeof(buf), format, args);
 664   pool->debugcallback(pool, pool->debugcallbackdata, type, buf);
 665 }
 666
 667 void
 668 pool_setdebuglevel(Pool *pool, int level)
 669 {
 670   int mask = SAT_DEBUG_RESULT;
 671   if (level > 0)
 672     mask |= SAT_DEBUG_STATS|SAT_DEBUG_ANALYZE|SAT_DEBUG_UNSOLVABLE;
 673   if (level > 1)
 674     mask |= SAT_DEBUG_JOB|SAT_DEBUG_SOLUTIONS|SAT_DEBUG_POLICY;
 675   if (level > 2)
 676     mask |= SAT_DEBUG_PROPAGATE;
 677   if (level > 3)
 678     mask |= SAT_DEBUG_RULE_CREATION;
 679   if (level > 4)
 680     mask |= SAT_DEBUG_SCHUBI;
 681   pool->debugmask = mask;
 682 }
 683
 684 /*************************************************************************/
 685
 686 struct searchfiles {
 687   Id *ids;
 688   char **dirs;
 689   char **names;
 690   int nfiles;
 691   Map seen;
 692 };
 693
 694 #define SEARCHFILES_BLOCK 127
 695
 696 static void
 697 pool_addfileprovides_dep(Pool *pool, Id *ida, struct searchfiles *sf, struct searchfiles *isf)
 698 {
 699   Id dep, sid;
 700   const char *s, *sr;
 701
 702   while ((dep = *ida++) != 0)
 703     {
 704       while (ISRELDEP(dep))
 705         {
 706           Reldep *rd;
 707           sid = pool->ss.nstrings + GETRELID(dep);
 708           if (MAPTST(&sf->seen, sid))
 709             {
 710               dep = 0;
 711               break;
 712             }
 713           MAPSET(&sf->seen, sid);
 714           rd = GETRELDEP(pool, dep);
 715           if (rd->flags < 8)
 716             dep = rd->name;
 717           else if (rd->flags == REL_NAMESPACE)
 718             {
 719               if (isf && (rd->name == NAMESPACE_INSTALLED || rd->name == NAMESPACE_SPLITPROVIDES))
 720                 {
 721                   sf = isf;
 722                   isf = 0;
 723                   if (MAPTST(&sf->seen, sid))
 724                     {
 725                       dep = 0;
 726                       break;
 727                     }
 728                   MAPSET(&sf->seen, sid);
 729                 }
 730               dep = rd->evr;
 731             }
 732           else
 733             {
 734               Id ids[2];
 735               ids[0] = rd->name;
 736               ids[1] = 0;
 737               pool_addfileprovides_dep(pool, ids, sf, isf);
 738               dep = rd->evr;
 739             }
 740         }
 741       if (!dep)
 742         continue;
 743       if (MAPTST(&sf->seen, dep))
 744         continue;
 745       MAPSET(&sf->seen, dep);
 746       s = id2str(pool, dep);
 747       if (*s != '/')
 748         continue;
 749       sf->ids = sat_extend(sf->ids, sf->nfiles, 1, sizeof(const char *), SEARCHFILES_BLOCK);
 750       sf->dirs = sat_extend(sf->dirs, sf->nfiles, 1, sizeof(const char *), SEARCHFILES_BLOCK);
 751       sf->names = sat_extend(sf->names, sf->nfiles, 1, sizeof(const char *), SEARCHFILES_BLOCK);
 752       sf->ids[sf->nfiles] = dep;
 753       sr = strrchr(s, '/');
 754       sf->names[sf->nfiles] = strdup(sr + 1);
 755       sf->dirs[sf->nfiles] = sat_malloc(sr - s + 1);
 756       if (sr != s)
 757         strncpy(sf->dirs[sf->nfiles], s, sr - s);
 758       sf->dirs[sf->nfiles][sr - s] = 0;
 759       sf->nfiles++;
 760     }
 761 }
 762
 763 struct addfileprovides_cbdata {
 764   int nfiles;
 765   Id *ids;
 766   char **dirs;
 767   char **names;
 768
 769   Repodata *olddata;
 770   Id *dids;
 771   Map useddirs;
 772 };
 773
 774 static int
 775 addfileprovides_cb(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *value)
 776 {
 777   struct addfileprovides_cbdata *cbd = cbdata;
 778   int i;
 779
 780   if (data != cbd->olddata)
 781     {
 782       map_free(&cbd->useddirs);
 783       map_init(&cbd->useddirs, data->dirpool.ndirs);
 784       for (i = 0; i < cbd->nfiles; i++)
 785         {
 786           Id did = repodata_str2dir(data, cbd->dirs[i], 0);
 787           cbd->dids[i] = did;
 788           if (did)
 789             MAPSET(&cbd->useddirs, did);
 790         }
 791       cbd->olddata = data;
 792     }
 793   if (!MAPTST(&cbd->useddirs, value->id))
 794     return 0;
 795   for (i = 0; i < cbd->nfiles; i++)
 796     {
 797       if (cbd->dids[i] != value->id)
 798         continue;
 799       if (!strcmp(cbd->names[i], value->str))
 800         break;
 801     }
 802   if (i == cbd->nfiles)
 803     return 0;
 804   s->provides = repo_addid_dep(s->repo, s->provides, cbd->ids[i], SOLVABLE_FILEMARKER);
 805   return 0;
 806 }
 807
 808 void
 809 pool_addfileprovides(Pool *pool, Repo *installed)
 810 {
 811   Solvable *s;
 812   Repo *repo;
 813   struct searchfiles sf, isf;
 814   struct addfileprovides_cbdata cbd;
 815   int i;
 816
 817   memset(&sf, 0, sizeof(sf));
 818   map_init(&sf.seen, pool->ss.nstrings + pool->nrels);
 819   memset(&isf, 0, sizeof(isf));
 820   map_init(&isf.seen, pool->ss.nstrings + pool->nrels);
 821
 822   for (i = 1, s = pool->solvables + i; i < pool->nsolvables; i++, s++)
 823     {
 824       repo = s->repo;
 825       if (!repo)
 826         continue;
 827       if (s->obsoletes)
 828         pool_addfileprovides_dep(pool, repo->idarraydata + s->obsoletes, &sf, &isf);
 829       if (s->conflicts)
 830         pool_addfileprovides_dep(pool, repo->idarraydata + s->conflicts, &sf, &isf);
 831       if (s->requires)
 832         pool_addfileprovides_dep(pool, repo->idarraydata + s->requires, &sf, &isf);
 833       if (s->recommends)
 834         pool_addfileprovides_dep(pool, repo->idarraydata + s->recommends, &sf, &isf);
 835       if (s->suggests)
 836         pool_addfileprovides_dep(pool, repo->idarraydata + s->suggests, &sf, &isf);
 837       if (s->supplements)
 838         pool_addfileprovides_dep(pool, repo->idarraydata + s->supplements, &sf, &isf);
 839       if (s->enhances)
 840         pool_addfileprovides_dep(pool, repo->idarraydata + s->enhances, &sf, &isf);
 841       if (s->freshens)
 842         pool_addfileprovides_dep(pool, repo->idarraydata + s->freshens, &sf, &isf);
 843     }
 844   map_free(&sf.seen);
 845   map_free(&isf.seen);
 846   POOL_DEBUG(SAT_DEBUG_STATS, "found %d file dependencies\n", sf.nfiles);
 847   POOL_DEBUG(SAT_DEBUG_STATS, "found %d installed file dependencies\n", isf.nfiles);
 848   cbd.dids = 0;
 849   map_init(&cbd.useddirs, 1);
 850   if (sf.nfiles)
 851     {
 852 #if 0
 853       for (i = 0; i < sf.nfiles; i++)
 854         POOL_DEBUG(SAT_DEBUG_STATS, "looking up %s in filelist\n", id2str(pool, sf.ids[i]));
 855 #endif
 856       cbd.nfiles = sf.nfiles;
 857       cbd.ids = sf.ids;
 858       cbd.dirs = sf.dirs;
 859       cbd.names = sf.names;
 860       cbd.olddata = 0;
 861       cbd.dids = sat_realloc2(cbd.dids, sf.nfiles, sizeof(Id));
 862       pool_search(pool, 0, SOLVABLE_FILELIST, 0, 0, addfileprovides_cb, &cbd);
 863       sat_free(sf.ids);
 864       for (i = 0; i < sf.nfiles; i++)
 865         {
 866           sat_free(sf.dirs[i]);
 867           sat_free(sf.names[i]);
 868         }
 869       sat_free(sf.dirs);
 870       sat_free(sf.names);
 871     }
 872   if (isf.nfiles && installed)
 873     {
 874 #if 0
 875       for (i = 0; i < isf.nfiles; i++)
 876         POOL_DEBUG(SAT_DEBUG_STATS, "looking up %s in installed filelist\n", id2str(pool, isf.ids[i]));
 877 #endif
 878       cbd.nfiles = isf.nfiles;
 879       cbd.ids = isf.ids;
 880       cbd.dirs = isf.dirs;
 881       cbd.names = isf.names;
 882       cbd.olddata = 0;
 883       cbd.dids = sat_realloc2(cbd.dids, isf.nfiles, sizeof(Id));
 884       repo_search(installed, 0, SOLVABLE_FILELIST, 0, 0, addfileprovides_cb, &cbd);
 885       sat_free(isf.ids);
 886       for (i = 0; i < isf.nfiles; i++)
 887         {
 888           sat_free(isf.dirs[i]);
 889           sat_free(isf.names[i]);
 890         }
 891       sat_free(isf.dirs);
 892       sat_free(isf.names);
 893     }
 894   map_free(&cbd.useddirs);
 895   sat_free(cbd.dids);
 896   pool_freewhatprovides(pool);  /* as we have added provides */
 897 }
 898
 899 void
 900 pool_search(Pool *pool, Id p, Id key, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, struct _Repodata *data, struct _Repokey *key, struct _KeyValue *kv), void *cbdata)
 901 {
 902   if (p)
 903     {
 904       if (pool->solvables[p].repo)
 905         repo_search(pool->solvables[p].repo, p, key, match, flags, callback, cbdata);
 906       return;
 907     }
 908   /* FIXME: obey callback return value! */
 909   for (p = 1; p < pool->nsolvables; p++)
 910     if (pool->solvables[p].repo)
 911       repo_search(pool->solvables[p].repo, p, key, match, flags, callback, cbdata);
 912 }
 913
 914
 915 void
 916 pool_set_languages(Pool *pool, const char **languages, int nlanguages)
 917 {
 918   int i;
 919
 920   pool->languagecache = sat_free(pool->languagecache);
 921   pool->languagecacheother = 0;
 922   if (pool->nlanguages)
 923     {
 924       for (i = 0; i < pool->nlanguages; i++)
 925         free((char *)pool->languages[i]);
 926       free(pool->languages);
 927     }
 928   pool->nlanguages = nlanguages;
 929   if (!nlanguages)
 930     return;
 931   pool->languages = sat_calloc(nlanguages, sizeof(const char **));
 932   for (i = 0; i < pool->nlanguages; i++)
 933     pool->languages[i] = strdup(languages[i]);
 934 }
 935
 936 // EOF