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