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);
 167 }
 168
 169 Id
 170 pool_add_solvable(Pool *pool)
 171 {
 172   pool->solvables = sat_extend(pool->solvables, pool->nsolvables, 1, sizeof(Solvable), SOLVABLE_BLOCK);
 173   memset(pool->solvables + pool->nsolvables, 0, sizeof(Solvable));
 174   return pool->nsolvables++;
 175 }
 176
 177 Id
 178 pool_add_solvable_block(Pool *pool, int count)
 179 {
 180   Id nsolvables = pool->nsolvables;
 181   if (!count)
 182     return nsolvables;
 183   pool->solvables = sat_extend(pool->solvables, pool->nsolvables, count, sizeof(Solvable), SOLVABLE_BLOCK);
 184   memset(pool->solvables + nsolvables, 0, sizeof(Solvable) * count);
 185   pool->nsolvables += count;
 186   return nsolvables;
 187 }
 188
 189 void
 190 pool_free_solvable_block(Pool *pool, Id start, int count, int reuseids)
 191 {
 192   if (!count)
 193     return;
 194   if (reuseids && start + count == pool->nsolvables)
 195     {
 196       /* might want to shrink solvable array */
 197       pool->nsolvables = start;
 198       return;
 199     }
 200   memset(pool->solvables + start, 0, sizeof(Solvable) * count);
 201 }
 202
 203
 204 const char *
 205 solvable2str(Pool *pool, Solvable *s)
 206 {
 207   int l, nn = pool->dep2strn;
 208   const char *n, *e, *a;
 209   n = id2str(pool, s->name);
 210   e = id2str(pool, s->evr);
 211   a = id2str(pool, s->arch);
 212   l = strlen(n) + strlen(e) + strlen(a) + 3;
 213   if (l > pool->dep2strlen[nn])
 214     {
 215       pool->dep2strbuf[nn] = sat_realloc(pool->dep2strbuf[nn], l + 32);
 216       pool->dep2strlen[nn] = l + 32;
 217     }
 218   sprintf(pool->dep2strbuf[nn], "%s-%s.%s", n, e, a);
 219   pool->dep2strn = (nn + 1) % DEP2STRBUF;
 220   return pool->dep2strbuf[nn];
 221 }
 222
 223 static Pool *pool_shrink_whatprovides_sortcmp_data;
 224
 225 static int
 226 pool_shrink_whatprovides_sortcmp(const void *ap, const void *bp)
 227 {
 228   int r;
 229   Pool *pool = pool_shrink_whatprovides_sortcmp_data;
 230   Id oa, ob, *da, *db;
 231   oa = pool->whatprovides[*(Id *)ap];
 232   ob = pool->whatprovides[*(Id *)bp];
 233   if (oa == ob)
 234     return *(Id *)ap - *(Id *)bp;
 235   if (!oa)
 236     return -1;
 237   if (!ob)
 238     return 1;
 239   da = pool->whatprovidesdata + oa;
 240   db = pool->whatprovidesdata + ob;
 241   while (*db)
 242     if ((r = (*da++ - *db++)) != 0)
 243       return r;
 244   if (*da)
 245     return *da;
 246   return *(Id *)ap - *(Id *)bp;
 247 }
 248
 249 /*
 250  * pool_shrink_whatprovides  - unify whatprovides data
 251  *
 252  * whatprovides_rel must be empty for this to work!
 253  *
 254  */
 255 static void
 256 pool_shrink_whatprovides(Pool *pool)
 257 {
 258   Id i, id;
 259   Id *sorted;
 260   Id lastid, *last, *dp, *lp;
 261   Offset o;
 262   int r;
 263
 264   if (pool->ss.nstrings < 3)
 265     return;
 266   sorted = sat_malloc2(pool->ss.nstrings, sizeof(Id));
 267   for (id = 0; id < pool->ss.nstrings; id++)
 268     sorted[id] = id;
 269   pool_shrink_whatprovides_sortcmp_data = pool;
 270   qsort(sorted + 1, pool->ss.nstrings - 1, sizeof(Id), pool_shrink_whatprovides_sortcmp);
 271   last = 0;
 272   lastid = 0;
 273   for (i = 1; i < pool->ss.nstrings; i++)
 274     {
 275       id = sorted[i];
 276       o = pool->whatprovides[id];
 277       if (o == 0 || o == 1)
 278         continue;
 279       dp = pool->whatprovidesdata + o;
 280       if (last)
 281         {
 282           lp = last;
 283           while (*dp)
 284             if (*dp++ != *lp++)
 285               {
 286                 last = 0;
 287                 break;
 288               }
 289           if (last && *lp)
 290             last = 0;
 291           if (last)
 292             {
 293               pool->whatprovides[id] = -lastid;
 294               continue;
 295             }
 296         }
 297       last = pool->whatprovidesdata + o;
 298       lastid = id;
 299     }
 300   sat_free(sorted);
 301   dp = pool->whatprovidesdata + 2;
 302   for (id = 1; id < pool->ss.nstrings; id++)
 303     {
 304       o = pool->whatprovides[id];
 305       if (o == 0 || o == 1)
 306         continue;
 307       if ((Id)o < 0)
 308         {
 309           i = -(Id)o;
 310           if (i >= id)
 311             abort();
 312           pool->whatprovides[id] = pool->whatprovides[i];
 313           continue;
 314         }
 315       lp = pool->whatprovidesdata + o;
 316       if (lp < dp)
 317         abort();
 318       pool->whatprovides[id] = dp - pool->whatprovidesdata;
 319       while ((*dp++ = *lp++) != 0)
 320         ;
 321     }
 322   o = dp - pool->whatprovidesdata;
 323   POOL_DEBUG(SAT_DEBUG_STATS, "shrunk whatprovidesdata from %d to %d\n", pool->whatprovidesdataoff, o);
 324   if (pool->whatprovidesdataoff == o)
 325     return;
 326   r = pool->whatprovidesdataoff - o;
 327   pool->whatprovidesdataoff = o;
 328   pool->whatprovidesdata = sat_realloc(pool->whatprovidesdata, (o + pool->whatprovidesdataleft) * sizeof(Id));
 329   if (r > pool->whatprovidesdataleft)
 330     r = pool->whatprovidesdataleft;
 331   memset(pool->whatprovidesdata + o, 0, r * sizeof(Id));
 332 }
 333
 334
 335 /*
 336  * pool_createwhatprovides()
 337  *
 338  * create hashes over pool of solvables to ease provide lookups
 339  *
 340  */
 341 void
 342 pool_createwhatprovides(Pool *pool)
 343 {
 344   int i, num, np, extra;
 345   Offset off;
 346   Solvable *s;
 347   Id id;
 348   Offset *idp, n;
 349   Offset *whatprovides;
 350   Id *whatprovidesdata, *d;
 351
 352   POOL_DEBUG(SAT_DEBUG_STATS, "number of solvables: %d\n", pool->nsolvables);
 353   POOL_DEBUG(SAT_DEBUG_STATS, "number of ids: %d + %d\n", pool->ss.nstrings, pool->nrels);
 354
 355   pool_freeidhashes(pool);      /* XXX: should not be here! */
 356   pool_freewhatprovides(pool);
 357   num = pool->ss.nstrings;
 358   pool->whatprovides = whatprovides = sat_extend_resize(0, num, sizeof(Offset), WHATPROVIDES_BLOCK);
 359   memset(whatprovides, 0, num * sizeof(Offset));
 360   pool->whatprovides_rel = sat_extend_resize(0, pool->nrels, sizeof(Offset), WHATPROVIDES_BLOCK);
 361   memset(pool->whatprovides_rel, 0, pool->nrels * sizeof(Offset));
 362
 363   /* count providers for each name */
 364   for (i = 1; i < pool->nsolvables; i++)
 365     {
 366       Id *pp;
 367       s = pool->solvables + i;
 368       if (!s->provides)
 369         continue;
 370       if (!pool_installable(pool, s))
 371         continue;
 372       pp = s->repo->idarraydata + s->provides;
 373       while ((id = *pp++) != ID_NULL)
 374         {
 375           while (ISRELDEP(id))
 376             {
 377               Reldep *rd = GETRELDEP(pool, id);
 378               id = rd->name;
 379             }
 380           whatprovides[id]++;          /* inc count of providers */
 381         }
 382     }
 383
 384   off = 2;      /* first entry is undef, second is empty list */
 385   idp = whatprovides;
 386   np = 0;                              /* number of names provided */
 387   for (i = 0; i < num; i++, idp++)
 388     {
 389       n = *idp;
 390       if (!n)                          /* no providers */
 391         continue;
 392       *idp = off;                      /* move from counts to offsets into whatprovidesdata */
 393       off += n + 1;                    /* make space for all providers + terminating ID_NULL */
 394       np++;                            /* inc # of provider 'slots' */
 395     }
 396
 397   POOL_DEBUG(SAT_DEBUG_STATS, "provide ids: %d\n", np);
 398
 399   /* reserve some space for relation data */
 400   extra = 2 * pool->nrels;
 401   if (extra < 256)
 402     extra = 256;
 403
 404   POOL_DEBUG(SAT_DEBUG_STATS, "provide space needed: %d + %d\n", off, extra);
 405
 406   /* alloc space for all providers + extra */
 407   whatprovidesdata = sat_calloc(off + extra, sizeof(Id));
 408
 409   /* now fill data for all provides */
 410   for (i = 1; i < pool->nsolvables; i++)
 411     {
 412       Id *pp;
 413       s = pool->solvables + i;
 414       if (!s->provides)
 415         continue;
 416       if (!pool_installable(pool, s))
 417         continue;
 418
 419       /* for all provides of this solvable */
 420       pp = s->repo->idarraydata + s->provides;
 421       while ((id = *pp++) != 0)
 422         {
 423           while (ISRELDEP(id))
 424             {
 425               Reldep *rd = GETRELDEP(pool, id);
 426               id = rd->name;
 427             }
 428           d = whatprovidesdata + whatprovides[id];   /* offset into whatprovidesdata */
 429           if (*d)
 430             {
 431               d++;
 432               while (*d)               /* find free slot */
 433                 d++;
 434               if (d[-1] == i)
 435                 continue;
 436             }
 437           *d = i;                      /* put solvable Id into data */
 438         }
 439     }
 440   pool->whatprovidesdata = whatprovidesdata;
 441   pool->whatprovidesdataoff = off;
 442   pool->whatprovidesdataleft = extra;
 443   pool_shrink_whatprovides(pool);
 444 }
 445
 446 /*
 447  * free all of our whatprovides data
 448  * be careful, everything internalized with pool_queuetowhatprovides is gone, too
 449  */
 450 void
 451 pool_freewhatprovides(Pool *pool)
 452 {
 453   pool->whatprovides = sat_free(pool->whatprovides);
 454   pool->whatprovides_rel = sat_free(pool->whatprovides_rel);
 455   pool->whatprovidesdata = sat_free(pool->whatprovidesdata);
 456   pool->whatprovidesdataoff = 0;
 457   pool->whatprovidesdataleft = 0;
 458 }
 459
 460
 461 /******************************************************************************/
 462
 463 /*
 464  * pool_queuetowhatprovides  - add queue contents to whatprovidesdata
 465  *
 466  * on-demand filling of provider information
 467  * move queue data into whatprovidesdata
 468  * q: queue of Ids
 469  * returns: Offset into whatprovides
 470  *
 471  */
 472 Id
 473 pool_queuetowhatprovides(Pool *pool, Queue *q)
 474 {
 475   Offset off;
 476   int count = q->count;
 477
 478   if (count == 0)                      /* queue empty -> ID_EMPTY */
 479     return ID_EMPTY;
 480
 481   /* extend whatprovidesdata if needed, +1 for ID_NULL-termination */
 482   if (pool->whatprovidesdataleft < count + 1)
 483     {
 484       POOL_DEBUG(SAT_DEBUG_STATS, "growing provides hash data...\n");
 485       pool->whatprovidesdata = sat_realloc(pool->whatprovidesdata, (pool->whatprovidesdataoff + count + 4096) * sizeof(Id));
 486       pool->whatprovidesdataleft = count + 4096;
 487     }
 488
 489   /* copy queue to next free slot */
 490   off = pool->whatprovidesdataoff;
 491   memcpy(pool->whatprovidesdata + pool->whatprovidesdataoff, q->elements, count * sizeof(Id));
 492
 493   /* adapt count and ID_NULL-terminate */
 494   pool->whatprovidesdataoff += count;
 495   pool->whatprovidesdata[pool->whatprovidesdataoff++] = ID_NULL;
 496   pool->whatprovidesdataleft -= count + 1;
 497
 498   return (Id)off;
 499 }
 500
 501
 502 /*************************************************************************/
 503
 504 /*
 505  * addrelproviders
 506  *
 507  * add packages fulfilling the relation to whatprovides array
 508  * no exact providers, do range match
 509  *
 510  */
 511
 512 Id *
 513 pool_addrelproviders(Pool *pool, Id d)
 514 {
 515   Reldep *rd = GETRELDEP(pool, d);
 516   Reldep *prd;
 517   Queue plist;
 518   Id buf[16];
 519   Id name = rd->name;
 520   Id evr = rd->evr;
 521   int flags = rd->flags;
 522   Id pid, *pidp;
 523   Id p, *pp, *pp2, *pp3;
 524
 525   d = GETRELID(d);
 526   queue_init_buffer(&plist, buf, sizeof(buf)/sizeof(*buf));
 527   switch (flags)
 528     {
 529     case REL_AND:
 530     case REL_WITH:
 531       pp = pool_whatprovides(pool, name);
 532       pp2 = pool_whatprovides(pool, evr);
 533       while ((p = *pp++) != 0)
 534         {
 535           for (pp3 = pp2; *pp3;)
 536             if (*pp3++ == p)
 537               {
 538                 queue_push(&plist, p);
 539                 break;
 540               }
 541         }
 542       break;
 543     case REL_OR:
 544       pp = pool_whatprovides(pool, name);
 545       while ((p = *pp++) != 0)
 546         queue_push(&plist, p);
 547       pp = pool_whatprovides(pool, evr);
 548       while ((p = *pp++) != 0)
 549         queue_pushunique(&plist, p);
 550       break;
 551     case REL_NAMESPACE:
 552       if (pool->nscallback)
 553         {
 554           p = pool->nscallback(pool, pool->nscallbackdata, name, evr);
 555           if (p > 1)
 556             {
 557               queue_free(&plist);
 558               pool->whatprovides_rel[d] = p;
 559               return pool->whatprovidesdata + p;
 560             }
 561           if (p == 1)
 562             queue_push(&plist, SYSTEMSOLVABLE);
 563         }
 564       break;
 565     default:
 566       break;
 567     }
 568
 569   /* convert to whatprovides id */
 570 #if 0
 571   POOL_DEBUG(SAT_DEBUG_STATS, "addrelproviders: what provides %s?\n", dep2str(pool, name));
 572 #endif
 573   if (flags && flags < 8)
 574     {
 575       FOR_PROVIDES(p, pp, name)
 576         {
 577 #if 0
 578           POOL_DEBUG(DEBUG_1, "addrelproviders: checking package %s\n", id2str(pool, pool->p[p].name));
 579 #endif
 580           /* solvable p provides name in some rels */
 581           pidp = pool->solvables[p].repo->idarraydata + pool->solvables[p].provides;
 582           while ((pid = *pidp++) != 0)
 583             {
 584               int pflags;
 585               Id pevr;
 586
 587               if (pid == name)
 588                 {
 589 #ifdef DEBIAN_SEMANTICS
 590                   continue;             /* unversioned provides can
 591                                          * never match versioned deps */
 592 #else
 593                   break;                /* yes, provides all versions */
 594 #endif
 595                 }
 596               if (!ISRELDEP(pid))
 597                 continue;               /* wrong provides name */
 598               prd = GETRELDEP(pool, pid);
 599               if (prd->name != name)
 600                 continue;               /* wrong provides name */
 601               /* right package, both deps are rels */
 602               pflags = prd->flags;
 603               if (!pflags)
 604                 continue;
 605               if (flags == 7 || pflags == 7)
 606                 break; /* included */
 607               if ((pflags & flags & 5) != 0)
 608                 break; /* same direction, match */
 609               pevr = prd->evr;
 610               if (pevr == evr)
 611                 {
 612                   if ((pflags & flags & 2) != 0)
 613                     break; /* both have =, match */
 614                 }
 615               else
 616                 {
 617                   int f = flags == 5 ? 5 : flags == 2 ? pflags : (flags ^ 5) & (pflags | 5);
 618                   if ((f & (1 << (1 + evrcmp(pool, pevr, evr, EVRCMP_MATCH_RELEASE)))) != 0)
 619                     break;
 620                 }
 621             }
 622           if (!pid)
 623             continue;   /* no rel match */
 624           queue_push(&plist, p);
 625         }
 626       /* make our system solvable provide all unknown rpmlib() stuff */
 627       if (plist.count == 0 && !strncmp(id2str(pool, name), "rpmlib(", 7))
 628         queue_push(&plist, SYSTEMSOLVABLE);
 629     }
 630   /* add providers to whatprovides */
 631 #if 0
 632   POOL_DEBUG(SAT_DEBUG_STATS, "addrelproviders: adding %d packages to %d\n", plist.count, d);
 633 #endif
 634   pool->whatprovides_rel[d] = pool_queuetowhatprovides(pool, &plist);
 635   queue_free(&plist);
 636
 637   return pool->whatprovidesdata + pool->whatprovides_rel[d];
 638 }
 639
 640 /*************************************************************************/
 641
 642 void
 643 pool_debug(Pool *pool, int type, const char *format, ...)
 644 {
 645   va_list args;
 646   char buf[1024];
 647
 648   if ((type & (SAT_FATAL|SAT_ERROR)) == 0)
 649     {
 650       if ((pool->debugmask & type) == 0)
 651         return;
 652     }
 653   va_start(args, format);
 654   if (!pool->debugcallback)
 655     {
 656       if ((type & (SAT_FATAL|SAT_ERROR)) == 0)
 657         vprintf(format, args);
 658       else
 659         vfprintf(stderr, format, args);
 660       return;
 661     }
 662   vsnprintf(buf, sizeof(buf), format, args);
 663   pool->debugcallback(pool, pool->debugcallbackdata, type, buf);
 664 }
 665
 666 void
 667 pool_setdebuglevel(Pool *pool, int level)
 668 {
 669   int mask = SAT_DEBUG_RESULT;
 670   if (level > 0)
 671     mask |= SAT_DEBUG_STATS|SAT_DEBUG_ANALYZE|SAT_DEBUG_UNSOLVABLE;
 672   if (level > 1)
 673     mask |= SAT_DEBUG_JOB|SAT_DEBUG_SOLUTIONS|SAT_DEBUG_POLICY;
 674   if (level > 2)
 675     mask |= SAT_DEBUG_PROPAGATE;
 676   if (level > 3)
 677     mask |= SAT_DEBUG_RULE_CREATION;
 678   if (level > 4)
 679     mask |= SAT_DEBUG_SCHUBI;
 680   pool->debugmask = mask;
 681 }
 682
 683 /*************************************************************************/
 684
 685 struct searchfiles {
 686   Id *ids;
 687   char **dirs;
 688   char **names;
 689   int nfiles;
 690   Map seen;
 691 };
 692
 693 #define SEARCHFILES_BLOCK 127
 694
 695 static void
 696 pool_addfileprovides_dep(Pool *pool, Id *ida, struct searchfiles *sf, struct searchfiles *isf)
 697 {
 698   Id dep, sid;
 699   const char *s, *sr;
 700
 701   while ((dep = *ida++) != 0)
 702     {
 703       while (ISRELDEP(dep))
 704         {
 705           Reldep *rd;
 706           sid = pool->ss.nstrings + GETRELID(dep);
 707           if (MAPTST(&sf->seen, sid))
 708             {
 709               dep = 0;
 710               break;
 711             }
 712           MAPSET(&sf->seen, sid);
 713           rd = GETRELDEP(pool, dep);
 714           if (rd->flags < 8)
 715             dep = rd->name;
 716           else if (rd->flags == REL_NAMESPACE)
 717             {
 718               if (isf && (rd->name == NAMESPACE_INSTALLED || rd->name == NAMESPACE_SPLITPROVIDES))
 719                 {
 720                   sf = isf;
 721                   isf = 0;
 722                   if (MAPTST(&sf->seen, sid))
 723                     {
 724                       dep = 0;
 725                       break;
 726                     }
 727                   MAPSET(&sf->seen, sid);
 728                 }
 729               dep = rd->evr;
 730             }
 731           else
 732             {
 733               Id ids[2];
 734               ids[0] = rd->name;
 735               ids[1] = 0;
 736               pool_addfileprovides_dep(pool, ids, sf, isf);
 737               dep = rd->evr;
 738             }
 739         }
 740       if (!dep)
 741         continue;
 742       if (MAPTST(&sf->seen, dep))
 743         continue;
 744       MAPSET(&sf->seen, dep);
 745       s = id2str(pool, dep);
 746       if (*s != '/')
 747         continue;
 748       sf->ids = sat_extend(sf->ids, sf->nfiles, 1, sizeof(const char *), SEARCHFILES_BLOCK);
 749       sf->dirs = sat_extend(sf->dirs, sf->nfiles, 1, sizeof(const char *), SEARCHFILES_BLOCK);
 750       sf->names = sat_extend(sf->names, sf->nfiles, 1, sizeof(const char *), SEARCHFILES_BLOCK);
 751       sf->ids[sf->nfiles] = dep;
 752       sr = strrchr(s, '/');
 753       sf->names[sf->nfiles] = strdup(sr + 1);
 754       sf->dirs[sf->nfiles] = sat_malloc(sr - s + 1);
 755       if (sr != s)
 756         strncpy(sf->dirs[sf->nfiles], s, sr - s);
 757       sf->dirs[sf->nfiles][sr - s] = 0;
 758       sf->nfiles++;
 759     }
 760 }
 761
 762 struct addfileprovides_cbdata {
 763   int nfiles;
 764   Id *ids;
 765   char **dirs;
 766   char **names;
 767
 768   Repodata *olddata;
 769   Id *dids;
 770   Map useddirs;
 771 };
 772
 773 static int
 774 addfileprovides_cb(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *value)
 775 {
 776   struct addfileprovides_cbdata *cbd = cbdata;
 777   int i;
 778
 779   if (data != cbd->olddata)
 780     {
 781       map_free(&cbd->useddirs);
 782       map_init(&cbd->useddirs, data->dirpool.ndirs);
 783       for (i = 0; i < cbd->nfiles; i++)
 784         {
 785           Id did = repodata_str2dir(data, cbd->dirs[i], 0);
 786           cbd->dids[i] = did;
 787           if (did)
 788             MAPSET(&cbd->useddirs, did);
 789         }
 790       cbd->olddata = data;
 791     }
 792   if (!MAPTST(&cbd->useddirs, value->id))
 793     return 0;
 794   for (i = 0; i < cbd->nfiles; i++)
 795     {
 796       if (cbd->dids[i] != value->id)
 797         continue;
 798       if (!strcmp(cbd->names[i], value->str))
 799         break;
 800     }
 801   if (i == cbd->nfiles)
 802     return 0;
 803   s->provides = repo_addid_dep(s->repo, s->provides, cbd->ids[i], SOLVABLE_FILEMARKER);
 804   return 0;
 805 }
 806
 807 void
 808 pool_addfileprovides(Pool *pool, Repo *installed)
 809 {
 810   Solvable *s;
 811   Repo *repo;
 812   struct searchfiles sf, isf;
 813   struct addfileprovides_cbdata cbd;
 814   int i;
 815
 816   memset(&sf, 0, sizeof(sf));
 817   map_init(&sf.seen, pool->ss.nstrings + pool->nrels);
 818   memset(&isf, 0, sizeof(isf));
 819   map_init(&isf.seen, pool->ss.nstrings + pool->nrels);
 820
 821   for (i = 1, s = pool->solvables + i; i < pool->nsolvables; i++, s++)
 822     {
 823       repo = s->repo;
 824       if (!repo)
 825         continue;
 826       if (s->obsoletes)
 827         pool_addfileprovides_dep(pool, repo->idarraydata + s->obsoletes, &sf, &isf);
 828       if (s->conflicts)
 829         pool_addfileprovides_dep(pool, repo->idarraydata + s->conflicts, &sf, &isf);
 830       if (s->requires)
 831         pool_addfileprovides_dep(pool, repo->idarraydata + s->requires, &sf, &isf);
 832       if (s->recommends)
 833         pool_addfileprovides_dep(pool, repo->idarraydata + s->recommends, &sf, &isf);
 834       if (s->suggests)
 835         pool_addfileprovides_dep(pool, repo->idarraydata + s->suggests, &sf, &isf);
 836       if (s->supplements)
 837         pool_addfileprovides_dep(pool, repo->idarraydata + s->supplements, &sf, &isf);
 838       if (s->enhances)
 839         pool_addfileprovides_dep(pool, repo->idarraydata + s->enhances, &sf, &isf);
 840       if (s->freshens)
 841         pool_addfileprovides_dep(pool, repo->idarraydata + s->freshens, &sf, &isf);
 842     }
 843   map_free(&sf.seen);
 844   map_free(&isf.seen);
 845   POOL_DEBUG(SAT_DEBUG_STATS, "found %d file dependencies\n", sf.nfiles);
 846   POOL_DEBUG(SAT_DEBUG_STATS, "found %d installed file dependencies\n", isf.nfiles);
 847   cbd.dids = 0;
 848   map_init(&cbd.useddirs, 1);
 849   if (sf.nfiles)
 850     {
 851 #if 0
 852       for (i = 0; i < sf.nfiles; i++)
 853         POOL_DEBUG(SAT_DEBUG_STATS, "looking up %s in filelist\n", id2str(pool, sf.ids[i]));
 854 #endif
 855       cbd.nfiles = sf.nfiles;
 856       cbd.ids = sf.ids;
 857       cbd.dirs = sf.dirs;
 858       cbd.names = sf.names;
 859       cbd.olddata = 0;
 860       cbd.dids = sat_realloc2(cbd.dids, sf.nfiles, sizeof(Id));
 861       pool_search(pool, 0, SOLVABLE_FILELIST, 0, 0, addfileprovides_cb, &cbd);
 862       sat_free(sf.ids);
 863       for (i = 0; i < sf.nfiles; i++)
 864         {
 865           sat_free(sf.dirs[i]);
 866           sat_free(sf.names[i]);
 867         }
 868       sat_free(sf.dirs);
 869       sat_free(sf.names);
 870     }
 871   if (isf.nfiles && installed)
 872     {
 873 #if 0
 874       for (i = 0; i < isf.nfiles; i++)
 875         POOL_DEBUG(SAT_DEBUG_STATS, "looking up %s in installed filelist\n", id2str(pool, isf.ids[i]));
 876 #endif
 877       cbd.nfiles = isf.nfiles;
 878       cbd.ids = isf.ids;
 879       cbd.dirs = isf.dirs;
 880       cbd.names = isf.names;
 881       cbd.olddata = 0;
 882       cbd.dids = sat_realloc2(cbd.dids, isf.nfiles, sizeof(Id));
 883       repo_search(installed, 0, SOLVABLE_FILELIST, 0, 0, addfileprovides_cb, &cbd);
 884       sat_free(isf.ids);
 885       for (i = 0; i < isf.nfiles; i++)
 886         {
 887           sat_free(isf.dirs[i]);
 888           sat_free(isf.names[i]);
 889         }
 890       sat_free(isf.dirs);
 891       sat_free(isf.names);
 892     }
 893   map_free(&cbd.useddirs);
 894   sat_free(cbd.dids);
 895   pool_freewhatprovides(pool);  /* as we have added provides */
 896 }
 897
 898 void
 899 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)
 900 {
 901   if (p)
 902     {
 903       if (pool->solvables[p].repo)
 904         repo_search(pool->solvables[p].repo, p, key, match, flags, callback, cbdata);
 905       return;
 906     }
 907   /* FIXME: obey callback return value! */
 908   for (p = 1; p < pool->nsolvables; p++)
 909     if (pool->solvables[p].repo)
 910       repo_search(pool->solvables[p].repo, p, key, match, flags, callback, cbdata);
 911 }
 912
 913
 914 void
 915 pool_set_languages(Pool *pool, const char **languages, int nlanguages)
 916 {
 917   int i;
 918
 919   pool->languagecache = sat_free(pool->languagecache);
 920   pool->languagecacheother = 0;
 921   if (pool->nlanguages)
 922     {
 923       for (i = 0; i < pool->nlanguages; i++)
 924         free((char *)pool->languages[i]);
 925       free(pool->languages);
 926     }
 927   pool->nlanguages = nlanguages;
 928   if (!nlanguages)
 929     return;
 930   pool->languages = sat_calloc(nlanguages, sizeof(const char **));
 931   for (i = 0; i < pool->nlanguages; i++)
 932     pool->languages[i] = strdup(languages[i]);
 933 }
 934
 935 const char *
 936 solvable_lookup_str_lang(Solvable *s, Id keyname)
 937 {
 938   Pool *pool;
 939   int i, cols;
 940   const char *str;
 941   Id *row;
 942
 943   if (!s->repo)
 944     return repo_lookup_str(s, keyname);
 945   pool = s->repo->pool;
 946   if (!pool->nlanguages)
 947     return repo_lookup_str(s, keyname);
 948   cols = pool->nlanguages + 1;
 949   if (!pool->languagecache)
 950     {
 951       pool->languagecache = sat_calloc(cols * ID_NUM_INTERNAL, sizeof(Id));
 952       pool->languagecacheother = 0;
 953     }
 954   if (keyname >= ID_NUM_INTERNAL)
 955     {
 956       row = pool->languagecache + ID_NUM_INTERNAL * cols;
 957       for (i = 0; i < pool->languagecacheother; i++, row += cols)
 958         if (*row == keyname)
 959           break;
 960       if (i >= pool->languagecacheother)
 961         {
 962           pool->languagecache = sat_realloc2(pool->languagecache, pool->languagecacheother + 1, cols * sizeof(Id));
 963           pool->languagecacheother++;
 964           row = pool->languagecache + cols * (ID_NUM_INTERNAL + pool->languagecacheother++);
 965         }
 966     }
 967   else
 968     row = pool->languagecache + keyname * cols;
 969   row++;        /* skip keyname */
 970   for (i = 0; i < pool->nlanguages; i++, row++)
 971     {
 972       if (!*row)
 973         {
 974           char *p;
 975           const char *kn;
 976
 977           kn = id2str(pool, keyname);
 978           p = sat_malloc(strlen(kn) + strlen(pool->languages[i]) + 2);
 979           sprintf(p, "%s:%s", kn, pool->languages[i]);
 980           *row = str2id(pool, p, 1);
 981         }
 982       str = repo_lookup_str(s, *row);
 983       if (str)
 984         return str;
 985     }
 986   return repo_lookup_str(s, keyname);
 987 }
 988
 989 // EOF