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 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18
  19 #include "repo.h"
  20 #include "pool.h"
  21 #include "poolid_private.h"
  22 #include "util.h"
  23 #include "attr_store_p.h"
  24
  25 #define IDARRAY_BLOCK     4095
  26
  27
  28 /*
  29  * create empty repo
  30  * and add to pool
  31  */
  32
  33 Repo *
  34 repo_create(Pool *pool, const char *name)
  35 {
  36   Repo *repo;
  37
  38   pool_freewhatprovides(pool);
  39   repo = (Repo *)xcalloc(1, sizeof(*repo));
  40   pool->repos = (Repo **)xrealloc(pool->repos, (pool->nrepos + 1) * sizeof(Repo *));
  41   pool->repos[pool->nrepos++] = repo;
  42   repo->name = name ? strdup(name) : 0;
  43   repo->pool = pool;
  44   repo->start = pool->nsolvables;
  45   repo->end = pool->nsolvables;
  46   repo->nsolvables = 0;
  47   return repo;
  48 }
  49
  50 static void
  51 repo_freedata(Repo *repo)
  52 {
  53   xfree(repo->idarraydata);
  54   xfree(repo->rpmdbid);
  55   xfree((char *)repo->name);
  56   xfree(repo);
  57 }
  58
  59 /*
  60  * add Id to repo
  61  * olddeps = old array to extend
  62  *
  63  */
  64
  65 Offset
  66 repo_addid(Repo *repo, Offset olddeps, Id id)
  67 {
  68   Id *idarray;
  69   int idarraysize;
  70   int i;
  71
  72   idarray = repo->idarraydata;
  73   idarraysize = repo->idarraysize;
  74
  75   if (!idarray)                        /* alloc idarray if not done yet */
  76     {
  77       idarray = (Id *)xmalloc((1 + IDARRAY_BLOCK) * sizeof(Id));
  78       idarray[0] = 0;
  79       idarraysize = 1;
  80       repo->lastoff = 0;
  81     }
  82
  83   if (!olddeps)                         /* no deps yet */
  84     {
  85       olddeps = idarraysize;
  86       if ((idarraysize & IDARRAY_BLOCK) == 0)
  87         idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
  88     }
  89   else if (olddeps == repo->lastoff)    /* extend at end */
  90     idarraysize--;
  91   else                                  /* can't extend, copy old */
  92     {
  93       i = olddeps;
  94       olddeps = idarraysize;
  95       for (; idarray[i]; i++)
  96         {
  97           if ((idarraysize & IDARRAY_BLOCK) == 0)
  98             idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
  99           idarray[idarraysize++] = idarray[i];
 100         }
 101       if ((idarraysize & IDARRAY_BLOCK) == 0)
 102         idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
 103     }
 104
 105   idarray[idarraysize++] = id;          /* insert Id into array */
 106
 107   if ((idarraysize & IDARRAY_BLOCK) == 0)   /* realloc if at block boundary */
 108     idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
 109
 110   idarray[idarraysize++] = 0;           /* ensure NULL termination */
 111
 112   repo->idarraydata = idarray;
 113   repo->idarraysize = idarraysize;
 114   repo->lastoff = olddeps;
 115
 116   return olddeps;
 117 }
 118
 119
 120 /*
 121  * add dependency (as Id) to repo
 122  * olddeps = offset into idarraydata
 123  * isreq = 0 for normal dep
 124  * isreq = 1 for requires
 125  * isreq = 2 for pre-requires
 126  *
 127  */
 128
 129 Offset
 130 repo_addid_dep(Repo *repo, Offset olddeps, Id id, int isreq)
 131 {
 132   Id oid, *oidp, *marker = 0;
 133
 134   if (!olddeps)
 135     return repo_addid(repo, olddeps, id);
 136
 137   if (!isreq)
 138     {
 139       for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
 140         {
 141           if (oid == id)
 142             return olddeps;
 143         }
 144       return repo_addid(repo, olddeps, id);
 145     }
 146
 147   for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
 148     {
 149       if (oid == SOLVABLE_PREREQMARKER)
 150         marker = oidp;
 151       else if (oid == id)
 152         break;
 153     }
 154
 155   if (oid)
 156     {
 157       if (marker || isreq == 1)
 158         return olddeps;
 159       marker = oidp++;
 160       for (; (oid = *oidp) != ID_NULL; oidp++)
 161         if (oid == SOLVABLE_PREREQMARKER)
 162           break;
 163       if (!oid)
 164         {
 165           oidp--;
 166           if (marker < oidp)
 167             memmove(marker, marker + 1, (oidp - marker) * sizeof(Id));
 168           *oidp = SOLVABLE_PREREQMARKER;
 169           return repo_addid(repo, olddeps, id);
 170         }
 171       while (oidp[1])
 172         oidp++;
 173       memmove(marker, marker + 1, (oidp - marker) * sizeof(Id));
 174       *oidp = id;
 175       return olddeps;
 176     }
 177   if (isreq == 2 && !marker)
 178     olddeps = repo_addid(repo, olddeps, SOLVABLE_PREREQMARKER);
 179   else if (isreq == 1 && marker)
 180     {
 181       *marker++ = id;
 182       id = *--oidp;
 183       if (marker < oidp)
 184         memmove(marker + 1, marker, (oidp - marker) * sizeof(Id));
 185       *marker = SOLVABLE_PREREQMARKER;
 186     }
 187   return repo_addid(repo, olddeps, id);
 188 }
 189
 190
 191 /*
 192  * reserve Ids
 193  * make space for 'num' more dependencies
 194  */
 195
 196 Offset
 197 repo_reserve_ids(Repo *repo, Offset olddeps, int num)
 198 {
 199   num++;        /* room for trailing ID_NULL */
 200
 201   if (!repo->idarraysize)              /* ensure buffer space */
 202     {
 203       repo->idarraysize = 1;
 204       repo->idarraydata = (Id *)xmalloc(((1 + num + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id));
 205       repo->idarraydata[0] = 0;
 206       repo->lastoff = 1;
 207       return 1;
 208     }
 209
 210   if (olddeps && olddeps != repo->lastoff)   /* if not appending */
 211     {
 212       /* can't insert into idarray, this would invalidate all 'larger' offsets
 213        * so create new space at end and move existing deps there.
 214        * Leaving 'hole' at old position.
 215        */
 216
 217       Id *idstart, *idend;
 218       int count;
 219
 220       for (idstart = idend = repo->idarraydata + olddeps; *idend++; )   /* find end */
 221         ;
 222       count = idend - idstart - 1 + num;               /* new size */
 223
 224       /* realloc if crossing block boundary */
 225       if (((repo->idarraysize - 1) | IDARRAY_BLOCK) != ((repo->idarraysize + count - 1) | IDARRAY_BLOCK))
 226         repo->idarraydata = (Id *)xrealloc(repo->idarraydata, ((repo->idarraysize + count + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id));
 227
 228       /* move old deps to end */
 229       olddeps = repo->lastoff = repo->idarraysize;
 230       memcpy(repo->idarraydata + olddeps, idstart, count - num);
 231       repo->idarraysize = olddeps + count - num;
 232
 233       return olddeps;
 234     }
 235
 236   if (olddeps)                         /* appending */
 237     repo->idarraysize--;
 238
 239   /* realloc if crossing block boundary */
 240   if (((repo->idarraysize - 1) | IDARRAY_BLOCK) != ((repo->idarraysize + num - 1) | IDARRAY_BLOCK))
 241     repo->idarraydata = (Id *)xrealloc(repo->idarraydata, ((repo->idarraysize + num + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id));
 242
 243   /* appending or new */
 244   repo->lastoff = olddeps ? olddeps : repo->idarraysize;
 245
 246   return repo->lastoff;
 247 }
 248
 249
 250 /*
 251  * remove repo from pool, zero out solvables
 252  *
 253  */
 254
 255 void
 256 repo_free(Repo *repo, int reuseids)
 257 {
 258   Pool *pool = repo->pool;
 259   Solvable *s;
 260   int i;
 261
 262   pool_freewhatprovides(pool);
 263
 264   if (reuseids && repo->end == pool->nsolvables)
 265     {
 266       /* it's ok to reuse the ids. As this is the last repo, we can
 267          just shrink the solvable array */
 268       for (i = repo->end - 1, s = pool->solvables + i; i >= repo->start; i--, s--)
 269         if (s->repo != repo)
 270           break;
 271       repo->end = i + 1;
 272       pool->nsolvables = i + 1;
 273     }
 274   /* zero out solvables belonging to this repo */
 275   for (i = repo->start, s = pool->solvables + i; i < repo->end; i++, s++)
 276     if (s->repo == repo)
 277       memset(s, 0, sizeof(*s));
 278   for (i = 0; i < pool->nrepos; i++)    /* find repo in pool */
 279     if (pool->repos[i] == repo)
 280       break;
 281   if (i == pool->nrepos)               /* repo not in pool, return */
 282     return;
 283   if (i < pool->nrepos - 1)
 284     memmove(pool->repos + i, pool->repos + i + 1, (pool->nrepos - 1 - i) * sizeof(Repo *));
 285   pool->nrepos--;
 286   repo_freedata(repo);
 287 }
 288
 289 void
 290 repo_freeallrepos(Pool *pool, int reuseids)
 291 {
 292   int i;
 293
 294   pool_freewhatprovides(pool);
 295   for (i = 0; i < pool->nrepos; i++)
 296     repo_freedata(pool->repos[i]);
 297   pool->repos = xfree(pool->repos);
 298   pool->nrepos = 0;
 299   /* the first two solvables don't belong to a repo */
 300   pool_free_solvable_block(pool, 2, pool->nsolvables - 2, reuseids);
 301 }
 302
 303 Offset
 304 repo_fix_legacy(Repo *repo, Offset provides, Offset supplements)
 305 {
 306   Pool *pool = repo->pool;
 307   Id id, idp, idl, idns;
 308   char buf[1024], *p, *dep;
 309   int i;
 310
 311   if (provides)
 312     {
 313       for (i = provides; repo->idarraydata[i]; i++)
 314         {
 315           id = repo->idarraydata[i];
 316           if (ISRELDEP(id))
 317             continue;
 318           dep = (char *)id2str(pool, id);
 319           if (!strncmp(dep, "locale(", 7) && strlen(dep) < sizeof(buf) - 2)
 320             {
 321               idp = 0;
 322               strcpy(buf + 2, dep);
 323               dep = buf + 2 + 7;
 324               if ((p = strchr(dep, ':')) != 0 && p != dep)
 325                 {
 326                   *p++ = 0;
 327                   idp = str2id(pool, dep, 1);
 328                   dep = p;
 329                 }
 330               id = 0;
 331               while ((p = strchr(dep, ';')) != 0)
 332                 {
 333                   if (p == dep)
 334                     {
 335                       dep = p + 1;
 336                       continue;
 337                     }
 338                   strncpy(dep - 9, "language:", 9);
 339                   *p++ = 0;
 340                   idl = str2id(pool, dep - 9, 1);
 341                   if (id)
 342                     id = rel2id(pool, id, idl, REL_OR, 1);
 343                   else
 344                     id = idl;
 345                   dep = p;
 346                 }
 347               if (dep[0] && dep[1])
 348                 {
 349                   for (p = dep; *p && *p != ')'; p++)
 350                     ;
 351                   *p = 0;
 352                   strncpy(dep - 9, "language:", 9);
 353                   idl = str2id(pool, dep - 9, 1);
 354                   if (id)
 355                     id = rel2id(pool, id, idl, REL_OR, 1);
 356                   else
 357                     id = idl;
 358                 }
 359               if (idp)
 360                 id = rel2id(pool, idp, id, REL_AND, 1);
 361               if (id)
 362                 supplements = repo_addid_dep(repo, supplements, id, 0);
 363             }
 364           else if ((p = strchr(dep, ':')) != 0 && p != dep && p[1] == '/' && strlen(dep) < sizeof(buf))
 365             {
 366               strcpy(buf, dep);
 367               p = buf + (p - dep);
 368               *p++ = 0;
 369               idp = str2id(pool, buf, 1);
 370               idns = str2id(pool, "namespace:installed", 1);
 371               id = str2id(pool, p, 1);
 372               id = rel2id(pool, idns, id, REL_NAMESPACE, 1);
 373               id = rel2id(pool, idp, id, REL_AND, 1);
 374               supplements = repo_addid_dep(repo, supplements, id, 0);
 375             }
 376         }
 377     }
 378   if (!supplements)
 379     return 0;
 380   for (i = supplements; repo->idarraydata[i]; i++)
 381     {
 382       id = repo->idarraydata[i];
 383       if (ISRELDEP(id))
 384         continue;
 385       dep = (char *)id2str(pool, id);
 386       if (!strncmp(dep, "system:modalias(", 16))
 387         dep += 7;
 388       if (!strncmp(dep, "modalias(", 9) && dep[9] && dep[10] && strlen(dep) < sizeof(buf))
 389         {
 390           strcpy(buf, dep);
 391           p = strchr(buf + 9, ':');
 392           idns = str2id(pool, "namespace:modalias", 1);
 393           if (p && p != buf + 9 && strchr(p + 1, ':'))
 394             {
 395               *p++ = 0;
 396               idp = str2id(pool, buf + 9, 1);
 397               p[strlen(p) - 1] = 0;
 398               id = str2id(pool, p, 1);
 399               id = rel2id(pool, idns, id, REL_NAMESPACE, 1);
 400               id = rel2id(pool, idp, id, REL_AND, 1);
 401             }
 402           else
 403             {
 404               p = buf + 9;
 405               p[strlen(p) - 1] = 0;
 406               id = str2id(pool, p, 1);
 407               id = rel2id(pool, idns, id, REL_NAMESPACE, 1);
 408             }
 409           if (id)
 410             repo->idarraydata[i] = id;
 411         }
 412       else if (!strncmp(dep, "packageand(", 11) && strlen(dep) < sizeof(buf))
 413         {
 414           strcpy(buf, dep);
 415           id = 0;
 416           dep = buf + 11;
 417           while ((p = strchr(dep, ':')) != 0)
 418             {
 419               if (p == dep)
 420                 {
 421                   dep = p + 1;
 422                   continue;
 423                 }
 424               *p++ = 0;
 425               idp = str2id(pool, dep, 1);
 426               if (id)
 427                 id = rel2id(pool, id, idp, REL_AND, 1);
 428               else
 429                 id = idp;
 430               dep = p;
 431             }
 432           if (dep[0] && dep[1])
 433             {
 434               dep[strlen(dep) - 1] = 0;
 435               idp = str2id(pool, dep, 1);
 436               if (id)
 437                 id = rel2id(pool, id, idp, REL_AND, 1);
 438               else
 439                 id = idp;
 440             }
 441           if (id)
 442             repo->idarraydata[i] = id;
 443         }
 444     }
 445   return supplements;
 446 }
 447
 448 static unsigned char *
 449 data_read_id(unsigned char *dp, Id *idp)
 450 {
 451   Id x = 0;
 452   unsigned char c;
 453   for (;;)
 454     {
 455       c = *dp++;
 456       if (!(c & 0x80))
 457         {
 458           *idp = (x << 7) ^ c;
 459           return dp;
 460         }
 461       x = (x << 7) ^ c ^ 128;
 462     }
 463 }
 464
 465 static unsigned char *
 466 data_skip(unsigned char *dp, int type)
 467 {
 468   switch (type)
 469     {
 470     case TYPE_VOID:
 471       return dp;
 472     case TYPE_ID:
 473       while ((*dp & 0x80) != 0)
 474         dp++;
 475       return dp;
 476     case TYPE_IDARRAY:
 477     case TYPE_REL_IDARRAY:
 478     case TYPE_IDVALUEARRAY:
 479     case TYPE_IDVALUEVALUEARRAY:
 480       while ((*dp & 0xc0) != 0)
 481         dp++;
 482       return dp;
 483     default:
 484       fprintf(stderr, "unknown type in data_skip\n");
 485       exit(1);
 486     }
 487 }
 488
 489 static unsigned char *
 490 forward_to_key(Repodata *data, Id key, Id schema, unsigned char *dp)
 491 {
 492   Id k, *keyp;
 493
 494   keyp = data->schemadata + schema;
 495   while ((k = *keyp++) != 0)
 496     {
 497       if (k == key)
 498         return dp;
 499       if (data->keys[k].storage == KEY_STORAGE_VERTICAL_OFFSET)
 500         {
 501           /* skip that offset */
 502           dp = data_skip(dp, TYPE_ID);
 503           continue;
 504         }
 505       if (data->keys[k].storage != KEY_STORAGE_INCORE)
 506         continue;
 507       dp = data_skip(dp, data->keys[k].type);
 508     }
 509   return 0;
 510 }
 511
 512 static unsigned char *
 513 load_page_range(Repodata *data, unsigned int pstart, unsigned int pend)
 514 {
 515   /* add smart paging here */
 516   return 0;
 517 }
 518
 519 static unsigned char *
 520 get_data(Repodata *data, Repokey *key, unsigned char **dpp)
 521 {
 522   Id off;
 523   unsigned char *dp = *dpp;
 524   int i, max;
 525   unsigned int pstart, pend, poff, plen;
 526
 527   if (!dp)
 528     return 0;
 529   if (key->storage == KEY_STORAGE_INCORE)
 530     return dp;
 531   if (key->storage != KEY_STORAGE_VERTICAL_OFFSET)
 532     return 0;
 533   if (!data->fp)
 534     return 0;
 535   dp = data_read_id(dp, &off);
 536   *dpp = dp;
 537   if (key->type == TYPE_VOID)
 538     return 0;
 539   max = key->size - off;
 540   if (max <= 0)
 541     return 0;
 542   /* we now have the offset, go into vertical */
 543   for (i = key - data->keys - 1; i > 0; i--)
 544     if (data->keys[i].storage == KEY_STORAGE_VERTICAL_OFFSET)
 545       off += data->keys[i].size;
 546   pstart = off / BLOB_PAGESIZE;
 547   pend = pstart;
 548   poff = off % BLOB_PAGESIZE;
 549   plen = BLOB_PAGESIZE - poff;
 550   for (;;)
 551     {
 552       if (plen > max)
 553         plen = max;
 554       dp = load_page_range(data, pstart, pend) + poff;
 555       if (!dp)
 556         return 0;
 557       switch (key->type)
 558         {
 559         case TYPE_STR:
 560           if (memchr(dp, 0, plen))
 561             return dp;
 562           break;
 563         case TYPE_ID:
 564           for (i = 0; i < plen; i++)
 565             if ((dp[i] & 0x80) == 0)
 566               return dp;
 567           break;
 568         case TYPE_IDARRAY:
 569         case TYPE_REL_IDARRAY:
 570         case TYPE_IDVALUEARRAY:
 571         case TYPE_IDVALUEVALUEARRAY:
 572           for (i = 0; i < plen; i++)
 573             if ((dp[i] & 0xc0) == 0)
 574               return dp;
 575           break;
 576         }
 577       if (plen == max)
 578         return 0;
 579       pend++;
 580       plen += BLOB_PAGESIZE;
 581     }
 582 }
 583
 584
 585 const char *
 586 repodata_lookup_str(Repodata *data, Id entry, Id key)
 587 {
 588   Id schema;
 589   Id id, k, *kp, *keyp;
 590   unsigned char *dp;
 591
 592   if (data->entryschemau8)
 593     schema = data->entryschemau8[entry];
 594   else
 595     schema = data->entryschema[entry];
 596   keyp = data->schemadata + schema;
 597   /* make sure the schema of this solvable contains the key */
 598   for (kp = keyp; (k = *kp++) != 0; )
 599     if (k == key)
 600       break;
 601   if (k == 0)
 602     return 0;
 603   dp = forward_to_key(data, key, schema, data->incoredata + data->incoreoffset[entry]);
 604   dp = get_data(data, data->keys + key, &dp);
 605   if (!dp)
 606     return 0;
 607   if (data->keys[key].type == TYPE_STR)
 608     return (const char *)dp;
 609   /* id type, must either use global or local string strore*/
 610   dp = data_read_id(dp, &id);
 611 #if 0
 612   /* not yet working */
 613   return data->ss.stringspace + data->ss.strings[id];
 614 #else
 615   return id2str(data->repo->pool, id);
 616 #endif
 617 }
 618
 619 struct matchdata
 620 {
 621   Pool *pool;
 622   const char *matchstr;
 623   int flags;
 624 #if 0
 625   regex_t regex;
 626 #endif
 627   int stop;
 628   int (*callback)(void *data, Solvable *s, Id key, const char *str);
 629   void *callback_data;
 630 };
 631
 632 static void
 633 domatch(Id p, Id key, struct matchdata *md, const char *str)
 634 {
 635   /* fill match code here */
 636   md->callback(md->callback_data, md->pool->solvables + p, key, str);
 637 }
 638
 639 static void
 640 repodata_search(Repodata *data, Id entry, Id key, struct matchdata *md)
 641 {
 642   Id schema;
 643   Id id, k, *kp, *keyp;
 644   unsigned char *dp, *ddp;
 645   int onekey = 0;
 646
 647   if (data->entryschemau8)
 648     schema = data->entryschemau8[entry];
 649   else
 650     schema = data->entryschema[entry];
 651   keyp = data->schemadata + schema;
 652   dp = data->incoredata + data->incoreoffset[entry];
 653   if (key)
 654     {
 655       /* search in a specific key */
 656       for (kp = keyp; (k = *kp++) != 0; )
 657         if (k == key)
 658           break;
 659       if (k == 0)
 660         return;
 661       dp = forward_to_key(data, key, schema, dp);
 662       if (!dp)
 663         return;
 664       keyp = kp - 1;
 665       onekey = 1;
 666     }
 667   while ((key = *keyp++) != 0)
 668     {
 669       ddp = get_data(data, data->keys + key, &dp);
 670       while (ddp)
 671         {
 672           switch (data->keys[key].type)
 673             {
 674             case TYPE_STR:
 675               domatch(data->start + entry, data->keys[key].name, md, (const char *)ddp);
 676               ddp = 0;
 677               break;
 678             case TYPE_ID:
 679               data_read_id(ddp, &id);
 680               /* domatch */
 681               ddp = 0;
 682               break;
 683             case TYPE_IDARRAY:
 684               ddp = data_read_id(ddp, &id);
 685               if ((id & 0x40) == 0)
 686                 ddp = 0;
 687               id = (id & 0x3f) | ((id >> 1) & ~0x3f);
 688               /* domatch */
 689               break;
 690             default:
 691               ddp = 0;
 692             }
 693         }
 694       if (onekey || md->stop)
 695         return;
 696     }
 697 }
 698
 699 static void
 700 repo_search_md(Repo *repo, Id p, Id key, struct matchdata *md)
 701 {
 702   Pool *pool = repo->pool;
 703   Repodata *data;
 704   Solvable *s;
 705   int i;
 706
 707   if (!p)
 708     {
 709       for (p = repo->start, s = repo->pool->solvables + p; p < repo->end; p++, s++)
 710         if (s->repo == repo)
 711           repo_search_md(repo, p, key, md);
 712       return;
 713     }
 714   s = pool->solvables + p;
 715   if ((!key || key == SOLVABLE_NAME) && s->name)
 716     domatch(p, SOLVABLE_NAME, md, id2str(pool, s->name));
 717   if ((!key || key == SOLVABLE_ARCH) && s->arch)
 718     domatch(p, SOLVABLE_ARCH, md, id2str(pool, s->arch));
 719   if ((!key || key == SOLVABLE_EVR) && s->evr)
 720     domatch(p, SOLVABLE_EVR, md, id2str(pool, s->evr));
 721   if ((!key || key == SOLVABLE_VENDOR) && s->vendor)
 722     domatch(p, SOLVABLE_VENDOR, md, id2str(pool, s->vendor));
 723   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 724     {
 725       if (p < data->start || p >= data->end)
 726         continue;
 727       repodata_search(data, p - data->start, key, md);
 728     }
 729 }
 730
 731 void
 732 repo_search(Repo *repo, Id p, Id key, const char *match, int flags, int (*callback)(void *data, Solvable *s, Id key, const char *str), void *callback_data)
 733 {
 734   struct matchdata md;
 735
 736   memset(&md, 0, sizeof(md));
 737   md.pool = repo->pool;
 738   md.matchstr = match;
 739   md.flags = flags;
 740   md.callback = callback;
 741   md.callback_data = callback_data;
 742   repo_search_md(repo, p, key, &md);
 743 }
 744
 745 const char *
 746 repo_lookup_str(Solvable *s, Id key)
 747 {
 748   Repo *repo = s->repo;
 749   Pool *pool = repo->pool;
 750   Repodata *data;
 751   int i, j, n;
 752
 753   switch(key)
 754     {
 755     case SOLVABLE_NAME:
 756       return id2str(pool, s->name);
 757     case SOLVABLE_ARCH:
 758       return id2str(pool, s->arch);
 759     case SOLVABLE_EVR:
 760       return id2str(pool, s->evr);
 761     case SOLVABLE_VENDOR:
 762       return id2str(pool, s->vendor);
 763     }
 764   n = s - pool->solvables;
 765   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 766     {
 767       if (n < data->start || n >= data->end)
 768         continue;
 769       for (j = 1; j < data->nkeys; j++)
 770         {
 771           if (data->keys[j].name == key && (data->keys[j].type == TYPE_ID || data->keys[j].type == TYPE_STR))
 772             return repodata_lookup_str(data, n - data->start, j);
 773         }
 774     }
 775   return 0;
 776 }
 777
 778
 779
 780 static int
 781 key_cmp (const void *pa, const void *pb)
 782 {
 783   Repokey *a = (Repokey *)pa;
 784   Repokey *b = (Repokey *)pb;
 785   return a->name - b->name;
 786 }
 787
 788 void
 789 repo_add_attrstore (Repo *repo, Attrstore *s, const char *location)
 790 {
 791   unsigned i;
 792   Repodata *data;
 793   /* If this is meant to be the embedded attributes, make sure we don't
 794      have them already.  */
 795   if (!location)
 796     {
 797       for (i = 0; i < repo->nrepodata; i++)
 798         if (repo->repodata[i].location == 0)
 799           break;
 800       if (i != repo->nrepodata)
 801         {
 802           pool_debug (repo->pool, SAT_FATAL, "embedded attribs added twice\n");
 803           exit (1);
 804         }
 805     }
 806   repo->nrepodata++;
 807   repo->repodata = xrealloc (repo->repodata, repo->nrepodata * sizeof (*data));
 808   data = repo->repodata + repo->nrepodata - 1;
 809   memset (data, 0, sizeof (*data));
 810   data->s = s;
 811   data->nkeys = s->nkeys;
 812   if (data->nkeys)
 813     {
 814       data->keys = xmalloc(data->nkeys * sizeof(data->keys[0]));
 815       for (i = 1; i < data->nkeys; i++)
 816         {
 817           data->keys[i].name = s->keys[i].name;
 818           data->keys[i].type = s->keys[i].type;
 819         }
 820       if (data->nkeys > 2)
 821         qsort(data->keys + 1, data->nkeys - 1, sizeof(data->keys[0]), key_cmp);
 822     }
 823   if (location)
 824     data->location = strdup(location);
 825 }
 826
 827 // EOF