src/repo.c

   1 /*
   2  * Copyright (c) 2007, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * repo.c
  10  *
  11  * Manage metadata coming from one repository
  12  *
  13  */
  14
  15 #define _GNU_SOURCE
  16 #include <string.h>
  17 #include <fnmatch.h>
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21
  22
  23
  24 #include "repo.h"
  25 #include "pool.h"
  26 #include "poolid_private.h"
  27 #include "util.h"
  28 #if 0
  29 #include "attr_store_p.h"
  30 #endif
  31
  32 #define IDARRAY_BLOCK     4095
  33
  34
  35 /*
  36  * create empty repo
  37  * and add to pool
  38  */
  39
  40 Repo *
  41 repo_create(Pool *pool, const char *name)
  42 {
  43   Repo *repo;
  44
  45   pool_freewhatprovides(pool);
  46   repo = (Repo *)sat_calloc(1, sizeof(*repo));
  47   pool->repos = (Repo **)sat_realloc2(pool->repos, pool->nrepos + 1, sizeof(Repo *));
  48   pool->repos[pool->nrepos++] = repo;
  49   repo->repoid = pool->nrepos;
  50   repo->name = name ? strdup(name) : 0;
  51   repo->pool = pool;
  52   repo->start = pool->nsolvables;
  53   repo->end = pool->nsolvables;
  54   repo->nsolvables = 0;
  55   return repo;
  56 }
  57
  58 static void
  59 repo_freedata(Repo *repo)
  60 {
  61   int i;
  62   for (i = 0; i < repo->nrepodata; i++)
  63     repodata_freedata(repo->repodata + i);
  64   sat_free(repo->repodata);
  65   sat_free(repo->idarraydata);
  66   sat_free(repo->rpmdbid);
  67   sat_free((char *)repo->name);
  68   sat_free(repo);
  69 }
  70
  71 /*
  72  * remove repo from pool, zero out (i.e. free) solvables
  73  *
  74  */
  75
  76 void
  77 repo_free(Repo *repo, int reuseids)
  78 {
  79   Pool *pool = repo->pool;
  80   Solvable *s;
  81   int i;
  82
  83   pool_freewhatprovides(pool);
  84   if (repo == pool->installed)
  85     pool->installed = 0;
  86
  87   if (reuseids && repo->end == pool->nsolvables)
  88     {
  89       /* it's ok to reuse the ids. As this is the last repo, we can
  90          just shrink the solvable array */
  91       for (i = repo->end - 1, s = pool->solvables + i; i >= repo->start; i--, s--)
  92         if (s->repo != repo)
  93           break;
  94       repo->end = i + 1;
  95       pool->nsolvables = i + 1;
  96     }
  97   /* zero out (i.e. free) solvables belonging to this repo */
  98   for (i = repo->start, s = pool->solvables + i; i < repo->end; i++, s++)
  99     if (s->repo == repo)
 100       memset(s, 0, sizeof(*s));
 101   for (i = 0; i < pool->nrepos; i++)    /* find repo in pool */
 102     if (pool->repos[i] == repo)
 103       break;
 104   if (i == pool->nrepos)               /* repo not in pool, return */
 105     return;
 106   if (i < pool->nrepos - 1)
 107     {
 108       memmove(pool->repos + i, pool->repos + i + 1, (pool->nrepos - 1 - i) * sizeof(Repo *));
 109       /* fix repo ids */
 110       for (; i < pool->nrepos - 1; i++)
 111         pool->repos[i]->repoid = i + 1;
 112     }
 113   pool->nrepos--;
 114   repo_freedata(repo);
 115 }
 116
 117 void
 118 repo_freeallrepos(Pool *pool, int reuseids)
 119 {
 120   int i;
 121
 122   pool_freewhatprovides(pool);
 123   for (i = 0; i < pool->nrepos; i++)
 124     repo_freedata(pool->repos[i]);
 125   pool->repos = sat_free(pool->repos);
 126   pool->nrepos = 0;
 127   /* the first two solvables don't belong to a repo */
 128   pool_free_solvable_block(pool, 2, pool->nsolvables - 2, reuseids);
 129 }
 130
 131 void repo_free_solvable_block(Repo *repo, Id start, int count, int reuseids)
 132 {
 133   Solvable *s;
 134   Repodata *data;
 135   int i;
 136   if (start + count == repo->end)
 137     repo->end -= count;
 138   repo->nsolvables -= count;
 139   for (s = repo->pool->solvables + start, i = count; i--; s++)
 140     s->repo = 0;
 141   pool_free_solvable_block(repo->pool, start, count, reuseids);
 142   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 143     if (data->end > repo->end)
 144       repodata_shrink(data, repo->end);
 145 }
 146
 147
 148 /* repository sidedata is solvable data allocated on demand.
 149  * It is used for data that is normally not present
 150  * in the solvable like the rpmdbid.
 151  * The solvable allocation funcions need to make sure that
 152  * the sidedata gets extended if new solvables get added.
 153  */
 154
 155 #define REPO_SIDEDATA_BLOCK 63
 156
 157 void *
 158 repo_sidedata_create(Repo *repo, size_t size)
 159 {
 160   return sat_calloc_block(repo->end - repo->start, size, REPO_SIDEDATA_BLOCK);
 161 }
 162
 163 void *
 164 repo_sidedata_extend(Repo *repo, void *b, size_t size, Id p, int count)
 165 {
 166   int n = repo->end - repo->start;
 167   if (p < repo->start)
 168     {
 169       int d = repo->start - p;
 170       b = sat_extend(b, n, d, size, REPO_SIDEDATA_BLOCK);
 171       memmove((char *)b + d * size, b, n * size);
 172       memset(b, 0, d * size);
 173       n += d;
 174     }
 175   if (p + count > repo->end)
 176     {
 177       int d = p + count - repo->end;
 178       b = sat_extend(b, n, d, size, REPO_SIDEDATA_BLOCK);
 179       memset((char *)b + n * size, 0, d * size);
 180     }
 181   return b;
 182 }
 183
 184 /*
 185  * add Id to idarraydata used to store dependencies
 186  * olddeps: old array offset to extend
 187  * returns new array offset
 188  */
 189
 190 Offset
 191 repo_addid(Repo *repo, Offset olddeps, Id id)
 192 {
 193   Id *idarray;
 194   int idarraysize;
 195   int i;
 196
 197   idarray = repo->idarraydata;
 198   idarraysize = repo->idarraysize;
 199
 200   if (!idarray)                        /* alloc idarray if not done yet */
 201     {
 202       idarraysize = 1;
 203       idarray = sat_extend_resize(0, 1, sizeof(Id), IDARRAY_BLOCK);
 204       idarray[0] = 0;
 205       repo->lastoff = 0;
 206     }
 207
 208   if (!olddeps)                         /* no deps yet */
 209     {
 210       olddeps = idarraysize;
 211       idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
 212     }
 213   else if (olddeps == repo->lastoff)    /* extend at end */
 214     idarraysize--;
 215   else                                  /* can't extend, copy old */
 216     {
 217       i = olddeps;
 218       olddeps = idarraysize;
 219       for (; idarray[i]; i++)
 220         {
 221           idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
 222           idarray[idarraysize++] = idarray[i];
 223         }
 224       idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
 225     }
 226
 227   idarray[idarraysize++] = id;          /* insert Id into array */
 228   idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
 229   idarray[idarraysize++] = 0;           /* ensure NULL termination */
 230
 231   repo->idarraydata = idarray;
 232   repo->idarraysize = idarraysize;
 233   repo->lastoff = olddeps;
 234
 235   return olddeps;
 236 }
 237
 238
 239 /*
 240  * add dependency (as Id) to repo, also unifies dependencies
 241  * olddeps = offset into idarraydata
 242  * marker= 0 for normal dep
 243  * marker > 0 add dep after marker
 244  * marker < 0 add dep after -marker
 245  * returns new start of dependency array
 246  */
 247 Offset
 248 repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker)
 249 {
 250   Id oid, *oidp, *markerp;
 251   int before;
 252
 253   if (!olddeps)
 254     {
 255       if (marker > 0)
 256         olddeps = repo_addid(repo, olddeps, marker);
 257       return repo_addid(repo, olddeps, id);
 258     }
 259
 260   if (!marker)
 261     {
 262       for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
 263         {
 264           if (oid == id)
 265             return olddeps;
 266         }
 267       return repo_addid(repo, olddeps, id);
 268     }
 269
 270   before = 0;
 271   markerp = 0;
 272   if (marker < 0)
 273     {
 274       before = 1;
 275       marker = -marker;
 276     }
 277   for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
 278     {
 279       if (oid == marker)
 280         markerp = oidp;
 281       else if (oid == id)
 282         break;
 283     }
 284
 285   if (oid)
 286     {
 287       if (markerp || before)
 288         return olddeps;
 289       /* we found it, but in the wrong half */
 290       markerp = oidp++;
 291       for (; (oid = *oidp) != ID_NULL; oidp++)
 292         if (oid == marker)
 293           break;
 294       if (!oid)
 295         {
 296           /* no marker in array yet */
 297           oidp--;
 298           if (markerp < oidp)
 299             memmove(markerp, markerp + 1, (oidp - markerp) * sizeof(Id));
 300           *oidp = marker;
 301           return repo_addid(repo, olddeps, id);
 302         }
 303       while (oidp[1])
 304         oidp++;
 305       memmove(markerp, markerp + 1, (oidp - markerp) * sizeof(Id));
 306       *oidp = id;
 307       return olddeps;
 308     }
 309   /* id not yet in array */
 310   if (!before && !markerp)
 311     olddeps = repo_addid(repo, olddeps, marker);
 312   else if (before && markerp)
 313     {
 314       *markerp++ = id;
 315       id = *--oidp;
 316       if (markerp < oidp)
 317         memmove(markerp + 1, markerp, (oidp - markerp) * sizeof(Id));
 318       *markerp = marker;
 319     }
 320   return repo_addid(repo, olddeps, id);
 321 }
 322
 323
 324 /*
 325  * reserve Ids
 326  * make space for 'num' more dependencies
 327  * returns new start of dependency array
 328  *
 329  * reserved ids will always begin at offset idarraysize
 330  */
 331
 332 Offset
 333 repo_reserve_ids(Repo *repo, Offset olddeps, int num)
 334 {
 335   num++;        /* room for trailing ID_NULL */
 336
 337   if (!repo->idarraysize)              /* ensure buffer space */
 338     {
 339       repo->idarraysize = 1;
 340       repo->idarraydata = sat_extend_resize(0, 1 + num, sizeof(Id), IDARRAY_BLOCK);
 341       repo->idarraydata[0] = 0;
 342       repo->lastoff = 1;
 343       return 1;
 344     }
 345
 346   if (olddeps && olddeps != repo->lastoff)   /* if not appending */
 347     {
 348       /* can't insert into idarray, this would invalidate all 'larger' offsets
 349        * so create new space at end and move existing deps there.
 350        * Leaving 'hole' at old position.
 351        */
 352
 353       Id *idstart, *idend;
 354       int count;
 355
 356       for (idstart = idend = repo->idarraydata + olddeps; *idend++; )   /* find end */
 357         ;
 358       count = idend - idstart - 1 + num;               /* new size */
 359
 360       repo->idarraydata = sat_extend(repo->idarraydata, repo->idarraysize, count, sizeof(Id), IDARRAY_BLOCK);
 361       /* move old deps to end */
 362       olddeps = repo->lastoff = repo->idarraysize;
 363       memcpy(repo->idarraydata + olddeps, idstart, count - num);
 364       repo->idarraysize = olddeps + count - num;
 365
 366       return olddeps;
 367     }
 368
 369   if (olddeps)                         /* appending */
 370     repo->idarraysize--;
 371
 372   /* make room*/
 373   repo->idarraydata = sat_extend(repo->idarraydata, repo->idarraysize, num, sizeof(Id), IDARRAY_BLOCK);
 374
 375   /* appending or new */
 376   repo->lastoff = olddeps ? olddeps : repo->idarraysize;
 377
 378   return repo->lastoff;
 379 }
 380
 381
 382
 383 Offset
 384 repo_fix_supplements(Repo *repo, Offset provides, Offset supplements, Offset freshens)
 385 {
 386   Pool *pool = repo->pool;
 387   Id id, idp, idl;
 388   char buf[1024], *p, *dep;
 389   int i, l;
 390
 391   if (provides)
 392     {
 393       for (i = provides; repo->idarraydata[i]; i++)
 394         {
 395           id = repo->idarraydata[i];
 396           if (ISRELDEP(id))
 397             continue;
 398           dep = (char *)id2str(pool, id);
 399           if (!strncmp(dep, "locale(", 7) && strlen(dep) < sizeof(buf) - 2)
 400             {
 401               idp = 0;
 402               strcpy(buf + 2, dep);
 403               dep = buf + 2 + 7;
 404               if ((p = strchr(dep, ':')) != 0 && p != dep)
 405                 {
 406                   *p++ = 0;
 407                   idp = str2id(pool, dep, 1);
 408                   dep = p;
 409                 }
 410               id = 0;
 411               while ((p = strchr(dep, ';')) != 0)
 412                 {
 413                   if (p == dep)
 414                     {
 415                       dep = p + 1;
 416                       continue;
 417                     }
 418                   *p++ = 0;
 419 #if 0
 420                   strncpy(dep - 9, "language:", 9);
 421                   idl = str2id(pool, dep - 9, 1);
 422 #else
 423                   idl = str2id(pool, dep, 1);
 424                   idl = rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1);
 425 #endif
 426                   if (id)
 427                     id = rel2id(pool, id, idl, REL_OR, 1);
 428                   else
 429                     id = idl;
 430                   dep = p;
 431                 }
 432               if (dep[0] && dep[1])
 433                 {
 434                   for (p = dep; *p && *p != ')'; p++)
 435                     ;
 436                   *p = 0;
 437 #if 0
 438                   strncpy(dep - 9, "language:", 9);
 439                   idl = str2id(pool, dep - 9, 1);
 440 #else
 441                   idl = str2id(pool, dep, 1);
 442                   idl = rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1);
 443 #endif
 444                   if (id)
 445                     id = rel2id(pool, id, idl, REL_OR, 1);
 446                   else
 447                     id = idl;
 448                 }
 449               if (idp)
 450                 id = rel2id(pool, idp, id, REL_AND, 1);
 451               if (id)
 452                 supplements = repo_addid_dep(repo, supplements, id, 0);
 453             }
 454           else if ((p = strchr(dep, ':')) != 0 && p != dep && p[1] == '/' && strlen(dep) < sizeof(buf))
 455             {
 456               strcpy(buf, dep);
 457               p = buf + (p - dep);
 458               *p++ = 0;
 459               idp = str2id(pool, buf, 1);
 460               /* strip trailing slashes */
 461               l = strlen(p);
 462               while (l > 1 && p[l - 1] == '/')
 463                 p[--l] = 0;
 464               id = str2id(pool, p, 1);
 465               id = rel2id(pool, idp, id, REL_WITH, 1);
 466               id = rel2id(pool, NAMESPACE_SPLITPROVIDES, id, REL_NAMESPACE, 1);
 467               supplements = repo_addid_dep(repo, supplements, id, 0);
 468             }
 469         }
 470     }
 471   if (supplements)
 472     {
 473       for (i = supplements; repo->idarraydata[i]; i++)
 474         {
 475           id = repo->idarraydata[i];
 476           if (ISRELDEP(id))
 477             continue;
 478           dep = (char *)id2str(pool, id);
 479           if (!strncmp(dep, "system:modalias(", 16))
 480             dep += 7;
 481           if (!strncmp(dep, "modalias(", 9) && dep[9] && dep[10] && strlen(dep) < sizeof(buf))
 482             {
 483               strcpy(buf, dep);
 484               p = strchr(buf + 9, ':');
 485               if (p && p != buf + 9 && strchr(p + 1, ':'))
 486                 {
 487                   *p++ = 0;
 488                   idp = str2id(pool, buf + 9, 1);
 489                   p[strlen(p) - 1] = 0;
 490                   id = str2id(pool, p, 1);
 491                   id = rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1);
 492                   id = rel2id(pool, idp, id, REL_AND, 1);
 493                 }
 494               else
 495                 {
 496                   p = buf + 9;
 497                   p[strlen(p) - 1] = 0;
 498                   id = str2id(pool, p, 1);
 499                   id = rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1);
 500                 }
 501               if (id)
 502                 repo->idarraydata[i] = id;
 503             }
 504           else if (!strncmp(dep, "packageand(", 11) && strlen(dep) < sizeof(buf))
 505             {
 506               strcpy(buf, dep);
 507               id = 0;
 508               dep = buf + 11;
 509               while ((p = strchr(dep, ':')) != 0)
 510                 {
 511                   if (p == dep)
 512                     {
 513                       dep = p + 1;
 514                       continue;
 515                     }
 516                   *p++ = 0;
 517                   idp = str2id(pool, dep, 1);
 518                   if (id)
 519                     id = rel2id(pool, id, idp, REL_AND, 1);
 520                   else
 521                     id = idp;
 522                   dep = p;
 523                 }
 524               if (dep[0] && dep[1])
 525                 {
 526                   dep[strlen(dep) - 1] = 0;
 527                   idp = str2id(pool, dep, 1);
 528                   if (id)
 529                     id = rel2id(pool, id, idp, REL_AND, 1);
 530                   else
 531                     id = idp;
 532                 }
 533               if (id)
 534                 repo->idarraydata[i] = id;
 535             }
 536           else if (!strncmp(dep, "filesystem(", 11) && strlen(dep) < sizeof(buf))
 537             {
 538               strcpy(buf, dep + 11);
 539               if ((p = strrchr(buf, ')')) != 0)
 540                 *p = 0;
 541               id = str2id(pool, buf, 1);
 542               id = rel2id(pool, NAMESPACE_FILESYSTEM, id, REL_NAMESPACE, 1);
 543               repo->idarraydata[i] = id;
 544             }
 545         }
 546     }
 547   if (freshens && repo->idarraydata[freshens])
 548     {
 549       Id idsupp = 0, idfresh = 0;
 550       if (!supplements)
 551         return freshens;
 552       for (i = supplements; repo->idarraydata[i]; i++)
 553         {
 554           if (!idsupp)
 555             idsupp = repo->idarraydata[i];
 556           else
 557             idsupp = rel2id(pool, idsupp, repo->idarraydata[i], REL_OR, 1);
 558         }
 559       for (i = freshens; repo->idarraydata[i]; i++)
 560         {
 561           if (!idfresh)
 562             idfresh = repo->idarraydata[i];
 563           else
 564             idfresh = rel2id(pool, idfresh, repo->idarraydata[i], REL_OR, 1);
 565         }
 566       if (!idsupp)
 567         idsupp = idfresh;
 568       else
 569         idsupp = rel2id(pool, idsupp, idfresh, REL_AND, 1);
 570       supplements = repo_addid_dep(repo, 0, idsupp, 0);
 571     }
 572   return supplements;
 573 }
 574
 575 Offset
 576 repo_fix_conflicts(Repo *repo, Offset conflicts)
 577 {
 578   char buf[1024], *p, *dep;
 579   Pool *pool = repo->pool;
 580   Id id;
 581   int i;
 582
 583   if (!conflicts)
 584     return conflicts;
 585   for (i = conflicts; repo->idarraydata[i]; i++)
 586     {
 587       id = repo->idarraydata[i];
 588       if (ISRELDEP(id))
 589         continue;
 590       dep = (char *)id2str(pool, id);
 591       if (!strncmp(dep, "otherproviders(", 15) && strlen(dep) < sizeof(buf) - 2)
 592         {
 593           strcpy(buf, dep + 15);
 594           if ((p = strchr(buf, ')')) != 0)
 595             *p = 0;
 596           id = str2id(pool, buf, 1);
 597           id = rel2id(pool, NAMESPACE_OTHERPROVIDERS, id, REL_NAMESPACE, 1);
 598           repo->idarraydata[i] = id;
 599         }
 600     }
 601   return conflicts;
 602 }
 603
 604 struct matchdata
 605 {
 606   Pool *pool;
 607   int flags;
 608   Datamatcher matcher;
 609   int stop;
 610   int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv);
 611   void *callback_data;
 612 };
 613
 614 int
 615 repo_matchvalue(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv)
 616 {
 617   struct matchdata *md = cbdata;
 618
 619   if (md->matcher.match)
 620     {
 621       if (!repodata_stringify(md->pool, data, key, kv, md->flags))
 622         return 0;
 623       if (!datamatcher_match(&md->matcher, kv->str))
 624         return 0;
 625     }
 626   md->stop = md->callback(md->callback_data, s, data, key, kv);
 627   return md->stop;
 628 }
 629
 630
 631 static Repokey solvablekeys[RPM_RPMDBID - SOLVABLE_NAME + 1] = {
 632   { SOLVABLE_NAME,        REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 633   { SOLVABLE_ARCH,        REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 634   { SOLVABLE_EVR,         REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 635   { SOLVABLE_VENDOR,      REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 636   { SOLVABLE_PROVIDES,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 637   { SOLVABLE_OBSOLETES,   REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 638   { SOLVABLE_CONFLICTS,   REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 639   { SOLVABLE_REQUIRES,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 640   { SOLVABLE_RECOMMENDS,  REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 641   { SOLVABLE_SUGGESTS,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 642   { SOLVABLE_SUPPLEMENTS, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 643   { SOLVABLE_ENHANCES,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 644   { RPM_RPMDBID,          REPOKEY_TYPE_U32, 0, KEY_STORAGE_SOLVABLE },
 645 };
 646
 647 static void
 648 domatch_idarray(Solvable *s, Id keyname, struct matchdata *md, Id *ida)
 649 {
 650   KeyValue kv;
 651   kv.entry = 0;
 652   kv.parent = 0;
 653   for (; *ida && !md->stop; ida++)
 654     {
 655       kv.id = *ida;
 656       kv.eof = ida[1] ? 0 : 1;
 657       repo_matchvalue(md, s, 0, solvablekeys + (keyname - SOLVABLE_NAME), &kv);
 658       kv.entry++;
 659     }
 660 }
 661
 662 static void
 663 repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md)
 664 {
 665   KeyValue kv;
 666   Pool *pool = repo->pool;
 667   Repodata *data;
 668   int i, j, flags;
 669   Solvable *s;
 670
 671   kv.parent = 0;
 672   md->stop = 0;
 673   if (!p)
 674     {
 675       for (p = repo->start, s = repo->pool->solvables + p; p < repo->end; p++, s++)
 676         {
 677           if (s->repo == repo)
 678             repo_search_md(repo, p, keyname, md);
 679           if (md->stop > SEARCH_NEXT_SOLVABLE)
 680             break;
 681         }
 682       return;
 683     }
 684   else if (p < 0)
 685     /* The callback only supports solvables, so we can't iterate over the
 686        extra things.  */
 687     return;
 688   flags = md->flags;
 689   if (!(flags & SEARCH_NO_STORAGE_SOLVABLE))
 690     {
 691       s = pool->solvables + p;
 692       switch(keyname)
 693         {
 694           case 0:
 695           case SOLVABLE_NAME:
 696             if (s->name)
 697               {
 698                 kv.id = s->name;
 699                 repo_matchvalue(md, s, 0, solvablekeys + 0, &kv);
 700               }
 701             if (keyname || md->stop > SEARCH_NEXT_KEY)
 702               return;
 703           case SOLVABLE_ARCH:
 704             if (s->arch)
 705               {
 706                 kv.id = s->arch;
 707                 repo_matchvalue(md, s, 0, solvablekeys + 1, &kv);
 708               }
 709             if (keyname || md->stop > SEARCH_NEXT_KEY)
 710               return;
 711           case SOLVABLE_EVR:
 712             if (s->evr)
 713               {
 714                 kv.id = s->evr;
 715                 repo_matchvalue(md, s, 0, solvablekeys + 2, &kv);
 716               }
 717             if (keyname || md->stop > SEARCH_NEXT_KEY)
 718               return;
 719           case SOLVABLE_VENDOR:
 720             if (s->vendor)
 721               {
 722                 kv.id = s->vendor;
 723                 repo_matchvalue(md, s, 0, solvablekeys + 3, &kv);
 724               }
 725             if (keyname || md->stop > SEARCH_NEXT_KEY)
 726               return;
 727           case SOLVABLE_PROVIDES:
 728             if (s->provides)
 729               domatch_idarray(s, SOLVABLE_PROVIDES, md, repo->idarraydata + s->provides);
 730             if (keyname || md->stop > SEARCH_NEXT_KEY)
 731               return;
 732           case SOLVABLE_OBSOLETES:
 733             if (s->obsoletes)
 734               domatch_idarray(s, SOLVABLE_OBSOLETES, md, repo->idarraydata + s->obsoletes);
 735             if (keyname || md->stop > SEARCH_NEXT_KEY)
 736               return;
 737           case SOLVABLE_CONFLICTS:
 738             if (s->conflicts)
 739               domatch_idarray(s, SOLVABLE_CONFLICTS, md, repo->idarraydata + s->conflicts);
 740             if (keyname || md->stop > SEARCH_NEXT_KEY)
 741               return;
 742           case SOLVABLE_REQUIRES:
 743             if (s->requires)
 744               domatch_idarray(s, SOLVABLE_REQUIRES, md, repo->idarraydata + s->requires);
 745             if (keyname || md->stop > SEARCH_NEXT_KEY)
 746               return;
 747           case SOLVABLE_RECOMMENDS:
 748             if (s->recommends)
 749               domatch_idarray(s, SOLVABLE_RECOMMENDS, md, repo->idarraydata + s->recommends);
 750             if (keyname || md->stop > SEARCH_NEXT_KEY)
 751               return;
 752           case SOLVABLE_SUPPLEMENTS:
 753             if (s->supplements)
 754               domatch_idarray(s, SOLVABLE_SUPPLEMENTS, md, repo->idarraydata + s->supplements);
 755             if (keyname || md->stop > SEARCH_NEXT_KEY)
 756               return;
 757           case SOLVABLE_SUGGESTS:
 758             if (s->suggests)
 759               domatch_idarray(s, SOLVABLE_SUGGESTS, md, repo->idarraydata + s->suggests);
 760             if (keyname || md->stop > SEARCH_NEXT_KEY)
 761               return;
 762           case SOLVABLE_ENHANCES:
 763             if (s->enhances)
 764               domatch_idarray(s, SOLVABLE_ENHANCES, md, repo->idarraydata + s->enhances);
 765             if (keyname || md->stop > SEARCH_NEXT_KEY)
 766               return;
 767           case RPM_RPMDBID:
 768             if (repo->rpmdbid)
 769               {
 770                 kv.num = repo->rpmdbid[p - repo->start];
 771                 repo_matchvalue(md, s, 0, solvablekeys + (RPM_RPMDBID - SOLVABLE_NAME), &kv);
 772               }
 773             if (keyname || md->stop > SEARCH_NEXT_KEY)
 774               return;
 775             break;
 776           default:
 777             break;
 778         }
 779     }
 780
 781   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 782     {
 783       if (p < data->start || p >= data->end)
 784         continue;
 785       if (keyname && !repodata_precheck_keyname(data, keyname))
 786         continue;
 787       if (keyname == SOLVABLE_FILELIST && !(md->flags & SEARCH_COMPLETE_FILELIST))
 788         {
 789           /* do not search filelist extensions */
 790           if (data->state != REPODATA_AVAILABLE)
 791             continue;
 792           if (!repodata_precheck_keyname(data, REPOSITORY_EXTERNAL))
 793             continue;
 794           for (j = 0; j < data->nkeys; j++)
 795             if (data->keys[j].name == REPOSITORY_EXTERNAL)
 796               break;
 797           if (j == data->nkeys)
 798             continue;
 799         }
 800       if (data->state == REPODATA_STUB)
 801         {
 802           if (keyname)
 803             {
 804               for (j = 1; j < data->nkeys; j++)
 805                 if (keyname == data->keys[j].name)
 806                   break;
 807               if (j == data->nkeys)
 808                 continue;
 809             }
 810           /* load it */
 811           if (data->loadcallback)
 812             data->loadcallback(data);
 813           else
 814             data->state = REPODATA_ERROR;
 815         }
 816       if (data->state == REPODATA_ERROR)
 817         continue;
 818       repodata_search(data, p, keyname, md->flags, repo_matchvalue, md);
 819       if (md->stop > SEARCH_NEXT_KEY)
 820         break;
 821     }
 822 }
 823
 824 void
 825 repo_search(Repo *repo, Id p, Id keyname, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv), void *cbdata)
 826 {
 827   struct matchdata md;
 828
 829   if (repo->disabled && !(flags & SEARCH_DISABLED_REPOS))
 830     return;
 831   memset(&md, 0, sizeof(md));
 832   md.pool = repo->pool;
 833   md.flags = flags;
 834   md.callback = callback;
 835   md.callback_data = cbdata;
 836   if (match)
 837     datamatcher_init(&md.matcher, match, flags);
 838   repo_search_md(repo, p, keyname, &md);
 839   if (match)
 840     datamatcher_free(&md.matcher);
 841 }
 842
 843 const char *
 844 repo_lookup_str(Repo *repo, Id entry, Id keyname)
 845 {
 846   Pool *pool = repo->pool;
 847   Repodata *data;
 848   int i, j;
 849
 850   switch(keyname)
 851     {
 852     case SOLVABLE_NAME:
 853       return id2str(pool, pool->solvables[entry].name);
 854     case SOLVABLE_ARCH:
 855       return id2str(pool, pool->solvables[entry].arch);
 856     case SOLVABLE_EVR:
 857       return id2str(pool, pool->solvables[entry].evr);
 858     case SOLVABLE_VENDOR:
 859       return id2str(pool, pool->solvables[entry].vendor);
 860     }
 861   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 862     {
 863       if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
 864         continue;
 865       if (!repodata_precheck_keyname(data, keyname))
 866         continue;
 867       for (j = 1; j < data->nkeys; j++)
 868         {
 869           if (data->keys[j].name == keyname && (data->keys[j].type == REPOKEY_TYPE_ID || data->keys[j].type == REPOKEY_TYPE_CONSTANTID || data->keys[j].type == REPOKEY_TYPE_STR))
 870             return repodata_lookup_str(data, entry, keyname);
 871         }
 872     }
 873   return 0;
 874 }
 875
 876
 877 unsigned int
 878 repo_lookup_num(Repo *repo, Id entry, Id keyname, unsigned int notfound)
 879 {
 880   Repodata *data;
 881   int i, j;
 882
 883   if (keyname == RPM_RPMDBID)
 884     {
 885       if (repo->rpmdbid && entry >= repo->start && entry < repo->end)
 886         return repo->rpmdbid[entry - repo->start];
 887       return notfound;
 888     }
 889   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 890     {
 891       if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
 892         continue;
 893       if (!repodata_precheck_keyname(data, keyname))
 894         continue;
 895       for (j = 1; j < data->nkeys; j++)
 896         {
 897           if (data->keys[j].name == keyname
 898               && (data->keys[j].type == REPOKEY_TYPE_U32
 899                   || data->keys[j].type == REPOKEY_TYPE_NUM
 900                   || data->keys[j].type == REPOKEY_TYPE_CONSTANT))
 901             {
 902               unsigned value;
 903               if (repodata_lookup_num(data, entry, keyname, &value))
 904                 return value;
 905             }
 906         }
 907     }
 908   return notfound;
 909 }
 910
 911 Id
 912 repo_lookup_id(Repo *repo, Id entry, Id keyname)
 913 {
 914   Repodata *data;
 915   int i, j;
 916
 917   switch(keyname)
 918     {
 919     case SOLVABLE_NAME:
 920       return repo->pool->solvables[entry].name;
 921     case SOLVABLE_ARCH:
 922       return repo->pool->solvables[entry].arch;
 923     case SOLVABLE_EVR:
 924       return repo->pool->solvables[entry].evr;
 925     case SOLVABLE_VENDOR:
 926       return repo->pool->solvables[entry].vendor;
 927     }
 928   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 929     {
 930       if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
 931         continue;
 932       if (!repodata_precheck_keyname(data, keyname))
 933         continue;
 934       for (j = 1; j < data->nkeys; j++)
 935         {
 936           if (data->keys[j].name == keyname && (data->keys[j].type == REPOKEY_TYPE_ID || data->keys[j].type == REPOKEY_TYPE_CONSTANTID))
 937             {
 938               Id id = repodata_lookup_id(data, entry, keyname);
 939               if (id)
 940                 return data->localpool ? repodata_globalize_id(data, id, 1) : id;
 941             }
 942         }
 943     }
 944   return 0;
 945 }
 946
 947 const unsigned char *
 948 repo_lookup_bin_checksum(Repo *repo, Id entry, Id keyname, Id *typep)
 949 {
 950   Repodata *data;
 951   int i, j;
 952   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 953     {
 954       if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
 955         continue;
 956       if (!repodata_precheck_keyname(data, keyname))
 957         continue;
 958       for (j = 1; j < data->nkeys; j++)
 959         {
 960           if (data->keys[j].name == keyname)
 961             {
 962               const unsigned char *chk = repodata_lookup_bin_checksum(data, entry, keyname, typep);
 963               if (chk)
 964                 return chk;
 965             }
 966         }
 967     }
 968   *typep = 0;
 969   return 0;
 970 }
 971
 972 int
 973 repo_lookup_void(Repo *repo, Id entry, Id keyname)
 974 {
 975   Repodata *data;
 976   int i, j;
 977   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 978     {
 979       if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
 980         continue;
 981       if (!repodata_precheck_keyname(data, keyname))
 982         continue;
 983       for (j = 1; j < data->nkeys; j++)
 984         {
 985           if (data->keys[j].name == keyname
 986               && (data->keys[j].type == REPOKEY_TYPE_VOID))
 987             {
 988               if (repodata_lookup_void(data, entry, keyname))
 989                 return 1;
 990             }
 991         }
 992     }
 993   return 0;
 994 }
 995
 996 /***********************************************************************/
 997
 998 Repodata *
 999 repo_add_repodata(Repo *repo, int flags)
1000 {
1001   int i;
1002   if ((flags & REPO_USE_LOADING) != 0)
1003     {
1004       for (i = repo->nrepodata - 1; i >= 0; i--)
1005         if (repo->repodata[i].state == REPODATA_LOADING)
1006           {
1007             Repodata *data = repo->repodata + i;
1008             /* re-init */
1009             /* hack: we mis-use REPO_REUSE_REPODATA here */
1010             if (!(flags & REPO_REUSE_REPODATA))
1011               {
1012                 repodata_freedata(data);
1013                 repodata_initdata(data, repo, (flags & REPO_LOCALPOOL) ? 1 : 0);
1014               }
1015             return data;
1016           }
1017       return 0; /* must not create a new repodata! */
1018     }
1019   if ((flags & REPO_REUSE_REPODATA) != 0)
1020     {
1021       for (i = repo->nrepodata - 1; i >= 0; i--)
1022         if (repo->repodata[i].state != REPODATA_STUB)
1023           return repo->repodata + i;
1024     }
1025   return repodata_create(repo, (flags & REPO_LOCALPOOL) ? 1 : 0);
1026 }
1027
1028 Repodata *
1029 repo_last_repodata(Repo *repo)
1030 {
1031   int i;
1032   for (i = repo->nrepodata - 1; i >= 0; i--)
1033     if (repo->repodata[i].state != REPODATA_STUB)
1034       return repo->repodata + i;
1035   return repo_add_repodata(repo, 0);
1036 }
1037
1038 void
1039 repo_set_id(Repo *repo, Id p, Id keyname, Id id)
1040 {
1041   Repodata *data = repo_last_repodata(repo);
1042   repodata_set_id(data, p, keyname, id);
1043 }
1044
1045 void
1046 repo_set_num(Repo *repo, Id p, Id keyname, Id num)
1047 {
1048   Repodata *data = repo_last_repodata(repo);
1049   repodata_set_num(data, p, keyname, num);
1050 }
1051
1052 void
1053 repo_set_str(Repo *repo, Id p, Id keyname, const char *str)
1054 {
1055   Repodata *data = repo_last_repodata(repo);
1056   repodata_set_str(data, p, keyname, str);
1057 }
1058
1059 void
1060 repo_set_poolstr(Repo *repo, Id p, Id keyname, const char *str)
1061 {
1062   Repodata *data = repo_last_repodata(repo);
1063   repodata_set_poolstr(data, p, keyname, str);
1064 }
1065
1066 void
1067 repo_add_poolstr_array(Repo *repo, Id p, Id keyname, const char *str)
1068 {
1069   Repodata *data = repo_last_repodata(repo);
1070   repodata_add_poolstr_array(data, p, keyname, str);
1071 }
1072
1073 void
1074 repo_internalize(Repo *repo)
1075 {
1076   int i;
1077   Repodata *data;
1078
1079   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
1080     if (data->attrs || data->xattrs)
1081       repodata_internalize(data);
1082 }
1083
1084 void
1085 repo_disable_paging(Repo *repo)
1086 {
1087   int i;
1088   Repodata *data;
1089
1090   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
1091     repodata_disable_paging(data);
1092 }
1093 // EOF
1094 /*
1095 vim:cinoptions={.5s,g0,p5,t0,(0,^-0.5s,n-0.5s:tw=78:cindent:sw=4:
1096 */