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);
 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 int
 339 selection_depglob(Pool *pool, Queue *selection, const char *name, int flags)
 340 {
 341   Id id, p, pp;
 342   int i, match = 0;
 343   int doglob = 0;
 344   int globflags = 0;
 345
 346   if ((flags & SELECTION_SOURCE_ONLY) != 0)
 347     {
 348       flags &= ~SELECTION_PROVIDES;     /* sources don't provide anything */
 349       flags &= ~SELECTION_WITH_SOURCE;
 350     }
 351
 352   if (!(flags & (SELECTION_NAME|SELECTION_PROVIDES)))
 353     return 0;
 354
 355   if ((flags & SELECTION_INSTALLED_ONLY) != 0 && !pool->installed)
 356     return 0;
 357
 358   if (!(flags & SELECTION_NOCASE))
 359     {
 360       id = pool_str2id(pool, name, 0);
 361       if (id)
 362         {
 363           if ((flags & (SELECTION_SOURCE_ONLY | SELECTION_WITH_SOURCE)) != 0 && (flags & SELECTION_NAME) != 0)
 364             {
 365               /* src rpms don't have provides, so we must check every solvable */
 366               FOR_PROVIDES(p, pp, id)   /* try fast path first */
 367                 {
 368                   Solvable *s = pool->solvables + p;
 369                   if (s->name == id)
 370                     {
 371                       if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 372                         continue;
 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               FOR_POOL_SOLVABLES(p)     /* slow path */
 382                 {
 383                   Solvable *s = pool->solvables + p;
 384                   if (s->name == id && (s->arch == ARCH_SRC || s->arch == ARCH_NOSRC))
 385                     {
 386                       if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 387                         continue;       /* just in case... src rpms can't be installed */
 388                       if (pool_disabled_solvable(pool, s))
 389                         continue;
 390                       if ((flags & SELECTION_SOURCE_ONLY) != 0)
 391                         id = pool_rel2id(pool, id, ARCH_SRC, REL_ARCH, 1);
 392                       queue_push2(selection, SOLVER_SOLVABLE_NAME, id);
 393                       if ((flags & SELECTION_WITH_SOURCE) != 0)
 394                         selection_addsrc(pool, selection, flags);
 395                       return SELECTION_NAME;
 396                     }
 397                 }
 398             }
 399           FOR_PROVIDES(p, pp, id)
 400             {
 401               Solvable *s = pool->solvables + p;
 402               if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 403                 continue;
 404               match = 1;
 405               if (s->name == id && (flags & SELECTION_NAME) != 0)
 406                 {
 407                   if ((flags & SELECTION_SOURCE_ONLY) != 0)
 408                     id = pool_rel2id(pool, id, ARCH_SRC, REL_ARCH, 1);
 409                   queue_push2(selection, SOLVER_SOLVABLE_NAME, id);
 410                   if ((flags & SELECTION_WITH_SOURCE) != 0)
 411                     selection_addsrc(pool, selection, flags);
 412                   return SELECTION_NAME;
 413                 }
 414             }
 415           if (match && (flags & SELECTION_PROVIDES) != 0)
 416             {
 417               queue_push2(selection, SOLVER_SOLVABLE_PROVIDES, id);
 418               return SELECTION_PROVIDES;
 419             }
 420         }
 421     }
 422
 423   if ((flags & SELECTION_GLOB) != 0 && strpbrk(name, "[*?") != 0)
 424     doglob = 1;
 425
 426   if (!doglob && !(flags & SELECTION_NOCASE))
 427     return 0;
 428
 429   if (doglob && (flags & SELECTION_NOCASE) != 0)
 430     globflags = FNM_CASEFOLD;
 431
 432 #if 0   /* doesn't work with selection_filter_rel yet */
 433   if (doglob && !strcmp(name, "*") && (flags & SELECTION_FLAT) != 0)
 434     {
 435       /* can't do this for SELECTION_PROVIDES, as src rpms don't provide anything */
 436       if ((flags & SELECTION_NAME) != 0)
 437         {
 438           queue_push2(selection, SOLVER_SOLVABLE_ALL, 0);
 439           return SELECTION_NAME;
 440         }
 441     }
 442 #endif
 443
 444   if ((flags & SELECTION_NAME) != 0)
 445     {
 446       /* looks like a name glob. hard work. */
 447       FOR_POOL_SOLVABLES(p)
 448         {
 449           Solvable *s = pool->solvables + p;
 450           if (s->repo != pool->installed && !pool_installable(pool, s))
 451             {
 452               if (!(flags & SELECTION_SOURCE_ONLY) || (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC))
 453                 continue;
 454               if (pool_disabled_solvable(pool, s))
 455                 continue;
 456             }
 457           if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 458             continue;
 459           id = s->name;
 460           if ((doglob ? fnmatch(name, pool_id2str(pool, id), globflags) : strcasecmp(name, pool_id2str(pool, id))) == 0)
 461             {
 462               if ((flags & SELECTION_SOURCE_ONLY) != 0)
 463                 id = pool_rel2id(pool, id, ARCH_SRC, REL_ARCH, 1);
 464               /* queue_pushunique2 */
 465               for (i = 0; i < selection->count; i += 2)
 466                 if (selection->elements[i] == SOLVER_SOLVABLE_NAME && selection->elements[i + 1] == id)
 467                   break;
 468               if (i == selection->count)
 469                 queue_push2(selection, SOLVER_SOLVABLE_NAME, id);
 470               match = 1;
 471             }
 472         }
 473       if (match)
 474         {
 475           if ((flags & SELECTION_WITH_SOURCE) != 0)
 476             selection_addsrc(pool, selection, flags);
 477           return SELECTION_NAME;
 478         }
 479     }
 480   if ((flags & SELECTION_PROVIDES))
 481     {
 482       /* looks like a dep glob. really hard work. */
 483       for (id = 1; id < pool->ss.nstrings; id++)
 484         {
 485           if (!pool->whatprovides[id] || pool->whatprovides[id] == 1)
 486             continue;
 487           if ((doglob ? fnmatch(name, pool_id2str(pool, id), globflags) : strcasecmp(name, pool_id2str(pool, id))) == 0)
 488             {
 489               if ((flags & SELECTION_INSTALLED_ONLY) != 0)
 490                 {
 491                   FOR_PROVIDES(p, pp, id)
 492                     if (pool->solvables[p].repo == pool->installed)
 493                       break;
 494                   if (!p)
 495                     continue;
 496                 }
 497               queue_push2(selection, SOLVER_SOLVABLE_PROVIDES, id);
 498               match = 1;
 499             }
 500         }
 501       if (match)
 502         return SELECTION_PROVIDES;
 503     }
 504   return 0;
 505 }
 506
 507 static int
 508 selection_depglob_arch(Pool *pool, Queue *selection, const char *name, int flags)
 509 {
 510   int ret;
 511   const char *r;
 512   Id archid;
 513
 514   if ((ret = selection_depglob(pool, selection, name, flags)) != 0)
 515     return ret;
 516   if (!(flags & SELECTION_DOTARCH))
 517     return 0;
 518   /* check if there is an .arch suffix */
 519   if ((r = strrchr(name, '.')) != 0 && r[1] && (archid = str2archid(pool, r + 1)) != 0)
 520     {
 521       char *rname = solv_strdup(name);
 522       rname[r - name] = 0;
 523       if (archid == ARCH_SRC || archid == ARCH_NOSRC)
 524         flags |= SELECTION_SOURCE_ONLY;
 525       if ((ret = selection_depglob(pool, selection, rname, flags)) != 0)
 526         {
 527           selection_filter_rel(pool, selection, REL_ARCH, archid);
 528           solv_free(rname);
 529           return ret | SELECTION_DOTARCH;
 530         }
 531       solv_free(rname);
 532     }
 533   return 0;
 534 }
 535
 536 static int
 537 selection_filelist(Pool *pool, Queue *selection, const char *name, int flags)
 538 {
 539   Dataiterator di;
 540   Queue q;
 541   int type;
 542
 543   type = !(flags & SELECTION_GLOB) || strpbrk(name, "[*?") == 0 ? SEARCH_STRING : SEARCH_GLOB;
 544   if ((flags & SELECTION_NOCASE) != 0)
 545     type |= SEARCH_NOCASE;
 546   queue_init(&q);
 547   dataiterator_init(&di, pool, flags & SELECTION_INSTALLED_ONLY ? pool->installed : 0, 0, SOLVABLE_FILELIST, name, type|SEARCH_FILES|SEARCH_COMPLETE_FILELIST);
 548   while (dataiterator_step(&di))
 549     {
 550       Solvable *s = pool->solvables + di.solvid;
 551       if (!s->repo)
 552         continue;
 553       if (s->repo != pool->installed && !pool_installable(pool, s))
 554         {
 555           if (!(flags & SELECTION_SOURCE_ONLY) || (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC))
 556             continue;
 557           if (pool_disabled_solvable(pool, s))
 558             continue;
 559         }
 560       if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 561         continue;
 562       queue_push(&q, di.solvid);
 563       dataiterator_skip_solvable(&di);
 564     }
 565   dataiterator_free(&di);
 566   if (!q.count)
 567     return 0;
 568   if (q.count > 1)
 569     queue_push2(selection, SOLVER_SOLVABLE_ONE_OF, pool_queuetowhatprovides(pool, &q));
 570   else
 571     queue_push2(selection, SOLVER_SOLVABLE | SOLVER_NOAUTOSET, q.elements[0]);
 572   queue_free(&q);
 573   return SELECTION_FILELIST;
 574 }
 575
 576 static char *
 577 splitrel(char *rname, char *r, int *rflagsp)
 578 {
 579   int nend = r - rname;
 580   int rflags = 0;
 581   if (nend && *r == '=' && r[-1] == '!')
 582     {
 583       nend--;
 584       r++;
 585       rflags = REL_LT|REL_GT;
 586     }
 587   for (; *r; r++)
 588     {
 589       if (*r == '<')
 590         rflags |= REL_LT;
 591       else if (*r == '=')
 592         rflags |= REL_EQ;
 593       else if (*r == '>')
 594         rflags |= REL_GT;
 595       else
 596         break;
 597     }
 598   while (*r && (*r == ' ' || *r == '\t'))
 599     r++;
 600   while (nend && (rname[nend - 1] == ' ' || rname[nend - 1] == '\t'))
 601     nend--;
 602   if (!*rname || !*r)
 603     return 0;
 604   *rflagsp = rflags;
 605   rname[nend] = 0;
 606   return r;
 607 }
 608
 609 static int
 610 selection_rel(Pool *pool, Queue *selection, const char *name, int flags)
 611 {
 612   int ret, rflags = 0;
 613   char *r, *rname;
 614
 615   /* relation case, support:
 616    * depglob rel
 617    * depglob.arch rel
 618    */
 619   rname = solv_strdup(name);
 620   if ((r = strpbrk(rname, "<=>")) != 0)
 621     {
 622       if ((r = splitrel(rname, r, &rflags)) == 0)
 623         {
 624           solv_free(rname);
 625           return 0;
 626         }
 627     }
 628   if ((ret = selection_depglob_arch(pool, selection, rname, flags)) != 0)
 629     {
 630       if (rflags)
 631         selection_filter_rel(pool, selection, rflags, pool_str2id(pool, r, 1));
 632       solv_free(rname);
 633       return ret | SELECTION_REL;
 634     }
 635   solv_free(rname);
 636   return 0;
 637 }
 638
 639 #if defined(MULTI_SEMANTICS)
 640 # define EVRCMP_DEPCMP (pool->disttype == DISTTYPE_DEB ? EVRCMP_COMPARE : EVRCMP_MATCH_RELEASE)
 641 #elif defined(DEBIAN)
 642 # define EVRCMP_DEPCMP EVRCMP_COMPARE
 643 #else
 644 # define EVRCMP_DEPCMP EVRCMP_MATCH_RELEASE
 645 #endif
 646
 647 /* magic epoch promotion code, works only for SELECTION_NAME selections */
 648 static void
 649 selection_filter_evr(Pool *pool, Queue *selection, char *evr)
 650 {
 651   int i, j;
 652   Queue q;
 653   Id qbuf[10];
 654
 655   queue_init(&q);
 656   queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf));
 657   for (i = j = 0; i < selection->count; i += 2)
 658     {
 659       Id select = selection->elements[i] & SOLVER_SELECTMASK;
 660       Id id = selection->elements[i + 1];
 661       Id p, pp;
 662       const char *lastepoch = 0;
 663       int lastepochlen = 0;
 664
 665       queue_empty(&q);
 666       FOR_JOB_SELECT(p, pp, select, id)
 667         {
 668           Solvable *s = pool->solvables + p;
 669           const char *sevr = pool_id2str(pool, s->evr);
 670           const char *sp;
 671           for (sp = sevr; *sp >= '0' && *sp <= '9'; sp++)
 672             ;
 673           if (*sp != ':')
 674             sp = sevr;
 675           /* compare vr part */
 676           if (strcmp(evr, sp != sevr ? sp + 1 : sevr) != 0)
 677             {
 678               int r = pool_evrcmp_str(pool, sp != sevr ? sp + 1 : sevr, evr, EVRCMP_DEPCMP);
 679               if (r == -1 || r == 1)
 680                 continue;       /* solvable does not match vr */
 681             }
 682           queue_push(&q, p);
 683           if (sp > sevr)
 684             {
 685               while (sevr < sp && *sevr == '0') /* normalize epoch */
 686                 sevr++;
 687             }
 688           if (!lastepoch)
 689             {
 690               lastepoch = sevr;
 691               lastepochlen = sp - sevr;
 692             }
 693           else if (lastepochlen != sp - sevr || strncmp(lastepoch, sevr, lastepochlen) != 0)
 694             lastepochlen = -1;  /* multiple different epochs */
 695         }
 696       if (!lastepoch || lastepochlen == 0)
 697         id = pool_str2id(pool, evr, 1);         /* no match at all or zero epoch */
 698       else if (lastepochlen >= 0)
 699         {
 700           /* found exactly one epoch, simply prepend */
 701           char *evrx = solv_malloc(strlen(evr) + lastepochlen + 2);
 702           strncpy(evrx, lastepoch, lastepochlen + 1);
 703           strcpy(evrx + lastepochlen + 1, evr);
 704           id = pool_str2id(pool, evrx, 1);
 705           solv_free(evrx);
 706         }
 707       else
 708         {
 709           /* multiple epochs in multiple solvables, convert to list of solvables */
 710           selection->elements[j] = (selection->elements[i] & ~SOLVER_SELECTMASK) | SOLVER_SOLVABLE_ONE_OF;
 711           selection->elements[j + 1] = pool_queuetowhatprovides(pool, &q);
 712           j += 2;
 713           continue;
 714         }
 715       queue_empty(&q);
 716       queue_push2(&q, selection->elements[i], selection->elements[i + 1]);
 717       selection_filter_rel(pool, &q, REL_EQ, id);
 718       if (!q.count)
 719         continue;               /* oops, no match */
 720       selection->elements[j] = q.elements[0];
 721       selection->elements[j + 1] = q.elements[1];
 722       j += 2;
 723     }
 724   queue_truncate(selection, j);
 725   queue_free(&q);
 726 }
 727
 728 /* match the "canonical" name of the package */
 729 static int
 730 selection_canon(Pool *pool, Queue *selection, const char *name, int flags)
 731 {
 732   char *rname, *r, *r2;
 733   Id archid = 0;
 734   int ret;
 735
 736   /*
 737    * nameglob-version
 738    * nameglob-version.arch
 739    * nameglob-version-release
 740    * nameglob-version-release.arch
 741    */
 742   flags |= SELECTION_NAME;
 743   flags &= ~SELECTION_PROVIDES;
 744
 745   if (pool->disttype == DISTTYPE_DEB)
 746     {
 747       if ((r = strchr(name, '_')) == 0)
 748         return 0;
 749       rname = solv_strdup(name);        /* so we can modify it */
 750       r = rname + (r - name);
 751       *r++ = 0;
 752       if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 753         {
 754           solv_free(rname);
 755           return 0;
 756         }
 757       /* is there a vaild arch? */
 758       if ((r2 = strrchr(r, '_')) != 0 && r[1] && (archid = str2archid(pool, r + 1)) != 0)
 759         {
 760           *r2 = 0;      /* split off */
 761           selection_filter_rel(pool, selection, REL_ARCH, archid);
 762         }
 763       selection_filter_rel(pool, selection, REL_EQ, pool_str2id(pool, r, 1));
 764       solv_free(rname);
 765       return ret | SELECTION_CANON;
 766     }
 767
 768   if (pool->disttype == DISTTYPE_HAIKU)
 769     {
 770       if ((r = strchr(name, '-')) == 0)
 771         return 0;
 772       rname = solv_strdup(name);        /* so we can modify it */
 773       r = rname + (r - name);
 774       *r++ = 0;
 775       if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 776         {
 777           solv_free(rname);
 778           return 0;
 779         }
 780       /* is there a vaild arch? */
 781       if ((r2 = strrchr(r, '-')) != 0 && r[1] && (archid = str2archid(pool, r + 1)) != 0)
 782         {
 783           *r2 = 0;      /* split off */
 784           selection_filter_rel(pool, selection, REL_ARCH, archid);
 785         }
 786       selection_filter_rel(pool, selection, REL_EQ, pool_str2id(pool, r, 1));
 787       solv_free(rname);
 788       return ret | SELECTION_CANON;
 789     }
 790
 791   if ((r = strrchr(name, '-')) == 0)
 792     return 0;
 793   rname = solv_strdup(name);    /* so we can modify it */
 794   r = rname + (r - name);
 795   *r = 0;
 796
 797   /* split off potential arch part from version */
 798   if ((r2 = strrchr(r + 1, '.')) != 0 && r2[1] && (archid = str2archid(pool, r2 + 1)) != 0)
 799     *r2 = 0;    /* found valid arch, split it off */
 800   if (archid == ARCH_SRC || archid == ARCH_NOSRC)
 801     flags |= SELECTION_SOURCE_ONLY;
 802
 803   /* try with just the version */
 804   if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 805     {
 806       /* no luck, try with version-release */
 807       if ((r2 = strrchr(rname, '-')) == 0)
 808         {
 809           solv_free(rname);
 810           return 0;
 811         }
 812       *r = '-';
 813       *r2 = 0;
 814       r = r2;
 815       if ((ret = selection_depglob(pool, selection, rname, flags)) == 0)
 816         {
 817           solv_free(rname);
 818           return 0;
 819         }
 820     }
 821   if (archid)
 822     selection_filter_rel(pool, selection, REL_ARCH, archid);
 823   selection_filter_evr(pool, selection, r + 1); /* magic epoch promotion */
 824   solv_free(rname);
 825   return ret | SELECTION_CANON;
 826 }
 827
 828 int
 829 selection_make(Pool *pool, Queue *selection, const char *name, int flags)
 830 {
 831   int ret = 0;
 832   const char *r;
 833
 834   queue_empty(selection);
 835   if (*name == '/' && (flags & SELECTION_FILELIST))
 836     ret = selection_filelist(pool, selection, name, flags);
 837   if (!ret && (flags & SELECTION_REL) != 0 && (r = strpbrk(name, "<=>")) != 0)
 838     ret = selection_rel(pool, selection, name, flags);
 839   if (!ret)
 840     ret = selection_depglob_arch(pool, selection, name, flags);
 841   if (!ret && (flags & SELECTION_CANON) != 0)
 842     ret = selection_canon(pool, selection, name, flags);
 843   if (selection->count && (flags & SELECTION_INSTALLED_ONLY) != 0)
 844     selection_filter_installed(pool, selection);
 845   if (ret && !selection->count)
 846     ret = 0;    /* no match -> always return zero */
 847   if (ret && (flags & SELECTION_FLAT) != 0)
 848     selection_flatten(pool, selection);
 849   return ret;
 850 }
 851
 852 static int
 853 matchdep(Pool *pool, Id id, char *rname, int rflags, char *revr, int flags)
 854 {
 855   if (ISRELDEP(id))
 856     {
 857       Reldep *rd = GETRELDEP(pool, id);
 858       if (rd->flags == REL_AND || rd->flags == REL_OR || rd->flags == REL_WITH)
 859         {
 860           if (matchdep(pool, rd->name, rname, rflags, revr, flags))
 861             return 1;
 862           if (matchdep(pool, rd->evr, rname, rflags, revr, flags))
 863             return 1;
 864           return 0;
 865         }
 866       if (rd->flags == REL_ARCH)
 867         return matchdep(pool, rd->name, rname, rflags, revr, flags);
 868       if (!matchdep(pool, rd->name, rname, rflags, revr, flags))
 869         return 0;
 870       if (rflags)
 871         {
 872           /* XXX: need pool_match_flags_evr here */
 873           if (!pool_match_dep(pool, pool_rel2id(pool, rd->name, pool_str2id(pool, revr, 1), rflags, 1), id))
 874             return 0;
 875         }
 876       return 1;
 877     }
 878   if (flags & SELECTION_GLOB)
 879     {
 880       int globflags = (flags & SELECTION_NOCASE) != 0 ? FNM_CASEFOLD : 0;
 881       return fnmatch(rname, pool_id2str(pool, id), globflags) == 0 ? 1 : 0;
 882     }
 883   if (flags & SELECTION_NOCASE)
 884     return strcasecmp(rname, pool_id2str(pool, id)) == 0 ? 1 : 0;
 885   return strcmp(rname, pool_id2str(pool, id)) == 0 ? 1 : 0;
 886 }
 887
 888 /*
 889  *  select against the dependencies in keyname
 890  *  like SELECTION_REL and SELECTION_PROVIDES, but with the
 891  *  deps in keyname instead of provides.
 892  */
 893 int
 894 selection_make_deps(Pool *pool, Queue *selection, const char *name, int flags, int keyname)
 895 {
 896   char *rname, *r;
 897   int rflags = 0;
 898   Id p;
 899   Queue q;
 900
 901   queue_empty(selection);
 902   rname = solv_strdup(name);
 903   if ((r = strpbrk(rname, "<=>")) != 0)
 904     {
 905       if ((r = splitrel(rname, r, &rflags)) == 0)
 906         {
 907           solv_free(rname);
 908           return 0;
 909         }
 910     }
 911   if ((flags & SELECTION_GLOB) != 0 && !strpbrk(name, "[*?") != 0)
 912     flags &= ~SELECTION_GLOB;
 913
 914   queue_init(&q);
 915   FOR_POOL_SOLVABLES(p)
 916     {
 917       Solvable *s =  pool->solvables + p;
 918       int i;
 919
 920       if (s->repo != pool->installed && !pool_installable(pool, s))
 921         {
 922           if (!(flags & SELECTION_SOURCE_ONLY) || (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC))
 923             continue;
 924           if (pool_disabled_solvable(pool, s))
 925             continue;
 926         }
 927       if ((flags & SELECTION_INSTALLED_ONLY) != 0 && s->repo != pool->installed)
 928         continue;
 929       if ((s->arch == ARCH_SRC || s->arch == ARCH_NOSRC) && !(flags & SELECTION_SOURCE_ONLY) && !(flags & SELECTION_WITH_SOURCE))
 930         continue;
 931       queue_empty(&q);
 932       repo_lookup_idarray(s->repo, p, keyname, &q);
 933       for (i = 0; i < q.count; i++)
 934         {
 935           Id id = q.elements[i];
 936           if (matchdep(pool, id, rname, rflags, r, flags))
 937             break;
 938         }
 939       if (i < q.count)
 940         queue_push2(selection, SOLVER_SOLVABLE | SOLVER_NOAUTOSET, p);
 941     }
 942   queue_free(&q);
 943   if (!selection->count)
 944     return 0;
 945   if ((flags & SELECTION_FLAT) != 0)
 946     selection_flatten(pool, selection);
 947   return SELECTION_PROVIDES;
 948 }
 949
 950 void
 951 selection_filter(Pool *pool, Queue *sel1, Queue *sel2)
 952 {
 953   int i, j, miss;
 954   Id p, pp;
 955   Queue q1;
 956   Map m2;
 957   Id setflags = 0;
 958
 959   if (!sel1->count || !sel2->count)
 960     {
 961       queue_empty(sel1);
 962       return;
 963     }
 964   if (sel1->count == 2 && (sel1->elements[0] & SOLVER_SELECTMASK) == SOLVER_SOLVABLE_ALL)
 965     {
 966       /* XXX: not 100% correct, but very useful */
 967       queue_free(sel1);
 968       queue_init_clone(sel1, sel2);
 969       return;
 970     }
 971   queue_init(&q1);
 972   map_init(&m2, pool->nsolvables);
 973   for (i = 0; i < sel2->count; i += 2)
 974     {
 975       Id select = sel2->elements[i] & SOLVER_SELECTMASK;
 976       if (select == SOLVER_SOLVABLE_ALL)
 977         {
 978           queue_free(&q1);
 979           map_free(&m2);
 980           return;
 981         }
 982       if (select == SOLVER_SOLVABLE_REPO)
 983         {
 984           Solvable *s;
 985           Repo *repo = pool_id2repo(pool, sel2->elements[i + 1]);
 986           if (repo)
 987             FOR_REPO_SOLVABLES(repo, p, s)
 988               map_set(&m2, p);
 989         }
 990       else
 991         {
 992           FOR_JOB_SELECT(p, pp, select, sel2->elements[i + 1])
 993             map_set(&m2, p);
 994         }
 995     }
 996   if (sel2->count == 2)         /* XXX: AND all setmasks instead? */
 997     setflags = sel2->elements[0] & SOLVER_SETMASK & ~SOLVER_NOAUTOSET;
 998   for (i = j = 0; i < sel1->count; i += 2)
 999     {
1000       Id select = sel1->elements[i] & SOLVER_SELECTMASK;
1001       queue_empty(&q1);
1002       miss = 0;
1003       if (select == SOLVER_SOLVABLE_ALL)
1004         {
1005           FOR_POOL_SOLVABLES(p)
1006             {
1007               if (map_tst(&m2, p))
1008                 queue_push(&q1, p);
1009               else
1010                 miss = 1;
1011             }
1012         }
1013       else if (select == SOLVER_SOLVABLE_REPO)
1014         {
1015           Solvable *s;
1016           Repo *repo = pool_id2repo(pool, sel1->elements[i + 1]);
1017           if (repo)
1018             FOR_REPO_SOLVABLES(repo, p, s)
1019               {
1020                 if (map_tst(&m2, p))
1021                   queue_push(&q1, p);
1022                 else
1023                   miss = 1;
1024               }
1025         }
1026       else
1027         {
1028           FOR_JOB_SELECT(p, pp, select, sel1->elements[i + 1])
1029             {
1030               if (map_tst(&m2, p))
1031                 queue_pushunique(&q1, p);
1032               else
1033                 miss = 1;
1034             }
1035         }
1036       if (!q1.count)
1037         continue;
1038       if (!miss)
1039         {
1040           sel1->elements[j] = sel1->elements[i] | setflags;
1041           sel1->elements[j + 1] = sel1->elements[i + 1];
1042         }
1043       else if (q1.count > 1)
1044         {
1045           sel1->elements[j] = (sel1->elements[i] & ~SOLVER_SELECTMASK) | SOLVER_SOLVABLE_ONE_OF | setflags;
1046           sel1->elements[j + 1] = pool_queuetowhatprovides(pool, &q1);
1047         }
1048       else
1049         {
1050           sel1->elements[j] = (sel1->elements[i] & ~SOLVER_SELECTMASK) | SOLVER_SOLVABLE | SOLVER_NOAUTOSET | setflags;
1051           sel1->elements[j + 1] = q1.elements[0];
1052         }
1053       j += 2;
1054     }
1055   queue_truncate(sel1, j);
1056   queue_free(&q1);
1057   map_free(&m2);
1058 }
1059
1060 void
1061 selection_add(Pool *pool, Queue *sel1, Queue *sel2)
1062 {
1063   int i;
1064   for (i = 0; i < sel2->count; i++)
1065     queue_push(sel1, sel2->elements[i]);
1066 }
1067
1068 const char *
1069 pool_selection2str(Pool *pool, Queue *selection, Id flagmask)
1070 {
1071   char *s;
1072   const char *s2;
1073   int i;
1074   s = pool_tmpjoin(pool, 0, 0, 0);
1075   for (i = 0; i < selection->count; i += 2)
1076     {
1077       Id how = selection->elements[i];
1078       if (*s)
1079         s = pool_tmpappend(pool, s, " + ", 0);
1080       s2 = solver_select2str(pool, how & SOLVER_SELECTMASK, selection->elements[i + 1]);
1081       s = pool_tmpappend(pool, s, s2, 0);
1082       pool_freetmpspace(pool, s2);
1083       how &= flagmask & SOLVER_SETMASK;
1084       if (how)
1085         {
1086           int o = strlen(s);
1087           s = pool_tmpappend(pool, s, " ", 0);
1088           if (how & SOLVER_SETEV)
1089             s = pool_tmpappend(pool, s, ",setev", 0);
1090           if (how & SOLVER_SETEVR)
1091             s = pool_tmpappend(pool, s, ",setevr", 0);
1092           if (how & SOLVER_SETARCH)
1093             s = pool_tmpappend(pool, s, ",setarch", 0);
1094           if (how & SOLVER_SETVENDOR)
1095             s = pool_tmpappend(pool, s, ",setvendor", 0);
1096           if (how & SOLVER_SETREPO)
1097             s = pool_tmpappend(pool, s, ",setrepo", 0);
1098           if (how & SOLVER_NOAUTOSET)
1099             s = pool_tmpappend(pool, s, ",noautoset", 0);
1100           if (s[o + 1] != ',')
1101             s = pool_tmpappend(pool, s, ",?", 0);
1102           s[o + 1] = '[';
1103           s = pool_tmpappend(pool, s, "]", 0);
1104         }
1105     }
1106   return s;
1107 }
1108