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