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;
 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               i = strlen(p);
 397               while (i > 1 && p[i - 1] == '/')
 398                 p[--i] = 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     }
 472   return supplements;
 473 }
 474
 475 struct matchdata
 476 {
 477   Pool *pool;
 478   const char *match;
 479   int flags;
 480 #if 0
 481   regex_t regex;
 482 #endif
 483   int stop;
 484   int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv);
 485   void *callback_data;
 486 };
 487
 488 int
 489 repo_matchvalue(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv)
 490 {
 491   struct matchdata *md = cbdata;
 492   int flags = md->flags;
 493
 494   if ((flags & SEARCH_STRINGMASK) != 0)
 495     {
 496       switch (key->type)
 497         {
 498         case REPOKEY_TYPE_ID:
 499         case REPOKEY_TYPE_IDARRAY:
 500           if (data && data->localpool)
 501             kv->str = stringpool_id2str(&data->spool, kv->id);
 502           else
 503             kv->str = id2str(s->repo->pool, kv->id);
 504           break;
 505         case REPOKEY_TYPE_STR:
 506           break;
 507         default:
 508           return 0;
 509         }
 510       switch ((flags & SEARCH_STRINGMASK))
 511         {
 512           case SEARCH_SUBSTRING:
 513             if (flags & SEARCH_NOCASE)
 514               {
 515                 if (!strcasestr(kv->str, md->match))
 516                   return 0;
 517               }
 518             else
 519               {
 520                 if (!strstr(kv->str, md->match))
 521                   return 0;
 522               }
 523             break;
 524           case SEARCH_STRING:
 525             if (flags & SEARCH_NOCASE)
 526               {
 527                 if (strcasecmp(md->match, kv->str))
 528                   return 0;
 529               }
 530             else
 531               {
 532                 if (strcmp(md->match, kv->str))
 533                   return 0;
 534               }
 535             break;
 536           case SEARCH_GLOB:
 537             if (fnmatch(md->match, kv->str, (flags & SEARCH_NOCASE) ? FNM_CASEFOLD : 0))
 538               return 0;
 539             break;
 540 #if 0
 541           case SEARCH_REGEX:
 542             if (regexec(&md->regexp, kv->str, 0, NULL, 0))
 543               return 0;
 544 #endif
 545           default:
 546             return 0;
 547         }
 548     }
 549   md->stop = md->callback(md->callback_data, s, data, key, kv);
 550   return md->stop;
 551 }
 552
 553
 554 static Repokey solvablekeys[RPM_RPMDBID - SOLVABLE_NAME + 1] = {
 555   { SOLVABLE_NAME,        REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 556   { SOLVABLE_ARCH,        REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 557   { SOLVABLE_EVR,         REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 558   { SOLVABLE_VENDOR,      REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 559   { SOLVABLE_PROVIDES,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 560   { SOLVABLE_OBSOLETES,   REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 561   { SOLVABLE_CONFLICTS,   REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 562   { SOLVABLE_REQUIRES,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 563   { SOLVABLE_RECOMMENDS,  REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 564   { SOLVABLE_SUGGESTS,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 565   { SOLVABLE_SUPPLEMENTS, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 566   { SOLVABLE_ENHANCES,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 567   { SOLVABLE_FRESHENS,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 568   { RPM_RPMDBID,          REPOKEY_TYPE_U32, 0, KEY_STORAGE_SOLVABLE },
 569 };
 570
 571 static void
 572 domatch_idarray(Solvable *s, Id keyname, struct matchdata *md, Id *ida)
 573 {
 574   KeyValue kv;
 575   for (; *ida && !md->stop; ida++)
 576     {
 577       kv.id = *ida;
 578       kv.eof = ida[1] ? 0 : 1;
 579       repo_matchvalue(md, s, 0, solvablekeys + (keyname - SOLVABLE_NAME), &kv);
 580     }
 581 }
 582
 583 static void
 584 repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md)
 585 {
 586   KeyValue kv;
 587   Pool *pool = repo->pool;
 588   Repodata *data;
 589   Solvable *s;
 590   int i, j, flags;
 591
 592   md->stop = 0;
 593   if (!p)
 594     {
 595       for (p = repo->start, s = repo->pool->solvables + p; p < repo->end; p++, s++)
 596         {
 597           if (s->repo == repo)
 598             repo_search_md(repo, p, keyname, md);
 599           if (md->stop > SEARCH_NEXT_SOLVABLE)
 600             break;
 601         }
 602       return;
 603     }
 604   s = pool->solvables + p;
 605   flags = md->flags;
 606   if (!(flags & SEARCH_NO_STORAGE_SOLVABLE))
 607     {
 608       switch(keyname)
 609         {
 610           case 0:
 611           case SOLVABLE_NAME:
 612             if (s->name)
 613               {
 614                 kv.id = s->name;
 615                 repo_matchvalue(md, s, 0, solvablekeys + 0, &kv);
 616               }
 617             if (keyname || md->stop > SEARCH_NEXT_KEY)
 618               return;
 619           case SOLVABLE_ARCH:
 620             if (s->arch)
 621               {
 622                 kv.id = s->arch;
 623                 repo_matchvalue(md, s, 0, solvablekeys + 1, &kv);
 624               }
 625             if (keyname || md->stop > SEARCH_NEXT_KEY)
 626               return;
 627           case SOLVABLE_EVR:
 628             if (s->evr)
 629               {
 630                 kv.id = s->evr;
 631                 repo_matchvalue(md, s, 0, solvablekeys + 2, &kv);
 632               }
 633             if (keyname || md->stop > SEARCH_NEXT_KEY)
 634               return;
 635           case SOLVABLE_VENDOR:
 636             if (s->vendor)
 637               {
 638                 kv.id = s->vendor;
 639                 repo_matchvalue(md, s, 0, solvablekeys + 3, &kv);
 640               }
 641             if (keyname || md->stop > SEARCH_NEXT_KEY)
 642               return;
 643           case SOLVABLE_PROVIDES:
 644             if (s->provides)
 645               domatch_idarray(s, SOLVABLE_PROVIDES, md, repo->idarraydata + s->provides);
 646             if (keyname || md->stop > SEARCH_NEXT_KEY)
 647               return;
 648           case SOLVABLE_OBSOLETES:
 649             if (s->obsoletes)
 650               domatch_idarray(s, SOLVABLE_OBSOLETES, md, repo->idarraydata + s->obsoletes);
 651             if (keyname || md->stop > SEARCH_NEXT_KEY)
 652               return;
 653           case SOLVABLE_CONFLICTS:
 654             if (s->conflicts)
 655               domatch_idarray(s, SOLVABLE_CONFLICTS, md, repo->idarraydata + s->conflicts);
 656             if (keyname || md->stop > SEARCH_NEXT_KEY)
 657               return;
 658           case SOLVABLE_REQUIRES:
 659             if (s->requires)
 660               domatch_idarray(s, SOLVABLE_REQUIRES, md, repo->idarraydata + s->requires);
 661             if (keyname || md->stop > SEARCH_NEXT_KEY)
 662               return;
 663           case SOLVABLE_RECOMMENDS:
 664             if (s->recommends)
 665               domatch_idarray(s, SOLVABLE_RECOMMENDS, md, repo->idarraydata + s->recommends);
 666             if (keyname || md->stop > SEARCH_NEXT_KEY)
 667               return;
 668           case SOLVABLE_SUPPLEMENTS:
 669             if (s->supplements)
 670               domatch_idarray(s, SOLVABLE_SUPPLEMENTS, md, repo->idarraydata + s->supplements);
 671             if (keyname || md->stop > SEARCH_NEXT_KEY)
 672               return;
 673           case SOLVABLE_SUGGESTS:
 674             if (s->suggests)
 675               domatch_idarray(s, SOLVABLE_SUGGESTS, md, repo->idarraydata + s->suggests);
 676             if (keyname || md->stop > SEARCH_NEXT_KEY)
 677               return;
 678           case SOLVABLE_ENHANCES:
 679             if (s->enhances)
 680               domatch_idarray(s, SOLVABLE_ENHANCES, md, repo->idarraydata + s->enhances);
 681             if (keyname || md->stop > SEARCH_NEXT_KEY)
 682               return;
 683           case SOLVABLE_FRESHENS:
 684             if (s->freshens)
 685               domatch_idarray(s, SOLVABLE_FRESHENS, md, repo->idarraydata + s->freshens);
 686             if (keyname || md->stop > SEARCH_NEXT_KEY)
 687               return;
 688           case RPM_RPMDBID:
 689             if (repo->rpmdbid)
 690               {
 691                 kv.num = repo->rpmdbid[p - repo->start];
 692                 repo_matchvalue(md, s, 0, solvablekeys + (RPM_RPMDBID - SOLVABLE_NAME), &kv);
 693               }
 694             if (keyname || md->stop > SEARCH_NEXT_KEY)
 695               return;
 696             break;
 697           default:
 698             break;
 699         }
 700     }
 701
 702   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 703     {
 704       if (p < data->start || p >= data->end)
 705         continue;
 706       if (data->state == REPODATA_STUB)
 707         {
 708           if (keyname)
 709             {
 710               for (j = 1; j < data->nkeys; j++)
 711                 if (keyname == data->keys[j].name)
 712                   break;
 713               if (j == data->nkeys)
 714                 continue;
 715             }
 716           /* load it */
 717           if (data->loadcallback)
 718             data->loadcallback(data);
 719           else
 720             data->state = REPODATA_ERROR;
 721         }
 722       if (data->state == REPODATA_ERROR)
 723         continue;
 724       repodata_search(data, p - data->start, keyname, repo_matchvalue, md);
 725       if (md->stop > SEARCH_NEXT_KEY)
 726         break;
 727     }
 728 }
 729
 730 void
 731 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)
 732 {
 733   struct matchdata md;
 734
 735   memset(&md, 0, sizeof(md));
 736   md.pool = repo->pool;
 737   md.match = match;
 738   md.flags = flags;
 739   md.callback = callback;
 740   md.callback_data = cbdata;
 741   repo_search_md(repo, p, keyname, &md);
 742 }
 743
 744 const char *
 745 repo_lookup_str(Solvable *s, Id key)
 746 {
 747   Repo *repo = s->repo;
 748   Pool *pool = repo->pool;
 749   Repodata *data;
 750   int i, j, n;
 751
 752   switch(key)
 753     {
 754     case SOLVABLE_NAME:
 755       return id2str(pool, s->name);
 756     case SOLVABLE_ARCH:
 757       return id2str(pool, s->arch);
 758     case SOLVABLE_EVR:
 759       return id2str(pool, s->evr);
 760     case SOLVABLE_VENDOR:
 761       return id2str(pool, s->vendor);
 762     }
 763   n = s - pool->solvables;
 764   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 765     {
 766       if (n < data->start || n >= data->end)
 767         continue;
 768       for (j = 1; j < data->nkeys; j++)
 769         {
 770           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))
 771             return repodata_lookup_str(data, n - data->start, j);
 772         }
 773     }
 774   return 0;
 775 }
 776
 777 int
 778 repo_lookup_num(Solvable *s, Id key)
 779 {
 780   Repo *repo = s->repo;
 781   Pool *pool = repo->pool;
 782   Repodata *data;
 783   int i, j, n;
 784
 785   if (key == RPM_RPMDBID)
 786     {
 787       if (repo->rpmdbid)
 788         return repo->rpmdbid[(s - pool->solvables) - repo->start];
 789       return 0;
 790     }
 791   n = s - pool->solvables;
 792   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 793     {
 794       if (n < data->start || n >= data->end)
 795         continue;
 796       for (j = 1; j < data->nkeys; j++)
 797         {
 798           if (data->keys[j].name == key
 799               && (data->keys[j].type == REPOKEY_TYPE_U32
 800                   || data->keys[j].type == REPOKEY_TYPE_NUM
 801                   || data->keys[j].type == REPOKEY_TYPE_CONSTANT))
 802             {
 803               unsigned value;
 804               if (repodata_lookup_num(data, n - data->start, j, &value))
 805                 return value;
 806             }
 807         }
 808     }
 809   return 0;
 810 }
 811
 812
 813 /*
 814  * generic attribute lookup
 815  * returns non-zero if found
 816  * zero if not found
 817  * (XXX: return value is broken atm!)
 818  */
 819
 820 int
 821 repo_lookup(Solvable *s, Id key, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv), void *cbdata)
 822 {
 823   Repo *repo = s->repo;
 824   Pool *pool = repo->pool;
 825   Repodata *data;
 826   int i, s_id;
 827
 828   s_id = s - pool->solvables;
 829   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 830     {
 831       if (s_id < data->start || s_id >= data->end)
 832         continue;
 833       repodata_search(data, s_id - data->start, key, callback, cbdata);
 834       return 1;
 835     }
 836   return 0;
 837 }
 838
 839
 840 /***********************************************************************/
 841
 842 Repodata *
 843 repo_add_repodata(Repo *repo)
 844 {
 845   Repodata *data;
 846
 847   repo->nrepodata++;
 848   repo->repodata = sat_realloc2(repo->repodata, repo->nrepodata, sizeof(*data));
 849   data = repo->repodata + repo->nrepodata - 1;
 850   repodata_init(data, repo, 0);
 851   return data;
 852 }
 853
 854 static Repodata *
 855 findrepodata(Repo *repo, Id p, Id keyname)
 856 {
 857   int i;
 858   Repodata *data;
 859
 860   /* FIXME: enter nice code here */
 861   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 862     if (p >= data->start && p < data->end)
 863       return data;
 864   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 865     if (p == data->end)
 866       break;
 867   if (i < repo->nrepodata)
 868     {
 869       repodata_extend(data, p);
 870       return data;
 871     }
 872   return repo_add_repodata(repo);
 873 }
 874
 875 void
 876 repo_set_id(Repo *repo, Id p, Id keyname, Id id)
 877 {
 878   Repodata *data = findrepodata(repo, p, keyname);
 879   repodata_set_id(data, p - data->start, keyname, id);
 880 }
 881
 882 void
 883 repo_set_num(Repo *repo, Id p, Id keyname, Id num)
 884 {
 885   Repodata *data = findrepodata(repo, p, keyname);
 886   repodata_set_num(data, p - data->start, keyname, num);
 887 }
 888
 889 void
 890 repo_set_str(Repo *repo, Id p, Id keyname, const char *str)
 891 {
 892   Repodata *data = findrepodata(repo, p, keyname);
 893   repodata_set_str(data, p - data->start, keyname, str);
 894 }
 895
 896 void
 897 repo_set_poolstr(Repo *repo, Id p, Id keyname, const char *str)
 898 {
 899   Repodata *data = findrepodata(repo, p, keyname);
 900   repodata_set_poolstr(data, p - data->start, keyname, str);
 901 }
 902
 903 void
 904 repo_internalize(Repo *repo)
 905 {
 906   int i;
 907   Repodata *data;
 908
 909   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 910     if (data->attrs)
 911       repodata_internalize(data);
 912 }
 913
 914 // EOF
 915 /*
 916 vim:cinoptions={.5s,g0,p5,t0,(0,^-0.5s,n-0.5s:tw=78:cindent:sw=4:
 917 */