src/selection.c

   1 /*
   2  * Copyright (c) 2012, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * selection.c
  10  *
  11  */
  12
  13 #define _GNU_SOURCE
  14 #include <string.h>
  15 #include <fnmatch.h>
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20
  21 #include "selection.h"
  22 #include "solver.h"
  23 #include "evr.h"
  24
  25
  26 static int
  27 str2archid(Pool *pool, const char *arch)
  28 {
  29   Id id;
  30   if (!*arch)
  31     return 0;
  32   id = pool_str2id(pool, arch, 0);
  33   if (!id || id == ARCH_SRC || id == ARCH_NOSRC || id == ARCH_NOARCH)
  34     return id;
  35   if (pool->id2arch && (id > pool->lastarch || !pool->id2arch[id]))
  36     return 0;
  37   return id;
  38 }
  39
  40 static void
  41 selection_prune(Pool *pool, Queue *selection)
  42 {
  43   int i, j;
  44   Id p, pp;
  45   for (i = j = 0; i < selection->count; i += 2)
  46     {
  47       Id select = selection->elements[i] & SOLVER_SELECTMASK;
  48       p = 0;
  49       if (select == SOLVER_SOLVABLE_ALL)
  50         p = 1;
  51       else if (select == SOLVER_SOLVABLE_REPO)
  52         {
  53           Solvable *s;
  54           Repo *repo = pool_id2repo(pool, selection->elements[i + 1]);
  55           if (repo)
  56             FOR_REPO_SOLVABLES(repo, p, s)
  57               break;
  58         }
  59       else
  60         {
  61           FOR_JOB_SELECT(p, pp, select, selection->elements[i + 1])
  62             break;
  63         }
  64       if (!p)
  65         continue;
  66       selection->elements[j] = selection->elements[i];
  67       selection->elements[j + 1] = selection->elements[i + 1];
  68       j += 2;
  69     }
  70   queue_truncate(selection, j);
  71 }
  72
  73
  74 static int
  75 selection_solvables_sortcmp(const void *ap, const void *bp, void *dp)
  76 {
  77   return *(const Id *)ap - *(const Id *)bp;
  78 }
  79
  80 void
  81 selection_solvables(Pool *pool, Queue *selection, Queue *pkgs)
  82 {
  83   int i, j;
  84   Id p, pp, lastid;
  85   queue_empty(pkgs);
  86   for (i = 0; i < selection->count; i += 2)
  87     {
  88       Id select = selection->elements[i] & SOLVER_SELECTMASK;
  89       if (select == SOLVER_SOLVABLE_ALL)
  90         {
  91           FOR_POOL_SOLVABLES(p)
  92             queue_push(pkgs, p);
  93         }
  94       if (select == SOLVER_SOLVABLE_REPO)
  95         {
  96           Solvable *s;
  97           Repo *repo = pool_id2repo(pool, selection->elements[i + 1]);
  98           if (repo)
  99             FOR_REPO_SOLVABLES(repo, p, s)
 100               queue_push(pkgs, p);
 101         }
 102       else
 103         {
 104           FOR_JOB_SELECT(p, pp, select, selection->elements[i + 1])
 105             queue_push(pkgs, p);
 106         }
 107     }
 108   if (pkgs->count < 2)
 109     return;
 110   /* sort and unify */
 111   solv_sort(pkgs->elements, pkgs->count, sizeof(Id), selection_solvables_sortcmp, NULL);
 112   lastid = pkgs->elements[0];
 113   for (i = j = 1; i < pkgs->count; i++)
 114     if (pkgs->elements[i] != lastid)
 115       pkgs->elements[j++] = lastid = pkgs->elements[i];
 116   queue_truncate(pkgs, j);
 117 }
 118
 119 static void
 120 selection_flatten(Pool *pool, Queue *selection)
 121 {
 122   Queue q;
 123   int i;
 124   if (selection->count <= 2)
 125     return;
 126   for (i = 0; i < selection->count; i += 2)
 127     if ((selection->elements[i] & SOLVER_SELECTMASK) == SOLVER_SOLVABLE_ALL)
 128       {
 129         selection->elements[0] = selection->elements[i];
 130         selection->elements[1] = selection->elements[i + 1];
 131         queue_truncate(selection, 2);
 132         return;
 133       }
 134   queue_init(&q);
 135   selection_solvables(pool, selection, &q);
 136   if (!q.count)
 137     {
 138       queue_empty(selection);
 139       return;
 140     }
 141   queue_truncate(selection, 2);
 142   if (q.count > 1)
 143     {
 144       selection->elements[0] = SOLVER_SOLVABLE_ONE_OF;
 145       selection->elements[1] = pool_queuetowhatprovides(pool, &q);
 146     }
 147   else
 148     {
 149       selection->elements[0] = SOLVER_SOLVABLE | SOLVER_NOAUTOSET;
 150       selection->elements[1] = q.elements[0];
 151     }
 152 }
 153
 154 static void
 155 selection_filter_rel(Pool *pool, Queue *selection, Id relflags, Id relevr)
 156 {
 157   int i;
 158
 159   for (i = 0; i < selection->count; i += 2)
 160     {
 161       Id select = selection->elements[i] & SOLVER_SELECTMASK;
 162       Id id = selection->elements[i + 1];
 163       if (select == SOLVER_SOLVABLE || select == SOLVER_SOLVABLE_ONE_OF)
 164         {
 165           /* done by selection_addsrc, currently implies SELECTION_NAME */
 166           Queue q;
 167           Id p, pp;
 168           Id rel = 0, relname = 0;
 169           int miss = 0;
 170
 171           queue_init(&q);
 172           FOR_JOB_SELECT(p, pp, select, id)
 173             {
 174               Solvable *s = pool->solvables + p;
 175               if (!rel || s->name != relname)
 176                 {
 177                   relname = s->name;
 178                   rel = pool_rel2id(pool, relname, relevr, relflags, 1);
 179                 }
 180               if (pool_match_nevr(pool, s, rel))
 181                 queue_push(&q, p);
 182               else
 183                 miss = 1;
 184             }
 185           if (miss)
 186             {
 187               if (q.count == 1)
 188                 {
 189                   selection->elements[i] = SOLVER_SOLVABLE | SOLVER_NOAUTOSET;
 190                   selection->elements[i + 1] = q.elements[0];
 191                 }
 192               else
 193                 {
 194                   selection->elements[i] = SOLVER_SOLVABLE_ONE_OF;
 195                   selection->elements[i + 1] = pool_queuetowhatprovides(pool, &q);
 196                 }
 197             }
 198           queue_free(&q);
 199         }
 200       else if (select == SOLVER_SOLVABLE_NAME || select == SOLVER_SOLVABLE_PROVIDES)
 201         {
 202           /* don't stack src reldeps */
 203           if (relflags == REL_ARCH && (relevr == ARCH_SRC || relevr == ARCH_NOSRC) && ISRELDEP(id))
 204             {
 205               Reldep *rd = GETRELDEP(pool, id);
 206               if (rd->flags == REL_ARCH && rd->evr == ARCH_SRC)
 207                 id = rd->name;
 208             }
 209           selection->elements[i + 1] = pool_rel2id(pool, id, relevr, relflags, 1);
 210         }
 211       else
 212         continue;       /* actually internal error */
 213       if (relflags == REL_ARCH)
 214         selection->elements[i] |= SOLVER_SETARCH;
 215       if (relflags == REL_EQ && select != SOLVER_SOLVABLE_PROVIDES)
 216         {
 217           if (pool->disttype == DISTTYPE_DEB)
 218             selection->elements[i] |= SOLVER_SETEVR;    /* debian can't match version only like rpm */
 219           else
 220             {
 221               const char *rel =  strrchr(pool_id2str(pool, relevr), '-');
 222               selection->elements[i] |= rel ? SOLVER_SETEVR : SOLVER_SETEV;
 223             }
 224         }
 225     }
 226   selection_prune(pool, selection);
 227 }
 228
 229 static void
 230 selection_filter_installed(Pool *pool, Queue *selection)
 231 {
 232   Queue q;
 233   int i, j;
 234
 235   if (!pool->installed)
 236     queue_empty(selection);
 237   queue_init(&q);
 238   for (i = j = 0; i < selection->count; i += 2)
 239     {
 240       Id select = selection->elements[i] & SOLVER_SELECTMASK;
 241       Id id = selection->elements[i + 1];
 242       if (select == SOLVER_SOLVABLE_ALL)
 243         {
 244           select = SOLVER_SOLVABLE_REPO;
 245           id = pool->installed->repoid;
 246         }
 247       else if (select == SOLVER_SOLVABLE_REPO)
 248         {
 249           if (id != pool->installed->repoid)
 250             select = 0;
 251         }
 252       else
 253         {
 254           int bad = 0;
 255           Id p, pp;
 256           queue_empty(&q);
 257           FOR_JOB_SELECT(p, pp, select, id)
 258             {
 259               if (pool->solvables[p].repo != pool->installed)
 260                 bad = 1;
 261               else
 262                 queue_push(&q, p);
 263             }
 264           if (bad || !q.count)
 265             {
 266               if (!q.count)
 267                 select = 0;
 268               else if (q.count == 1)
 269                 {
 270                   select = SOLVER_SOLVABLE | SOLVER_NOAUTOSET;
 271                   id = q.elements[0];
 272                 }
 273               else
 274                 {
 275                   select = SOLVER_SOLVABLE_ONE_OF;
 276                   id = pool_queuetowhatprovides(pool, &q);
 277                 }
 278             }
 279         }
 280       if (select)
 281         {
 282           selection->elements[j++] = select | (selection->elements[i] & ~SOLVER_SELECTMASK) | SOLVER_SETREPO;
 283           selection->elements[j++] = id;
 284         }
 285     }
 286   queue_truncate(selection, j);
 287   queue_free(&q);
 288 }
 289
 290 static void
 291 selection_addsrc(Pool *pool, Queue *selection, int flags)
 292 {
 293   Queue q;
 294   Id p, name;
 295   int i, havesrc;
 296
 297   if ((flags & SELECTION_INSTALLED_ONLY) != 0)
 298     return;     /* sources can't be installed */
 299   queue_init(&q);
 300   for (i = 0; i < selection->count; i += 2)
 301     {
 302       if (selection->elements[i] != SOLVER_SOLVABLE_NAME)
 303         continue;
 304       name = selection->elements[i + 1];
 305       havesrc = 0;
 306       queue_empty(&q);
 307       FOR_POOL_SOLVABLES(p)
 308         {
 309           Solvable *s = pool->solvables + p;
 310           if (s->name != name)
 311             continue;
 312           if (s->arch == ARCH_SRC || s->arch == ARCH_NOSRC)
 313             {
 314               if (pool_disabled_solvable(pool, s))
 315                 continue;
 316               havesrc = 1;
 317             }
 318           else if (s->repo != pool->installed && !pool_installable(pool, s))
 319             continue;
 320           queue_push(&q, p);
 321         }
 322       if (!havesrc || !q.count)
 323         continue;
 324       if (q.count == 1)
 325         {
 326           selection->elements[i] = SOLVER_SOLVABLE | SOLVER_NOAUTOSET;
 327           selection->elements[i + 1] = q.elements[0];
 328         }
 329       else
 330         {
 331           selection->elements[i] = SOLVER_SOLVABLE_ONE_OF;
 332           selection->elements[i + 1] = pool_queuetowhatprovides(pool, &q);
 333         }
 334     }
 335   queue_free(&q);
 336 }
 337
 338 static inline const char *
 339 skipkind(const char *n)
 340 {
 341   const char *s;
 342   for (s = n; *s >= 'a' && *s <= 'z'; s++)
 343     ;
 344   if (*s == ':' && s != n)
 345      return s + 1;
 346   return n;
 347 }
 348
 349 static inline void
 350 queue_pushunique2(Queue *q, Id id1, Id id2)
 351 {
 352   int i;
 353   for (i = 0; i < q->count; i += 2)
 354     if (q->elements[i] == id1 && q->elements[i + 1] == id2)
 355       return;
 356   queue_push2(q, id1, id2);
 357 }
 358
 359 static int
 360 selection_depglob_id(Pool *pool, Queue *selection, Id id, int flags)
 361 {
 362   Id p, pp;
 363   int match = 0;
 364
 365   FOR_PROVIDES(p, pp, id)
 366     {
 367       Solvable *s = pool->solvables + p;
 368       if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 369         continue;
 370       match = 1;
 371       if (s->name == id && (flags & SELECTION_NAME) != 0)
 372         {
 373           if ((flags & SELECTION_SOURCE_ONLY) != 0)
 374             id = pool_rel2id(pool, id, ARCH_SRC, REL_ARCH, 1);
 375           queue_push2(selection, SOLVER_SOLVABLE_NAME, id);
 376           if ((flags & SELECTION_WITH_SOURCE) != 0)
 377             selection_addsrc(pool, selection, flags);
 378           return SELECTION_NAME;
 379         }
 380     }
 381   if ((flags & (SELECTION_SOURCE_ONLY | SELECTION_WITH_SOURCE)) != 0 && (flags & SELECTION_NAME) != 0)
 382     {
 383       /* src rpms don't have provides, so we must check every solvable */
 384       FOR_POOL_SOLVABLES(p)     /* slow path */
 385         {
 386           Solvable *s = pool->solvables + p;
 387           if (s->name == id && (s->arch == ARCH_SRC || s->arch == ARCH_NOSRC))
 388             {
 389               if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 390                 continue;       /* just in case... src rpms can't be installed */
 391               if (pool_disabled_solvable(pool, s))
 392                 continue;
 393               if ((flags & SELECTION_SOURCE_ONLY) != 0)
 394                 id = pool_rel2id(pool, id, ARCH_SRC, REL_ARCH, 1);
 395               queue_push2(selection, SOLVER_SOLVABLE_NAME, id);
 396               if ((flags & SELECTION_WITH_SOURCE) != 0)
 397                 selection_addsrc(pool, selection, flags);
 398               return SELECTION_NAME;
 399             }
 400         }
 401     }
 402   if (match && (flags & SELECTION_PROVIDES) != 0)
 403     {
 404       queue_push2(selection, SOLVER_SOLVABLE_PROVIDES, id);
 405       return SELECTION_PROVIDES;
 406     }
 407   return 0;
 408 }
 409
 410 static int
 411 selection_depglob(Pool *pool, Queue *selection, const char *name, int flags)
 412 {
 413   Id id, p, pp;
 414   int match = 0;
 415   int doglob = 0;
 416   int nocase = 0;
 417   int globflags = 0;
 418
 419   if ((flags & SELECTION_SOURCE_ONLY) != 0)
 420     {
 421       flags &= ~SELECTION_PROVIDES;     /* sources don't provide anything */
 422       flags &= ~SELECTION_WITH_SOURCE;
 423     }
 424
 425   if (!(flags & (SELECTION_NAME|SELECTION_PROVIDES)))
 426     return 0;
 427
 428   if ((flags & SELECTION_INSTALLED_ONLY) != 0 && !pool->installed)
 429     return 0;
 430
 431   nocase = flags & SELECTION_NOCASE;
 432   if (!nocase && !(flags & SELECTION_SKIP_KIND))
 433     {
 434       id = pool_str2id(pool, name, 0);
 435       if (id)
 436         {
 437           /* the id is know, do the fast id matching using the whatprovides lookup */
 438           int ret = selection_depglob_id(pool, selection, id, flags);
 439           if (ret)
 440             return ret;
 441         }
 442     }
 443
 444   if ((flags & SELECTION_GLOB) != 0 && strpbrk(name, "[*?") != 0)
 445     doglob = 1;
 446
 447   if (!nocase && !(flags & SELECTION_SKIP_KIND) && !doglob)
 448     return 0;   /* all done above in depglob_id */
 449
 450   if (doglob && nocase)
 451     globflags = FNM_CASEFOLD;
 452
 453   if ((flags & SELECTION_NAME) != 0)
 454     {
 455       /* looks like a name glob. hard work. */
 456       FOR_POOL_SOLVABLES(p)
 457         {
 458           Solvable *s = pool->solvables + p;
 459           const char *n;
 460           if (s->repo != pool->installed && !pool_installable(pool, s))
 461             {
 462               if (!(flags & SELECTION_SOURCE_ONLY) || (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC))
 463                 continue;
 464               if (pool_disabled_solvable(pool, s))
 465                 continue;
 466             }
 467           if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 468             continue;
 469           id = s->name;
 470           n = pool_id2str(pool, id);
 471           if (flags & SELECTION_SKIP_KIND)
 472             n = skipkind(n);
 473           if ((doglob ? fnmatch(name, n, globflags) : nocase ? strcasecmp(name, n) : strcmp(name, n)) == 0)
 474             {
 475               if ((flags & SELECTION_SOURCE_ONLY) != 0)
 476                 id = pool_rel2id(pool, id, ARCH_SRC, REL_ARCH, 1);
 477               queue_pushunique2(selection, SOLVER_SOLVABLE_NAME, id);
 478               match = 1;
 479             }
 480         }
 481       if (match)
 482         {
 483           if ((flags & SELECTION_WITH_SOURCE) != 0)
 484             selection_addsrc(pool, selection, flags);
 485           return SELECTION_NAME;
 486         }
 487     }
 488
 489   if ((flags & SELECTION_PROVIDES))
 490     {
 491       /* looks like a dep glob. really hard work. */
 492       for (id = 1; id < pool->ss.nstrings; id++)
 493         {
 494           const char *n;
 495           if (!pool->whatprovides[id] || pool->whatprovides[id] == 1)
 496             continue;
 497           n = pool_id2str(pool, id);
 498           if ((doglob ? fnmatch(name, n, globflags) : nocase ? strcasecmp(name, n) : strcmp(name, n)) == 0)
 499             {
 500               if ((flags & SELECTION_INSTALLED_ONLY) != 0)
 501                 {
 502                   FOR_PROVIDES(p, pp, id)
 503                     if (pool->solvables[p].repo == pool->installed)
 504                       break;
 505                   if (!p)
 506                     continue;
 507                 }
 508               queue_push2(selection, SOLVER_SOLVABLE_PROVIDES, id);
 509               match = 1;
 510             }
 511         }
 512       if (match)
 513         return SELECTION_PROVIDES;
 514     }
 515   return 0;
 516 }
 517
 518 static int
 519 selection_depglob_arch(Pool *pool, Queue *selection, const char *name, int flags)
 520 {
 521   int ret;
 522   const char *r;
 523   Id archid;
 524
 525   if ((ret = selection_depglob(pool, selection, name, flags)) != 0)
 526     return ret;
 527   if (!(flags & SELECTION_DOTARCH))
 528     return 0;
 529   /* check if there is an .arch suffix */
 530   if ((r = strrchr(name, '.')) != 0 && r[1] && (archid = str2archid(pool, r + 1)) != 0)
 531     {
 532       char *rname = solv_strdup(name);
 533       rname[r - name] = 0;
 534       if (archid == ARCH_SRC || archid == ARCH_NOSRC)
 535         flags |= SELECTION_SOURCE_ONLY;
 536       if ((ret = selection_depglob(pool, selection, rname, flags)) != 0)
 537         {
 538           selection_filter_rel(pool, selection, REL_ARCH, archid);
 539           solv_free(rname);
 540           return ret | SELECTION_DOTARCH;
 541         }
 542       solv_free(rname);
 543     }
 544   return 0;
 545 }
 546
 547 static int
 548 selection_filelist(Pool *pool, Queue *selection, const char *name, int flags)
 549 {
 550   Dataiterator di;
 551   Queue q;
 552   int type;
 553
 554   type = !(flags & SELECTION_GLOB) || strpbrk(name, "[*?") == 0 ? SEARCH_STRING : SEARCH_GLOB;
 555   if ((flags & SELECTION_NOCASE) != 0)
 556     type |= SEARCH_NOCASE;
 557   queue_init(&q);
 558   dataiterator_init(&di, pool, flags & SELECTION_INSTALLED_ONLY ? pool->installed : 0, 0, SOLVABLE_FILELIST, name, type|SEARCH_FILES|SEARCH_COMPLETE_FILELIST);
 559   while (dataiterator_step(&di))
 560     {
 561       Solvable *s = pool->solvables + di.solvid;
 562       if (!s->repo)
 563         continue;
 564       if (s->repo != pool->installed && !pool_installable(pool, s))
 565         {
 566           if (!(flags & SELECTION_SOURCE_ONLY) || (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC))
 567             continue;
 568           if (pool_disabled_solvable(pool, s))
 569             continue;
 570         }
 571       if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 572         continue;
 573       queue_push(&q, di.solvid);
 574       dataiterator_skip_solvable(&di);
 575     }
 576   dataiterator_free(&di);
 577   if (!q.count)
 578     return 0;
 579   if (q.count > 1)
 580     queue_push2(selection, SOLVER_SOLVABLE_ONE_OF, pool_queuetowhatprovides(pool, &q));
 581   else
 582     queue_push2(selection, SOLVER_SOLVABLE | SOLVER_NOAUTOSET, q.elements[0]);
 583   queue_free(&q);
 584   return SELECTION_FILELIST;
 585 }
 586
 587 static char *
 588 splitrel(char *rname, char *r, int *rflagsp)
 589 {
 590   int nend = r - rname;
 591   int rflags = 0;
 592   if (nend && *r == '=' && r[-1] == '!')
 593     {
 594       nend--;
 595       r++;
 596       rflags = REL_LT|REL_GT;
 597     }
 598   for (; *r; r++)
 599     {
 600       if (*r == '<')
 601         rflags |= REL_LT;
 602       else if (*r == '=')
 603         rflags |= REL_EQ;
 604       else if (*r == '>')
 605         rflags |= REL_GT;
 606       else
 607         break;
 608     }
 609   while (*r && (*r == ' ' || *r == '\t'))
 610     r++;
 611   while (nend && (rname[nend - 1] == ' ' || rname[nend - 1] == '\t'))
 612     nend--;
 613   if (!*rname || !*r)
 614     return 0;
 615   *rflagsp = rflags;
 616   rname[nend] = 0;
 617   return r;
 618 }
 619
 620 static int
 621 selection_rel(Pool *pool, Queue *selection, const char *name, int flags)
 622 {
 623   int ret, rflags = 0;
 624   char *r, *rname;
 625
 626   /* relation case, support:
 627    * depglob rel
 628    * depglob.arch rel
 629    */
 630   rname = solv_strdup(name);
 631   if ((r = strpbrk(rname, "<=>")) != 0)
 632     {
 633       if ((r = splitrel(rname, r, &rflags)) == 0)
 634         {
 635           solv_free(rname);
 636           return 0;
 637         }
 638     }
 639   if ((ret = selection_depglob_arch(pool, selection, rname, flags)) != 0)
 640     {
 641       if (rflags)
 642         selection_filter_rel(pool, selection, rflags, pool_str2id(pool, r, 1));
 643       solv_free(rname);
 644       return ret | SELECTION_REL;
 645     }
 646   solv_free(rname);
 647   return 0;
 648 }
 649
 650 #if defined(MULTI_SEMANTICS)
 651 # define EVRCMP_DEPCMP (pool->disttype == DISTTYPE_DEB ? EVRCMP_COMPARE : EVRCMP_MATCH_RELEASE)
 652 #elif defined(DEBIAN)
 653 # define EVRCMP_DEPCMP EVRCMP_COMPARE
 654 #else
 655 # define EVRCMP_DEPCMP EVRCMP_MATCH_RELEASE
 656 #endif
 657
 658 /* magic epoch promotion code, works only for SELECTION_NAME selections */
 659 static void
 660 selection_filter_evr(Pool *pool, Queue *selection, char *evr)
 661 {
 662   int i, j;
 663   Queue q;
 664   Id qbuf[10];
 665
 666   queue_init(&q);
 667   queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf));
 668   for (i = j = 0; i < selection->count; i += 2)
 669     {
 670       Id select = selection->elements[i] & SOLVER_SELECTMASK;
 671       Id id = selection->elements[i + 1];
 672       Id p, pp;
 673       const char *lastepoch = 0;
 674       int lastepochlen = 0;
 675
 676       queue_empty(&q);
 677       FOR_JOB_SELECT(p, pp, select, id)
 678         {
 679           Solvable *s = pool->solvables + p;
 680           const char *sevr = pool_id2str(pool, s->evr);
 681           const char *sp;
 682           for (sp = sevr; *sp >= '0' && *sp <= '9'; sp++)
 683             ;
 684           if (*sp != ':')
 685             sp = sevr;
 686           /* compare vr part */
 687           if (strcmp(evr, sp != sevr ? sp + 1 : sevr) != 0)
 688             {
 689               int r = pool_evrcmp_str(pool, sp != sevr ? sp + 1 : sevr, evr, EVRCMP_DEPCMP);
 690               if (r == -1 || r == 1)
 691                 continue;       /* solvable does not match vr */
 692             }
 693           queue_push(&q, p);
 694           if (sp > sevr)
 695             {
 696               while (sevr < sp && *sevr == '0') /* normalize epoch */
 697                 sevr++;
 698             }
 699           if (!lastepoch)
 700             {
 701               lastepoch = sevr;
 702               lastepochlen = sp - sevr;
 703             }
 704           else if (lastepochlen != sp - sevr || strncmp(lastepoch, sevr, lastepochlen) != 0)
 705             lastepochlen = -1;  /* multiple different epochs */
 706         }
 707       if (!lastepoch || lastepochlen == 0)
 708         id = pool_str2id(pool, evr, 1);         /* no match at all or zero epoch */
 709       else if (lastepochlen >= 0)
 710         {
 711           /* found exactly one epoch, simply prepend */
 712           char *evrx = solv_malloc(strlen(evr) + lastepochlen + 2);
 713           strncpy(evrx, lastepoch, lastepochlen + 1);
 714           strcpy(evrx + lastepochlen + 1, evr);
 715           id = pool_str2id(pool, evrx, 1);
 716           solv_free(evrx);
 717         }
 718       else
 719         {
 720           /* multiple epochs in multiple solvables, convert to list of solvables */
 721           selection->elements[j] = (selection->elements[i] & ~SOLVER_SELECTMASK) | SOLVER_SOLVABLE_ONE_OF;
 722           selection->elements[j + 1] = pool_queuetowhatprovides(pool, &q);
 723           j += 2;
 724           continue;
 725         }
 726       queue_empty(&q);
 727       queue_push2(&q, selection->elements[i], selection->elements[i + 1]);
 728       selection_filter_rel(pool, &q, REL_EQ, id);
 729       if (!q.count)
 730         continue;               /* oops, no match */
 731       selection->elements[j] = q.elements[0];
 732       selection->elements[j + 1] = q.elements[1];
 733       j += 2;
 734     }
 735   queue_truncate(selection, j);
 736   queue_free(&q);
 737 }
 738
 739 /* match the "canonical" name of the package */
 740 static int
 741 selection_canon(Pool *pool, Queue *selection, const char *name, int flags)
 742 {
 743   char *rname, *r, *r2;
 744   Id archid = 0;
 745   int ret;
 746
 747   /*
 748    * nameglob-version
 749    * nameglob-version.arch
 750    * nameglob-version-release
 751    * nameglob-version-release.arch
 752    */
 753   flags |= SELECTION_NAME;
 754   flags &= ~SELECTION_PROVIDES;
 755
 756   if (pool->disttype == DISTTYPE_DEB)
 757     {
 758       if ((r = strchr(name, '_')) == 0)
 759         return 0;
 760       rname = solv_strdup(name);        /* so we can modify it */
 761       r = rname + (r - name);
 762       *r++ = 0;
 763       if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 764         {
 765           solv_free(rname);
 766           return 0;
 767         }
 768       /* is there a vaild arch? */
 769       if ((r2 = strrchr(r, '_')) != 0 && r[1] && (archid = str2archid(pool, r + 1)) != 0)
 770         {
 771           *r2 = 0;      /* split off */
 772           selection_filter_rel(pool, selection, REL_ARCH, archid);
 773         }
 774       selection_filter_rel(pool, selection, REL_EQ, pool_str2id(pool, r, 1));
 775       solv_free(rname);
 776       return ret | SELECTION_CANON;
 777     }
 778
 779   if (pool->disttype == DISTTYPE_HAIKU)
 780     {
 781       if ((r = strchr(name, '-')) == 0)
 782         return 0;
 783       rname = solv_strdup(name);        /* so we can modify it */
 784       r = rname + (r - name);
 785       *r++ = 0;
 786       if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 787         {
 788           solv_free(rname);
 789           return 0;
 790         }
 791       /* is there a vaild arch? */
 792       if ((r2 = strrchr(r, '-')) != 0 && r[1] && (archid = str2archid(pool, r + 1)) != 0)
 793         {
 794           *r2 = 0;      /* split off */
 795           selection_filter_rel(pool, selection, REL_ARCH, archid);
 796         }
 797       selection_filter_rel(pool, selection, REL_EQ, pool_str2id(pool, r, 1));
 798       solv_free(rname);
 799       return ret | SELECTION_CANON;
 800     }
 801
 802   if ((r = strrchr(name, '-')) == 0)
 803     return 0;
 804   rname = solv_strdup(name);    /* so we can modify it */
 805   r = rname + (r - name);
 806   *r = 0;
 807
 808   /* split off potential arch part from version */
 809   if ((r2 = strrchr(r + 1, '.')) != 0 && r2[1] && (archid = str2archid(pool, r2 + 1)) != 0)
 810     *r2 = 0;    /* found valid arch, split it off */
 811   if (archid == ARCH_SRC || archid == ARCH_NOSRC)
 812     flags |= SELECTION_SOURCE_ONLY;
 813
 814   /* try with just the version */
 815   if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 816     {
 817       /* no luck, try with version-release */
 818       if ((r2 = strrchr(rname, '-')) == 0)
 819         {
 820           solv_free(rname);
 821           return 0;
 822         }
 823       *r = '-';
 824       *r2 = 0;
 825       r = r2;
 826       if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 827         {
 828           solv_free(rname);
 829           return 0;
 830         }
 831     }
 832   if (archid)
 833     selection_filter_rel(pool, selection, REL_ARCH, archid);
 834   selection_filter_evr(pool, selection, r + 1); /* magic epoch promotion */
 835   solv_free(rname);
 836   return ret | SELECTION_CANON;
 837 }
 838
 839 int
 840 selection_make(Pool *pool, Queue *selection, const char *name, int flags)
 841 {
 842   int ret = 0;
 843
 844   queue_empty(selection);
 845   if (*name == '/' && (flags & SELECTION_FILELIST))
 846     ret = selection_filelist(pool, selection, name, flags);
 847   if (!ret && (flags & SELECTION_REL) != 0 && strpbrk(name, "<=>") != 0)
 848     ret = selection_rel(pool, selection, name, flags);
 849   if (!ret)
 850     ret = selection_depglob_arch(pool, selection, name, flags);
 851   if (!ret && (flags & SELECTION_CANON) != 0)
 852     ret = selection_canon(pool, selection, name, flags);
 853   if (selection->count && (flags & SELECTION_INSTALLED_ONLY) != 0)
 854     selection_filter_installed(pool, selection);
 855   if (ret && !selection->count)
 856     ret = 0;    /* no match -> always return zero */
 857   if (ret && (flags & SELECTION_FLAT) != 0)
 858     selection_flatten(pool, selection);
 859   return ret;
 860 }
 861
 862 static int
 863 matchdep(Pool *pool, Id id, char *rname, int rflags, char *revr, int flags)
 864 {
 865   if (ISRELDEP(id))
 866     {
 867       Reldep *rd = GETRELDEP(pool, id);
 868       if (rd->flags == REL_AND || rd->flags == REL_OR || rd->flags == REL_WITH)
 869         {
 870           if (matchdep(pool, rd->name, rname, rflags, revr, flags))
 871             return 1;
 872           if (matchdep(pool, rd->evr, rname, rflags, revr, flags))
 873             return 1;
 874           return 0;
 875         }
 876       if (rd->flags == REL_ARCH)
 877         return matchdep(pool, rd->name, rname, rflags, revr, flags);
 878       if (!matchdep(pool, rd->name, rname, rflags, revr, flags))
 879         return 0;
 880       if (rflags)
 881         {
 882           /* XXX: need pool_match_flags_evr here */
 883           if (!pool_match_dep(pool, pool_rel2id(pool, rd->name, pool_str2id(pool, revr, 1), rflags, 1), id))
 884             return 0;
 885         }
 886       return 1;
 887     }
 888   if (flags & SELECTION_GLOB)
 889     {
 890       int globflags = (flags & SELECTION_NOCASE) != 0 ? FNM_CASEFOLD : 0;
 891       return fnmatch(rname, pool_id2str(pool, id), globflags) == 0 ? 1 : 0;
 892     }
 893   if (flags & SELECTION_NOCASE)
 894     return strcasecmp(rname, pool_id2str(pool, id)) == 0 ? 1 : 0;
 895   return strcmp(rname, pool_id2str(pool, id)) == 0 ? 1 : 0;
 896 }
 897
 898 /*
 899  *  select against the dependencies in keyname
 900  *  like SELECTION_REL and SELECTION_PROVIDES, but with the
 901  *  deps in keyname instead of provides.
 902  */
 903 int
 904 selection_make_matchdeps(Pool *pool, Queue *selection, const char *name, int flags, int keyname, int marker)
 905 {
 906   char *rname, *r;
 907   int rflags = 0;
 908   Id p;
 909   Queue q;
 910
 911   queue_empty(selection);
 912   rname = solv_strdup(name);
 913   if ((r = strpbrk(rname, "<=>")) != 0)
 914     {
 915       if ((r = splitrel(rname, r, &rflags)) == 0)
 916         {
 917           solv_free(rname);
 918           return 0;
 919         }
 920     }
 921   if ((flags & SELECTION_GLOB) != 0 && !strpbrk(name, "[*?") != 0)
 922     flags &= ~SELECTION_GLOB;
 923
 924   queue_init(&q);
 925   FOR_POOL_SOLVABLES(p)
 926     {
 927       Solvable *s =  pool->solvables + p;
 928       int i;
 929
 930       if (s->repo != pool->installed && !pool_installable(pool, s))
 931         {
 932           if (!(flags & SELECTION_SOURCE_ONLY) || (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC))
 933             continue;
 934           if (pool_disabled_solvable(pool, s))
 935             continue;
 936         }
 937       if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 938         continue;
 939       if ((s->arch == ARCH_SRC || s->arch == ARCH_NOSRC) && !(flags & SELECTION_SOURCE_ONLY) && !(flags & SELECTION_WITH_SOURCE))
 940         continue;
 941       queue_empty(&q);
 942       repo_lookup_deparray(s->repo, p, keyname, &q, marker);
 943       for (i = 0; i < q.count; i++)
 944         {
 945           Id id = q.elements[i];
 946           if (matchdep(pool, id, rname, rflags, r, flags))
 947             break;
 948         }
 949       if (i < q.count)
 950         queue_push2(selection, SOLVER_SOLVABLE | SOLVER_NOAUTOSET, p);
 951     }
 952   queue_free(&q);
 953   solv_free(rname);
 954   if (!selection->count)
 955     return 0;
 956   if ((flags & SELECTION_FLAT) != 0)
 957     selection_flatten(pool, selection);
 958   return SELECTION_PROVIDES;
 959 }
 960
 961 static inline int
 962 pool_is_kind(Pool *pool, Id name, Id kind)
 963 {
 964   const char *n;
 965   if (!kind)
 966     return 1;
 967   n = pool_id2str(pool, name);
 968   if (kind != 1)
 969     {
 970       const char *kn = pool_id2str(pool, kind);
 971       int knl = strlen(kn);
 972       return !strncmp(n, kn, knl) && n[knl] == ':' ? 1 : 0;
 973     }
 974   else
 975     {
 976       if (*n == ':')
 977         return 1;
 978       while(*n >= 'a' && *n <= 'z')
 979         n++;
 980       return *n == ':' ? 0 : 1;
 981     }
 982 }
 983
 984 void
 985 selection_filter(Pool *pool, Queue *sel1, Queue *sel2)
 986 {
 987   int i, j, miss;
 988   Id p, pp, q1filled = 0;
 989   Queue q1;
 990   Map m2;
 991   Id setflags = 0;
 992
 993   if (!sel1->count || !sel2->count)
 994     {
 995       queue_empty(sel1);
 996       return;
 997     }
 998   if (sel1->count == 2 && (sel1->elements[0] & SOLVER_SELECTMASK) == SOLVER_SOLVABLE_ALL)
 999     {
1000       /* XXX: not 100% correct, but very useful */
1001       p = sel1->elements[0] & ~(SOLVER_SELECTMASK | SOLVER_SETMASK);    /* job & jobflags */
1002       queue_free(sel1);
1003       queue_init_clone(sel1, sel2);
1004       for (i = 0; i < sel1->count; i += 2)
1005         sel1->elements[i] = (sel1->elements[i] & (SOLVER_SELECTMASK | SOLVER_SETMASK)) | p ;
1006       return;
1007     }
1008   queue_init(&q1);
1009   map_init(&m2, pool->nsolvables);
1010   for (i = 0; i < sel2->count; i += 2)
1011     {
1012       Id select = sel2->elements[i] & SOLVER_SELECTMASK;
1013       if (select == SOLVER_SOLVABLE_ALL)
1014         {
1015           queue_free(&q1);
1016           map_free(&m2);
1017           return;
1018         }
1019       if (select == SOLVER_SOLVABLE_REPO)
1020         {
1021           Solvable *s;
1022           Repo *repo = pool_id2repo(pool, sel2->elements[i + 1]);
1023           if (repo)
1024             FOR_REPO_SOLVABLES(repo, p, s)
1025               map_set(&m2, p);
1026         }
1027       else
1028         {
1029           if ((select == SOLVER_SOLVABLE_NAME || select == SOLVER_SOLVABLE_PROVIDES) && ISRELDEP(sel2->elements[i + 1]))
1030             {
1031               Reldep *rd = GETRELDEP(pool, sel2->elements[i + 1]);
1032               if (rd->flags == REL_ARCH && rd->name == 0)
1033                 {
1034                   /* special arch filter */
1035                   if (!q1filled++)
1036                     selection_solvables(pool, sel1, &q1);
1037                   for (j = 0; j < q1.count; j++)
1038                     {
1039                       Id p = q1.elements[j];
1040                       Solvable *s = pool->solvables + p;
1041                       if (s->arch == rd->evr || (rd->evr == ARCH_SRC && s->arch == ARCH_NOSRC))
1042                         map_set(&m2, p);
1043                     }
1044                   continue;
1045                 }
1046               else if (rd->flags == REL_KIND && rd->name == 0)
1047                 {
1048                   /* special kind filter */
1049                   if (!q1filled++)
1050                     selection_solvables(pool, sel1, &q1);
1051                   for (j = 0; j < q1.count; j++)
1052                     {
1053                       Id p = q1.elements[j];
1054                       Solvable *s = pool->solvables + p;
1055                       if (pool_is_kind(pool, s->name, rd->evr))
1056                         map_set(&m2, p);
1057                     }
1058                   continue;
1059                 }
1060             }
1061           FOR_JOB_SELECT(p, pp, select, sel2->elements[i + 1])
1062             map_set(&m2, p);
1063         }
1064     }
1065   if (sel2->count == 2)         /* XXX: AND all setmasks instead? */
1066     setflags = sel2->elements[0] & SOLVER_SETMASK & ~SOLVER_NOAUTOSET;
1067   for (i = j = 0; i < sel1->count; i += 2)
1068     {
1069       Id select = sel1->elements[i] & SOLVER_SELECTMASK;
1070       queue_empty(&q1);
1071       miss = 0;
1072       if (select == SOLVER_SOLVABLE_ALL)
1073         {
1074           FOR_POOL_SOLVABLES(p)
1075             {
1076               if (map_tst(&m2, p))
1077                 queue_push(&q1, p);
1078               else
1079                 miss = 1;
1080             }
1081         }
1082       else if (select == SOLVER_SOLVABLE_REPO)
1083         {
1084           Solvable *s;
1085           Repo *repo = pool_id2repo(pool, sel1->elements[i + 1]);
1086           if (repo)
1087             FOR_REPO_SOLVABLES(repo, p, s)
1088               {
1089                 if (map_tst(&m2, p))
1090                   queue_push(&q1, p);
1091                 else
1092                   miss = 1;
1093               }
1094         }
1095       else
1096         {
1097           FOR_JOB_SELECT(p, pp, select, sel1->elements[i + 1])
1098             {
1099               if (map_tst(&m2, p))
1100                 queue_pushunique(&q1, p);
1101               else
1102                 miss = 1;
1103             }
1104         }
1105       if (!q1.count)
1106         continue;
1107       if (!miss)
1108         {
1109           sel1->elements[j] = sel1->elements[i] | setflags;
1110           sel1->elements[j + 1] = sel1->elements[i + 1];
1111         }
1112       else if (q1.count > 1)
1113         {
1114           sel1->elements[j] = (sel1->elements[i] & ~SOLVER_SELECTMASK) | SOLVER_SOLVABLE_ONE_OF | setflags;
1115           sel1->elements[j + 1] = pool_queuetowhatprovides(pool, &q1);
1116         }
1117       else
1118         {
1119           sel1->elements[j] = (sel1->elements[i] & ~SOLVER_SELECTMASK) | SOLVER_SOLVABLE | SOLVER_NOAUTOSET | setflags;
1120           sel1->elements[j + 1] = q1.elements[0];
1121         }
1122       j += 2;
1123     }
1124   queue_truncate(sel1, j);
1125   queue_free(&q1);
1126   map_free(&m2);
1127 }
1128
1129 void
1130 selection_add(Pool *pool, Queue *sel1, Queue *sel2)
1131 {
1132   int i;
1133   for (i = 0; i < sel2->count; i++)
1134     queue_push(sel1, sel2->elements[i]);
1135 }
1136
1137 const char *
1138 pool_selection2str(Pool *pool, Queue *selection, Id flagmask)
1139 {
1140   char *s;
1141   const char *s2;
1142   int i;
1143   s = pool_tmpjoin(pool, 0, 0, 0);
1144   for (i = 0; i < selection->count; i += 2)
1145     {
1146       Id how = selection->elements[i];
1147       if (*s)
1148         s = pool_tmpappend(pool, s, " + ", 0);
1149       s2 = solver_select2str(pool, how & SOLVER_SELECTMASK, selection->elements[i + 1]);
1150       s = pool_tmpappend(pool, s, s2, 0);
1151       pool_freetmpspace(pool, s2);
1152       how &= flagmask & SOLVER_SETMASK;
1153       if (how)
1154         {
1155           int o = strlen(s);
1156           s = pool_tmpappend(pool, s, " ", 0);
1157           if (how & SOLVER_SETEV)
1158             s = pool_tmpappend(pool, s, ",setev", 0);
1159           if (how & SOLVER_SETEVR)
1160             s = pool_tmpappend(pool, s, ",setevr", 0);
1161           if (how & SOLVER_SETARCH)
1162             s = pool_tmpappend(pool, s, ",setarch", 0);
1163           if (how & SOLVER_SETVENDOR)
1164             s = pool_tmpappend(pool, s, ",setvendor", 0);
1165           if (how & SOLVER_SETREPO)
1166             s = pool_tmpappend(pool, s, ",setrepo", 0);
1167           if (how & SOLVER_NOAUTOSET)
1168             s = pool_tmpappend(pool, s, ",noautoset", 0);
1169           if (s[o + 1] != ',')
1170             s = pool_tmpappend(pool, s, ",?", 0);
1171           s[o + 1] = '[';
1172           s = pool_tmpappend(pool, s, "]", 0);
1173         }
1174     }
1175   return s;
1176 }
1177