src/solvable.c

   1 /*
   2  * Copyright (c) 2008, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * solvable.c
  10  *
  11  * set/retrieve data from solvables
  12  */
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <stdarg.h>
  17 #include <unistd.h>
  18 #include <string.h>
  19
  20 #include "pool.h"
  21 #include "repo.h"
  22 #include "util.h"
  23 #include "policy.h"
  24 #include "poolvendor.h"
  25 #include "chksum.h"
  26 #include "linkedpkg.h"
  27
  28 const char *
  29 pool_solvable2str(Pool *pool, Solvable *s)
  30 {
  31   const char *n, *e, *a;
  32   int nl, el, al;
  33   char *p;
  34   n = pool_id2str(pool, s->name);
  35   e = s->evr ? pool_id2str(pool, s->evr) : "";
  36   /* XXX: may want to skip the epoch here */
  37   a = s->arch ? pool_id2str(pool, s->arch) : "";
  38   nl = strlen(n);
  39   el = strlen(e);
  40   al = strlen(a);
  41   if (pool->havedistepoch)
  42     {
  43       /* strip the distepoch from the evr */
  44       const char *de = strrchr(e, '-');
  45       if (de && (de = strchr(de, ':')) != 0)
  46         el = de - e;
  47     }
  48   p = pool_alloctmpspace(pool, nl + el + al + 3);
  49   strcpy(p, n);
  50   if (el)
  51     {
  52       p[nl++] = '-';
  53       strncpy(p + nl, e, el);
  54       p[nl + el] = 0;
  55     }
  56   if (al)
  57     {
  58       p[nl + el] = pool->disttype == DISTTYPE_HAIKU ? '-' : '.';
  59       strcpy(p + nl + el + 1, a);
  60     }
  61   if (pool->disttype == DISTTYPE_CONDA && solvable_lookup_type(s, SOLVABLE_BUILDFLAVOR))
  62     {
  63       Queue flavorq;
  64       int i;
  65       queue_init(&flavorq);
  66       solvable_lookup_idarray(s, SOLVABLE_BUILDFLAVOR, &flavorq);
  67       for (i = 0; i < flavorq.count; i++)
  68         p = pool_tmpappend(pool, p, "-", pool_id2str(pool, flavorq.elements[i]));
  69       queue_free(&flavorq);
  70     }
  71   return p;
  72 }
  73
  74 Id
  75 solvable_lookup_type(Solvable *s, Id keyname)
  76 {
  77   if (!s->repo)
  78     return 0;
  79   return repo_lookup_type(s->repo, s - s->repo->pool->solvables, keyname);
  80 }
  81
  82 Id
  83 solvable_lookup_id(Solvable *s, Id keyname)
  84 {
  85   if (!s->repo)
  86     return 0;
  87   return repo_lookup_id(s->repo, s - s->repo->pool->solvables, keyname);
  88 }
  89
  90 int
  91 solvable_lookup_idarray(Solvable *s, Id keyname, Queue *q)
  92 {
  93   if (!s->repo)
  94     {
  95       queue_empty(q);
  96       return 0;
  97     }
  98   return repo_lookup_idarray(s->repo, s - s->repo->pool->solvables, keyname, q);
  99 }
 100
 101 int
 102 solvable_lookup_deparray(Solvable *s, Id keyname, Queue *q, Id marker)
 103 {
 104   if (!s->repo)
 105     {
 106       queue_empty(q);
 107       return 0;
 108     }
 109   return repo_lookup_deparray(s->repo, s - s->repo->pool->solvables, keyname, q, marker);
 110 }
 111
 112 static const char *
 113 solvable_lookup_str_joinarray(Solvable *s, Id keyname, const char *joinstr)
 114 {
 115   Queue q;
 116   Id qbuf[10];
 117   char *str = 0;
 118
 119   queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf));
 120   if (solvable_lookup_idarray(s, keyname, &q) && q.count)
 121     {
 122       Pool *pool = s->repo->pool;
 123       if (q.count == 1)
 124         str = (char *)pool_id2str(pool, q.elements[0]);
 125       else
 126         {
 127           int i;
 128           str = pool_tmpjoin(pool, pool_id2str(pool, q.elements[0]), 0, 0);
 129           for (i = 1; i < q.count; i++)
 130             str = pool_tmpappend(pool, str, joinstr, pool_id2str(pool, q.elements[i]));
 131         }
 132     }
 133   queue_free(&q);
 134   return str;
 135 }
 136
 137 const char *
 138 solvable_lookup_str(Solvable *s, Id keyname)
 139 {
 140   const char *str;
 141   if (!s->repo)
 142     return 0;
 143   str = repo_lookup_str(s->repo, s - s->repo->pool->solvables, keyname);
 144   if (!str && (keyname == SOLVABLE_LICENSE || keyname == SOLVABLE_GROUP || keyname == SOLVABLE_BUILDFLAVOR))
 145     str = solvable_lookup_str_joinarray(s, keyname, ", ");
 146   return str;
 147 }
 148
 149 static const char *
 150 solvable_lookup_str_base(Solvable *s, Id keyname, Id basekeyname, int usebase)
 151 {
 152   Pool *pool;
 153   const char *str, *basestr;
 154   Id p, pp, name;
 155   Solvable *s2;
 156   int pass;
 157
 158   if (!s->repo)
 159     return 0;
 160   pool = s->repo->pool;
 161   str = solvable_lookup_str(s, keyname);
 162   if (str || keyname == basekeyname)
 163     return str;
 164   basestr = solvable_lookup_str(s, basekeyname);
 165   if (!basestr)
 166     return 0;
 167   /* search for a solvable with same name and same base that has the
 168    * translation */
 169   if (!pool->whatprovides)
 170     return usebase ? basestr : 0;
 171   name = s->name;
 172   /* we do this in two passes, first same vendor, then all other vendors */
 173   for (pass = 0; pass < 2; pass++)
 174     {
 175       FOR_PROVIDES(p, pp, name)
 176         {
 177           s2 = pool->solvables + p;
 178           if (s2->name != name)
 179             continue;
 180           if ((s->vendor == s2->vendor) != (pass == 0))
 181             continue;
 182           str = solvable_lookup_str(s2, basekeyname);
 183           if (!str || strcmp(str, basestr))
 184             continue;
 185           str = solvable_lookup_str(s2, keyname);
 186           if (str)
 187             return str;
 188         }
 189 #ifdef ENABLE_LINKED_PKGS
 190       /* autopattern/product translation magic */
 191       if (pass)
 192         {
 193           const char *n = pool_id2str(pool, name);
 194           if (*n == 'p')
 195             {
 196               if (!strncmp("pattern:", n, 8) && (name = find_autopattern_name(pool, s)) != 0)
 197                 pass = -1;
 198               if (!strncmp("product:", n, 8) && (name = find_autoproduct_name(pool, s)) != 0)
 199                 pass = -1;
 200             }
 201         }
 202 #endif
 203     }
 204   return usebase ? basestr : 0;
 205 }
 206
 207 const char *
 208 solvable_lookup_str_poollang(Solvable *s, Id keyname)
 209 {
 210   Pool *pool;
 211   int i, cols;
 212   const char *str;
 213   Id *row;
 214
 215   if (!s->repo)
 216     return 0;
 217   pool = s->repo->pool;
 218   if (!pool->nlanguages)
 219     return solvable_lookup_str(s, keyname);
 220   cols = pool->nlanguages + 1;
 221   if (!pool->languagecache)
 222     {
 223       pool->languagecache = solv_calloc(cols * ID_NUM_INTERNAL, sizeof(Id));
 224       pool->languagecacheother = 0;
 225     }
 226   if (keyname >= ID_NUM_INTERNAL)
 227     {
 228       row = pool->languagecache + ID_NUM_INTERNAL * cols;
 229       for (i = 0; i < pool->languagecacheother; i++, row += cols)
 230         if (*row == keyname)
 231           break;
 232       if (i >= pool->languagecacheother)
 233         {
 234           pool->languagecache = solv_realloc2(pool->languagecache, pool->languagecacheother + 1, cols * sizeof(Id));
 235           row = pool->languagecache + cols * (ID_NUM_INTERNAL + pool->languagecacheother++);
 236           *row = keyname;
 237         }
 238     }
 239   else
 240     row = pool->languagecache + keyname * cols;
 241   row++;        /* skip keyname */
 242   for (i = 0; i < pool->nlanguages; i++, row++)
 243     {
 244       if (!*row)
 245         *row = pool_id2langid(pool, keyname, pool->languages[i], 1);
 246       str = solvable_lookup_str_base(s, *row, keyname, 0);
 247       if (str)
 248         return str;
 249     }
 250   return solvable_lookup_str(s, keyname);
 251 }
 252
 253 const char *
 254 solvable_lookup_str_lang(Solvable *s, Id keyname, const char *lang, int usebase)
 255 {
 256   Id id;
 257   if (!s->repo)
 258     return 0;
 259   id = pool_id2langid(s->repo->pool, keyname, lang, 0);
 260   if (id)
 261     return solvable_lookup_str_base(s, id, keyname, usebase);
 262   if (!usebase)
 263     return 0;
 264   return solvable_lookup_str(s, keyname);
 265 }
 266
 267 unsigned long long
 268 solvable_lookup_num(Solvable *s, Id keyname, unsigned long long notfound)
 269 {
 270   if (!s->repo)
 271     return notfound;
 272   return repo_lookup_num(s->repo, s - s->repo->pool->solvables, keyname, notfound);
 273 }
 274
 275 unsigned long long
 276 solvable_lookup_sizek(Solvable *s, Id keyname, unsigned long long notfound)
 277 {
 278   unsigned long long size;
 279   if (!s->repo)
 280     return notfound;
 281   size = solvable_lookup_num(s, keyname, (unsigned long long)-1);
 282   return size == (unsigned long long)-1 ? notfound : ((size + 1023) >> 10);
 283 }
 284
 285 int
 286 solvable_lookup_void(Solvable *s, Id keyname)
 287 {
 288   if (!s->repo)
 289     return 0;
 290   return repo_lookup_void(s->repo, s - s->repo->pool->solvables, keyname);
 291 }
 292
 293 int
 294 solvable_lookup_bool(Solvable *s, Id keyname)
 295 {
 296   Id type;
 297   if (!s->repo)
 298     return 0;
 299   /* historic nonsense: there are two ways of storing a bool, as num == 1 or void. test both. */
 300   type = repo_lookup_type(s->repo, s - s->repo->pool->solvables, keyname);
 301   if (type == REPOKEY_TYPE_VOID)
 302     return 1;
 303   if (type == REPOKEY_TYPE_NUM || type == REPOKEY_TYPE_CONSTANT)
 304     return repo_lookup_num(s->repo, s - s->repo->pool->solvables, keyname, 0) == 1;
 305   return 0;
 306 }
 307
 308 const unsigned char *
 309 solvable_lookup_bin_checksum(Solvable *s, Id keyname, Id *typep)
 310 {
 311   if (!s->repo)
 312     {
 313       *typep = 0;
 314       return 0;
 315     }
 316   return repo_lookup_bin_checksum(s->repo, s - s->repo->pool->solvables, keyname, typep);
 317 }
 318
 319 const char *
 320 solvable_lookup_checksum(Solvable *s, Id keyname, Id *typep)
 321 {
 322   const unsigned char *chk = solvable_lookup_bin_checksum(s, keyname, typep);
 323   return chk ? pool_bin2hex(s->repo->pool, chk, solv_chksum_len(*typep)) : 0;
 324 }
 325
 326 static inline const char *
 327 evrid2vrstr(Pool *pool, Id evrid)
 328 {
 329   const char *p, *evr = pool_id2str(pool, evrid);
 330   if (!evr)
 331     return evr;
 332   for (p = evr; *p >= '0' && *p <= '9'; p++)
 333     ;
 334   return p != evr && *p == ':' && p[1] ? p + 1 : evr;
 335 }
 336
 337 const char *
 338 solvable_lookup_location(Solvable *s, unsigned int *medianrp)
 339 {
 340   Pool *pool;
 341   int l = 0;
 342   char *loc;
 343   const char *mediadir, *mediafile;
 344
 345   if (medianrp)
 346     *medianrp = 0;
 347   if (!s->repo)
 348     return 0;
 349   pool = s->repo->pool;
 350   if (medianrp)
 351     *medianrp = solvable_lookup_num(s, SOLVABLE_MEDIANR, 0);
 352   if (solvable_lookup_void(s, SOLVABLE_MEDIADIR))
 353     mediadir = pool_id2str(pool, s->arch);
 354   else
 355     mediadir = solvable_lookup_str(s, SOLVABLE_MEDIADIR);
 356   if (mediadir)
 357     l = strlen(mediadir) + 1;
 358   if (solvable_lookup_void(s, SOLVABLE_MEDIAFILE))
 359     {
 360       const char *name, *evr, *arch;
 361       name = pool_id2str(pool, s->name);
 362       evr = evrid2vrstr(pool, s->evr);
 363       arch = pool_id2str(pool, s->arch);
 364       /* name-vr.arch.rpm */
 365       loc = pool_alloctmpspace(pool, l + strlen(name) + strlen(evr) + strlen(arch) + 7);
 366       if (mediadir)
 367         sprintf(loc, "%s/%s-%s.%s.rpm", mediadir, name, evr, arch);
 368       else
 369         sprintf(loc, "%s-%s.%s.rpm", name, evr, arch);
 370     }
 371   else
 372     {
 373       mediafile = solvable_lookup_str(s, SOLVABLE_MEDIAFILE);
 374       if (!mediafile)
 375         return 0;
 376       loc = pool_alloctmpspace(pool, l + strlen(mediafile) + 1);
 377       if (mediadir)
 378         sprintf(loc, "%s/%s", mediadir, mediafile);
 379       else
 380         strcpy(loc, mediafile);
 381     }
 382   return loc;
 383 }
 384
 385 const char *
 386 solvable_get_location(Solvable *s, unsigned int *medianrp)
 387 {
 388   const char *loc = solvable_lookup_location(s, medianrp);
 389   if (medianrp && *medianrp == 0)
 390     *medianrp = 1;      /* compat, to be removed */
 391   return loc;
 392 }
 393
 394 const char *
 395 solvable_lookup_sourcepkg(Solvable *s)
 396 {
 397   Pool *pool;
 398   const char *evr, *name;
 399   Id archid;
 400
 401   if (!s->repo)
 402     return 0;
 403   pool = s->repo->pool;
 404   if (solvable_lookup_void(s, SOLVABLE_SOURCENAME))
 405     name = pool_id2str(pool, s->name);
 406   else
 407     name = solvable_lookup_str(s, SOLVABLE_SOURCENAME);
 408   if (!name)
 409     return 0;
 410   archid = solvable_lookup_id(s, SOLVABLE_SOURCEARCH);
 411   if (solvable_lookup_void(s, SOLVABLE_SOURCEEVR))
 412     evr = evrid2vrstr(pool, s->evr);
 413   else
 414     evr = solvable_lookup_str(s, SOLVABLE_SOURCEEVR);
 415   if (archid == ARCH_SRC || archid == ARCH_NOSRC)
 416     {
 417       char *str;
 418       str = pool_tmpjoin(pool, name, evr ? "-" : 0, evr);
 419       str = pool_tmpappend(pool, str, ".", pool_id2str(pool, archid));
 420       return pool_tmpappend(pool, str, ".rpm", 0);
 421     }
 422   else
 423     return name;        /* FIXME */
 424 }
 425
 426
 427 /*****************************************************************************/
 428
 429 /*
 430  * Create maps containing the state of each solvable. Input is a "installed" queue,
 431  * it contains all solvable ids that are considered to be installed.
 432  *
 433  * The created maps can be used for * pool_calc_duchanges() and
 434  * pool_calc_installsizechange().
 435  *
 436  */
 437 void
 438 pool_create_state_maps(Pool *pool, Queue *installed, Map *installedmap, Map *conflictsmap)
 439 {
 440   int i;
 441   Solvable *s;
 442   Id p, *dp;
 443   Id *conp, con;
 444
 445   map_init(installedmap, pool->nsolvables);
 446   if (conflictsmap)
 447     map_init(conflictsmap, pool->nsolvables);
 448   for (i = 0; i < installed->count; i++)
 449     {
 450       p = installed->elements[i];
 451       if (p <= 0)       /* makes it work with decisionq */
 452         continue;
 453       MAPSET(installedmap, p);
 454       if (!conflictsmap)
 455         continue;
 456       s = pool->solvables + p;
 457       if (!s->conflicts)
 458         continue;
 459       conp = s->repo->idarraydata + s->conflicts;
 460       while ((con = *conp++) != 0)
 461         {
 462           dp = pool_whatprovides_ptr(pool, con);
 463           for (; *dp; dp++)
 464             MAPSET(conflictsmap, *dp);
 465         }
 466     }
 467 }
 468
 469 /* Tests if two solvables have identical content. Currently
 470  * both solvables need to come from the same pool
 471  */
 472
 473 int
 474 solvable_identical(Solvable *s1, Solvable *s2)
 475 {
 476   unsigned long long bt1, bt2;
 477   Id rq1, rq2;
 478   Id *reqp;
 479   if (s1->name != s2->name)
 480     return 0;
 481   if (s1->arch != s2->arch)
 482     return 0;
 483   if (s1->evr != s2->evr)
 484     return 0;
 485
 486   /* check vendor, map missing vendor to empty string */
 487   if ((s1->vendor ? s1->vendor : 1) != (s2->vendor ? s2->vendor : 1))
 488     {
 489       /* workaround for bug 881493 */
 490       if (s1->repo && !strncmp(pool_id2str(s1->repo->pool, s1->name), "product:", 8))
 491         return 1;
 492       return 0;
 493     }
 494
 495   /* looking good, try some fancier stuff */
 496   /* might also look up the package checksum here */
 497   bt1 = solvable_lookup_num(s1, SOLVABLE_BUILDTIME, 0);
 498   bt2 = solvable_lookup_num(s2, SOLVABLE_BUILDTIME, 0);
 499   if (bt1 && bt2)
 500     {
 501       if (bt1 != bt2)
 502         return 0;
 503     }
 504   else
 505     {
 506       if (s1->repo)
 507         {
 508           /* workaround for bugs 881493 and 885830*/
 509           const char *n = pool_id2str(s1->repo->pool, s1->name);
 510           if (!strncmp(n, "product:", 8) || !strncmp(n, "application:", 12))
 511             return 1;
 512         }
 513       /* look at requires in a last attempt to find recompiled packages */
 514       rq1 = rq2 = 0;
 515       if (s1->requires)
 516         for (reqp = s1->repo->idarraydata + s1->requires; *reqp; reqp++)
 517           rq1 ^= *reqp;
 518       if (s2->requires)
 519         for (reqp = s2->repo->idarraydata + s2->requires; *reqp; reqp++)
 520           rq2 ^= *reqp;
 521       if (rq1 != rq2)
 522          return 0;
 523     }
 524   if (s1->repo && s1->repo->pool->disttype == DISTTYPE_CONDA)
 525     {
 526       /* check buildflavor and buildversion */
 527       const char *str1, *str2;
 528       str1 = solvable_lookup_str(s1, SOLVABLE_BUILDFLAVOR);
 529       str2 = solvable_lookup_str(s2, SOLVABLE_BUILDFLAVOR);
 530       if (str1 != str2 && (!str1 || !str2 || strcmp(str1, str2) != 0))
 531         return 0;
 532       str1 = solvable_lookup_str(s1, SOLVABLE_BUILDVERSION);
 533       str2 = solvable_lookup_str(s2, SOLVABLE_BUILDVERSION);
 534       if (str1 != str2 && (!str1 || !str2 || strcmp(str1, str2) != 0))
 535         return 0;
 536     }
 537   return 1;
 538 }
 539
 540 /* return the self provide dependency of a solvable */
 541 Id
 542 solvable_selfprovidedep(Solvable *s)
 543 {
 544   Pool *pool;
 545   Reldep *rd;
 546   Id prov, *provp;
 547
 548   if (!s->repo)
 549     return s->name;
 550   pool = s->repo->pool;
 551   if (s->provides)
 552     {
 553       provp = s->repo->idarraydata + s->provides;
 554       while ((prov = *provp++) != 0)
 555         {
 556           if (!ISRELDEP(prov))
 557             continue;
 558           rd = GETRELDEP(pool, prov);
 559           if (rd->name == s->name && rd->evr == s->evr && rd->flags == REL_EQ)
 560             return prov;
 561         }
 562     }
 563   return pool_rel2id(pool, s->name, s->evr, REL_EQ, 1);
 564 }
 565
 566 /* setter functions, simply call the repo variants */
 567 void
 568 solvable_set_id(Solvable *s, Id keyname, Id id)
 569 {
 570   repo_set_id(s->repo, s - s->repo->pool->solvables, keyname, id);
 571 }
 572
 573 void
 574 solvable_set_num(Solvable *s, Id keyname, unsigned long long num)
 575 {
 576   repo_set_num(s->repo, s - s->repo->pool->solvables, keyname, num);
 577 }
 578
 579 void
 580 solvable_set_str(Solvable *s, Id keyname, const char *str)
 581 {
 582   repo_set_str(s->repo, s - s->repo->pool->solvables, keyname, str);
 583 }
 584
 585 void
 586 solvable_set_poolstr(Solvable *s, Id keyname, const char *str)
 587 {
 588   repo_set_poolstr(s->repo, s - s->repo->pool->solvables, keyname, str);
 589 }
 590
 591 void
 592 solvable_add_poolstr_array(Solvable *s, Id keyname, const char *str)
 593 {
 594   repo_add_poolstr_array(s->repo, s - s->repo->pool->solvables, keyname, str);
 595 }
 596
 597 void
 598 solvable_add_idarray(Solvable *s, Id keyname, Id id)
 599 {
 600   repo_add_idarray(s->repo, s - s->repo->pool->solvables, keyname, id);
 601 }
 602
 603 void
 604 solvable_add_deparray(Solvable *s, Id keyname, Id dep, Id marker)
 605 {
 606   repo_add_deparray(s->repo, s - s->repo->pool->solvables, keyname, dep, marker);
 607 }
 608
 609 void
 610 solvable_set_idarray(Solvable *s, Id keyname, Queue *q)
 611 {
 612   repo_set_idarray(s->repo, s - s->repo->pool->solvables, keyname, q);
 613 }
 614
 615 void
 616 solvable_set_deparray(Solvable *s, Id keyname, Queue *q, Id marker)
 617 {
 618   repo_set_deparray(s->repo, s - s->repo->pool->solvables, keyname, q, marker);
 619 }
 620
 621 void
 622 solvable_unset(Solvable *s, Id keyname)
 623 {
 624   repo_unset(s->repo, s - s->repo->pool->solvables, keyname);
 625 }
 626
 627 /* return true if a dependency intersects dep in the keyname array */
 628 int
 629 solvable_matchesdep(Solvable *s, Id keyname, Id dep, int marker)
 630 {
 631   int i;
 632   Pool *pool = s->repo->pool;
 633   Queue q;
 634
 635   if (keyname == SOLVABLE_NAME)
 636     return pool_match_nevr(pool, s, dep) ? 1 : 0;       /* nevr match hack */
 637   queue_init(&q);
 638   solvable_lookup_deparray(s, keyname, &q, marker);
 639   for (i = 0; i < q.count; i++)
 640     if (pool_match_dep(pool, q.elements[i], dep))
 641       break;
 642   i = i == q.count ? 0 : 1;
 643   queue_free(&q);
 644   return i;
 645 }
 646
 647 int
 648 solvable_matchessolvable_int(Solvable *s, Id keyname, int marker, Id solvid, Map *solvidmap, Queue *depq, Map *missc, int reloff)
 649 {
 650   Pool *pool = s->repo->pool;
 651   int i, boff;
 652   Id *wp;
 653
 654   if (depq->count)
 655     queue_empty(depq);
 656   solvable_lookup_deparray(s, keyname, depq, marker);
 657   for (i = 0; i < depq->count; i++)
 658     {
 659       Id dep = depq->elements[i];
 660       boff = ISRELDEP(dep) ? reloff + GETRELID(dep) : dep;
 661       if (MAPTST(missc, boff))
 662         continue;
 663       if (ISRELDEP(dep))
 664         {
 665           Reldep *rd = GETRELDEP(pool, dep);
 666           if (!ISRELDEP(rd->name) && rd->flags < 8)
 667             {
 668               /* do pre-filtering on the base */
 669               if (MAPTST(missc, rd->name))
 670                 continue;
 671               wp = pool_whatprovides_ptr(pool, rd->name);
 672               if (solvidmap)
 673                 {
 674                   for (; *wp; wp++)
 675                     if (MAPTST(solvidmap, *wp))
 676                       break;
 677                 }
 678               else
 679                 {
 680                   for (; *wp; wp++)
 681                     if (*wp == solvid)
 682                       break;
 683                 }
 684               if (!*wp)
 685                 {
 686                   /* the base does not include solvid, no need to check the complete dep */
 687                   MAPSET(missc, rd->name);
 688                   MAPSET(missc, boff);
 689                   continue;
 690                 }
 691             }
 692         }
 693       wp = pool_whatprovides_ptr(pool, dep);
 694       if (solvidmap)
 695         {
 696           for (; *wp; wp++)
 697             if (MAPTST(solvidmap, *wp))
 698               return 1;
 699         }
 700       else
 701         {
 702           for (; *wp; wp++)
 703             if (*wp == solvid)
 704               return 1;
 705         }
 706       MAPSET(missc, boff);
 707     }
 708   return 0;
 709 }