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