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->repoid = pool->nrepos;
  50   repo->name = name ? strdup(name) : 0;
  51   repo->pool = pool;
  52   repo->start = pool->nsolvables;
  53   repo->end = pool->nsolvables;
  54   repo->nsolvables = 0;
  55   return repo;
  56 }
  57
  58 static void
  59 repo_freedata(Repo *repo)
  60 {
  61   int i;
  62   for (i = 0; i < repo->nrepodata; i++)
  63     repodata_freedata(repo->repodata + i);
  64   sat_free(repo->repodata);
  65   sat_free(repo->idarraydata);
  66   sat_free(repo->rpmdbid);
  67   sat_free((char *)repo->name);
  68   sat_free(repo);
  69 }
  70
  71 /* delete all solvables and repodata blocks from this repo */
  72
  73 void
  74 repo_empty(Repo *repo, int reuseids)
  75 {
  76   Pool *pool = repo->pool;
  77   Solvable *s;
  78   int i;
  79
  80   pool_freewhatprovides(pool);
  81   if (repo == pool->installed)
  82     pool->installed = 0;
  83
  84   if (reuseids && repo->end == pool->nsolvables)
  85     {
  86       /* it's ok to reuse the ids. As this is the last repo, we can
  87          just shrink the solvable array */
  88       for (i = repo->end - 1, s = pool->solvables + i; i >= repo->start; i--, s--)
  89         if (s->repo != repo)
  90           break;
  91       pool_free_solvable_block(pool, i + 1, repo->end - (i + 1), reuseids);
  92     }
  93   /* zero out (i.e. free) solvables belonging to this repo */
  94   for (i = repo->start, s = pool->solvables + i; i < repo->end; i++, s++)
  95     if (s->repo == repo)
  96       memset(s, 0, sizeof(*s));
  97   repo->nsolvables = 0;
  98
  99   /* free all data belonging to this repo */
 100   repo->idarraydata = sat_free(repo->idarraydata);
 101   repo->idarraysize = 0;
 102   repo->lastoff = 0;
 103   repo->rpmdbid = sat_free(repo->rpmdbid);
 104   for (i = 0; i < repo->nrepodata; i++)
 105     repodata_freedata(repo->repodata + i);
 106   repo->repodata = 0;
 107   repo->nrepodata = 0;
 108 }
 109
 110 /*
 111  * remove repo from pool, delete solvables
 112  *
 113  */
 114
 115 void
 116 repo_free(Repo *repo, int reuseids)
 117 {
 118   Pool *pool = repo->pool;
 119   int i;
 120
 121   repo_empty(repo, reuseids);
 122   for (i = 0; i < pool->nrepos; i++)    /* find repo in pool */
 123     if (pool->repos[i] == repo)
 124       break;
 125   if (i == pool->nrepos)               /* repo not in pool, return */
 126     return;
 127   if (i < pool->nrepos - 1)
 128     {
 129       memmove(pool->repos + i, pool->repos + i + 1, (pool->nrepos - 1 - i) * sizeof(Repo *));
 130       /* fix repo ids */
 131       for (; i < pool->nrepos - 1; i++)
 132         pool->repos[i]->repoid = i + 1;
 133     }
 134   pool->nrepos--;
 135   repo_freedata(repo);
 136 }
 137
 138 void
 139 repo_freeallrepos(Pool *pool, int reuseids)
 140 {
 141   int i;
 142
 143   pool_freewhatprovides(pool);
 144   for (i = 0; i < pool->nrepos; i++)
 145     repo_freedata(pool->repos[i]);
 146   pool->repos = sat_free(pool->repos);
 147   pool->nrepos = 0;
 148   /* the first two solvables don't belong to a repo */
 149   pool_free_solvable_block(pool, 2, pool->nsolvables - 2, reuseids);
 150 }
 151
 152 void repo_free_solvable_block(Repo *repo, Id start, int count, int reuseids)
 153 {
 154   Solvable *s;
 155   Repodata *data;
 156   int i;
 157   if (start + count == repo->end)
 158     repo->end -= count;
 159   repo->nsolvables -= count;
 160   for (s = repo->pool->solvables + start, i = count; i--; s++)
 161     s->repo = 0;
 162   pool_free_solvable_block(repo->pool, start, count, reuseids);
 163   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 164     if (data->end > repo->end)
 165       repodata_shrink(data, repo->end);
 166 }
 167
 168
 169 /* repository sidedata is solvable data allocated on demand.
 170  * It is used for data that is normally not present
 171  * in the solvable like the rpmdbid.
 172  * The solvable allocation funcions need to make sure that
 173  * the sidedata gets extended if new solvables get added.
 174  */
 175
 176 #define REPO_SIDEDATA_BLOCK 63
 177
 178 void *
 179 repo_sidedata_create(Repo *repo, size_t size)
 180 {
 181   return sat_calloc_block(repo->end - repo->start, size, REPO_SIDEDATA_BLOCK);
 182 }
 183
 184 void *
 185 repo_sidedata_extend(Repo *repo, void *b, size_t size, Id p, int count)
 186 {
 187   int n = repo->end - repo->start;
 188   if (p < repo->start)
 189     {
 190       int d = repo->start - p;
 191       b = sat_extend(b, n, d, size, REPO_SIDEDATA_BLOCK);
 192       memmove((char *)b + d * size, b, n * size);
 193       memset(b, 0, d * size);
 194       n += d;
 195     }
 196   if (p + count > repo->end)
 197     {
 198       int d = p + count - repo->end;
 199       b = sat_extend(b, n, d, size, REPO_SIDEDATA_BLOCK);
 200       memset((char *)b + n * size, 0, d * size);
 201     }
 202   return b;
 203 }
 204
 205 /*
 206  * add Id to idarraydata used to store dependencies
 207  * olddeps: old array offset to extend
 208  * returns new array offset
 209  */
 210
 211 Offset
 212 repo_addid(Repo *repo, Offset olddeps, Id id)
 213 {
 214   Id *idarray;
 215   int idarraysize;
 216   int i;
 217
 218   idarray = repo->idarraydata;
 219   idarraysize = repo->idarraysize;
 220
 221   if (!idarray)                        /* alloc idarray if not done yet */
 222     {
 223       idarraysize = 1;
 224       idarray = sat_extend_resize(0, 1, sizeof(Id), IDARRAY_BLOCK);
 225       idarray[0] = 0;
 226       repo->lastoff = 0;
 227     }
 228
 229   if (!olddeps)                         /* no deps yet */
 230     {
 231       olddeps = idarraysize;
 232       idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
 233     }
 234   else if (olddeps == repo->lastoff)    /* extend at end */
 235     idarraysize--;
 236   else                                  /* can't extend, copy old */
 237     {
 238       i = olddeps;
 239       olddeps = idarraysize;
 240       for (; idarray[i]; i++)
 241         {
 242           idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
 243           idarray[idarraysize++] = idarray[i];
 244         }
 245       idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
 246     }
 247
 248   idarray[idarraysize++] = id;          /* insert Id into array */
 249   idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
 250   idarray[idarraysize++] = 0;           /* ensure NULL termination */
 251
 252   repo->idarraydata = idarray;
 253   repo->idarraysize = idarraysize;
 254   repo->lastoff = olddeps;
 255
 256   return olddeps;
 257 }
 258
 259
 260 /*
 261  * add dependency (as Id) to repo, also unifies dependencies
 262  * olddeps = offset into idarraydata
 263  * marker= 0 for normal dep
 264  * marker > 0 add dep after marker
 265  * marker < 0 add dep after -marker
 266  * returns new start of dependency array
 267  */
 268 Offset
 269 repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker)
 270 {
 271   Id oid, *oidp, *markerp;
 272   int before;
 273
 274   if (!olddeps)
 275     {
 276       if (marker > 0)
 277         olddeps = repo_addid(repo, olddeps, marker);
 278       return repo_addid(repo, olddeps, id);
 279     }
 280
 281   if (!marker)
 282     {
 283       for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
 284         {
 285           if (oid == id)
 286             return olddeps;
 287         }
 288       return repo_addid(repo, olddeps, id);
 289     }
 290
 291   before = 0;
 292   markerp = 0;
 293   if (marker < 0)
 294     {
 295       before = 1;
 296       marker = -marker;
 297     }
 298   for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
 299     {
 300       if (oid == marker)
 301         markerp = oidp;
 302       else if (oid == id)
 303         break;
 304     }
 305
 306   if (oid)
 307     {
 308       if (markerp || before)
 309         return olddeps;
 310       /* we found it, but in the wrong half */
 311       markerp = oidp++;
 312       for (; (oid = *oidp) != ID_NULL; oidp++)
 313         if (oid == marker)
 314           break;
 315       if (!oid)
 316         {
 317           /* no marker in array yet */
 318           oidp--;
 319           if (markerp < oidp)
 320             memmove(markerp, markerp + 1, (oidp - markerp) * sizeof(Id));
 321           *oidp = marker;
 322           return repo_addid(repo, olddeps, id);
 323         }
 324       while (oidp[1])
 325         oidp++;
 326       memmove(markerp, markerp + 1, (oidp - markerp) * sizeof(Id));
 327       *oidp = id;
 328       return olddeps;
 329     }
 330   /* id not yet in array */
 331   if (!before && !markerp)
 332     olddeps = repo_addid(repo, olddeps, marker);
 333   else if (before && markerp)
 334     {
 335       *markerp++ = id;
 336       id = *--oidp;
 337       if (markerp < oidp)
 338         memmove(markerp + 1, markerp, (oidp - markerp) * sizeof(Id));
 339       *markerp = marker;
 340     }
 341   return repo_addid(repo, olddeps, id);
 342 }
 343
 344
 345 /*
 346  * reserve Ids
 347  * make space for 'num' more dependencies
 348  * returns new start of dependency array
 349  *
 350  * reserved ids will always begin at offset idarraysize
 351  */
 352
 353 Offset
 354 repo_reserve_ids(Repo *repo, Offset olddeps, int num)
 355 {
 356   num++;        /* room for trailing ID_NULL */
 357
 358   if (!repo->idarraysize)              /* ensure buffer space */
 359     {
 360       repo->idarraysize = 1;
 361       repo->idarraydata = sat_extend_resize(0, 1 + num, sizeof(Id), IDARRAY_BLOCK);
 362       repo->idarraydata[0] = 0;
 363       repo->lastoff = 1;
 364       return 1;
 365     }
 366
 367   if (olddeps && olddeps != repo->lastoff)   /* if not appending */
 368     {
 369       /* can't insert into idarray, this would invalidate all 'larger' offsets
 370        * so create new space at end and move existing deps there.
 371        * Leaving 'hole' at old position.
 372        */
 373
 374       Id *idstart, *idend;
 375       int count;
 376
 377       for (idstart = idend = repo->idarraydata + olddeps; *idend++; )   /* find end */
 378         ;
 379       count = idend - idstart - 1 + num;               /* new size */
 380
 381       repo->idarraydata = sat_extend(repo->idarraydata, repo->idarraysize, count, sizeof(Id), IDARRAY_BLOCK);
 382       /* move old deps to end */
 383       olddeps = repo->lastoff = repo->idarraysize;
 384       memcpy(repo->idarraydata + olddeps, idstart, count - num);
 385       repo->idarraysize = olddeps + count - num;
 386
 387       return olddeps;
 388     }
 389
 390   if (olddeps)                         /* appending */
 391     repo->idarraysize--;
 392
 393   /* make room*/
 394   repo->idarraydata = sat_extend(repo->idarraydata, repo->idarraysize, num, sizeof(Id), IDARRAY_BLOCK);
 395
 396   /* appending or new */
 397   repo->lastoff = olddeps ? olddeps : repo->idarraysize;
 398
 399   return repo->lastoff;
 400 }
 401
 402
 403
 404 Offset
 405 repo_fix_supplements(Repo *repo, Offset provides, Offset supplements, Offset freshens)
 406 {
 407   Pool *pool = repo->pool;
 408   Id id, idp, idl;
 409   char buf[1024], *p, *dep;
 410   int i, l;
 411
 412   if (provides)
 413     {
 414       for (i = provides; repo->idarraydata[i]; i++)
 415         {
 416           id = repo->idarraydata[i];
 417           if (ISRELDEP(id))
 418             continue;
 419           dep = (char *)id2str(pool, id);
 420           if (!strncmp(dep, "locale(", 7) && strlen(dep) < sizeof(buf) - 2)
 421             {
 422               idp = 0;
 423               strcpy(buf + 2, dep);
 424               dep = buf + 2 + 7;
 425               if ((p = strchr(dep, ':')) != 0 && p != dep)
 426                 {
 427                   *p++ = 0;
 428                   idp = str2id(pool, dep, 1);
 429                   dep = p;
 430                 }
 431               id = 0;
 432               while ((p = strchr(dep, ';')) != 0)
 433                 {
 434                   if (p == dep)
 435                     {
 436                       dep = p + 1;
 437                       continue;
 438                     }
 439                   *p++ = 0;
 440 #if 0
 441                   strncpy(dep - 9, "language:", 9);
 442                   idl = str2id(pool, dep - 9, 1);
 443 #else
 444                   idl = str2id(pool, dep, 1);
 445                   idl = rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1);
 446 #endif
 447                   if (id)
 448                     id = rel2id(pool, id, idl, REL_OR, 1);
 449                   else
 450                     id = idl;
 451                   dep = p;
 452                 }
 453               if (dep[0] && dep[1])
 454                 {
 455                   for (p = dep; *p && *p != ')'; p++)
 456                     ;
 457                   *p = 0;
 458 #if 0
 459                   strncpy(dep - 9, "language:", 9);
 460                   idl = str2id(pool, dep - 9, 1);
 461 #else
 462                   idl = str2id(pool, dep, 1);
 463                   idl = rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1);
 464 #endif
 465                   if (id)
 466                     id = rel2id(pool, id, idl, REL_OR, 1);
 467                   else
 468                     id = idl;
 469                 }
 470               if (idp)
 471                 id = rel2id(pool, idp, id, REL_AND, 1);
 472               if (id)
 473                 supplements = repo_addid_dep(repo, supplements, id, 0);
 474             }
 475           else if ((p = strchr(dep, ':')) != 0 && p != dep && p[1] == '/' && strlen(dep) < sizeof(buf))
 476             {
 477               strcpy(buf, dep);
 478               p = buf + (p - dep);
 479               *p++ = 0;
 480               idp = str2id(pool, buf, 1);
 481               /* strip trailing slashes */
 482               l = strlen(p);
 483               while (l > 1 && p[l - 1] == '/')
 484                 p[--l] = 0;
 485               id = str2id(pool, p, 1);
 486               id = rel2id(pool, idp, id, REL_WITH, 1);
 487               id = rel2id(pool, NAMESPACE_SPLITPROVIDES, id, REL_NAMESPACE, 1);
 488               supplements = repo_addid_dep(repo, supplements, id, 0);
 489             }
 490         }
 491     }
 492   if (supplements)
 493     {
 494       for (i = supplements; repo->idarraydata[i]; i++)
 495         {
 496           id = repo->idarraydata[i];
 497           if (ISRELDEP(id))
 498             continue;
 499           dep = (char *)id2str(pool, id);
 500           if (!strncmp(dep, "system:modalias(", 16))
 501             dep += 7;
 502           if (!strncmp(dep, "modalias(", 9) && dep[9] && dep[10] && strlen(dep) < sizeof(buf))
 503             {
 504               strcpy(buf, dep);
 505               p = strchr(buf + 9, ':');
 506               if (p && p != buf + 9 && strchr(p + 1, ':'))
 507                 {
 508                   *p++ = 0;
 509                   idp = str2id(pool, buf + 9, 1);
 510                   p[strlen(p) - 1] = 0;
 511                   id = str2id(pool, p, 1);
 512                   id = rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1);
 513                   id = rel2id(pool, idp, id, REL_AND, 1);
 514                 }
 515               else
 516                 {
 517                   p = buf + 9;
 518                   p[strlen(p) - 1] = 0;
 519                   id = str2id(pool, p, 1);
 520                   id = rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1);
 521                 }
 522               if (id)
 523                 repo->idarraydata[i] = id;
 524             }
 525           else if (!strncmp(dep, "packageand(", 11) && strlen(dep) < sizeof(buf))
 526             {
 527               strcpy(buf, dep);
 528               id = 0;
 529               dep = buf + 11;
 530               while ((p = strchr(dep, ':')) != 0)
 531                 {
 532                   if (p == dep)
 533                     {
 534                       dep = p + 1;
 535                       continue;
 536                     }
 537                   *p++ = 0;
 538                   idp = str2id(pool, dep, 1);
 539                   if (id)
 540                     id = rel2id(pool, id, idp, REL_AND, 1);
 541                   else
 542                     id = idp;
 543                   dep = p;
 544                 }
 545               if (dep[0] && dep[1])
 546                 {
 547                   dep[strlen(dep) - 1] = 0;
 548                   idp = str2id(pool, dep, 1);
 549                   if (id)
 550                     id = rel2id(pool, id, idp, REL_AND, 1);
 551                   else
 552                     id = idp;
 553                 }
 554               if (id)
 555                 repo->idarraydata[i] = id;
 556             }
 557           else if (!strncmp(dep, "filesystem(", 11) && strlen(dep) < sizeof(buf))
 558             {
 559               strcpy(buf, dep + 11);
 560               if ((p = strrchr(buf, ')')) != 0)
 561                 *p = 0;
 562               id = str2id(pool, buf, 1);
 563               id = rel2id(pool, NAMESPACE_FILESYSTEM, id, REL_NAMESPACE, 1);
 564               repo->idarraydata[i] = id;
 565             }
 566         }
 567     }
 568   if (freshens && repo->idarraydata[freshens])
 569     {
 570       Id idsupp = 0, idfresh = 0;
 571       if (!supplements)
 572         return freshens;
 573       for (i = supplements; repo->idarraydata[i]; i++)
 574         {
 575           if (!idsupp)
 576             idsupp = repo->idarraydata[i];
 577           else
 578             idsupp = rel2id(pool, idsupp, repo->idarraydata[i], REL_OR, 1);
 579         }
 580       for (i = freshens; repo->idarraydata[i]; i++)
 581         {
 582           if (!idfresh)
 583             idfresh = repo->idarraydata[i];
 584           else
 585             idfresh = rel2id(pool, idfresh, repo->idarraydata[i], REL_OR, 1);
 586         }
 587       if (!idsupp)
 588         idsupp = idfresh;
 589       else
 590         idsupp = rel2id(pool, idsupp, idfresh, REL_AND, 1);
 591       supplements = repo_addid_dep(repo, 0, idsupp, 0);
 592     }
 593   return supplements;
 594 }
 595
 596 Offset
 597 repo_fix_conflicts(Repo *repo, Offset conflicts)
 598 {
 599   char buf[1024], *p, *dep;
 600   Pool *pool = repo->pool;
 601   Id id;
 602   int i;
 603
 604   if (!conflicts)
 605     return conflicts;
 606   for (i = conflicts; repo->idarraydata[i]; i++)
 607     {
 608       id = repo->idarraydata[i];
 609       if (ISRELDEP(id))
 610         continue;
 611       dep = (char *)id2str(pool, id);
 612       if (!strncmp(dep, "otherproviders(", 15) && strlen(dep) < sizeof(buf) - 2)
 613         {
 614           strcpy(buf, dep + 15);
 615           if ((p = strchr(buf, ')')) != 0)
 616             *p = 0;
 617           id = str2id(pool, buf, 1);
 618           id = rel2id(pool, NAMESPACE_OTHERPROVIDERS, id, REL_NAMESPACE, 1);
 619           repo->idarraydata[i] = id;
 620         }
 621     }
 622   return conflicts;
 623 }
 624
 625 struct matchdata
 626 {
 627   Pool *pool;
 628   int flags;
 629   Datamatcher matcher;
 630   int stop;
 631   int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv);
 632   void *callback_data;
 633 };
 634
 635 int
 636 repo_matchvalue(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv)
 637 {
 638   struct matchdata *md = cbdata;
 639
 640   if (md->matcher.match)
 641     {
 642       if (!repodata_stringify(md->pool, data, key, kv, md->flags))
 643         return 0;
 644       if (!datamatcher_match(&md->matcher, kv->str))
 645         return 0;
 646     }
 647   md->stop = md->callback(md->callback_data, s, data, key, kv);
 648   return md->stop;
 649 }
 650
 651
 652 static Repokey solvablekeys[RPM_RPMDBID - SOLVABLE_NAME + 1] = {
 653   { SOLVABLE_NAME,        REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 654   { SOLVABLE_ARCH,        REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 655   { SOLVABLE_EVR,         REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 656   { SOLVABLE_VENDOR,      REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
 657   { SOLVABLE_PROVIDES,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 658   { SOLVABLE_OBSOLETES,   REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 659   { SOLVABLE_CONFLICTS,   REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 660   { SOLVABLE_REQUIRES,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 661   { SOLVABLE_RECOMMENDS,  REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 662   { SOLVABLE_SUGGESTS,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 663   { SOLVABLE_SUPPLEMENTS, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 664   { SOLVABLE_ENHANCES,    REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
 665   { RPM_RPMDBID,          REPOKEY_TYPE_U32, 0, KEY_STORAGE_SOLVABLE },
 666 };
 667
 668 static void
 669 domatch_idarray(Solvable *s, Id keyname, struct matchdata *md, Id *ida)
 670 {
 671   KeyValue kv;
 672   kv.entry = 0;
 673   kv.parent = 0;
 674   for (; *ida && !md->stop; ida++)
 675     {
 676       kv.id = *ida;
 677       kv.eof = ida[1] ? 0 : 1;
 678       repo_matchvalue(md, s, 0, solvablekeys + (keyname - SOLVABLE_NAME), &kv);
 679       kv.entry++;
 680     }
 681 }
 682
 683 static void
 684 repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md)
 685 {
 686   KeyValue kv;
 687   Pool *pool = repo->pool;
 688   Repodata *data;
 689   int i, j, flags;
 690   Solvable *s;
 691
 692   kv.parent = 0;
 693   md->stop = 0;
 694   if (!p)
 695     {
 696       for (p = repo->start, s = repo->pool->solvables + p; p < repo->end; p++, s++)
 697         {
 698           if (s->repo == repo)
 699             repo_search_md(repo, p, keyname, md);
 700           if (md->stop > SEARCH_NEXT_SOLVABLE)
 701             break;
 702         }
 703       return;
 704     }
 705   else if (p < 0)
 706     /* The callback only supports solvables, so we can't iterate over the
 707        extra things.  */
 708     return;
 709   flags = md->flags;
 710   if (!(flags & SEARCH_NO_STORAGE_SOLVABLE))
 711     {
 712       s = pool->solvables + p;
 713       switch(keyname)
 714         {
 715           case 0:
 716           case SOLVABLE_NAME:
 717             if (s->name)
 718               {
 719                 kv.id = s->name;
 720                 repo_matchvalue(md, s, 0, solvablekeys + 0, &kv);
 721               }
 722             if (keyname || md->stop > SEARCH_NEXT_KEY)
 723               return;
 724           case SOLVABLE_ARCH:
 725             if (s->arch)
 726               {
 727                 kv.id = s->arch;
 728                 repo_matchvalue(md, s, 0, solvablekeys + 1, &kv);
 729               }
 730             if (keyname || md->stop > SEARCH_NEXT_KEY)
 731               return;
 732           case SOLVABLE_EVR:
 733             if (s->evr)
 734               {
 735                 kv.id = s->evr;
 736                 repo_matchvalue(md, s, 0, solvablekeys + 2, &kv);
 737               }
 738             if (keyname || md->stop > SEARCH_NEXT_KEY)
 739               return;
 740           case SOLVABLE_VENDOR:
 741             if (s->vendor)
 742               {
 743                 kv.id = s->vendor;
 744                 repo_matchvalue(md, s, 0, solvablekeys + 3, &kv);
 745               }
 746             if (keyname || md->stop > SEARCH_NEXT_KEY)
 747               return;
 748           case SOLVABLE_PROVIDES:
 749             if (s->provides)
 750               domatch_idarray(s, SOLVABLE_PROVIDES, md, repo->idarraydata + s->provides);
 751             if (keyname || md->stop > SEARCH_NEXT_KEY)
 752               return;
 753           case SOLVABLE_OBSOLETES:
 754             if (s->obsoletes)
 755               domatch_idarray(s, SOLVABLE_OBSOLETES, md, repo->idarraydata + s->obsoletes);
 756             if (keyname || md->stop > SEARCH_NEXT_KEY)
 757               return;
 758           case SOLVABLE_CONFLICTS:
 759             if (s->conflicts)
 760               domatch_idarray(s, SOLVABLE_CONFLICTS, md, repo->idarraydata + s->conflicts);
 761             if (keyname || md->stop > SEARCH_NEXT_KEY)
 762               return;
 763           case SOLVABLE_REQUIRES:
 764             if (s->requires)
 765               domatch_idarray(s, SOLVABLE_REQUIRES, md, repo->idarraydata + s->requires);
 766             if (keyname || md->stop > SEARCH_NEXT_KEY)
 767               return;
 768           case SOLVABLE_RECOMMENDS:
 769             if (s->recommends)
 770               domatch_idarray(s, SOLVABLE_RECOMMENDS, md, repo->idarraydata + s->recommends);
 771             if (keyname || md->stop > SEARCH_NEXT_KEY)
 772               return;
 773           case SOLVABLE_SUPPLEMENTS:
 774             if (s->supplements)
 775               domatch_idarray(s, SOLVABLE_SUPPLEMENTS, md, repo->idarraydata + s->supplements);
 776             if (keyname || md->stop > SEARCH_NEXT_KEY)
 777               return;
 778           case SOLVABLE_SUGGESTS:
 779             if (s->suggests)
 780               domatch_idarray(s, SOLVABLE_SUGGESTS, md, repo->idarraydata + s->suggests);
 781             if (keyname || md->stop > SEARCH_NEXT_KEY)
 782               return;
 783           case SOLVABLE_ENHANCES:
 784             if (s->enhances)
 785               domatch_idarray(s, SOLVABLE_ENHANCES, md, repo->idarraydata + s->enhances);
 786             if (keyname || md->stop > SEARCH_NEXT_KEY)
 787               return;
 788           case RPM_RPMDBID:
 789             if (repo->rpmdbid)
 790               {
 791                 kv.num = repo->rpmdbid[p - repo->start];
 792                 repo_matchvalue(md, s, 0, solvablekeys + (RPM_RPMDBID - SOLVABLE_NAME), &kv);
 793               }
 794             if (keyname || md->stop > SEARCH_NEXT_KEY)
 795               return;
 796             break;
 797           default:
 798             break;
 799         }
 800     }
 801
 802   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 803     {
 804       if (p < data->start || p >= data->end)
 805         continue;
 806       if (keyname && !repodata_precheck_keyname(data, keyname))
 807         continue;
 808       if (keyname == SOLVABLE_FILELIST && !(md->flags & SEARCH_COMPLETE_FILELIST))
 809         {
 810           /* do not search filelist extensions */
 811           if (data->state != REPODATA_AVAILABLE)
 812             continue;
 813           for (j = 1; j < data->nkeys; j++)
 814             if (data->keys[j].name != REPOSITORY_SOLVABLES && data->keys[j].name != SOLVABLE_FILELIST)
 815               break;
 816           if (j == data->nkeys)
 817             continue;
 818         }
 819       if (data->state == REPODATA_STUB)
 820         {
 821           if (keyname)
 822             {
 823               for (j = 1; j < data->nkeys; j++)
 824                 if (keyname == data->keys[j].name)
 825                   break;
 826               if (j == data->nkeys)
 827                 continue;
 828             }
 829           /* load it */
 830           if (data->loadcallback)
 831             data->loadcallback(data);
 832           else
 833             data->state = REPODATA_ERROR;
 834         }
 835       if (data->state == REPODATA_ERROR)
 836         continue;
 837       repodata_search(data, p, keyname, md->flags, repo_matchvalue, md);
 838       if (md->stop > SEARCH_NEXT_KEY)
 839         break;
 840     }
 841 }
 842
 843 void
 844 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)
 845 {
 846   struct matchdata md;
 847
 848   if (repo->disabled && !(flags & SEARCH_DISABLED_REPOS))
 849     return;
 850   memset(&md, 0, sizeof(md));
 851   md.pool = repo->pool;
 852   md.flags = flags;
 853   md.callback = callback;
 854   md.callback_data = cbdata;
 855   if (match)
 856     datamatcher_init(&md.matcher, match, flags);
 857   repo_search_md(repo, p, keyname, &md);
 858   if (match)
 859     datamatcher_free(&md.matcher);
 860 }
 861
 862 const char *
 863 repo_lookup_str(Repo *repo, Id entry, Id keyname)
 864 {
 865   Pool *pool = repo->pool;
 866   Repodata *data;
 867   int i, j;
 868
 869   switch(keyname)
 870     {
 871     case SOLVABLE_NAME:
 872       return id2str(pool, pool->solvables[entry].name);
 873     case SOLVABLE_ARCH:
 874       return id2str(pool, pool->solvables[entry].arch);
 875     case SOLVABLE_EVR:
 876       return id2str(pool, pool->solvables[entry].evr);
 877     case SOLVABLE_VENDOR:
 878       return id2str(pool, pool->solvables[entry].vendor);
 879     }
 880   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 881     {
 882       if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
 883         continue;
 884       if (!repodata_precheck_keyname(data, keyname))
 885         continue;
 886       for (j = 1; j < data->nkeys; j++)
 887         {
 888           if (data->keys[j].name == keyname && (data->keys[j].type == REPOKEY_TYPE_ID || data->keys[j].type == REPOKEY_TYPE_CONSTANTID || data->keys[j].type == REPOKEY_TYPE_STR))
 889             return repodata_lookup_str(data, entry, keyname);
 890         }
 891     }
 892   return 0;
 893 }
 894
 895
 896 unsigned int
 897 repo_lookup_num(Repo *repo, Id entry, Id keyname, unsigned int notfound)
 898 {
 899   Repodata *data;
 900   int i, j;
 901
 902   if (keyname == RPM_RPMDBID)
 903     {
 904       if (repo->rpmdbid && entry >= repo->start && entry < repo->end)
 905         return repo->rpmdbid[entry - repo->start];
 906       return notfound;
 907     }
 908   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 909     {
 910       if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
 911         continue;
 912       if (!repodata_precheck_keyname(data, keyname))
 913         continue;
 914       for (j = 1; j < data->nkeys; j++)
 915         {
 916           if (data->keys[j].name == keyname
 917               && (data->keys[j].type == REPOKEY_TYPE_U32
 918                   || data->keys[j].type == REPOKEY_TYPE_NUM
 919                   || data->keys[j].type == REPOKEY_TYPE_CONSTANT))
 920             {
 921               unsigned value;
 922               if (repodata_lookup_num(data, entry, keyname, &value))
 923                 return value;
 924             }
 925         }
 926     }
 927   return notfound;
 928 }
 929
 930 Id
 931 repo_lookup_id(Repo *repo, Id entry, Id keyname)
 932 {
 933   Repodata *data;
 934   int i, j;
 935
 936   switch(keyname)
 937     {
 938     case SOLVABLE_NAME:
 939       return repo->pool->solvables[entry].name;
 940     case SOLVABLE_ARCH:
 941       return repo->pool->solvables[entry].arch;
 942     case SOLVABLE_EVR:
 943       return repo->pool->solvables[entry].evr;
 944     case SOLVABLE_VENDOR:
 945       return repo->pool->solvables[entry].vendor;
 946     }
 947   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 948     {
 949       if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
 950         continue;
 951       if (!repodata_precheck_keyname(data, keyname))
 952         continue;
 953       for (j = 1; j < data->nkeys; j++)
 954         {
 955           if (data->keys[j].name == keyname && (data->keys[j].type == REPOKEY_TYPE_ID || data->keys[j].type == REPOKEY_TYPE_CONSTANTID))
 956             {
 957               Id id = repodata_lookup_id(data, entry, keyname);
 958               if (id)
 959                 return data->localpool ? repodata_globalize_id(data, id, 1) : id;
 960             }
 961         }
 962     }
 963   return 0;
 964 }
 965
 966 const unsigned char *
 967 repo_lookup_bin_checksum(Repo *repo, Id entry, Id keyname, Id *typep)
 968 {
 969   Repodata *data;
 970   int i, j;
 971   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 972     {
 973       if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
 974         continue;
 975       if (!repodata_precheck_keyname(data, keyname))
 976         continue;
 977       for (j = 1; j < data->nkeys; j++)
 978         {
 979           if (data->keys[j].name == keyname)
 980             {
 981               const unsigned char *chk = repodata_lookup_bin_checksum(data, entry, keyname, typep);
 982               if (chk)
 983                 return chk;
 984             }
 985         }
 986     }
 987   *typep = 0;
 988   return 0;
 989 }
 990
 991 int
 992 repo_lookup_void(Repo *repo, Id entry, Id keyname)
 993 {
 994   Repodata *data;
 995   int i, j;
 996   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 997     {
 998       if (entry != SOLVID_META && (entry < data->start || entry >= data->end))
 999         continue;
1000       if (!repodata_precheck_keyname(data, keyname))
1001         continue;
1002       for (j = 1; j < data->nkeys; j++)
1003         {
1004           if (data->keys[j].name == keyname
1005               && (data->keys[j].type == REPOKEY_TYPE_VOID))
1006             {
1007               if (repodata_lookup_void(data, entry, keyname))
1008                 return 1;
1009             }
1010         }
1011     }
1012   return 0;
1013 }
1014
1015 /***********************************************************************/
1016
1017 Repodata *
1018 repo_add_repodata(Repo *repo, int flags)
1019 {
1020   int i;
1021   if ((flags & REPO_USE_LOADING) != 0)
1022     {
1023       for (i = repo->nrepodata - 1; i >= 0; i--)
1024         if (repo->repodata[i].state == REPODATA_LOADING)
1025           {
1026             Repodata *data = repo->repodata + i;
1027             /* re-init */
1028             /* hack: we mis-use REPO_REUSE_REPODATA here */
1029             if (!(flags & REPO_REUSE_REPODATA))
1030               {
1031                 repodata_freedata(data);
1032                 repodata_initdata(data, repo, (flags & REPO_LOCALPOOL) ? 1 : 0);
1033               }
1034             return data;
1035           }
1036       return 0; /* must not create a new repodata! */
1037     }
1038   if ((flags & REPO_REUSE_REPODATA) != 0)
1039     {
1040       for (i = repo->nrepodata - 1; i >= 0; i--)
1041         if (repo->repodata[i].state != REPODATA_STUB)
1042           return repo->repodata + i;
1043     }
1044   return repodata_create(repo, (flags & REPO_LOCALPOOL) ? 1 : 0);
1045 }
1046
1047 Repodata *
1048 repo_last_repodata(Repo *repo)
1049 {
1050   int i;
1051   for (i = repo->nrepodata - 1; i >= 0; i--)
1052     if (repo->repodata[i].state != REPODATA_STUB)
1053       return repo->repodata + i;
1054   return repo_add_repodata(repo, 0);
1055 }
1056
1057 void
1058 repo_set_id(Repo *repo, Id p, Id keyname, Id id)
1059 {
1060   Repodata *data = repo_last_repodata(repo);
1061   repodata_set_id(data, p, keyname, id);
1062 }
1063
1064 void
1065 repo_set_num(Repo *repo, Id p, Id keyname, Id num)
1066 {
1067   Repodata *data = repo_last_repodata(repo);
1068   repodata_set_num(data, p, keyname, num);
1069 }
1070
1071 void
1072 repo_set_str(Repo *repo, Id p, Id keyname, const char *str)
1073 {
1074   Repodata *data = repo_last_repodata(repo);
1075   repodata_set_str(data, p, keyname, str);
1076 }
1077
1078 void
1079 repo_set_poolstr(Repo *repo, Id p, Id keyname, const char *str)
1080 {
1081   Repodata *data = repo_last_repodata(repo);
1082   repodata_set_poolstr(data, p, keyname, str);
1083 }
1084
1085 void
1086 repo_add_poolstr_array(Repo *repo, Id p, Id keyname, const char *str)
1087 {
1088   Repodata *data = repo_last_repodata(repo);
1089   repodata_add_poolstr_array(data, p, keyname, str);
1090 }
1091
1092 void
1093 repo_internalize(Repo *repo)
1094 {
1095   int i;
1096   Repodata *data;
1097
1098   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
1099     if (data->attrs || data->xattrs)
1100       repodata_internalize(data);
1101 }
1102
1103 void
1104 repo_disable_paging(Repo *repo)
1105 {
1106   int i;
1107   Repodata *data;
1108
1109   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
1110     repodata_disable_paging(data);
1111 }
1112 // EOF
1113 /*
1114 vim:cinoptions={.5s,g0,p5,t0,(0,^-0.5s,n-0.5s:tw=78:cindent:sw=4:
1115 */