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