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