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