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