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   int i, j, flags;
 599   Solvable *s;
 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   else if (p < 0)
 614     /* The callback only supports solvables, so we can't iterate over the
 615        extra things.  */
 616     return;
 617   flags = md->flags;
 618   if (!(flags & SEARCH_NO_STORAGE_SOLVABLE))
 619     {
 620       s = pool->solvables + p;
 621       switch(keyname)
 622         {
 623           case 0:
 624           case SOLVABLE_NAME:
 625             if (s->name)
 626               {
 627                 kv.id = s->name;
 628                 repo_matchvalue(md, s, 0, solvablekeys + 0, &kv);
 629               }
 630             if (keyname || md->stop > SEARCH_NEXT_KEY)
 631               return;
 632           case SOLVABLE_ARCH:
 633             if (s->arch)
 634               {
 635                 kv.id = s->arch;
 636                 repo_matchvalue(md, s, 0, solvablekeys + 1, &kv);
 637               }
 638             if (keyname || md->stop > SEARCH_NEXT_KEY)
 639               return;
 640           case SOLVABLE_EVR:
 641             if (s->evr)
 642               {
 643                 kv.id = s->evr;
 644                 repo_matchvalue(md, s, 0, solvablekeys + 2, &kv);
 645               }
 646             if (keyname || md->stop > SEARCH_NEXT_KEY)
 647               return;
 648           case SOLVABLE_VENDOR:
 649             if (s->vendor)
 650               {
 651                 kv.id = s->vendor;
 652                 repo_matchvalue(md, s, 0, solvablekeys + 3, &kv);
 653               }
 654             if (keyname || md->stop > SEARCH_NEXT_KEY)
 655               return;
 656           case SOLVABLE_PROVIDES:
 657             if (s->provides)
 658               domatch_idarray(s, SOLVABLE_PROVIDES, md, repo->idarraydata + s->provides);
 659             if (keyname || md->stop > SEARCH_NEXT_KEY)
 660               return;
 661           case SOLVABLE_OBSOLETES:
 662             if (s->obsoletes)
 663               domatch_idarray(s, SOLVABLE_OBSOLETES, md, repo->idarraydata + s->obsoletes);
 664             if (keyname || md->stop > SEARCH_NEXT_KEY)
 665               return;
 666           case SOLVABLE_CONFLICTS:
 667             if (s->conflicts)
 668               domatch_idarray(s, SOLVABLE_CONFLICTS, md, repo->idarraydata + s->conflicts);
 669             if (keyname || md->stop > SEARCH_NEXT_KEY)
 670               return;
 671           case SOLVABLE_REQUIRES:
 672             if (s->requires)
 673               domatch_idarray(s, SOLVABLE_REQUIRES, md, repo->idarraydata + s->requires);
 674             if (keyname || md->stop > SEARCH_NEXT_KEY)
 675               return;
 676           case SOLVABLE_RECOMMENDS:
 677             if (s->recommends)
 678               domatch_idarray(s, SOLVABLE_RECOMMENDS, md, repo->idarraydata + s->recommends);
 679             if (keyname || md->stop > SEARCH_NEXT_KEY)
 680               return;
 681           case SOLVABLE_SUPPLEMENTS:
 682             if (s->supplements)
 683               domatch_idarray(s, SOLVABLE_SUPPLEMENTS, md, repo->idarraydata + s->supplements);
 684             if (keyname || md->stop > SEARCH_NEXT_KEY)
 685               return;
 686           case SOLVABLE_SUGGESTS:
 687             if (s->suggests)
 688               domatch_idarray(s, SOLVABLE_SUGGESTS, md, repo->idarraydata + s->suggests);
 689             if (keyname || md->stop > SEARCH_NEXT_KEY)
 690               return;
 691           case SOLVABLE_ENHANCES:
 692             if (s->enhances)
 693               domatch_idarray(s, SOLVABLE_ENHANCES, md, repo->idarraydata + s->enhances);
 694             if (keyname || md->stop > SEARCH_NEXT_KEY)
 695               return;
 696           case SOLVABLE_FRESHENS:
 697             if (s->freshens)
 698               domatch_idarray(s, SOLVABLE_FRESHENS, md, repo->idarraydata + s->freshens);
 699             if (keyname || md->stop > SEARCH_NEXT_KEY)
 700               return;
 701           case RPM_RPMDBID:
 702             if (repo->rpmdbid)
 703               {
 704                 kv.num = repo->rpmdbid[p - repo->start];
 705                 repo_matchvalue(md, s, 0, solvablekeys + (RPM_RPMDBID - SOLVABLE_NAME), &kv);
 706               }
 707             if (keyname || md->stop > SEARCH_NEXT_KEY)
 708               return;
 709             break;
 710           default:
 711             break;
 712         }
 713     }
 714
 715   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 716     {
 717       if (p < data->start || p >= data->end)
 718         continue;
 719       if (data->state == REPODATA_STUB)
 720         {
 721           if (keyname)
 722             {
 723               for (j = 1; j < data->nkeys; j++)
 724                 if (keyname == data->keys[j].name)
 725                   break;
 726               if (j == data->nkeys)
 727                 continue;
 728             }
 729           /* load it */
 730           if (data->loadcallback)
 731             data->loadcallback(data);
 732           else
 733             data->state = REPODATA_ERROR;
 734         }
 735       if (data->state == REPODATA_ERROR)
 736         continue;
 737       repodata_search(data, p - data->start, keyname, repo_matchvalue, md);
 738       if (md->stop > SEARCH_NEXT_KEY)
 739         break;
 740     }
 741 }
 742
 743 void
 744 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)
 745 {
 746   struct matchdata md;
 747
 748   memset(&md, 0, sizeof(md));
 749   md.pool = repo->pool;
 750   md.match = match;
 751   md.flags = flags;
 752   md.callback = callback;
 753   md.callback_data = cbdata;
 754   repo_search_md(repo, p, keyname, &md);
 755 }
 756
 757 const char *
 758 repo_lookup_str(Solvable *s, Id key)
 759 {
 760   Repo *repo = s->repo;
 761   Pool *pool = repo->pool;
 762   Repodata *data;
 763   int i, j, n;
 764
 765   switch(key)
 766     {
 767     case SOLVABLE_NAME:
 768       return id2str(pool, s->name);
 769     case SOLVABLE_ARCH:
 770       return id2str(pool, s->arch);
 771     case SOLVABLE_EVR:
 772       return id2str(pool, s->evr);
 773     case SOLVABLE_VENDOR:
 774       return id2str(pool, s->vendor);
 775     }
 776   n = s - pool->solvables;
 777   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 778     {
 779       if (n < data->start || n >= data->end)
 780         continue;
 781       for (j = 1; j < data->nkeys; j++)
 782         {
 783           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))
 784             return repodata_lookup_str(data, n - data->start, j);
 785         }
 786     }
 787   return 0;
 788 }
 789
 790
 791 unsigned int
 792 repo_lookup_num(Solvable *s, Id key)
 793 {
 794   Repo *repo = s->repo;
 795   Pool *pool = repo->pool;
 796   Repodata *data;
 797   int i, j, n;
 798
 799   if (key == RPM_RPMDBID)
 800     {
 801       if (repo->rpmdbid)
 802         return repo->rpmdbid[(s - pool->solvables) - repo->start];
 803       return 0;
 804     }
 805   n = s - pool->solvables;
 806   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 807     {
 808       if (n < data->start || n >= data->end)
 809         continue;
 810       for (j = 1; j < data->nkeys; j++)
 811         {
 812           if (data->keys[j].name == key
 813               && (data->keys[j].type == REPOKEY_TYPE_U32
 814                   || data->keys[j].type == REPOKEY_TYPE_NUM
 815                   || data->keys[j].type == REPOKEY_TYPE_CONSTANT))
 816             {
 817               unsigned value;
 818               if (repodata_lookup_num(data, n - data->start, j, &value))
 819                 return value;
 820             }
 821         }
 822     }
 823   return 0;
 824 }
 825
 826
 827 /*
 828  * generic attribute lookup
 829  * returns non-zero if found
 830  * zero if not found
 831  * (XXX: return value is broken atm!)
 832  */
 833
 834 int
 835 repo_lookup(Solvable *s, Id key, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv), void *cbdata)
 836 {
 837   Repo *repo = s->repo;
 838   Pool *pool = repo->pool;
 839   Repodata *data;
 840   int i, s_id;
 841
 842   s_id = s - pool->solvables;
 843   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 844     {
 845       if (s_id < data->start || s_id >= data->end)
 846         continue;
 847       repodata_search(data, s_id - data->start, key, callback, cbdata);
 848       return 1;
 849     }
 850   return 0;
 851 }
 852
 853
 854 /***********************************************************************/
 855
 856 Repodata *
 857 repo_add_repodata(Repo *repo, int localpool)
 858 {
 859   Repodata *data;
 860
 861   repo->nrepodata++;
 862   repo->repodata = sat_realloc2(repo->repodata, repo->nrepodata, sizeof(*data));
 863   data = repo->repodata + repo->nrepodata - 1;
 864   repodata_init(data, repo, localpool);
 865   return data;
 866 }
 867
 868 static Repodata *
 869 repo_findrepodata(Repo *repo, Id p, Id keyname)
 870 {
 871   int i;
 872   Repodata *data;
 873
 874   /* FIXME: enter nice code here */
 875   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 876     if ((p < 0 && (-1 - p) >= data->extrastart && (-1 - p) < (data->extrastart + data->nextra))
 877         || (p >= 0 && p >= data->start && p < data->end))
 878       return data;
 879   if (p < 0)
 880     {
 881       data = repo->repodata;
 882       if (data)
 883         {
 884           for (i = 1; i < repo->nrepodata; i++)
 885             if (data->extrastart + data->nextra
 886                 > repo->repodata[i].extrastart + repo->repodata[i].nextra)
 887               data = repo->repodata + i;
 888         }
 889       else
 890         data = repo_add_repodata(repo, 0);
 891       repodata_extend_extra(data, (-1 - p) - data->extrastart + 1);
 892       if (-p > repo->nextra)
 893         repo->nextra = -p;
 894       return data;
 895     }
 896   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 897     if (p == data->end)
 898       break;
 899   if (i < repo->nrepodata)
 900     {
 901       repodata_extend(data, p);
 902       return data;
 903     }
 904   return repo_add_repodata(repo, 0);
 905 }
 906
 907 void
 908 repo_set_id(Repo *repo, Id p, Id keyname, Id id)
 909 {
 910   Repodata *data = repo_findrepodata(repo, p, keyname);
 911   if (p < 0)
 912     /* This is -1 - ((-1 - p) - data->extrastart).  */
 913     p = p + data->extrastart;
 914   else
 915     p = p - data->start;
 916   repodata_set_id(data, p, keyname, id);
 917 }
 918
 919 void
 920 repo_set_num(Repo *repo, Id p, Id keyname, Id num)
 921 {
 922   Repodata *data = repo_findrepodata(repo, p, keyname);
 923   if (p < 0)
 924     p = p + data->extrastart;
 925   else
 926     p = p - data->start;
 927   repodata_set_num(data, p, keyname, num);
 928 }
 929
 930 void
 931 repo_set_str(Repo *repo, Id p, Id keyname, const char *str)
 932 {
 933   Repodata *data = repo_findrepodata(repo, p, keyname);
 934   if (p < 0)
 935     p = p + data->extrastart;
 936   else
 937     p = p - data->start;
 938   repodata_set_str(data, p, keyname, str);
 939 }
 940
 941 void
 942 repo_set_poolstr(Repo *repo, Id p, Id keyname, const char *str)
 943 {
 944   Repodata *data = repo_findrepodata(repo, p, keyname);
 945   if (p < 0)
 946     p = p + data->extrastart;
 947   else
 948     p = p - data->start;
 949   repodata_set_poolstr(data, p, keyname, str);
 950 }
 951
 952 void
 953 repo_internalize(Repo *repo)
 954 {
 955   int i;
 956   Repodata *data;
 957
 958   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 959     if (data->attrs || data->extraattrs)
 960       repodata_internalize(data);
 961 }
 962
 963 void
 964 repo_disable_paging(Repo *repo)
 965 {
 966   int i;
 967   Repodata *data;
 968
 969   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 970     repodata_disable_paging(data);
 971 }
 972 // EOF
 973 /*
 974 vim:cinoptions={.5s,g0,p5,t0,(0,^-0.5s,n-0.5s:tw=78:cindent:sw=4:
 975 */