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   /* all files in the file list start with a '/' */
 555   if (*name != '/')
 556     {
 557       if (!(flags & SELECTION_GLOB))
 558         return 0;
 559       if (*name != '*' && *name != '[' && *name != '?')
 560         return 0;
 561     }
 562   type = !(flags & SELECTION_GLOB) || strpbrk(name, "[*?") == 0 ? SEARCH_STRING : SEARCH_GLOB;
 563   if ((flags & SELECTION_NOCASE) != 0)
 564     type |= SEARCH_NOCASE;
 565   queue_init(&q);
 566   dataiterator_init(&di, pool, flags & SELECTION_INSTALLED_ONLY ? pool->installed : 0, 0, SOLVABLE_FILELIST, name, type|SEARCH_FILES|SEARCH_COMPLETE_FILELIST);
 567   while (dataiterator_step(&di))
 568     {
 569       Solvable *s = pool->solvables + di.solvid;
 570       if (!s->repo)
 571         continue;
 572       if (s->repo != pool->installed && !pool_installable(pool, s))
 573         {
 574           if (!(flags & SELECTION_SOURCE_ONLY) || (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC))
 575             continue;
 576           if (pool_disabled_solvable(pool, s))
 577             continue;
 578         }
 579       if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 580         continue;
 581       queue_push(&q, di.solvid);
 582       dataiterator_skip_solvable(&di);
 583     }
 584   dataiterator_free(&di);
 585   if (!q.count)
 586     return 0;
 587   if (q.count > 1)
 588     queue_push2(selection, SOLVER_SOLVABLE_ONE_OF, pool_queuetowhatprovides(pool, &q));
 589   else
 590     queue_push2(selection, SOLVER_SOLVABLE | SOLVER_NOAUTOSET, q.elements[0]);
 591   queue_free(&q);
 592   return SELECTION_FILELIST;
 593 }
 594
 595 static char *
 596 splitrel(char *rname, char *r, int *rflagsp)
 597 {
 598   int nend = r - rname;
 599   int rflags = 0;
 600   if (nend && *r == '=' && r[-1] == '!')
 601     {
 602       nend--;
 603       r++;
 604       rflags = REL_LT|REL_GT;
 605     }
 606   for (; *r; r++)
 607     {
 608       if (*r == '<')
 609         rflags |= REL_LT;
 610       else if (*r == '=')
 611         rflags |= REL_EQ;
 612       else if (*r == '>')
 613         rflags |= REL_GT;
 614       else
 615         break;
 616     }
 617   while (*r && (*r == ' ' || *r == '\t'))
 618     r++;
 619   while (nend && (rname[nend - 1] == ' ' || rname[nend - 1] == '\t'))
 620     nend--;
 621   if (!*rname || !*r)
 622     return 0;
 623   *rflagsp = rflags;
 624   rname[nend] = 0;
 625   return r;
 626 }
 627
 628 static int
 629 selection_rel(Pool *pool, Queue *selection, const char *name, int flags)
 630 {
 631   int ret, rflags = 0;
 632   char *r, *rname;
 633
 634   /* relation case, support:
 635    * depglob rel
 636    * depglob.arch rel
 637    */
 638   rname = solv_strdup(name);
 639   if ((r = strpbrk(rname, "<=>")) != 0)
 640     {
 641       if ((r = splitrel(rname, r, &rflags)) == 0)
 642         {
 643           solv_free(rname);
 644           return 0;
 645         }
 646     }
 647   if ((ret = selection_depglob_arch(pool, selection, rname, flags)) != 0)
 648     {
 649       if (rflags)
 650         selection_filter_rel(pool, selection, rflags, pool_str2id(pool, r, 1));
 651       solv_free(rname);
 652       return ret | SELECTION_REL;
 653     }
 654   solv_free(rname);
 655   return 0;
 656 }
 657
 658 #if defined(MULTI_SEMANTICS)
 659 # define EVRCMP_DEPCMP (pool->disttype == DISTTYPE_DEB ? EVRCMP_COMPARE : EVRCMP_MATCH_RELEASE)
 660 #elif defined(DEBIAN)
 661 # define EVRCMP_DEPCMP EVRCMP_COMPARE
 662 #else
 663 # define EVRCMP_DEPCMP EVRCMP_MATCH_RELEASE
 664 #endif
 665
 666 /* magic epoch promotion code, works only for SELECTION_NAME selections */
 667 static void
 668 selection_filter_evr(Pool *pool, Queue *selection, char *evr)
 669 {
 670   int i, j;
 671   Queue q;
 672   Id qbuf[10];
 673
 674   queue_init(&q);
 675   queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf));
 676   for (i = j = 0; i < selection->count; i += 2)
 677     {
 678       Id select = selection->elements[i] & SOLVER_SELECTMASK;
 679       Id id = selection->elements[i + 1];
 680       Id p, pp;
 681       const char *lastepoch = 0;
 682       int lastepochlen = 0;
 683
 684       queue_empty(&q);
 685       FOR_JOB_SELECT(p, pp, select, id)
 686         {
 687           Solvable *s = pool->solvables + p;
 688           const char *sevr = pool_id2str(pool, s->evr);
 689           const char *sp;
 690           for (sp = sevr; *sp >= '0' && *sp <= '9'; sp++)
 691             ;
 692           if (*sp != ':')
 693             sp = sevr;
 694           /* compare vr part */
 695           if (strcmp(evr, sp != sevr ? sp + 1 : sevr) != 0)
 696             {
 697               int r = pool_evrcmp_str(pool, sp != sevr ? sp + 1 : sevr, evr, EVRCMP_DEPCMP);
 698               if (r == -1 || r == 1)
 699                 continue;       /* solvable does not match vr */
 700             }
 701           queue_push(&q, p);
 702           if (sp > sevr)
 703             {
 704               while (sevr < sp && *sevr == '0') /* normalize epoch */
 705                 sevr++;
 706             }
 707           if (!lastepoch)
 708             {
 709               lastepoch = sevr;
 710               lastepochlen = sp - sevr;
 711             }
 712           else if (lastepochlen != sp - sevr || strncmp(lastepoch, sevr, lastepochlen) != 0)
 713             lastepochlen = -1;  /* multiple different epochs */
 714         }
 715       if (!lastepoch || lastepochlen == 0)
 716         id = pool_str2id(pool, evr, 1);         /* no match at all or zero epoch */
 717       else if (lastepochlen >= 0)
 718         {
 719           /* found exactly one epoch, simply prepend */
 720           char *evrx = solv_malloc(strlen(evr) + lastepochlen + 2);
 721           strncpy(evrx, lastepoch, lastepochlen + 1);
 722           strcpy(evrx + lastepochlen + 1, evr);
 723           id = pool_str2id(pool, evrx, 1);
 724           solv_free(evrx);
 725         }
 726       else
 727         {
 728           /* multiple epochs in multiple solvables, convert to list of solvables */
 729           selection->elements[j] = (selection->elements[i] & ~SOLVER_SELECTMASK) | SOLVER_SOLVABLE_ONE_OF;
 730           selection->elements[j + 1] = pool_queuetowhatprovides(pool, &q);
 731           j += 2;
 732           continue;
 733         }
 734       queue_empty(&q);
 735       queue_push2(&q, selection->elements[i], selection->elements[i + 1]);
 736       selection_filter_rel(pool, &q, REL_EQ, id);
 737       if (!q.count)
 738         continue;               /* oops, no match */
 739       selection->elements[j] = q.elements[0];
 740       selection->elements[j + 1] = q.elements[1];
 741       j += 2;
 742     }
 743   queue_truncate(selection, j);
 744   queue_free(&q);
 745 }
 746
 747 /* match the "canonical" name of the package */
 748 static int
 749 selection_canon(Pool *pool, Queue *selection, const char *name, int flags)
 750 {
 751   char *rname, *r, *r2;
 752   Id archid = 0;
 753   int ret;
 754
 755   /*
 756    * nameglob-version
 757    * nameglob-version.arch
 758    * nameglob-version-release
 759    * nameglob-version-release.arch
 760    */
 761   flags |= SELECTION_NAME;
 762   flags &= ~SELECTION_PROVIDES;
 763
 764   if (pool->disttype == DISTTYPE_DEB)
 765     {
 766       if ((r = strchr(name, '_')) == 0)
 767         return 0;
 768       rname = solv_strdup(name);        /* so we can modify it */
 769       r = rname + (r - name);
 770       *r++ = 0;
 771       if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 772         {
 773           solv_free(rname);
 774           return 0;
 775         }
 776       /* is there a vaild arch? */
 777       if ((r2 = strrchr(r, '_')) != 0 && r[1] && (archid = str2archid(pool, r + 1)) != 0)
 778         {
 779           *r2 = 0;      /* split off */
 780           selection_filter_rel(pool, selection, REL_ARCH, archid);
 781         }
 782       selection_filter_rel(pool, selection, REL_EQ, pool_str2id(pool, r, 1));
 783       solv_free(rname);
 784       return ret | SELECTION_CANON;
 785     }
 786
 787   if (pool->disttype == DISTTYPE_HAIKU)
 788     {
 789       if ((r = strchr(name, '-')) == 0)
 790         return 0;
 791       rname = solv_strdup(name);        /* so we can modify it */
 792       r = rname + (r - name);
 793       *r++ = 0;
 794       if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 795         {
 796           solv_free(rname);
 797           return 0;
 798         }
 799       /* is there a vaild arch? */
 800       if ((r2 = strrchr(r, '-')) != 0 && r[1] && (archid = str2archid(pool, r + 1)) != 0)
 801         {
 802           *r2 = 0;      /* split off */
 803           selection_filter_rel(pool, selection, REL_ARCH, archid);
 804         }
 805       selection_filter_rel(pool, selection, REL_EQ, pool_str2id(pool, r, 1));
 806       solv_free(rname);
 807       return ret | SELECTION_CANON;
 808     }
 809
 810   if ((r = strrchr(name, '-')) == 0)
 811     return 0;
 812   rname = solv_strdup(name);    /* so we can modify it */
 813   r = rname + (r - name);
 814   *r = 0;
 815
 816   /* split off potential arch part from version */
 817   if ((r2 = strrchr(r + 1, '.')) != 0 && r2[1] && (archid = str2archid(pool, r2 + 1)) != 0)
 818     *r2 = 0;    /* found valid arch, split it off */
 819   if (archid == ARCH_SRC || archid == ARCH_NOSRC)
 820     flags |= SELECTION_SOURCE_ONLY;
 821
 822   /* try with just the version */
 823   if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 824     {
 825       /* no luck, try with version-release */
 826       if ((r2 = strrchr(rname, '-')) == 0)
 827         {
 828           solv_free(rname);
 829           return 0;
 830         }
 831       *r = '-';
 832       *r2 = 0;
 833       r = r2;
 834       if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 835         {
 836           solv_free(rname);
 837           return 0;
 838         }
 839     }
 840   if (archid)
 841     selection_filter_rel(pool, selection, REL_ARCH, archid);
 842   selection_filter_evr(pool, selection, r + 1); /* magic epoch promotion */
 843   solv_free(rname);
 844   return ret | SELECTION_CANON;
 845 }
 846
 847 int
 848 selection_make(Pool *pool, Queue *selection, const char *name, int flags)
 849 {
 850   int ret = 0;
 851
 852   queue_empty(selection);
 853   if ((flags & SELECTION_FILELIST) != 0)
 854     ret = selection_filelist(pool, selection, name, flags);
 855   if (!ret && (flags & SELECTION_REL) != 0 && strpbrk(name, "<=>") != 0)
 856     ret = selection_rel(pool, selection, name, flags);
 857   if (!ret)
 858     ret = selection_depglob_arch(pool, selection, name, flags);
 859   if (!ret && (flags & SELECTION_CANON) != 0)
 860     ret = selection_canon(pool, selection, name, flags);
 861   if (selection->count && (flags & SELECTION_INSTALLED_ONLY) != 0)
 862     selection_filter_installed(pool, selection);
 863   if (ret && !selection->count)
 864     ret = 0;    /* no match -> always return zero */
 865   if (ret && (flags & SELECTION_FLAT) != 0)
 866     selection_flatten(pool, selection);
 867   return ret;
 868 }
 869
 870 static int
 871 matchdep(Pool *pool, Id id, char *rname, int rflags, char *revr, int flags)
 872 {
 873   if (ISRELDEP(id))
 874     {
 875       Reldep *rd = GETRELDEP(pool, id);
 876       if (rd->flags == REL_AND || rd->flags == REL_OR || rd->flags == REL_WITH || rd->flags == REL_COND)
 877         {
 878           if (matchdep(pool, rd->name, rname, rflags, revr, flags))
 879             return 1;
 880           if (rd->flags == REL_COND && ISRELDEP(rd->evr))
 881             {
 882               rd = GETRELDEP(pool, rd->evr);
 883               if (rd->flags != REL_ELSE)
 884                 return 0;
 885             }
 886           if (rd->flags != REL_COND && matchdep(pool, rd->evr, rname, rflags, revr, flags))
 887             return 1;
 888           return 0;
 889         }
 890       if (rd->flags == REL_ARCH)
 891         return matchdep(pool, rd->name, rname, rflags, revr, flags);
 892       if (!matchdep(pool, rd->name, rname, rflags, revr, flags))
 893         return 0;
 894       if (rflags)
 895         {
 896           /* XXX: need pool_match_flags_evr here */
 897           if (!pool_match_dep(pool, pool_rel2id(pool, rd->name, pool_str2id(pool, revr, 1), rflags, 1), id))
 898             return 0;
 899         }
 900       return 1;
 901     }
 902   if (flags & SELECTION_GLOB)
 903     {
 904       int globflags = (flags & SELECTION_NOCASE) != 0 ? FNM_CASEFOLD : 0;
 905       return fnmatch(rname, pool_id2str(pool, id), globflags) == 0 ? 1 : 0;
 906     }
 907   if (flags & SELECTION_NOCASE)
 908     return strcasecmp(rname, pool_id2str(pool, id)) == 0 ? 1 : 0;
 909   return strcmp(rname, pool_id2str(pool, id)) == 0 ? 1 : 0;
 910 }
 911
 912 /*
 913  *  select against the dependencies in keyname
 914  *  like SELECTION_REL and SELECTION_PROVIDES, but with the
 915  *  deps in keyname instead of provides.
 916  */
 917 int
 918 selection_make_matchdeps(Pool *pool, Queue *selection, const char *name, int flags, int keyname, int marker)
 919 {
 920   char *rname, *r;
 921   int rflags = 0;
 922   Id p;
 923   Queue q;
 924
 925   queue_empty(selection);
 926   rname = solv_strdup(name);
 927   if ((r = strpbrk(rname, "<=>")) != 0)
 928     {
 929       if ((r = splitrel(rname, r, &rflags)) == 0)
 930         {
 931           solv_free(rname);
 932           return 0;
 933         }
 934     }
 935   if ((flags & SELECTION_GLOB) != 0 && !strpbrk(name, "[*?") != 0)
 936     flags &= ~SELECTION_GLOB;
 937
 938   queue_init(&q);
 939   FOR_POOL_SOLVABLES(p)
 940     {
 941       Solvable *s =  pool->solvables + p;
 942       int i;
 943
 944       if (s->repo != pool->installed && !pool_installable(pool, s))
 945         {
 946           if (!(flags & SELECTION_SOURCE_ONLY) || (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC))
 947             continue;
 948           if (pool_disabled_solvable(pool, s))
 949             continue;
 950         }
 951       if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 952         continue;
 953       if ((s->arch == ARCH_SRC || s->arch == ARCH_NOSRC) && !(flags & SELECTION_SOURCE_ONLY) && !(flags & SELECTION_WITH_SOURCE))
 954         continue;
 955       queue_empty(&q);
 956       repo_lookup_deparray(s->repo, p, keyname, &q, marker);
 957       for (i = 0; i < q.count; i++)
 958         {
 959           Id id = q.elements[i];
 960           if (matchdep(pool, id, rname, rflags, r, flags))
 961             break;
 962         }
 963       if (i < q.count)
 964         queue_push2(selection, SOLVER_SOLVABLE | SOLVER_NOAUTOSET, p);
 965     }
 966   queue_free(&q);
 967   solv_free(rname);
 968   if (!selection->count)
 969     return 0;
 970   if ((flags & SELECTION_FLAT) != 0)
 971     selection_flatten(pool, selection);
 972   return SELECTION_PROVIDES;
 973 }
 974
 975 static inline int
 976 pool_is_kind(Pool *pool, Id name, Id kind)
 977 {
 978   const char *n;
 979   if (!kind)
 980     return 1;
 981   n = pool_id2str(pool, name);
 982   if (kind != 1)
 983     {
 984       const char *kn = pool_id2str(pool, kind);
 985       int knl = strlen(kn);
 986       return !strncmp(n, kn, knl) && n[knl] == ':' ? 1 : 0;
 987     }
 988   else
 989     {
 990       if (*n == ':')
 991         return 1;
 992       while(*n >= 'a' && *n <= 'z')
 993         n++;
 994       return *n == ':' ? 0 : 1;
 995     }
 996 }
 997
 998 void
 999 selection_filter(Pool *pool, Queue *sel1, Queue *sel2)
1000 {
1001   int i, j, miss;
1002   Id p, pp, q1filled = 0;
1003   Queue q1;
1004   Map m2;
1005   Id setflags = 0;
1006
1007   if (!sel1->count || !sel2->count)
1008     {
1009       queue_empty(sel1);
1010       return;
1011     }
1012   if (sel1->count == 2 && (sel1->elements[0] & SOLVER_SELECTMASK) == SOLVER_SOLVABLE_ALL)
1013     {
1014       /* XXX: not 100% correct, but very useful */
1015       p = sel1->elements[0] & ~(SOLVER_SELECTMASK | SOLVER_SETMASK);    /* job & jobflags */
1016       queue_free(sel1);
1017       queue_init_clone(sel1, sel2);
1018       for (i = 0; i < sel1->count; i += 2)
1019         sel1->elements[i] = (sel1->elements[i] & (SOLVER_SELECTMASK | SOLVER_SETMASK)) | p ;
1020       return;
1021     }
1022   queue_init(&q1);
1023   map_init(&m2, pool->nsolvables);
1024   for (i = 0; i < sel2->count; i += 2)
1025     {
1026       Id select = sel2->elements[i] & SOLVER_SELECTMASK;
1027       if (select == SOLVER_SOLVABLE_ALL)
1028         {
1029           queue_free(&q1);
1030           map_free(&m2);
1031           return;
1032         }
1033       if (select == SOLVER_SOLVABLE_REPO)
1034         {
1035           Solvable *s;
1036           Repo *repo = pool_id2repo(pool, sel2->elements[i + 1]);
1037           if (repo)
1038             FOR_REPO_SOLVABLES(repo, p, s)
1039               map_set(&m2, p);
1040         }
1041       else
1042         {
1043           if ((select == SOLVER_SOLVABLE_NAME || select == SOLVER_SOLVABLE_PROVIDES) && ISRELDEP(sel2->elements[i + 1]))
1044             {
1045               Reldep *rd = GETRELDEP(pool, sel2->elements[i + 1]);
1046               if (rd->flags == REL_ARCH && rd->name == 0)
1047                 {
1048                   /* special arch 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 (s->arch == rd->evr || (rd->evr == ARCH_SRC && s->arch == ARCH_NOSRC))
1056                         map_set(&m2, p);
1057                     }
1058                   continue;
1059                 }
1060               else if (rd->flags == REL_KIND && rd->name == 0)
1061                 {
1062                   /* special kind filter */
1063                   if (!q1filled++)
1064                     selection_solvables(pool, sel1, &q1);
1065                   for (j = 0; j < q1.count; j++)
1066                     {
1067                       Id p = q1.elements[j];
1068                       Solvable *s = pool->solvables + p;
1069                       if (pool_is_kind(pool, s->name, rd->evr))
1070                         map_set(&m2, p);
1071                     }
1072                   continue;
1073                 }
1074             }
1075           FOR_JOB_SELECT(p, pp, select, sel2->elements[i + 1])
1076             map_set(&m2, p);
1077         }
1078     }
1079   if (sel2->count == 2)         /* XXX: AND all setmasks instead? */
1080     setflags = sel2->elements[0] & SOLVER_SETMASK & ~SOLVER_NOAUTOSET;
1081   for (i = j = 0; i < sel1->count; i += 2)
1082     {
1083       Id select = sel1->elements[i] & SOLVER_SELECTMASK;
1084       queue_empty(&q1);
1085       miss = 0;
1086       if (select == SOLVER_SOLVABLE_ALL)
1087         {
1088           FOR_POOL_SOLVABLES(p)
1089             {
1090               if (map_tst(&m2, p))
1091                 queue_push(&q1, p);
1092               else
1093                 miss = 1;
1094             }
1095         }
1096       else if (select == SOLVER_SOLVABLE_REPO)
1097         {
1098           Solvable *s;
1099           Repo *repo = pool_id2repo(pool, sel1->elements[i + 1]);
1100           if (repo)
1101             FOR_REPO_SOLVABLES(repo, p, s)
1102               {
1103                 if (map_tst(&m2, p))
1104                   queue_push(&q1, p);
1105                 else
1106                   miss = 1;
1107               }
1108         }
1109       else
1110         {
1111           FOR_JOB_SELECT(p, pp, select, sel1->elements[i + 1])
1112             {
1113               if (map_tst(&m2, p))
1114                 queue_pushunique(&q1, p);
1115               else
1116                 miss = 1;
1117             }
1118         }
1119       if (!q1.count)
1120         continue;
1121       if (!miss)
1122         {
1123           sel1->elements[j] = sel1->elements[i] | setflags;
1124           sel1->elements[j + 1] = sel1->elements[i + 1];
1125         }
1126       else if (q1.count > 1)
1127         {
1128           sel1->elements[j] = (sel1->elements[i] & ~SOLVER_SELECTMASK) | SOLVER_SOLVABLE_ONE_OF | setflags;
1129           sel1->elements[j + 1] = pool_queuetowhatprovides(pool, &q1);
1130         }
1131       else
1132         {
1133           sel1->elements[j] = (sel1->elements[i] & ~SOLVER_SELECTMASK) | SOLVER_SOLVABLE | SOLVER_NOAUTOSET | setflags;
1134           sel1->elements[j + 1] = q1.elements[0];
1135         }
1136       j += 2;
1137     }
1138   queue_truncate(sel1, j);
1139   queue_free(&q1);
1140   map_free(&m2);
1141 }
1142
1143 void
1144 selection_add(Pool *pool, Queue *sel1, Queue *sel2)
1145 {
1146   int i;
1147   for (i = 0; i < sel2->count; i++)
1148     queue_push(sel1, sel2->elements[i]);
1149 }
1150
1151 const char *
1152 pool_selection2str(Pool *pool, Queue *selection, Id flagmask)
1153 {
1154   char *s;
1155   const char *s2;
1156   int i;
1157   s = pool_tmpjoin(pool, 0, 0, 0);
1158   for (i = 0; i < selection->count; i += 2)
1159     {
1160       Id how = selection->elements[i];
1161       if (*s)
1162         s = pool_tmpappend(pool, s, " + ", 0);
1163       s2 = solver_select2str(pool, how & SOLVER_SELECTMASK, selection->elements[i + 1]);
1164       s = pool_tmpappend(pool, s, s2, 0);
1165       pool_freetmpspace(pool, s2);
1166       how &= flagmask & SOLVER_SETMASK;
1167       if (how)
1168         {
1169           int o = strlen(s);
1170           s = pool_tmpappend(pool, s, " ", 0);
1171           if (how & SOLVER_SETEV)
1172             s = pool_tmpappend(pool, s, ",setev", 0);
1173           if (how & SOLVER_SETEVR)
1174             s = pool_tmpappend(pool, s, ",setevr", 0);
1175           if (how & SOLVER_SETARCH)
1176             s = pool_tmpappend(pool, s, ",setarch", 0);
1177           if (how & SOLVER_SETVENDOR)
1178             s = pool_tmpappend(pool, s, ",setvendor", 0);
1179           if (how & SOLVER_SETREPO)
1180             s = pool_tmpappend(pool, s, ",setrepo", 0);
1181           if (how & SOLVER_NOAUTOSET)
1182             s = pool_tmpappend(pool, s, ",noautoset", 0);
1183           if (s[o + 1] != ',')
1184             s = pool_tmpappend(pool, s, ",?", 0);
1185           s[o + 1] = '[';
1186           s = pool_tmpappend(pool, s, "]", 0);
1187         }
1188     }
1189   return s;
1190 }
1191