src/policy.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  * Generic policy interface for SAT solver
  10  *
  11  */
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <string.h>
  17
  18 #include "solver.h"
  19 #include "evr.h"
  20 #include "policy.h"
  21 #include "poolvendor.h"
  22 #include "poolarch.h"
  23
  24
  25 /*-----------------------------------------------------------------*/
  26
  27 /*
  28  * prep for prune_best_version
  29  *   sort by name
  30  */
  31
  32 static int
  33 prune_to_best_version_sortcmp(const void *ap, const void *bp, void *dp)
  34 {
  35   Pool *pool = dp;
  36   int r;
  37   Id a = *(Id *)ap;
  38   Id b = *(Id *)bp;
  39   Solvable *sa, *sb;
  40
  41   sa = pool->solvables + a;
  42   sb = pool->solvables + b;
  43   r = sa->name - sb->name;
  44   if (r)
  45     {
  46       const char *na, *nb;
  47       /* different names. We use real strcmp here so that the result
  48        * is not depending on some random solvable order */
  49       na = id2str(pool, sa->name);
  50       nb = id2str(pool, sb->name);
  51       return strcmp(na, nb);
  52     }
  53   /* the same name, bring installed solvables to the front */
  54   if (pool->installed)
  55     {
  56       if (sa->repo == pool->installed)
  57         {
  58           if (sb->repo != pool->installed)
  59             return -1;
  60         }
  61       else if (sb->repo == pool->installed)
  62         return 1;
  63     }
  64   /* sort by repository sub-prio (installed repo handled above) */
  65   r = (sb->repo ? sb->repo->subpriority : 0) - (sa->repo ? sa->repo->subpriority : 0);
  66   if (r)
  67     return r;
  68   /* no idea about the order, sort by id */
  69   return a - b;
  70 }
  71
  72
  73 /*
  74  * prune to repository with highest priority.
  75  * does not prune installed solvables.
  76  */
  77
  78 static void
  79 prune_to_highest_prio(Pool *pool, Queue *plist)
  80 {
  81   int i, j;
  82   Solvable *s;
  83   int bestprio = 0, bestprioset = 0;
  84
  85   /* prune to highest priority */
  86   for (i = 0; i < plist->count; i++)  /* find highest prio in queue */
  87     {
  88       s = pool->solvables + plist->elements[i];
  89       if (pool->installed && s->repo == pool->installed)
  90         continue;
  91       if (!bestprioset || s->repo->priority > bestprio)
  92         {
  93           bestprio = s->repo->priority;
  94           bestprioset = 1;
  95         }
  96     }
  97   if (!bestprioset)
  98     return;
  99   for (i = j = 0; i < plist->count; i++) /* remove all with lower prio */
 100     {
 101       s = pool->solvables + plist->elements[i];
 102       if (s->repo->priority == bestprio || (pool->installed && s->repo == pool->installed))
 103         plist->elements[j++] = plist->elements[i];
 104     }
 105   plist->count = j;
 106 }
 107
 108 static void
 109 prune_to_highest_prio_per_name(Pool *pool, Queue *plist)
 110 {
 111   Queue pq;
 112   int i, j, k;
 113   Id name;
 114
 115   queue_init(&pq);
 116   sat_sort(plist->elements, plist->count, sizeof(Id), prune_to_best_version_sortcmp, pool);
 117   queue_push(&pq, plist->elements[0]);
 118   name = pool->solvables[pq.elements[0]].name;
 119   for (i = 1, j = 0; i < plist->count; i++)
 120     {
 121       if (pool->solvables[plist->elements[i]].name != name)
 122         {
 123           if (pq.count > 2)
 124             prune_to_highest_prio(pool, &pq);
 125           for (k = 0; k < pq.count; k++)
 126             plist->elements[j++] = pq.elements[k];
 127           queue_empty(&pq);
 128           queue_push(&pq, plist->elements[i]);
 129           name = pool->solvables[pq.elements[0]].name;
 130         }
 131     }
 132   if (pq.count > 2)
 133     prune_to_highest_prio(pool, &pq);
 134   for (k = 0; k < pq.count; k++)
 135     plist->elements[j++] = pq.elements[k];
 136   queue_free(&pq);
 137   plist->count = j;
 138 }
 139
 140
 141 /*
 142  * prune to recommended/suggested packages.
 143  * does not prune installed packages (they are also somewhat recommended).
 144  */
 145
 146 static void
 147 prune_to_recommended(Solver *solv, Queue *plist)
 148 {
 149   Pool *pool = solv->pool;
 150   int i, j, k, ninst;
 151   Solvable *s;
 152   Id p, pp, rec, *recp, sug, *sugp;
 153
 154   ninst = 0;
 155   if (pool->installed)
 156     {
 157       for (i = 0; i < plist->count; i++)
 158         {
 159           p = plist->elements[i];
 160           s = pool->solvables + p;
 161           if (pool->installed && s->repo == pool->installed)
 162             ninst++;
 163         }
 164     }
 165   if (plist->count - ninst < 2)
 166     return;
 167
 168   /* update our recommendsmap/suggestsmap */
 169   if (solv->recommends_index < 0)
 170     {
 171       MAPZERO(&solv->recommendsmap);
 172       MAPZERO(&solv->suggestsmap);
 173       solv->recommends_index = 0;
 174     }
 175   while (solv->recommends_index < solv->decisionq.count)
 176     {
 177       p = solv->decisionq.elements[solv->recommends_index++];
 178       if (p < 0)
 179         continue;
 180       s = pool->solvables + p;
 181       if (s->recommends)
 182         {
 183           recp = s->repo->idarraydata + s->recommends;
 184           while ((rec = *recp++) != 0)
 185             FOR_PROVIDES(p, pp, rec)
 186               MAPSET(&solv->recommendsmap, p);
 187         }
 188       if (s->suggests)
 189         {
 190           sugp = s->repo->idarraydata + s->suggests;
 191           while ((sug = *sugp++) != 0)
 192             FOR_PROVIDES(p, pp, sug)
 193               MAPSET(&solv->suggestsmap, p);
 194         }
 195     }
 196
 197   /* prune to recommended/supplemented */
 198   ninst = 0;
 199   for (i = j = 0; i < plist->count; i++)
 200     {
 201       p = plist->elements[i];
 202       s = pool->solvables + p;
 203       if (pool->installed && s->repo == pool->installed)
 204         {
 205           ninst++;
 206           if (j)
 207             plist->elements[j++] = p;
 208           continue;
 209         }
 210       if (!MAPTST(&solv->recommendsmap, p))
 211         if (!solver_is_supplementing(solv, s))
 212           continue;
 213       if (!j && ninst)
 214         {
 215           for (k = 0; j < ninst; k++)
 216             {
 217               s = pool->solvables + plist->elements[k];
 218               if (pool->installed && s->repo == pool->installed)
 219                 plist->elements[j++] = plist->elements[k];
 220             }
 221         }
 222       plist->elements[j++] = p;
 223     }
 224   if (j)
 225     plist->count = j;
 226
 227   /* anything left to prune? */
 228   if (plist->count - ninst < 2)
 229     return;
 230
 231   /* prune to suggested/enhanced*/
 232   ninst = 0;
 233   for (i = j = 0; i < plist->count; i++)
 234     {
 235       p = plist->elements[i];
 236       s = pool->solvables + p;
 237       if (pool->installed && s->repo == pool->installed)
 238         {
 239           ninst++;
 240           if (j)
 241             plist->elements[j++] = p;
 242           continue;
 243         }
 244       if (!MAPTST(&solv->suggestsmap, p))
 245         if (!solver_is_enhancing(solv, s))
 246           continue;
 247       if (!j && ninst)
 248         {
 249           for (k = 0; j < ninst; k++)
 250             {
 251               s = pool->solvables + plist->elements[k];
 252               if (pool->installed && s->repo == pool->installed)
 253                 plist->elements[j++] = plist->elements[k];
 254             }
 255         }
 256       plist->elements[j++] = p;
 257     }
 258   if (j)
 259     plist->count = j;
 260 }
 261
 262 void
 263 prune_to_best_arch(const Pool *pool, Queue *plist)
 264 {
 265   Id a, bestscore;
 266   Solvable *s;
 267   int i, j;
 268
 269   if (!pool->id2arch || plist->count < 2)
 270     return;
 271   bestscore = 0;
 272   for (i = 0; i < plist->count; i++)
 273     {
 274       s = pool->solvables + plist->elements[i];
 275       a = s->arch;
 276       a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
 277       if (a && a != 1 && (!bestscore || a < bestscore))
 278         bestscore = a;
 279     }
 280   for (i = j = 0; i < plist->count; i++)
 281     {
 282       s = pool->solvables + plist->elements[i];
 283       a = s->arch;
 284       if (a > pool->lastarch)
 285         continue;
 286       a = pool->id2arch[a];
 287       /* a == 1 -> noarch */
 288       if (a != 1 && ((a ^ bestscore) & 0xffff0000) != 0)
 289         continue;
 290       plist->elements[j++] = plist->elements[i];
 291     }
 292   if (j)
 293     plist->count = j;
 294 }
 295
 296 /*
 297  * remove entries from plist that are obsoleted by other entries
 298  * with different name.
 299  * plist should be sorted in some way.
 300  */
 301 static void
 302 prune_obsoleted(Pool *pool, Queue *plist)
 303 {
 304   int i, j;
 305   Solvable *s;
 306
 307   /* FIXME maybe also check provides depending on noupdateprovide? */
 308   /* FIXME do not prune cycles */
 309   for (i = 0; i < plist->count; i++)
 310     {
 311       Id p, pp, obs, *obsp;
 312       s = pool->solvables + plist->elements[i];
 313       if (!s->obsoletes)
 314         continue;
 315       obsp = s->repo->idarraydata + s->obsoletes;
 316       while ((obs = *obsp++) != 0)
 317         {
 318           FOR_PROVIDES(p, pp, obs)
 319             {
 320               Solvable *ps = pool->solvables + p;
 321               if (ps->name == s->name)
 322                 continue;
 323               if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps, obs))
 324                 continue;
 325               if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps))
 326                 continue;
 327               /* hmm, expensive. should use hash if plist is big */
 328               for (j = 0; j < plist->count; j++)
 329                 {
 330                   if (i == j)
 331                     continue;
 332                   if (plist->elements[j] == p)
 333                     plist->elements[j] = 0;
 334                 }
 335             }
 336         }
 337     }
 338   /* delete zeroed out queue entries */
 339   for (i = j = 0; i < plist->count; i++)
 340     if (plist->elements[i])
 341       plist->elements[j++] = plist->elements[i];
 342   plist->count = j;
 343 }
 344
 345 /*
 346  * prune_to_best_version
 347  *
 348  * sort list of packages (given through plist) by name and evr
 349  * return result through plist
 350  */
 351 void
 352 prune_to_best_version(Pool *pool, Queue *plist)
 353 {
 354   int i, j;
 355   Solvable *s, *best;
 356
 357   if (plist->count < 2)         /* no need to prune for a single entry */
 358     return;
 359   POOL_DEBUG(SAT_DEBUG_POLICY, "prune_to_best_version %d\n", plist->count);
 360
 361   /* sort by name first, prefer installed */
 362   sat_sort(plist->elements, plist->count, sizeof(Id), prune_to_best_version_sortcmp, pool);
 363
 364   /* now find best 'per name' */
 365   best = 0;
 366   for (i = j = 0; i < plist->count; i++)
 367     {
 368       s = pool->solvables + plist->elements[i];
 369
 370       POOL_DEBUG(SAT_DEBUG_POLICY, "- %s[%s]\n",
 371                  solvable2str(pool, s),
 372                  (pool->installed && s->repo == pool->installed) ? "installed" : "not installed");
 373
 374       if (!best)                /* if no best yet, the current is best */
 375         {
 376           best = s;
 377           continue;
 378         }
 379
 380       /* name switch: finish group, re-init */
 381       if (best->name != s->name)   /* new name */
 382         {
 383           plist->elements[j++] = best - pool->solvables; /* move old best to front */
 384           best = s;             /* take current as new best */
 385           continue;
 386         }
 387
 388       if (best->evr != s->evr)  /* compare evr */
 389         {
 390           if (evrcmp(pool, best->evr, s->evr, EVRCMP_COMPARE) < 0)
 391             best = s;
 392         }
 393     }
 394   plist->elements[j++] = best - pool->solvables;        /* finish last group */
 395   plist->count = j;
 396
 397   /* we reduced the list to one package per name, now look at
 398    * package obsoletes */
 399   if (plist->count > 1)
 400     prune_obsoleted(pool, plist);
 401 }
 402
 403
 404 /* legacy, do not use anymore!
 405  * (rates arch higher than version, but thats a policy)
 406  */
 407
 408 void
 409 prune_best_arch_name_version(const Solver *solv, Pool *pool, Queue *plist)
 410 {
 411   if (solv && solv->bestSolvableCb)
 412     { /* The application is responsible for */
 413       return solv->bestSolvableCb(solv->pool, plist);
 414     }
 415
 416   if (plist->count > 1)
 417     prune_to_best_arch(pool, plist);
 418   if (plist->count > 1)
 419     prune_to_best_version(pool, plist);
 420 }
 421
 422 /* installed packages involed in a dup operation can only be kept
 423 * if they are identical to a non-installed one */
 424 static void
 425 prune_installed_dup_packages(Solver *solv, Queue *plist)
 426 {
 427   Pool *pool = solv->pool;
 428   int i, j, k;
 429
 430   for (i = j = 0; i < plist->count; i++)
 431     {
 432       Id p = plist->elements[i];
 433       Solvable *s = pool->solvables + p;
 434       if (s->repo == pool->installed && (solv->dupmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))))
 435         {
 436           for (k = 0; k < plist->count; k++)
 437             {
 438               Solvable *s2 = pool->solvables + plist->elements[k];
 439               if (s2->repo != pool->installed && solvable_identical(s, s2))
 440                 break;
 441             }
 442           if (k == plist->count)
 443             continue;   /* no identical package found, ignore installed package */
 444         }
 445       plist->elements[j++] = p;
 446     }
 447   if (j)
 448     plist->count = j;
 449 }
 450
 451 /*
 452  *  POLICY_MODE_CHOOSE:     default, do all pruning steps
 453  *  POLICY_MODE_RECOMMEND:  leave out prune_to_recommended
 454  *  POLICY_MODE_SUGGEST:    leave out prune_to_recommended, do prio pruning just per name
 455  */
 456 void
 457 policy_filter_unwanted(Solver *solv, Queue *plist, int mode)
 458 {
 459   Pool *pool = solv->pool;
 460   if (plist->count > 1)
 461     {
 462       if (mode != POLICY_MODE_SUGGEST)
 463         prune_to_highest_prio(pool, plist);
 464       else
 465         prune_to_highest_prio_per_name(pool, plist);
 466       /* installed dup packages need special treatment as prio pruning
 467        * does not prune installed packages */
 468       if (plist->count > 1 && pool->installed && (solv->dupmap_all || solv->dupinvolvedmap.size))
 469         prune_installed_dup_packages(solv, plist);
 470     }
 471   if (plist->count > 1 && mode == POLICY_MODE_CHOOSE)
 472     prune_to_recommended(solv, plist);
 473   prune_best_arch_name_version(solv, pool, plist);
 474 }
 475
 476
 477 int
 478 policy_illegal_archchange(Solver *solv, Solvable *s1, Solvable *s2)
 479 {
 480   Pool *pool = solv->pool;
 481   Id a1 = s1->arch, a2 = s2->arch;
 482
 483   if (solv && solv->archCheckCb)
 484     { /* The application is responsible for */
 485       return solv->archCheckCb(solv->pool, s1, s2);
 486     }
 487
 488   /* we allow changes to/from noarch */
 489 #ifndef DEBIAN_SEMANTICS
 490   if (a1 == a2 || a1 == ARCH_NOARCH || a2 == ARCH_NOARCH)
 491     return 0;
 492 #else
 493   if (a1 == a2 || a1 == ARCH_ALL || a2 == ARCH_ALL)
 494     return 0;
 495 #endif
 496   if (!pool->id2arch)
 497     return 0;
 498   a1 = a1 <= pool->lastarch ? pool->id2arch[a1] : 0;
 499   a2 = a2 <= pool->lastarch ? pool->id2arch[a2] : 0;
 500   if (((a1 ^ a2) & 0xffff0000) != 0)
 501     return 1;
 502   return 0;
 503 }
 504
 505 int
 506 policy_illegal_vendorchange(Solver *solv, Solvable *s1, Solvable *s2)
 507 {
 508   Pool *pool = solv->pool;
 509   Id v1, v2;
 510   Id vendormask1, vendormask2;
 511
 512   if (solv->vendorCheckCb)
 513    {   /* The application is responsible for */
 514      return solv->vendorCheckCb(pool, s1, s2);
 515    }
 516   /* treat a missing vendor as empty string */
 517   v1 = s1->vendor ? s1->vendor : ID_EMPTY;
 518   v2 = s2->vendor ? s2->vendor : ID_EMPTY;
 519   if (v1 == v2)
 520     return 0;
 521   vendormask1 = pool_vendor2mask(pool, v1);
 522   if (!vendormask1)
 523     return 1;   /* can't match */
 524   vendormask2 = pool_vendor2mask(pool, v2);
 525   if ((vendormask1 & vendormask2) != 0)
 526     return 0;
 527   return 1;     /* no class matches */
 528 }
 529
 530 /* check if it is illegal to replace installed
 531  * package "is" with package "s" (which must obsolete "is")
 532  */
 533 int
 534 policy_is_illegal(Solver *solv, Solvable *is, Solvable *s, int ignore)
 535 {
 536   Pool *pool = solv->pool;
 537   int ret = 0;
 538   if (!(ignore & POLICY_ILLEGAL_DOWNGRADE) && !solv->allowdowngrade)
 539     {
 540       if (is->name == s->name && evrcmp(pool, is->evr, s->evr, EVRCMP_COMPARE) > 0)
 541         ret |= POLICY_ILLEGAL_DOWNGRADE;
 542     }
 543   if (!(ignore & POLICY_ILLEGAL_ARCHCHANGE) && !solv->allowarchchange)
 544     {
 545       if (is->arch != s->arch && policy_illegal_archchange(solv, s, is))
 546         ret |= POLICY_ILLEGAL_ARCHCHANGE;
 547     }
 548   if (!(ignore & POLICY_ILLEGAL_VENDORCHANGE) && !solv->allowvendorchange)
 549     {
 550       if (is->vendor != s->vendor && policy_illegal_vendorchange(solv, s, is))
 551         ret |= POLICY_ILLEGAL_VENDORCHANGE;
 552     }
 553   return ret;
 554 }
 555
 556 /*-------------------------------------------------------------------
 557  *
 558  * create reverse obsoletes map for installed solvables
 559  *
 560  * For each installed solvable find which packages with *different* names
 561  * obsolete the solvable.
 562  * This index is used in policy_findupdatepackages() below.
 563  */
 564 void
 565 policy_create_obsolete_index(Solver *solv)
 566 {
 567   Pool *pool = solv->pool;
 568   Solvable *s;
 569   Repo *installed = solv->installed;
 570   Id p, pp, obs, *obsp, *obsoletes, *obsoletes_data;
 571   int i, n, cnt;
 572
 573   if (!installed || installed->start == installed->end)
 574     return;
 575   cnt = installed->end - installed->start;
 576   solv->obsoletes = obsoletes = sat_calloc(cnt, sizeof(Id));
 577   for (i = 1; i < pool->nsolvables; i++)
 578     {
 579       s = pool->solvables + i;
 580       if (!s->obsoletes)
 581         continue;
 582       if (!pool_installable(pool, s))
 583         continue;
 584       obsp = s->repo->idarraydata + s->obsoletes;
 585       while ((obs = *obsp++) != 0)
 586         {
 587           FOR_PROVIDES(p, pp, obs)
 588             {
 589               Solvable *ps = pool->solvables + p;;
 590               if (ps->repo != installed)
 591                 continue;
 592               if (ps->name == s->name)
 593                 continue;
 594               if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps, obs))
 595                 continue;
 596               if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps))
 597                 continue;
 598               obsoletes[p - installed->start]++;
 599             }
 600         }
 601     }
 602   n = 0;
 603   for (i = 0; i < cnt; i++)
 604     if (obsoletes[i])
 605       {
 606         n += obsoletes[i] + 1;
 607         obsoletes[i] = n;
 608       }
 609   solv->obsoletes_data = obsoletes_data = sat_calloc(n + 1, sizeof(Id));
 610   POOL_DEBUG(SAT_DEBUG_STATS, "obsoletes data: %d entries\n", n + 1);
 611   for (i = pool->nsolvables - 1; i > 0; i--)
 612     {
 613       s = pool->solvables + i;
 614       if (!s->obsoletes)
 615         continue;
 616       if (!pool_installable(pool, s))
 617         continue;
 618       obsp = s->repo->idarraydata + s->obsoletes;
 619       while ((obs = *obsp++) != 0)
 620         {
 621           FOR_PROVIDES(p, pp, obs)
 622             {
 623               Solvable *ps = pool->solvables + p;;
 624               if (ps->repo != installed)
 625                 continue;
 626               if (ps->name == s->name)
 627                 continue;
 628               if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps, obs))
 629                 continue;
 630               if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps))
 631                 continue;
 632               if (obsoletes_data[obsoletes[p - installed->start]] != i)
 633                 obsoletes_data[--obsoletes[p - installed->start]] = i;
 634             }
 635         }
 636     }
 637 }
 638
 639
 640 /*
 641  * find update candidates
 642  *
 643  * s: solvable to be updated
 644  * qs: [out] queue to hold Ids of candidates
 645  * allow_all: 0 = dont allow downgrades, 1 = allow all candidates
 646  *
 647  */
 648 void
 649 policy_findupdatepackages(Solver *solv, Solvable *s, Queue *qs, int allow_all)
 650 {
 651   /* installed packages get a special upgrade allowed rule */
 652   Pool *pool = solv->pool;
 653   Id p, pp, n, p2, pp2;
 654   Id obs, *obsp;
 655   Solvable *ps;
 656   int haveprovobs = 0;
 657
 658   queue_empty(qs);
 659
 660   if (solv && solv->updateCandidateCb)
 661     { /* The application is responsible for */
 662       return solv->updateCandidateCb(solv->pool, s, qs);
 663     }
 664
 665   /*
 666    * s = solvable ptr
 667    * n = solvable Id
 668    */
 669   n = s - pool->solvables;
 670
 671   /*
 672    * look for updates for s
 673    */
 674   FOR_PROVIDES(p, pp, s->name)  /* every provider of s' name */
 675     {
 676       if (p == n)               /* skip itself */
 677         continue;
 678
 679       ps = pool->solvables + p;
 680       if (s->name == ps->name)  /* name match */
 681         {
 682           if (!allow_all && !solv->allowdowngrade && evrcmp(pool, s->evr, ps->evr, EVRCMP_COMPARE) > 0)
 683             continue;
 684         }
 685       else if (!solv->noupdateprovide && ps->obsoletes)   /* provides/obsoletes combination ? */
 686         {
 687           obsp = ps->repo->idarraydata + ps->obsoletes;
 688           while ((obs = *obsp++) != 0)  /* for all obsoletes */
 689             {
 690               FOR_PROVIDES(p2, pp2, obs)   /* and all matching providers of the obsoletes */
 691                 {
 692                   Solvable *ps2 = pool->solvables + p2;
 693                   if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps2, obs))
 694                     continue;
 695                   if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps2))
 696                     continue;
 697                   if (p2 == n)          /* match ! */
 698                     break;
 699                 }
 700               if (p2)                   /* match! */
 701                 break;
 702             }
 703           if (!obs)                     /* continue if no match */
 704             continue;
 705           /* here we have 'p' with a matching provides/obsoletes combination
 706            * thus flagging p as a valid update candidate for s
 707            */
 708           haveprovobs = 1;
 709         }
 710       else
 711         continue;
 712       if (!allow_all && !solv->allowarchchange && s->arch != ps->arch && policy_illegal_archchange(solv, s, ps))
 713         continue;
 714       if (!allow_all && !solv->allowvendorchange && s->vendor != ps->vendor && policy_illegal_vendorchange(solv, s, ps))
 715         continue;
 716       queue_push(qs, p);
 717     }
 718   /* if we have found some valid candidates and noupdateprovide is not set, we're
 719      done. otherwise we fallback to all obsoletes */
 720   if (!solv->noupdateprovide && haveprovobs)
 721     return;
 722   if (solv->obsoletes && solv->obsoletes[n - solv->installed->start])
 723     {
 724       Id *opp;
 725       for (opp = solv->obsoletes_data + solv->obsoletes[n - solv->installed->start]; (p = *opp++) != 0;)
 726         {
 727           ps = pool->solvables + p;
 728           if (!allow_all && !solv->allowarchchange && s->arch != ps->arch && policy_illegal_archchange(solv, s, ps))
 729             continue;
 730           if (!allow_all && !solv->allowvendorchange && s->vendor != ps->vendor && policy_illegal_vendorchange(solv, s, ps))
 731             continue;
 732           queue_push(qs, p);
 733         }
 734     }
 735 }
 736