src/pool.c

   1 /*
   2  * Copyright (c) 2007-2009, 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 "poolvendor.h"
  23 #include "repo.h"
  24 #include "poolid.h"
  25 #include "poolid_private.h"
  26 #include "poolarch.h"
  27 #include "util.h"
  28 #include "bitmap.h"
  29 #include "evr.h"
  30 #ifdef ENABLE_CONDA
  31 #include "conda.h"
  32 #endif
  33
  34 #define SOLVABLE_BLOCK  255
  35
  36 #undef LIBSOLV_KNOWNID_H
  37 #define KNOWNID_INITIALIZE
  38 #include "knownid.h"
  39 #undef KNOWNID_INITIALIZE
  40
  41 /* create pool */
  42 Pool *
  43 pool_create(void)
  44 {
  45   Pool *pool;
  46   Solvable *s;
  47
  48   pool = (Pool *)solv_calloc(1, sizeof(*pool));
  49
  50   stringpool_init(&pool->ss, initpool_data);
  51
  52   /* alloc space for RelDep 0 */
  53   pool->rels = solv_extend_resize(0, 1, sizeof(Reldep), REL_BLOCK);
  54   pool->nrels = 1;
  55   memset(pool->rels, 0, sizeof(Reldep));
  56
  57   /* alloc space for Solvable 0 and system solvable */
  58   pool->solvables = solv_extend_resize(0, 2, sizeof(Solvable), SOLVABLE_BLOCK);
  59   pool->nsolvables = 2;
  60   memset(pool->solvables, 0, 2 * sizeof(Solvable));
  61
  62   queue_init(&pool->vendormap);
  63   queue_init(&pool->pooljobs);
  64   queue_init(&pool->lazywhatprovidesq);
  65
  66 #if defined(DEBIAN)
  67   pool->disttype = DISTTYPE_DEB;
  68   pool->noarchid = ARCH_ALL;
  69 #elif defined(ARCHLINUX)
  70   pool->disttype = DISTTYPE_ARCH;
  71   pool->noarchid = ARCH_ANY;
  72 #elif defined(HAIKU)
  73   pool->disttype = DISTTYPE_HAIKU;
  74   pool->noarchid = ARCH_ANY;
  75   pool->obsoleteusesprovides = 1;
  76 #else
  77   pool->disttype = DISTTYPE_RPM;
  78   pool->noarchid = ARCH_NOARCH;
  79 #endif
  80
  81   /* initialize the system solvable */
  82   s = pool->solvables + SYSTEMSOLVABLE;
  83   s->name = SYSTEM_SYSTEM;
  84   s->arch = pool->noarchid;
  85   s->evr = ID_EMPTY;
  86
  87   pool->debugmask = SOLV_DEBUG_RESULT;  /* FIXME */
  88 #if defined(FEDORA) || defined(MAGEIA)
  89   pool->implicitobsoleteusescolors = 1;
  90 #endif
  91 #ifdef RPM5
  92   pool->noobsoletesmultiversion = 1;
  93   pool->forbidselfconflicts = 1;
  94   pool->obsoleteusesprovides = 1;
  95   pool->implicitobsoleteusesprovides = 1;
  96   pool->havedistepoch = 1;
  97 #endif
  98   return pool;
  99 }
 100
 101
 102 /* free all the resources of our pool */
 103 void
 104 pool_free(Pool *pool)
 105 {
 106   int i;
 107
 108   pool_freewhatprovides(pool);
 109   pool_freeidhashes(pool);
 110   pool_freeallrepos(pool, 1);
 111   solv_free(pool->id2arch);
 112   solv_free(pool->id2color);
 113   solv_free(pool->solvables);
 114   stringpool_free(&pool->ss);
 115   solv_free(pool->rels);
 116   pool_setvendorclasses(pool, 0);
 117   queue_free(&pool->vendormap);
 118   queue_free(&pool->pooljobs);
 119   queue_free(&pool->lazywhatprovidesq);
 120   for (i = 0; i < POOL_TMPSPACEBUF; i++)
 121     solv_free(pool->tmpspace.buf[i]);
 122   for (i = 0; i < pool->nlanguages; i++)
 123     free((char *)pool->languages[i]);
 124   solv_free((void *)pool->languages);
 125   solv_free(pool->languagecache);
 126   solv_free(pool->errstr);
 127   solv_free(pool->rootdir);
 128   solv_free(pool);
 129 }
 130
 131 void
 132 pool_freeallrepos(Pool *pool, int reuseids)
 133 {
 134   int i;
 135
 136   pool_freewhatprovides(pool);
 137   for (i = 1; i < pool->nrepos; i++)
 138     if (pool->repos[i])
 139       repo_freedata(pool->repos[i]);
 140   pool->repos = solv_free(pool->repos);
 141   pool->nrepos = 0;
 142   pool->urepos = 0;
 143   /* the first two solvables don't belong to a repo */
 144   pool_free_solvable_block(pool, 2, pool->nsolvables - 2, reuseids);
 145 }
 146
 147 int
 148 pool_setdisttype(Pool *pool, int disttype)
 149 {
 150 #ifdef MULTI_SEMANTICS
 151   int olddisttype = pool->disttype;
 152   switch(disttype)
 153     {
 154     case DISTTYPE_RPM:
 155       pool->noarchid = ARCH_NOARCH;
 156       break;
 157     case DISTTYPE_DEB:
 158       pool->noarchid = ARCH_ALL;
 159       break;
 160     case DISTTYPE_ARCH:
 161     case DISTTYPE_HAIKU:
 162       pool->noarchid = ARCH_ANY;
 163       break;
 164     case DISTTYPE_CONDA:
 165       pool->noarchid = ARCH_ANY;
 166       break;
 167     default:
 168       return -1;
 169     }
 170   pool->disttype = disttype;
 171   pool->solvables[SYSTEMSOLVABLE].arch = pool->noarchid;
 172   return olddisttype;
 173 #else
 174   return pool->disttype == disttype ? disttype : -1;
 175 #endif
 176 }
 177
 178 int
 179 pool_get_flag(Pool *pool, int flag)
 180 {
 181   switch (flag)
 182     {
 183     case POOL_FLAG_PROMOTEEPOCH:
 184       return pool->promoteepoch;
 185     case POOL_FLAG_FORBIDSELFCONFLICTS:
 186       return pool->forbidselfconflicts;
 187     case POOL_FLAG_OBSOLETEUSESPROVIDES:
 188       return pool->obsoleteusesprovides;
 189     case POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES:
 190       return pool->implicitobsoleteusesprovides;
 191     case POOL_FLAG_OBSOLETEUSESCOLORS:
 192       return pool->obsoleteusescolors;
 193     case POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS:
 194       return pool->implicitobsoleteusescolors;
 195     case POOL_FLAG_NOINSTALLEDOBSOLETES:
 196       return pool->noinstalledobsoletes;
 197     case POOL_FLAG_HAVEDISTEPOCH:
 198       return pool->havedistepoch;
 199     case POOL_FLAG_NOOBSOLETESMULTIVERSION:
 200       return pool->noobsoletesmultiversion;
 201     case POOL_FLAG_ADDFILEPROVIDESFILTERED:
 202       return pool->addfileprovidesfiltered;
 203     case POOL_FLAG_NOWHATPROVIDESAUX:
 204       return pool->nowhatprovidesaux;
 205     case POOL_FLAG_WHATPROVIDESWITHDISABLED:
 206       return pool->whatprovideswithdisabled;
 207     default:
 208       break;
 209     }
 210   return -1;
 211 }
 212
 213 int
 214 pool_set_flag(Pool *pool, int flag, int value)
 215 {
 216   int old = pool_get_flag(pool, flag);
 217   switch (flag)
 218     {
 219     case POOL_FLAG_PROMOTEEPOCH:
 220       pool->promoteepoch = value;
 221       break;
 222     case POOL_FLAG_FORBIDSELFCONFLICTS:
 223       pool->forbidselfconflicts = value;
 224       break;
 225     case POOL_FLAG_OBSOLETEUSESPROVIDES:
 226       pool->obsoleteusesprovides = value;
 227       break;
 228     case POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES:
 229       pool->implicitobsoleteusesprovides = value;
 230       break;
 231     case POOL_FLAG_OBSOLETEUSESCOLORS:
 232       pool->obsoleteusescolors = value;
 233       break;
 234     case POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS:
 235       pool->implicitobsoleteusescolors = value;
 236       break;
 237     case POOL_FLAG_NOINSTALLEDOBSOLETES:
 238       pool->noinstalledobsoletes = value;
 239       break;
 240     case POOL_FLAG_HAVEDISTEPOCH:
 241       pool->havedistepoch = value;
 242       break;
 243     case POOL_FLAG_NOOBSOLETESMULTIVERSION:
 244       pool->noobsoletesmultiversion = value;
 245       break;
 246     case POOL_FLAG_ADDFILEPROVIDESFILTERED:
 247       pool->addfileprovidesfiltered = value;
 248       break;
 249     case POOL_FLAG_NOWHATPROVIDESAUX:
 250       pool->nowhatprovidesaux = value;
 251       break;
 252     case POOL_FLAG_WHATPROVIDESWITHDISABLED:
 253       pool->whatprovideswithdisabled = value;
 254       break;
 255     default:
 256       break;
 257     }
 258   return old;
 259 }
 260
 261
 262 Id
 263 pool_add_solvable(Pool *pool)
 264 {
 265   pool->solvables = solv_extend(pool->solvables, pool->nsolvables, 1, sizeof(Solvable), SOLVABLE_BLOCK);
 266   memset(pool->solvables + pool->nsolvables, 0, sizeof(Solvable));
 267   return pool->nsolvables++;
 268 }
 269
 270 Id
 271 pool_add_solvable_block(Pool *pool, int count)
 272 {
 273   Id nsolvables = pool->nsolvables;
 274   if (!count)
 275     return nsolvables;
 276   pool->solvables = solv_extend(pool->solvables, pool->nsolvables, count, sizeof(Solvable), SOLVABLE_BLOCK);
 277   memset(pool->solvables + nsolvables, 0, sizeof(Solvable) * count);
 278   pool->nsolvables += count;
 279   return nsolvables;
 280 }
 281
 282 void
 283 pool_free_solvable_block(Pool *pool, Id start, int count, int reuseids)
 284 {
 285   if (!count)
 286     return;
 287   if (reuseids && start + count == pool->nsolvables)
 288     {
 289       /* might want to shrink solvable array */
 290       pool->nsolvables = start;
 291       return;
 292     }
 293   memset(pool->solvables + start, 0, sizeof(Solvable) * count);
 294 }
 295
 296
 297 void
 298 pool_set_installed(Pool *pool, Repo *installed)
 299 {
 300   if (pool->installed == installed)
 301     return;
 302   pool->installed = installed;
 303   pool_freewhatprovides(pool);
 304 }
 305
 306 static int
 307 pool_shrink_whatprovides_sortcmp(const void *ap, const void *bp, void *dp)
 308 {
 309   int r;
 310   Pool *pool = dp;
 311   Id oa, ob, *da, *db;
 312   oa = pool->whatprovides[*(Id *)ap];
 313   ob = pool->whatprovides[*(Id *)bp];
 314   if (oa == ob)
 315     return *(Id *)ap - *(Id *)bp;
 316   da = pool->whatprovidesdata + oa;
 317   db = pool->whatprovidesdata + ob;
 318   while (*db)
 319     if ((r = (*da++ - *db++)) != 0)
 320       return r;
 321   if (*da)
 322     return *da;
 323   return *(Id *)ap - *(Id *)bp;
 324 }
 325
 326 /*
 327  * pool_shrink_whatprovides  - unify whatprovides data
 328  *
 329  * whatprovides_rel must be empty for this to work!
 330  *
 331  */
 332 static void
 333 pool_shrink_whatprovides(Pool *pool)
 334 {
 335   Id i, n, id;
 336   Id *sorted;
 337   Id lastid, *last, *dp, *lp;
 338   Offset o;
 339   int r;
 340
 341   if (pool->ss.nstrings < 3)
 342     return;
 343   sorted = solv_malloc2(pool->ss.nstrings, sizeof(Id));
 344   for (i = id = 0; id < pool->ss.nstrings; id++)
 345     if (pool->whatprovides[id] >= 4)
 346       sorted[i++] = id;
 347   n = i;
 348   solv_sort(sorted, n, sizeof(Id), pool_shrink_whatprovides_sortcmp, pool);
 349   last = 0;
 350   lastid = 0;
 351   for (i = 0; i < n; i++)
 352     {
 353       id = sorted[i];
 354       o = pool->whatprovides[id];
 355       dp = pool->whatprovidesdata + o;
 356       if (last)
 357         {
 358           lp = last;
 359           while (*dp)
 360             if (*dp++ != *lp++)
 361               {
 362                 last = 0;
 363                 break;
 364               }
 365           if (last && *lp)
 366             last = 0;
 367           if (last)
 368             {
 369               pool->whatprovides[id] = -lastid;
 370               continue;
 371             }
 372         }
 373       last = pool->whatprovidesdata + o;
 374       lastid = id;
 375     }
 376   solv_free(sorted);
 377   dp = pool->whatprovidesdata + 4;
 378   for (id = 1; id < pool->ss.nstrings; id++)
 379     {
 380       o = pool->whatprovides[id];
 381       if (!o)
 382         continue;
 383       if ((Id)o < 0)
 384         {
 385           i = -(Id)o;
 386           if (i >= id)
 387             abort();
 388           pool->whatprovides[id] = pool->whatprovides[i];
 389           continue;
 390         }
 391       if (o < 4)
 392         continue;
 393       lp = pool->whatprovidesdata + o;
 394       if (lp < dp)
 395         abort();
 396       pool->whatprovides[id] = dp - pool->whatprovidesdata;
 397       while ((*dp++ = *lp++) != 0)
 398         ;
 399     }
 400   o = dp - pool->whatprovidesdata;
 401   POOL_DEBUG(SOLV_DEBUG_STATS, "shrunk whatprovidesdata from %d to %d\n", pool->whatprovidesdataoff, o);
 402   if (pool->whatprovidesdataoff == o)
 403     return;
 404   r = pool->whatprovidesdataoff - o;
 405   pool->whatprovidesdataoff = o;
 406   pool->whatprovidesdata = solv_realloc(pool->whatprovidesdata, (o + pool->whatprovidesdataleft) * sizeof(Id));
 407   if (r > pool->whatprovidesdataleft)
 408     r = pool->whatprovidesdataleft;
 409   memset(pool->whatprovidesdata + o, 0, r * sizeof(Id));
 410 }
 411
 412 /* this gets rid of all the zeros in the aux */
 413 static void
 414 pool_shrink_whatprovidesaux(Pool *pool)
 415 {
 416   int num = pool->whatprovidesauxoff;
 417   Id id;
 418   Offset newoff;
 419   Id *op, *wp = pool->whatprovidesauxdata + 1;
 420   int i;
 421
 422   for (i = 0; i < num; i++)
 423     {
 424       Offset o = pool->whatprovidesaux[i];
 425       if (o < 2)
 426         continue;
 427       op = pool->whatprovidesauxdata + o;
 428       pool->whatprovidesaux[i] = wp - pool->whatprovidesauxdata;
 429       if (op < wp)
 430         abort();
 431       while ((id = *op++) != 0)
 432         *wp++ = id;
 433     }
 434   newoff = wp - pool->whatprovidesauxdata;
 435   pool->whatprovidesauxdata = solv_realloc(pool->whatprovidesauxdata, newoff * sizeof(Id));
 436   POOL_DEBUG(SOLV_DEBUG_STATS, "shrunk whatprovidesauxdata from %d to %d\n", pool->whatprovidesauxdataoff, newoff);
 437   pool->whatprovidesauxdataoff = newoff;
 438 }
 439
 440
 441 /*
 442  * pool_createwhatprovides()
 443  *
 444  * create hashes over pool of solvables to ease provide lookups
 445  *
 446  */
 447 void
 448 pool_createwhatprovides(Pool *pool)
 449 {
 450   int i, num, np, extra;
 451   Offset off;
 452   Solvable *s;
 453   Id id;
 454   Offset *idp, n;
 455   Offset *whatprovides;
 456   Id *whatprovidesdata, *dp, *whatprovidesauxdata;
 457   Offset *whatprovidesaux;
 458   unsigned int now;
 459
 460   now = solv_timems(0);
 461   POOL_DEBUG(SOLV_DEBUG_STATS, "number of solvables: %d, memory used: %d K\n", pool->nsolvables, pool->nsolvables * (int)sizeof(Solvable) / 1024);
 462   POOL_DEBUG(SOLV_DEBUG_STATS, "number of ids: %d + %d\n", pool->ss.nstrings, pool->nrels);
 463   POOL_DEBUG(SOLV_DEBUG_STATS, "string memory used: %d K array + %d K data,  rel memory used: %d K array\n", pool->ss.nstrings / (1024 / (int)sizeof(Id)), pool->ss.sstrings / 1024, pool->nrels * (int)sizeof(Reldep) / 1024);
 464   if (pool->ss.stringhashmask || pool->relhashmask)
 465     POOL_DEBUG(SOLV_DEBUG_STATS, "string hash memory: %d K, rel hash memory : %d K\n", (pool->ss.stringhashmask + 1) / (int)(1024/sizeof(Id)), (pool->relhashmask + 1) / (int)(1024/sizeof(Id)));
 466
 467   pool_freeidhashes(pool);      /* XXX: should not be here! */
 468   pool_freewhatprovides(pool);
 469   num = pool->ss.nstrings;
 470   pool->whatprovides = whatprovides = solv_calloc_block(num, sizeof(Offset), WHATPROVIDES_BLOCK);
 471   pool->whatprovides_rel = solv_calloc_block(pool->nrels, sizeof(Offset), WHATPROVIDES_BLOCK);
 472
 473   /* count providers for each name */
 474   for (i = pool->nsolvables - 1; i > 0; i--)
 475     {
 476       Id *pp;
 477       s = pool->solvables + i;
 478       if (!s->provides || !s->repo || s->repo->disabled)
 479         continue;
 480       if (!pool_installable_whatprovides(pool, s))
 481         continue;
 482       pp = s->repo->idarraydata + s->provides;
 483       while ((id = *pp++) != 0)
 484         {
 485           while (ISRELDEP(id))
 486             {
 487               Reldep *rd = GETRELDEP(pool, id);
 488               id = rd->name;
 489             }
 490           whatprovides[id]++;          /* inc count of providers */
 491         }
 492     }
 493
 494   off = 4;      /* first entry is undef, second is empty list, third is system solvable  */
 495   np = 0;                              /* number of names provided */
 496   for (i = 0, idp = whatprovides; i < num; i++, idp++)
 497     {
 498       n = *idp;
 499       if (!n)                           /* no providers */
 500         {
 501           *idp = 1;                     /* offset for empty list */
 502           continue;
 503         }
 504       off += n;                         /* make space for all providers */
 505       *idp = off++;                     /* now idp points to terminating zero */
 506       np++;                             /* inc # of provider 'slots' for stats */
 507     }
 508
 509   POOL_DEBUG(SOLV_DEBUG_STATS, "provide ids: %d\n", np);
 510
 511   /* reserve some space for relation data */
 512   extra = 2 * pool->nrels;
 513   if (extra < 256)
 514     extra = 256;
 515
 516   POOL_DEBUG(SOLV_DEBUG_STATS, "provide space needed: %d + %d\n", off, extra);
 517
 518   /* alloc space for all providers + extra */
 519   whatprovidesdata = solv_calloc(off + extra, sizeof(Id));
 520   whatprovidesdata[2] = SYSTEMSOLVABLE;
 521
 522   /* alloc aux vector */
 523   whatprovidesauxdata = 0;
 524   if (!pool->nowhatprovidesaux)
 525     {
 526       pool->whatprovidesaux = whatprovidesaux = solv_calloc(num, sizeof(Offset));
 527       pool->whatprovidesauxoff = num;
 528       pool->whatprovidesauxdataoff = off;
 529       pool->whatprovidesauxdata = whatprovidesauxdata = solv_calloc(pool->whatprovidesauxdataoff, sizeof(Id));
 530     }
 531
 532   /* now fill data for all provides */
 533   for (i = pool->nsolvables - 1; i > 0; i--)
 534     {
 535       Id *pp;
 536       s = pool->solvables + i;
 537       if (!s->provides || !s->repo || s->repo->disabled)
 538         continue;
 539       if (!pool_installable_whatprovides(pool, s))
 540         continue;
 541       /* for all provides of this solvable */
 542       pp = s->repo->idarraydata + s->provides;
 543       while ((id = *pp++) != 0)
 544         {
 545           Id auxid = id;
 546           while (ISRELDEP(id))
 547             {
 548               Reldep *rd = GETRELDEP(pool, id);
 549               id = rd->name;
 550             }
 551           dp = whatprovidesdata + whatprovides[id];   /* offset into whatprovidesdata */
 552           if (*dp != i)         /* don't add same solvable twice */
 553             {
 554               dp[-1] = i;
 555               whatprovides[id]--;
 556             }
 557           else
 558             auxid = 1;
 559           if (whatprovidesauxdata)
 560             whatprovidesauxdata[whatprovides[id]] = auxid;
 561         }
 562     }
 563   if (pool->whatprovidesaux)
 564     memcpy(pool->whatprovidesaux, pool->whatprovides, num * sizeof(Id));
 565   pool->whatprovidesdata = whatprovidesdata;
 566   pool->whatprovidesdataoff = off;
 567   pool->whatprovidesdataleft = extra;
 568   pool_shrink_whatprovides(pool);
 569   if (pool->whatprovidesaux)
 570     pool_shrink_whatprovidesaux(pool);
 571   POOL_DEBUG(SOLV_DEBUG_STATS, "whatprovides memory used: %d K id array, %d K data\n", (pool->ss.nstrings + pool->nrels + WHATPROVIDES_BLOCK) / (int)(1024/sizeof(Id)), (pool->whatprovidesdataoff + pool->whatprovidesdataleft) / (int)(1024/sizeof(Id)));
 572   if (pool->whatprovidesaux)
 573     POOL_DEBUG(SOLV_DEBUG_STATS, "whatprovidesaux memory used: %d K id array, %d K data\n", pool->whatprovidesauxoff / (int)(1024/sizeof(Id)), pool->whatprovidesauxdataoff / (int)(1024/sizeof(Id)));
 574
 575   queue_empty(&pool->lazywhatprovidesq);
 576   if ((!pool->addedfileprovides && pool->disttype == DISTTYPE_RPM) || pool->addedfileprovides == 1)
 577     {
 578       if (!pool->addedfileprovides)
 579         POOL_DEBUG(SOLV_DEBUG_STATS, "WARNING: pool_addfileprovides was not called, this may result in slow operation\n");
 580       /* lazyly add file provides */
 581       for (i = 1; i < num; i++)
 582         {
 583           const char *str = pool->ss.stringspace + pool->ss.strings[i];
 584           if (str[0] != '/')
 585             continue;
 586           if (pool->addedfileprovides == 1 && repodata_filelistfilter_matches(0, str))
 587             continue;
 588           /* setup lazy adding, but remember old value */
 589           if (pool->whatprovides[i] > 1)
 590             queue_push2(&pool->lazywhatprovidesq, i, pool->whatprovides[i]);
 591           pool->whatprovides[i] = 0;
 592           if (pool->whatprovidesaux)
 593             pool->whatprovidesaux[i] = 0;       /* sorry */
 594         }
 595       POOL_DEBUG(SOLV_DEBUG_STATS, "lazywhatprovidesq size: %d entries\n", pool->lazywhatprovidesq.count / 2);
 596     }
 597
 598   POOL_DEBUG(SOLV_DEBUG_STATS, "createwhatprovides took %d ms\n", solv_timems(now));
 599 }
 600
 601 /*
 602  * free all of our whatprovides data
 603  * be careful, everything internalized with pool_queuetowhatprovides is
 604  * gone, too
 605  */
 606 void
 607 pool_freewhatprovides(Pool *pool)
 608 {
 609   pool->whatprovides = solv_free(pool->whatprovides);
 610   pool->whatprovides_rel = solv_free(pool->whatprovides_rel);
 611   pool->whatprovidesdata = solv_free(pool->whatprovidesdata);
 612   pool->whatprovidesdataoff = 0;
 613   pool->whatprovidesdataleft = 0;
 614   pool->whatprovidesaux = solv_free(pool->whatprovidesaux);
 615   pool->whatprovidesauxdata = solv_free(pool->whatprovidesauxdata);
 616   pool->whatprovidesauxoff = 0;
 617   pool->whatprovidesauxdataoff = 0;
 618 }
 619
 620
 621 /******************************************************************************/
 622
 623 /*
 624  * pool_queuetowhatprovides  - add queue contents to whatprovidesdata
 625  *
 626  * used for whatprovides, jobs, learnt rules, selections
 627  * input: q: queue of Ids
 628  * returns: Offset into whatprovidesdata
 629  *
 630  */
 631
 632 Id
 633 pool_ids2whatprovides(Pool *pool, Id *ids, int count)
 634 {
 635   Offset off;
 636
 637   if (count == 0)                      /* queue empty -> 1 */
 638     return 1;
 639   if (count == 1 && *ids == SYSTEMSOLVABLE)
 640     return 2;
 641
 642   /* extend whatprovidesdata if needed, +1 for 0-termination */
 643   if (pool->whatprovidesdataleft < count + 1)
 644     {
 645       POOL_DEBUG(SOLV_DEBUG_STATS, "growing provides hash data...\n");
 646       pool->whatprovidesdata = solv_realloc(pool->whatprovidesdata, (pool->whatprovidesdataoff + count + 4096) * sizeof(Id));
 647       pool->whatprovidesdataleft = count + 4096;
 648     }
 649
 650   /* copy queue to next free slot */
 651   off = pool->whatprovidesdataoff;
 652   memcpy(pool->whatprovidesdata + pool->whatprovidesdataoff, ids, count * sizeof(Id));
 653
 654   /* adapt count and 0-terminate */
 655   pool->whatprovidesdataoff += count;
 656   pool->whatprovidesdata[pool->whatprovidesdataoff++] = 0;
 657   pool->whatprovidesdataleft -= count + 1;
 658
 659   return (Id)off;
 660 }
 661
 662 Id
 663 pool_queuetowhatprovides(Pool *pool, Queue *q)
 664 {
 665   int count = q->count;
 666   if (count == 0)                      /* queue empty -> 1 */
 667     return 1;
 668   if (count == 1 && q->elements[0] == SYSTEMSOLVABLE)
 669     return 2;
 670   return pool_ids2whatprovides(pool, q->elements, count);
 671 }
 672
 673
 674 /*************************************************************************/
 675
 676 #if defined(MULTI_SEMANTICS)
 677 # define EVRCMP_DEPCMP (pool->disttype == DISTTYPE_DEB ? EVRCMP_COMPARE : EVRCMP_MATCH_RELEASE)
 678 #elif defined(DEBIAN)
 679 # define EVRCMP_DEPCMP EVRCMP_COMPARE
 680 #else
 681 # define EVRCMP_DEPCMP EVRCMP_MATCH_RELEASE
 682 #endif
 683
 684 /* check if a package's nevr matches a dependency */
 685 /* semi-private, called from public pool_match_nevr */
 686
 687 int
 688 pool_match_nevr_rel(Pool *pool, Solvable *s, Id d)
 689 {
 690   Reldep *rd = GETRELDEP(pool, d);
 691   Id name = rd->name;
 692   Id evr = rd->evr;
 693   int flags = rd->flags;
 694
 695   if (flags > 7)
 696     {
 697       switch (flags)
 698         {
 699         case REL_ARCH:
 700           if (s->arch != evr)
 701             {
 702               if (evr != ARCH_SRC || s->arch != ARCH_NOSRC)
 703                 return 0;
 704             }
 705           return pool_match_nevr(pool, s, name);
 706         case REL_OR:
 707           if (pool_match_nevr(pool, s, name))
 708             return 1;
 709           return pool_match_nevr(pool, s, evr);
 710         case REL_AND:
 711         case REL_WITH:
 712           if (!pool_match_nevr(pool, s, name))
 713             return 0;
 714           return pool_match_nevr(pool, s, evr);
 715         case REL_WITHOUT:
 716           if (!pool_match_nevr(pool, s, name))
 717             return 0;
 718           return !pool_match_nevr(pool, s, evr);
 719         case REL_MULTIARCH:
 720           if (evr != ARCH_ANY)
 721             return 0;
 722           /* XXX : need to check for Multi-Arch: allowed! */
 723           return pool_match_nevr(pool, s, name);
 724         default:
 725           return 0;
 726         }
 727     }
 728   if (!pool_match_nevr(pool, s, name))
 729     return 0;
 730   if (evr == s->evr)
 731     return (flags & REL_EQ) ? 1 : 0;
 732   if (!flags)
 733     return 0;
 734   if (flags == 7)
 735     return 1;
 736   switch (pool_evrcmp(pool, s->evr, evr, EVRCMP_DEPCMP))
 737     {
 738     case -2:
 739       return 1;
 740     case -1:
 741       return (flags & REL_LT) ? 1 : 0;
 742     case 0:
 743       return (flags & REL_EQ) ? 1 : 0;
 744     case 1:
 745       return (flags & REL_GT) ? 1 : 0;
 746     case 2:
 747       return (flags & REL_EQ) ? 1 : 0;
 748     default:
 749       break;
 750     }
 751   return 0;
 752 }
 753
 754 #if defined(HAIKU) || defined(MULTI_SEMANTICS)
 755 /* forward declaration */
 756 static int pool_match_flags_evr_rel_compat(Pool *pool, Reldep *range, int flags, int evr);
 757 #endif
 758
 759 /* match (flags, evr) against provider (pflags, pevr) */
 760 static inline int
 761 pool_match_flags_evr(Pool *pool, int pflags, Id pevr, int flags, int evr)
 762 {
 763   if (!pflags || !flags || pflags >= 8 || flags >= 8)
 764     return 0;
 765   if (flags == 7 || pflags == 7)
 766     return 1;           /* rel provides every version */
 767   if ((pflags & flags & (REL_LT | REL_GT)) != 0)
 768     return 1;           /* both rels show in the same direction */
 769   if (pevr == evr)
 770     return (flags & pflags & REL_EQ) ? 1 : 0;
 771 #if defined(HAIKU) || defined(MULTI_SEMANTICS)
 772   if (ISRELDEP(pevr))
 773     {
 774       Reldep *rd = GETRELDEP(pool, pevr);
 775       if (rd->flags == REL_COMPAT)
 776         return pool_match_flags_evr_rel_compat(pool, rd, flags, evr);
 777     }
 778 #endif
 779   switch (pool_evrcmp(pool, pevr, evr, EVRCMP_DEPCMP))
 780     {
 781     case -2:
 782       return (pflags & REL_EQ) ? 1 : 0;
 783     case -1:
 784       return (flags & REL_LT) || (pflags & REL_GT) ? 1 : 0;
 785     case 0:
 786       return (flags & pflags & REL_EQ) ? 1 : 0;
 787     case 1:
 788       return (flags & REL_GT) || (pflags & REL_LT) ? 1 : 0;
 789     case 2:
 790       return (flags & REL_EQ) ? 1 : 0;
 791     default:
 792       break;
 793     }
 794   return 0;
 795 }
 796
 797 #if defined(HAIKU) || defined(MULTI_SEMANTICS)
 798 static int
 799 pool_match_flags_evr_rel_compat(Pool *pool, Reldep *range, int flags, int evr)
 800 {
 801   /* range->name is the actual version, range->evr the backwards compatibility
 802      version. If flags are '>=' or '>', we match the compatibility version
 803      as well, otherwise only the actual version. */
 804   if (!(flags & REL_GT) || (flags & REL_LT))
 805     return pool_match_flags_evr(pool, REL_EQ, range->name, flags, evr);
 806   return pool_match_flags_evr(pool, REL_LT | REL_EQ, range->name, flags, evr) &&
 807          pool_match_flags_evr(pool, REL_GT | REL_EQ, range->evr, REL_EQ, evr);
 808 }
 809 #endif
 810
 811 /* public (i.e. not inlined) version of pool_match_flags_evr */
 812 int
 813 pool_intersect_evrs(Pool *pool, int pflags, Id pevr, int flags, Id evr)
 814 {
 815   return pool_match_flags_evr(pool, pflags, pevr, flags, evr);
 816 }
 817
 818
 819 static int
 820 is_interval_dep(Pool *pool, Id d1, Id d2)
 821 {
 822   Reldep *rd1, *rd2;
 823   if (!ISRELDEP(d1) || !ISRELDEP(d2))
 824     return 0;
 825   rd1 = GETRELDEP(pool, d1);
 826   rd2 = GETRELDEP(pool, d2);
 827   if (rd1->name != rd2->name || rd1->flags >= 8 || rd2->flags >= 8)
 828     return 0;
 829   if (((rd1->flags ^ rd2->flags) & (REL_LT|REL_GT)) != (REL_LT|REL_GT))
 830     return 0;
 831   return 1;
 832 }
 833
 834
 835 /* match two dependencies (d1 = provider) */
 836
 837 int
 838 pool_match_dep(Pool *pool, Id d1, Id d2)
 839 {
 840   Reldep *rd1, *rd2;
 841
 842   if (d1 == d2)
 843     return 1;
 844
 845   if (ISRELDEP(d1))
 846     {
 847       /* we use potentially matches for complex deps */
 848       rd1 = GETRELDEP(pool, d1);
 849       if (rd1->flags == REL_AND || rd1->flags == REL_OR || rd1->flags == REL_WITH || rd1->flags == REL_WITHOUT || rd1->flags == REL_COND || rd1->flags == REL_UNLESS)
 850         {
 851           if (rd1->flags == REL_WITH && is_interval_dep(pool, rd1->name, rd1->evr))
 852             return pool_match_dep(pool, rd1->name, d2) && pool_match_dep(pool, rd1->evr, d2);
 853           if (pool_match_dep(pool, rd1->name, d2))
 854             return 1;
 855           if ((rd1->flags == REL_COND || rd1->flags == REL_UNLESS) && ISRELDEP(rd1->evr))
 856             {
 857               rd1 = GETRELDEP(pool, rd1->evr);
 858               if (rd1->flags != REL_ELSE)
 859                 return 0;
 860             }
 861           if (rd1->flags != REL_COND && rd1->flags != REL_UNLESS && rd1->flags != REL_WITHOUT && pool_match_dep(pool, rd1->evr, d2))
 862             return 1;
 863           return 0;
 864         }
 865     }
 866   if (ISRELDEP(d2))
 867     {
 868       /* we use potentially matches for complex deps */
 869       rd2 = GETRELDEP(pool, d2);
 870       if (rd2->flags == REL_AND || rd2->flags == REL_OR || rd2->flags == REL_WITH || rd2->flags == REL_WITHOUT || rd2->flags == REL_COND || rd2->flags == REL_UNLESS)
 871         {
 872           if (rd2->flags == REL_WITH && is_interval_dep(pool, rd2->name, rd2->evr))
 873             return pool_match_dep(pool, d1, rd2->name) && pool_match_dep(pool, d1, rd2->evr);
 874           if (pool_match_dep(pool, d1, rd2->name))
 875             return 1;
 876           if ((rd2->flags == REL_COND || rd2->flags == REL_UNLESS) && ISRELDEP(rd2->evr))
 877             {
 878               rd2 = GETRELDEP(pool, rd2->evr);
 879               if (rd2->flags != REL_ELSE)
 880                 return 0;
 881             }
 882           if (rd2->flags != REL_COND && rd2->flags != REL_UNLESS && rd2->flags != REL_WITHOUT && pool_match_dep(pool, d1, rd2->evr))
 883             return 1;
 884           return 0;
 885         }
 886     }
 887   if (!ISRELDEP(d1))
 888     {
 889       if (!ISRELDEP(d2))
 890         return 0;       /* cannot match as d1 != d2 */
 891       rd2 = GETRELDEP(pool, d2);
 892       return pool_match_dep(pool, d1, rd2->name);
 893     }
 894   rd1 = GETRELDEP(pool, d1);
 895   if (!ISRELDEP(d2))
 896     {
 897       return pool_match_dep(pool, rd1->name, d2);
 898     }
 899   rd2 = GETRELDEP(pool, d2);
 900   /* first match name */
 901   if (!pool_match_dep(pool, rd1->name, rd2->name))
 902     return 0;
 903   /* name matches, check flags and evr */
 904   return pool_intersect_evrs(pool, rd1->flags, rd1->evr, rd2->flags, rd2->evr);
 905 }
 906
 907 Id
 908 pool_searchlazywhatprovidesq(Pool *pool, Id d)
 909 {
 910   int start = 0;
 911   int end = pool->lazywhatprovidesq.count;
 912   Id *elements;
 913   if (!end)
 914     return 0;
 915   elements = pool->lazywhatprovidesq.elements;
 916   while (end - start > 16)
 917     {
 918       int mid = (start + end) / 2 & ~1;
 919       if (elements[mid] == d)
 920         return elements[mid + 1];
 921       if (elements[mid] < d)
 922         start = mid + 2;
 923       else
 924         end = mid;
 925     }
 926   for (; start < end; start += 2)
 927     if (elements[start] == d)
 928       return elements[start + 1];
 929   return 0;
 930 }
 931
 932 /*
 933  * addstdproviders
 934  *
 935  * lazy populating of the whatprovides array, non relation case
 936  */
 937 static Id
 938 pool_addstdproviders(Pool *pool, Id d)
 939 {
 940   const char *str;
 941   Queue q;
 942   Id qbuf[16];
 943   Dataiterator di;
 944   Id oldoffset;
 945
 946   if (pool->addedfileprovides == 2)
 947     {
 948       pool->whatprovides[d] = 1;
 949       return 1;
 950     }
 951   str =  pool->ss.stringspace + pool->ss.strings[d];
 952   if (*str != '/')
 953     {
 954       pool->whatprovides[d] = 1;
 955       return 1;
 956     }
 957   queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf));
 958   dataiterator_init(&di, pool, 0, 0, SOLVABLE_FILELIST, str, SEARCH_STRING|SEARCH_FILES);
 959   for (; dataiterator_step(&di); dataiterator_skip_solvable(&di))
 960     {
 961       Solvable *s = pool->solvables + di.solvid;
 962       /* XXX: maybe should add a provides dependency to the solvables
 963        * OTOH this is only needed for rel deps that filter the provides,
 964        * and those should not use filelist entries */
 965       if (s->repo->disabled)
 966         continue;
 967       if (!pool_installable_whatprovides(pool, s))
 968         continue;
 969       queue_push(&q, di.solvid);
 970     }
 971   dataiterator_free(&di);
 972   oldoffset = pool_searchlazywhatprovidesq(pool, d);
 973   if (!q.count)
 974     pool->whatprovides[d] = oldoffset ? oldoffset : 1;
 975   else
 976     {
 977       if (oldoffset)
 978         {
 979           Id *oo = pool->whatprovidesdata + oldoffset;
 980           int i;
 981           /* unify both queues. easy, as we know both are sorted */
 982           for (i = 0; i < q.count; i++)
 983             {
 984               if (*oo > q.elements[i])
 985                 continue;
 986               if (*oo < q.elements[i])
 987                 queue_insert(&q, i, *oo);
 988               oo++;
 989               if (!*oo)
 990                 break;
 991             }
 992           while (*oo)
 993             queue_push(&q, *oo++);
 994           if (q.count == oo - (pool->whatprovidesdata + oldoffset))
 995             {
 996               /* end result has same size as oldoffset -> no new entries */
 997               queue_free(&q);
 998               pool->whatprovides[d] = oldoffset;
 999               return oldoffset;
1000             }
1001         }
1002       pool->whatprovides[d] = pool_queuetowhatprovides(pool, &q);
1003     }
1004   queue_free(&q);
1005   return pool->whatprovides[d];
1006 }
1007
1008
1009 static inline int
1010 pool_is_kind(Pool *pool, Id name, Id kind)
1011 {
1012   const char *n;
1013   if (!kind)
1014     return 1;
1015   n = pool_id2str(pool, name);
1016   if (kind != 1)
1017     {
1018       const char *kn = pool_id2str(pool, kind);
1019       int knl = strlen(kn);
1020       return !strncmp(n, kn, knl) && n[knl] == ':' ? 1 : 0;
1021     }
1022   else
1023     {
1024       if (*n == ':')
1025         return 1;
1026       while(*n >= 'a' && *n <= 'z')
1027         n++;
1028       return *n == ':' ? 0 : 1;
1029     }
1030 }
1031
1032 /*
1033  * rpm eq magic:
1034  *
1035  * some dependencies are of the from "foo = md5sum", like the
1036  * buildid provides. There's not much we can do to speed up
1037  * getting the providers, because rpm's complex evr comparison
1038  * rules get in the way. But we can use the first character(s)
1039  * of the md5sum to do a simple pre-check.
1040  */
1041 static inline int
1042 rpmeqmagic(Pool *pool, Id evr)
1043 {
1044   const char *s = pool_id2str(pool, evr);
1045   if (*s == '0')
1046     {
1047       while (*s == '0' && s[1] >= '0' && s[1] <= '9')
1048         s++;
1049       /* ignore epoch 0 */
1050       if (*s == '0' && s[1] == ':')
1051         {
1052           s += 2;
1053           while (*s == '0' && s[1] >= '0' && s[1] <= '9')
1054             s++;
1055         }
1056     }
1057   if (*s >= '0' && *s <= '9')
1058     {
1059       if (s[1] >= '0' && s[1] <= '9')
1060         return *s + (s[1] << 8);
1061       return *s;
1062     }
1063   if ((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z'))
1064     {
1065       if ((s[1] >= 'a' && s[1] <= 'z') || (s[1] >= 'A' && s[1] <= 'Z'))
1066         return *s + (s[1] << 8);
1067       return *s;
1068     }
1069   return -1;
1070 }
1071
1072 static inline int
1073 rpmeqmagic_init(Pool *pool, int flags, Id evr)
1074 {
1075   if (flags != REL_EQ || pool->disttype != DISTTYPE_RPM || pool->promoteepoch || ISRELDEP(evr))
1076     return -1;
1077   else
1078     return rpmeqmagic(pool, evr);
1079 }
1080
1081 static inline int
1082 rpmeqmagic_cantmatch(Pool *pool, int flags, Id evr, int eqmagic)
1083 {
1084   int peqmagic = rpmeqmagic(pool, evr);
1085   if (peqmagic > 0 && peqmagic != eqmagic)
1086     return 1;
1087   return 0;
1088 }
1089
1090 /*
1091  * addrelproviders
1092  *
1093  * add packages fulfilling the relation to whatprovides array
1094  *
1095  * some words about REL_AND and REL_IF: we assume the best case
1096  * here, so that you get a "potential" result if you ask for a match.
1097  * E.g. if you ask for "whatrequires A" and package X contains
1098  * "Requires: A & B", you'll get "X" as an answer.
1099  */
1100 Id
1101 pool_addrelproviders(Pool *pool, Id d)
1102 {
1103   Reldep *rd;
1104   Reldep *prd;
1105   Queue plist;
1106   Id buf[16];
1107   Id name, evr, flags;
1108   Id pid, *pidp;
1109   Id p, *pp;
1110
1111   if (!ISRELDEP(d))
1112     return pool_addstdproviders(pool, d);
1113   rd = GETRELDEP(pool, d);
1114   name = rd->name;
1115   evr = rd->evr;
1116   flags = rd->flags;
1117   d = GETRELID(d);
1118   queue_init_buffer(&plist, buf, sizeof(buf)/sizeof(*buf));
1119
1120   if (flags >= 8)
1121     {
1122       /* special relation */
1123       Id wp = 0;
1124       Id *pp2, *pp3;
1125
1126       switch (flags)
1127         {
1128         case REL_WITH:
1129           wp = pool_whatprovides(pool, name);
1130           pp2 = pool_whatprovides_ptr(pool, evr);
1131           pp = pool->whatprovidesdata + wp;
1132           while ((p = *pp++) != 0)
1133             {
1134               for (pp3 = pp2; *pp3; pp3++)
1135                 if (*pp3 == p)
1136                   break;
1137               if (*pp3)
1138                 queue_push(&plist, p);  /* found it */
1139               else
1140                 wp = 0;
1141             }
1142           break;
1143         case REL_WITHOUT:
1144           wp = pool_whatprovides(pool, name);
1145           pp2 = pool_whatprovides_ptr(pool, evr);
1146           pp = pool->whatprovidesdata + wp;
1147           while ((p = *pp++) != 0)
1148             {
1149               for (pp3 = pp2; *pp3; pp3++)
1150                 if (*pp3 == p)
1151                   break;
1152               if (!*pp3)
1153                 queue_push(&plist, p);  /* use it */
1154               else
1155                 wp = 0;
1156             }
1157           break;
1158         case REL_AND:
1159         case REL_OR:
1160         case REL_COND:
1161         case REL_UNLESS:
1162           if (flags == REL_COND || flags == REL_UNLESS)
1163             {
1164               if (ISRELDEP(evr))
1165                 {
1166                   Reldep *rd2 = GETRELDEP(pool, evr);
1167                   evr = rd2->flags == REL_ELSE ? rd2->evr : 0;
1168                 }
1169               else
1170                 evr = 0;        /* assume cond is true */
1171             }
1172           wp = pool_whatprovides(pool, name);
1173           if (!pool->whatprovidesdata[wp])
1174             wp = evr ? pool_whatprovides(pool, evr) : 1;
1175           else if (evr)
1176             {
1177               /* sorted merge */
1178               pp2 = pool_whatprovides_ptr(pool, evr);
1179               pp = pool->whatprovidesdata + wp;
1180               while (*pp && *pp2)
1181                 {
1182                   if (*pp < *pp2)
1183                     queue_push(&plist, *pp++);
1184                   else
1185                     {
1186                       if (*pp == *pp2)
1187                         pp++;
1188                       queue_push(&plist, *pp2++);
1189                     }
1190                 }
1191               while (*pp)
1192                 queue_push(&plist, *pp++);
1193               while (*pp2)
1194                 queue_push(&plist, *pp2++);
1195               /* if the number of elements did not change, we can reuse wp */
1196               if (pp - (pool->whatprovidesdata + wp) != plist.count)
1197                 wp = 0;
1198             }
1199           break;
1200
1201         case REL_NAMESPACE:
1202           if (name == NAMESPACE_OTHERPROVIDERS)
1203             {
1204               wp = pool_whatprovides(pool, evr);
1205               break;
1206             }
1207           if (pool->nscallback)
1208             {
1209               /* ask callback which packages provide the dependency
1210                * 0:  none
1211                * 1:  the system (aka SYSTEMSOLVABLE)
1212                * >1: set of packages, stored as offset on whatprovidesdata
1213                */
1214               p = pool->nscallback(pool, pool->nscallbackdata, name, evr);
1215               if (p > 1)
1216                 wp = p;
1217               if (p == 1)
1218                 queue_push(&plist, SYSTEMSOLVABLE);
1219             }
1220           break;
1221         case REL_ARCH:
1222           /* small hack: make it possible to match <pkg>.src
1223            * we have to iterate over the solvables as src packages do not
1224            * provide anything, thus they are not indexed in our
1225            * whatprovides hash */
1226           if (evr == ARCH_SRC || evr == ARCH_NOSRC)
1227             {
1228               Solvable *s;
1229               for (p = 1, s = pool->solvables + p; p < pool->nsolvables; p++, s++)
1230                 {
1231                   if (!s->repo)
1232                     continue;
1233                   if (s->arch != evr && s->arch != ARCH_NOSRC)
1234                     continue;
1235                   if (pool_disabled_solvable(pool, s))
1236                     continue;
1237                   if (!name || pool_match_nevr(pool, s, name))
1238                     queue_push(&plist, p);
1239                 }
1240               break;
1241             }
1242           if (!name)
1243             {
1244               FOR_POOL_SOLVABLES(p)
1245                 {
1246                   Solvable *s = pool->solvables + p;
1247                   if (!pool_installable_whatprovides(pool, s))
1248                     continue;
1249                   if (s->arch == evr)
1250                     queue_push(&plist, p);
1251                 }
1252               break;
1253             }
1254           wp = pool_whatprovides(pool, name);
1255           pp = pool->whatprovidesdata + wp;
1256           while ((p = *pp++) != 0)
1257             {
1258               Solvable *s = pool->solvables + p;
1259               if (s->arch == evr)
1260                 queue_push(&plist, p);
1261               else
1262                 wp = 0;
1263             }
1264           break;
1265         case REL_MULTIARCH:
1266           if (evr != ARCH_ANY)
1267             break;
1268           /* XXX : need to check for Multi-Arch: allowed! */
1269           wp = pool_whatprovides(pool, name);
1270           break;
1271         case REL_KIND:
1272           /* package kind filtering */
1273           if (!name)
1274             {
1275               FOR_POOL_SOLVABLES(p)
1276                 {
1277                   Solvable *s = pool->solvables + p;
1278                   if (s->repo != pool->installed && !pool_installable(pool, s))
1279                     continue;
1280                   if (pool_is_kind(pool, s->name, evr))
1281                     queue_push(&plist, p);
1282                 }
1283               break;
1284             }
1285           wp = pool_whatprovides(pool, name);
1286           pp = pool->whatprovidesdata + wp;
1287           while ((p = *pp++) != 0)
1288             {
1289               Solvable *s = pool->solvables + p;
1290               if (pool_is_kind(pool, s->name, evr))
1291                 queue_push(&plist, p);
1292               else
1293                 wp = 0;
1294             }
1295           break;
1296         case REL_FILECONFLICT:
1297           pp = pool_whatprovides_ptr(pool, name);
1298           while ((p = *pp++) != 0)
1299             {
1300               Id origd = MAKERELDEP(d);
1301               Solvable *s = pool->solvables + p;
1302               if (!s->provides)
1303                 continue;
1304               pidp = s->repo->idarraydata + s->provides;
1305               while ((pid = *pidp++) != 0)
1306                 if (pid == origd)
1307                   break;
1308               if (pid)
1309                 queue_push(&plist, p);
1310             }
1311           break;
1312 #ifdef ENABLE_CONDA
1313         case REL_CONDA:
1314           wp = pool_addrelproviders_conda(pool, name, evr, &plist);
1315           break;
1316 #endif
1317         default:
1318           break;
1319         }
1320       if (wp)
1321         {
1322           /* we can reuse an existing entry */
1323           queue_free(&plist);
1324           pool->whatprovides_rel[d] = wp;
1325           return wp;
1326         }
1327     }
1328   else if (flags)
1329     {
1330       Id *ppaux = 0;
1331       int eqmagic = 0;
1332       /* simple version comparison relation */
1333 #if 0
1334       POOL_DEBUG(SOLV_DEBUG_STATS, "addrelproviders: what provides %s?\n", pool_dep2str(pool, name));
1335 #endif
1336       pp = pool_whatprovides_ptr(pool, name);
1337       if (!ISRELDEP(name) && (Offset)name < pool->whatprovidesauxoff)
1338         ppaux = pool->whatprovidesaux[name] ? pool->whatprovidesauxdata + pool->whatprovidesaux[name] : 0;
1339       while (ISRELDEP(name))
1340         {
1341           rd = GETRELDEP(pool, name);
1342           name = rd->name;
1343         }
1344       while ((p = *pp++) != 0)
1345         {
1346           Solvable *s = pool->solvables + p;
1347           if (ppaux)
1348             {
1349               pid = *ppaux++;
1350               if (pid && pid != 1)
1351                 {
1352 #if 0
1353                   POOL_DEBUG(SOLV_DEBUG_STATS, "addrelproviders: aux hit %d %s\n", p, pool_dep2str(pool, pid));
1354 #endif
1355                   if (!ISRELDEP(pid))
1356                     {
1357                       if (pid != name)
1358                         continue;               /* wrong provides name */
1359                       if (pool->disttype == DISTTYPE_DEB)
1360                         continue;               /* unversioned provides can never match versioned deps */
1361                     }
1362                   else
1363                     {
1364                       prd = GETRELDEP(pool, pid);
1365                       if (prd->name != name)
1366                         continue;               /* wrong provides name */
1367                       if (!eqmagic)
1368                         eqmagic = rpmeqmagic_init(pool, flags, evr);
1369                       if (eqmagic > 0 && prd->flags == REL_EQ && !ISRELDEP(prd->evr) &&
1370                           rpmeqmagic_cantmatch(pool, prd->flags, prd->evr, eqmagic))
1371                         continue;
1372                       /* right package, both deps are rels. check flags/evr */
1373                       if (!pool_match_flags_evr(pool, prd->flags, prd->evr, flags, evr))
1374                         continue;
1375                     }
1376                   queue_push(&plist, p);
1377                   continue;
1378                 }
1379             }
1380           if (!s->provides || s->arch == ARCH_SRC || s->arch == ARCH_NOSRC)
1381             {
1382               /* no provides or src rpm - check nevr */
1383               if (pool_match_nevr_rel(pool, s, MAKERELDEP(d)))
1384                 queue_push(&plist, p);
1385               continue;
1386             }
1387           /* solvable p provides name in some rels */
1388           if (!eqmagic)
1389             eqmagic = rpmeqmagic_init(pool, flags, evr);
1390           pidp = s->repo->idarraydata + s->provides;
1391           while ((pid = *pidp++) != 0)
1392             {
1393               if (!ISRELDEP(pid))
1394                 {
1395                   if (pid != name)
1396                     continue;           /* wrong provides name */
1397                   if (pool->disttype == DISTTYPE_DEB)
1398                     continue;           /* unversioned provides can never match versioned deps */
1399                   break;
1400                 }
1401               prd = GETRELDEP(pool, pid);
1402               if (prd->name != name)
1403                 continue;               /* wrong provides name */
1404               /* right package, both deps are rels. check flags/evr */
1405               if (eqmagic > 0 && prd->flags == REL_EQ && !ISRELDEP(prd->evr) &&
1406                   rpmeqmagic_cantmatch(pool, prd->flags, prd->evr, eqmagic))
1407                 continue;
1408               if (pool_match_flags_evr(pool, prd->flags, prd->evr, flags, evr))
1409                 break;  /* matches */
1410             }
1411           if (!pid)
1412             continue;   /* none of the providers matched */
1413           queue_push(&plist, p);
1414         }
1415       /* make our system solvable provide all unknown rpmlib() stuff */
1416       if (plist.count == 0 && !strncmp(pool_id2str(pool, name), "rpmlib(", 7))
1417         queue_push(&plist, SYSTEMSOLVABLE);
1418     }
1419   /* add providers to whatprovides */
1420 #if 0
1421   POOL_DEBUG(SOLV_DEBUG_STATS, "addrelproviders: adding %d packages to %d\n", plist.count, d);
1422 #endif
1423   pool->whatprovides_rel[d] = pool_queuetowhatprovides(pool, &plist);
1424   queue_free(&plist);
1425
1426   return pool->whatprovides_rel[d];
1427 }
1428
1429 void
1430 pool_flush_namespaceproviders(Pool *pool, Id ns, Id evr)
1431 {
1432   int nrels = pool->nrels;
1433   Id d;
1434   Reldep *rd;
1435
1436   if (!pool->whatprovides_rel)
1437     return;
1438   for (d = 1, rd = pool->rels + d; d < nrels; d++, rd++)
1439     {
1440       if (rd->flags != REL_NAMESPACE || rd->name == NAMESPACE_OTHERPROVIDERS)
1441         continue;
1442       if (ns && rd->name != ns)
1443         continue;
1444       if (evr && rd->evr != evr)
1445         continue;
1446       if (pool->whatprovides_rel[d])
1447         pool_set_whatprovides(pool, MAKERELDEP(d), 0);
1448     }
1449 }
1450
1451 /* intersect dependencies in keyname with dep, return list of matching packages */
1452 void
1453 pool_whatmatchesdep(Pool *pool, Id keyname, Id dep, Queue *q, int marker)
1454 {
1455   Id p;
1456   Queue qq;
1457   int i;
1458
1459   queue_empty(q);
1460   if (keyname == SOLVABLE_NAME)
1461     {
1462       Id pp;
1463       FOR_PROVIDES(p, pp, dep)
1464         if (pool_match_dep(pool, p, dep))
1465           queue_push(q, p);
1466       return;
1467     }
1468   queue_init(&qq);
1469   FOR_POOL_SOLVABLES(p)
1470     {
1471       Solvable *s = pool->solvables + p;
1472       if (s->repo->disabled)
1473         continue;
1474       if (s->repo != pool->installed && !pool_installable(pool, s))
1475         continue;
1476       if (qq.count)
1477         queue_empty(&qq);
1478       solvable_lookup_deparray(s, keyname, &qq, marker);
1479       for (i = 0; i < qq.count; i++)
1480         if (pool_match_dep(pool, qq.elements[i], dep))
1481           {
1482             queue_push(q, p);
1483             break;
1484           }
1485     }
1486   queue_free(&qq);
1487 }
1488
1489 /* check if keyname contains dep, return list of matching packages */
1490 void
1491 pool_whatcontainsdep(Pool *pool, Id keyname, Id dep, Queue *q, int marker)
1492 {
1493   Id p;
1494   Queue qq;
1495   int i;
1496
1497   queue_empty(q);
1498   if (!dep)
1499     return;
1500   queue_init(&qq);
1501   FOR_POOL_SOLVABLES(p)
1502     {
1503       Solvable *s = pool->solvables + p;
1504       if (s->repo->disabled)
1505         continue;
1506       if (s->repo != pool->installed && !pool_installable(pool, s))
1507         continue;
1508       if (qq.count)
1509         queue_empty(&qq);
1510       solvable_lookup_deparray(s, keyname, &qq, marker);
1511       for (i = 0; i < qq.count; i++)
1512         if (qq.elements[i] == dep)
1513           {
1514             queue_push(q, p);
1515             break;
1516           }
1517     }
1518   queue_free(&qq);
1519 }
1520
1521 /* intersect dependencies in keyname with all provides of solvable solvid,
1522  * return list of matching packages */
1523 /* this currently only works for installable packages */
1524 void
1525 pool_whatmatchessolvable(Pool *pool, Id keyname, Id solvid, Queue *q, int marker)
1526 {
1527   Id p;
1528   Queue qq;
1529   Map missc;            /* cache for misses */
1530   int reloff;
1531
1532   queue_empty(q);
1533   queue_init(&qq);
1534   reloff = pool->ss.nstrings;
1535   map_init(&missc, reloff + pool->nrels);
1536   FOR_POOL_SOLVABLES(p)
1537     {
1538       Solvable *s = pool->solvables + p;
1539       if (p == solvid)
1540         continue;       /* filter out self-matches */
1541       if (s->repo->disabled)
1542         continue;
1543       if (s->repo != pool->installed && !pool_installable(pool, s))
1544         continue;
1545       if (solvable_matchessolvable_int(s, keyname, marker, solvid, 0, &qq, &missc, reloff))
1546         queue_push(q, p);
1547     }
1548   map_free(&missc);
1549   queue_free(&qq);
1550 }
1551
1552 /*************************************************************************/
1553
1554 void
1555 pool_debug(Pool *pool, int type, const char *format, ...)
1556 {
1557   va_list args;
1558   char buf[1024];
1559
1560   if ((type & (SOLV_FATAL|SOLV_ERROR)) == 0)
1561     {
1562       if ((pool->debugmask & type) == 0)
1563         return;
1564     }
1565   va_start(args, format);
1566   if (!pool->debugcallback)
1567     {
1568       if ((type & (SOLV_FATAL|SOLV_ERROR)) == 0 && !(pool->debugmask & SOLV_DEBUG_TO_STDERR))
1569         vprintf(format, args);
1570       else
1571         vfprintf(stderr, format, args);
1572       va_end(args);
1573       return;
1574     }
1575   vsnprintf(buf, sizeof(buf), format, args);
1576   va_end(args);
1577   pool->debugcallback(pool, pool->debugcallbackdata, type, buf);
1578 }
1579
1580 int
1581 pool_error(Pool *pool, int ret, const char *format, ...)
1582 {
1583   va_list args;
1584   int l;
1585
1586   if (!pool)
1587     return ret;
1588   va_start(args, format);
1589   if (!pool->errstr)
1590     {
1591       pool->errstra = 1024;
1592       pool->errstr = solv_malloc(pool->errstra);
1593     }
1594   if (!*format)
1595     {
1596       *pool->errstr = 0;
1597       l = 0;
1598     }
1599   else
1600     l = vsnprintf(pool->errstr, pool->errstra, format, args);
1601   va_end(args);
1602   if (l >= 0 && l + 1 > pool->errstra)
1603     {
1604       pool->errstra = l + 256;
1605       pool->errstr = solv_realloc(pool->errstr, pool->errstra);
1606       va_start(args, format);
1607       l = vsnprintf(pool->errstr, pool->errstra, format, args);
1608       va_end(args);
1609     }
1610   if (l < 0)
1611     strcpy(pool->errstr, "unknown error");
1612   if (pool->debugmask & SOLV_ERROR)
1613     pool_debug(pool, SOLV_ERROR, "%s\n", pool->errstr);
1614   return ret;
1615 }
1616
1617 char *
1618 pool_errstr(Pool *pool)
1619 {
1620   return pool->errstr ? pool->errstr : "no error";
1621 }
1622
1623 void
1624 pool_setdebuglevel(Pool *pool, int level)
1625 {
1626   int mask = SOLV_DEBUG_RESULT;
1627   if (level > 0)
1628     mask |= SOLV_DEBUG_STATS|SOLV_DEBUG_ANALYZE|SOLV_DEBUG_UNSOLVABLE|SOLV_DEBUG_SOLVER|SOLV_DEBUG_TRANSACTION|SOLV_ERROR;
1629   if (level > 1)
1630     mask |= SOLV_DEBUG_JOB|SOLV_DEBUG_SOLUTIONS|SOLV_DEBUG_POLICY;
1631   if (level > 2)
1632     mask |= SOLV_DEBUG_PROPAGATE;
1633   if (level > 3)
1634     mask |= SOLV_DEBUG_RULE_CREATION | SOLV_DEBUG_WATCHES;
1635   mask |= pool->debugmask & SOLV_DEBUG_TO_STDERR;       /* keep bit */
1636   pool->debugmask = mask;
1637 }
1638
1639 void pool_setdebugcallback(Pool *pool, void (*debugcallback)(struct s_Pool *, void *data, int type, const char *str), void *debugcallbackdata)
1640 {
1641   pool->debugcallback = debugcallback;
1642   pool->debugcallbackdata = debugcallbackdata;
1643 }
1644
1645 void pool_setdebugmask(Pool *pool, int mask)
1646 {
1647   pool->debugmask = mask;
1648 }
1649
1650 void pool_setloadcallback(Pool *pool, int (*cb)(struct s_Pool *, struct s_Repodata *, void *), void *loadcbdata)
1651 {
1652   pool->loadcallback = cb;
1653   pool->loadcallbackdata = loadcbdata;
1654 }
1655
1656 void pool_setnamespacecallback(Pool *pool, Id (*cb)(struct s_Pool *, void *, Id, Id), void *nscbdata)
1657 {
1658   pool->nscallback = cb;
1659   pool->nscallbackdata = nscbdata;
1660 }
1661
1662 void
1663 pool_search(Pool *pool, Id p, Id key, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, struct s_Repodata *data, struct s_Repokey *key, struct s_KeyValue *kv), void *cbdata)
1664 {
1665   if (p)
1666     {
1667       if (pool->solvables[p].repo)
1668         repo_search(pool->solvables[p].repo, p, key, match, flags, callback, cbdata);
1669       return;
1670     }
1671   /* FIXME: obey callback return value! */
1672   for (p = 1; p < pool->nsolvables; p++)
1673     if (pool->solvables[p].repo)
1674       repo_search(pool->solvables[p].repo, p, key, match, flags, callback, cbdata);
1675 }
1676
1677 void
1678 pool_clear_pos(Pool *pool)
1679 {
1680   memset(&pool->pos, 0, sizeof(pool->pos));
1681 }
1682
1683 void
1684 pool_set_languages(Pool *pool, const char **languages, int nlanguages)
1685 {
1686   int i;
1687
1688   pool->languagecache = solv_free(pool->languagecache);
1689   pool->languagecacheother = 0;
1690   for (i = 0; i < pool->nlanguages; i++)
1691     free((char *)pool->languages[i]);
1692   pool->languages = solv_free((void *)pool->languages);
1693   pool->nlanguages = nlanguages;
1694   if (!nlanguages)
1695     return;
1696   pool->languages = solv_calloc(nlanguages, sizeof(const char **));
1697   for (i = 0; i < pool->nlanguages; i++)
1698     pool->languages[i] = solv_strdup(languages[i]);
1699 }
1700
1701 Id
1702 pool_id2langid(Pool *pool, Id id, const char *lang, int create)
1703 {
1704   const char *n;
1705   char buf[256], *p;
1706   int l;
1707
1708   if (!lang || !*lang)
1709     return id;
1710   n = pool_id2str(pool, id);
1711   l = strlen(n) + strlen(lang) + 2;
1712   if (l > sizeof(buf))
1713     p = solv_malloc(strlen(n) + strlen(lang) + 2);
1714   else
1715     p = buf;
1716   sprintf(p, "%s:%s", n, lang);
1717   id = pool_str2id(pool, p, create);
1718   if (p != buf)
1719     free(p);
1720   return id;
1721 }
1722
1723 char *
1724 pool_alloctmpspace(Pool *pool, int len)
1725 {
1726   int n = pool->tmpspace.n;
1727   if (!len)
1728     return 0;
1729   if (len > pool->tmpspace.len[n])
1730     {
1731       pool->tmpspace.buf[n] = solv_realloc(pool->tmpspace.buf[n], len + 32);
1732       pool->tmpspace.len[n] = len + 32;
1733     }
1734   pool->tmpspace.n = (n + 1) % POOL_TMPSPACEBUF;
1735   return pool->tmpspace.buf[n];
1736 }
1737
1738 static char *
1739 pool_alloctmpspace_free(Pool *pool, const char *space, int len)
1740 {
1741   if (space)
1742     {
1743       int n, oldn;
1744       n = oldn = pool->tmpspace.n;
1745       for (;;)
1746         {
1747           if (!n--)
1748             n = POOL_TMPSPACEBUF - 1;
1749           if (n == oldn)
1750             break;
1751           if (pool->tmpspace.buf[n] != space)
1752             continue;
1753           if (len > pool->tmpspace.len[n])
1754             {
1755               pool->tmpspace.buf[n] = solv_realloc(pool->tmpspace.buf[n], len + 32);
1756               pool->tmpspace.len[n] = len + 32;
1757             }
1758           return pool->tmpspace.buf[n];
1759         }
1760     }
1761   return 0;
1762 }
1763
1764 void
1765 pool_freetmpspace(Pool *pool, const char *space)
1766 {
1767   int n = pool->tmpspace.n;
1768   if (!space)
1769     return;
1770   n = (n + (POOL_TMPSPACEBUF - 1)) % POOL_TMPSPACEBUF;
1771   if (pool->tmpspace.buf[n] == space)
1772     pool->tmpspace.n = n;
1773 }
1774
1775 char *
1776 pool_tmpjoin(Pool *pool, const char *str1, const char *str2, const char *str3)
1777 {
1778   int l1, l2, l3;
1779   char *s, *str;
1780   l1 = str1 ? strlen(str1) : 0;
1781   l2 = str2 ? strlen(str2) : 0;
1782   l3 = str3 ? strlen(str3) : 0;
1783   s = str = pool_alloctmpspace(pool, l1 + l2 + l3 + 1);
1784   if (l1)
1785     {
1786       strcpy(s, str1);
1787       s += l1;
1788     }
1789   if (l2)
1790     {
1791       strcpy(s, str2);
1792       s += l2;
1793     }
1794   if (l3)
1795     {
1796       strcpy(s, str3);
1797       s += l3;
1798     }
1799   *s = 0;
1800   return str;
1801 }
1802
1803 char *
1804 pool_tmpappend(Pool *pool, const char *str1, const char *str2, const char *str3)
1805 {
1806   int l1, l2, l3;
1807   char *s, *str;
1808
1809   l1 = str1 ? strlen(str1) : 0;
1810   l2 = str2 ? strlen(str2) : 0;
1811   l3 = str3 ? strlen(str3) : 0;
1812   str = pool_alloctmpspace_free(pool, str1, l1 + l2 + l3 + 1);
1813   if (str)
1814     str1 = str;
1815   else
1816     str = pool_alloctmpspace(pool, l1 + l2 + l3 + 1);
1817   s = str;
1818   if (l1)
1819     {
1820       if (s != str1)
1821         strcpy(s, str1);
1822       s += l1;
1823     }
1824   if (l2)
1825     {
1826       strcpy(s, str2);
1827       s += l2;
1828     }
1829   if (l3)
1830     {
1831       strcpy(s, str3);
1832       s += l3;
1833     }
1834   *s = 0;
1835   return str;
1836 }
1837
1838 const char *
1839 pool_bin2hex(Pool *pool, const unsigned char *buf, int len)
1840 {
1841   char *s;
1842   if (!len)
1843     return "";
1844   s = pool_alloctmpspace(pool, 2 * len + 1);
1845   solv_bin2hex(buf, len, s);
1846   return s;
1847 }
1848
1849 const char *
1850 pool_lookup_str(Pool *pool, Id entry, Id keyname)
1851 {
1852   if (entry == SOLVID_POS && pool->pos.repo)
1853     return repo_lookup_str(pool->pos.repo, pool->pos.repodataid ? entry : pool->pos.solvid, keyname);
1854   if (entry <= 0)
1855     return 0;
1856   return solvable_lookup_str(pool->solvables + entry, keyname);
1857 }
1858
1859 Id
1860 pool_lookup_id(Pool *pool, Id entry, Id keyname)
1861 {
1862   if (entry == SOLVID_POS && pool->pos.repo)
1863     return repo_lookup_id(pool->pos.repo, pool->pos.repodataid ? entry : pool->pos.solvid, keyname);
1864   if (entry <= 0)
1865     return 0;
1866   return solvable_lookup_id(pool->solvables + entry, keyname);
1867 }
1868
1869 unsigned long long
1870 pool_lookup_num(Pool *pool, Id entry, Id keyname, unsigned long long notfound)
1871 {
1872   if (entry == SOLVID_POS && pool->pos.repo)
1873     return repo_lookup_num(pool->pos.repo, pool->pos.repodataid ? entry : pool->pos.solvid, keyname, notfound);
1874   if (entry <= 0)
1875     return notfound;
1876   return solvable_lookup_num(pool->solvables + entry, keyname, notfound);
1877 }
1878
1879 int
1880 pool_lookup_void(Pool *pool, Id entry, Id keyname)
1881 {
1882   if (entry == SOLVID_POS && pool->pos.repo)
1883     return repo_lookup_void(pool->pos.repo, pool->pos.repodataid ? entry : pool->pos.solvid, keyname);
1884   if (entry <= 0)
1885     return 0;
1886   return solvable_lookup_void(pool->solvables + entry, keyname);
1887 }
1888
1889 const unsigned char *
1890 pool_lookup_bin_checksum(Pool *pool, Id entry, Id keyname, Id *typep)
1891 {
1892   if (entry == SOLVID_POS && pool->pos.repo)
1893     return repo_lookup_bin_checksum(pool->pos.repo, pool->pos.repodataid ? entry : pool->pos.solvid, keyname, typep);
1894   if (entry <= 0)
1895     return 0;
1896   return solvable_lookup_bin_checksum(pool->solvables + entry, keyname, typep);
1897 }
1898
1899 const char *
1900 pool_lookup_checksum(Pool *pool, Id entry, Id keyname, Id *typep)
1901 {
1902   if (entry == SOLVID_POS && pool->pos.repo)
1903     return repo_lookup_checksum(pool->pos.repo, pool->pos.repodataid ? entry : pool->pos.solvid, keyname, typep);
1904   if (entry <= 0)
1905     return 0;
1906   return solvable_lookup_checksum(pool->solvables + entry, keyname, typep);
1907 }
1908
1909 int
1910 pool_lookup_idarray(Pool *pool, Id entry, Id keyname, Queue *q)
1911 {
1912   if (entry == SOLVID_POS && pool->pos.repo)
1913     return repo_lookup_idarray(pool->pos.repo, pool->pos.repodataid ? entry : pool->pos.solvid, keyname, q);
1914   if (entry <= 0)
1915     return 0;
1916   return solvable_lookup_idarray(pool->solvables + entry, keyname, q);
1917 }
1918
1919 const char *
1920 pool_lookup_deltalocation(Pool *pool, Id entry, unsigned int *medianrp)
1921 {
1922   const char *loc;
1923   if (medianrp)
1924     *medianrp = 0;
1925   if (entry != SOLVID_POS)
1926     return 0;
1927   loc = pool_lookup_str(pool, entry, DELTA_LOCATION_DIR);
1928   loc = pool_tmpjoin(pool, loc, loc ? "/" : 0, pool_lookup_str(pool, entry, DELTA_LOCATION_NAME));
1929   loc = pool_tmpappend(pool, loc, "-", pool_lookup_str(pool, entry, DELTA_LOCATION_EVR));
1930   loc = pool_tmpappend(pool, loc, ".", pool_lookup_str(pool, entry, DELTA_LOCATION_SUFFIX));
1931   return loc;
1932 }
1933
1934 void
1935 pool_set_whatprovides(Pool *pool, Id id, Id providers)
1936 {
1937   int d, nrels = pool->nrels;
1938   Reldep *rd;
1939   Map m;
1940
1941   /* set new entry */
1942   if (ISRELDEP(id))
1943     {
1944       d = GETRELID(id);
1945       pool->whatprovides_rel[d] = providers;
1946       d++;
1947     }
1948   else
1949     {
1950       pool->whatprovides[id] = providers;
1951       if ((Offset)id < pool->whatprovidesauxoff)
1952         pool->whatprovidesaux[id] = 0;  /* sorry */
1953       d = 1;
1954     }
1955   if (!pool->whatprovides_rel)
1956     return;
1957   /* clear cache of all rels that use it */
1958   map_init(&m, 0);
1959   for (rd = pool->rels + d; d < nrels; d++, rd++)
1960     {
1961       if (rd->name == id || rd->evr == id ||
1962           (m.size && ISRELDEP(rd->name) && MAPTST(&m, GETRELID(rd->name))) ||
1963           (m.size && ISRELDEP(rd->evr)  && MAPTST(&m, GETRELID(rd->evr))))
1964         {
1965           pool->whatprovides_rel[d] = 0;        /* clear cache */
1966           if (!m.size)
1967             map_init(&m, nrels);
1968           MAPSET(&m, d);
1969         }
1970     }
1971   map_free(&m);
1972 }
1973
1974 static void
1975 add_new_provider(Pool *pool, Id id, Id p)
1976 {
1977   Queue q;
1978   Id *pp;
1979
1980   /* find whatprovides entry */
1981   while (ISRELDEP(id))
1982     {
1983       Reldep *rd = GETRELDEP(pool, id);
1984       id = rd->name;
1985     }
1986
1987   /* add new provider to existing list keeping it sorted */
1988   queue_init(&q);
1989   for (pp = pool->whatprovidesdata + pool->whatprovides[id]; *pp; pp++)
1990     {
1991       if (*pp == p)
1992         {
1993           queue_free(&q);       /* already have it */
1994           return;
1995         }
1996       if (*pp > p)
1997         {
1998           queue_push(&q, p);
1999           p = 0;
2000         }
2001       queue_push(&q, *pp);
2002     }
2003   if (p)
2004     queue_push(&q, p);
2005   pool_set_whatprovides(pool, id, pool_queuetowhatprovides(pool, &q));
2006   queue_free(&q);
2007 }
2008
2009 void
2010 pool_add_fileconflicts_deps(Pool *pool, Queue *conflicts)
2011 {
2012   int hadhashes = pool->relhashtbl ? 1 : 0;
2013   Solvable *s;
2014   Id fn, p, q, md5;
2015   Id id;
2016   int i;
2017
2018   if (!conflicts->count)
2019     return;
2020   for (i = 0; i < conflicts->count; i += 6)
2021     {
2022       fn = conflicts->elements[i];
2023       p = conflicts->elements[i + 1];
2024       md5 = conflicts->elements[i + 2];
2025       q = conflicts->elements[i + 4];
2026       id = pool_rel2id(pool, fn, md5, REL_FILECONFLICT, 1);
2027       s = pool->solvables + p;
2028       if (!s->repo)
2029         continue;
2030       s->provides = repo_addid_dep(s->repo, s->provides, id, SOLVABLE_FILEMARKER);
2031       if (pool->whatprovides)
2032         add_new_provider(pool, id, p);
2033       s = pool->solvables + q;
2034       if (!s->repo)
2035         continue;
2036       s->conflicts = repo_addid_dep(s->repo, s->conflicts, id, 0);
2037     }
2038   if (!hadhashes)
2039     pool_freeidhashes(pool);
2040 }
2041
2042 char *
2043 pool_prepend_rootdir(Pool *pool, const char *path)
2044 {
2045   if (!path)
2046     return 0;
2047   if (!pool->rootdir)
2048     return solv_strdup(path);
2049   return solv_dupjoin(pool->rootdir, "/", *path == '/' ? path + 1 : path);
2050 }
2051
2052 const char *
2053 pool_prepend_rootdir_tmp(Pool *pool, const char *path)
2054 {
2055   if (!path)
2056     return 0;
2057   if (!pool->rootdir)
2058     return path;
2059   return pool_tmpjoin(pool, pool->rootdir, "/", *path == '/' ? path + 1 : path);
2060 }
2061
2062 void
2063 pool_set_rootdir(Pool *pool, const char *rootdir)
2064 {
2065   solv_free(pool->rootdir);
2066   pool->rootdir = solv_strdup(rootdir);
2067 }
2068
2069 const char *
2070 pool_get_rootdir(Pool *pool)
2071 {
2072   return pool->rootdir;
2073 }
2074
2075 /* only used in libzypp */
2076 void
2077 pool_set_custom_vendorcheck(Pool *pool, int (*vendorcheck)(Pool *, Solvable *, Solvable *))
2078 {
2079   pool->custom_vendorcheck = vendorcheck;
2080 }
2081
2082 /* EOF */