src/repo.c

   1 /*
   2  * Copyright (c) 2007, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * repo.c
  10  *
  11  * Manage metadata coming from one repository
  12  *
  13  */
  14
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18
  19 #include "repo.h"
  20 #include "pool.h"
  21 #include "poolid_private.h"
  22 #include "util.h"
  23 #include "attr_store_p.h"
  24
  25 #define IDARRAY_BLOCK     4095
  26
  27
  28 /*
  29  * create empty repo
  30  * and add to pool
  31  */
  32
  33 Repo *
  34 repo_create(Pool *pool, const char *name)
  35 {
  36   Repo *repo;
  37
  38   pool_freewhatprovides(pool);
  39   repo = (Repo *)xcalloc(1, sizeof(*repo));
  40   pool->repos = (Repo **)xrealloc(pool->repos, (pool->nrepos + 1) * sizeof(Repo *));
  41   pool->repos[pool->nrepos++] = repo;
  42   repo->name = name ? strdup(name) : 0;
  43   repo->pool = pool;
  44   repo->start = pool->nsolvables;
  45   repo->end = pool->nsolvables;
  46   repo->nsolvables = 0;
  47   return repo;
  48 }
  49
  50 static void
  51 repo_freedata(Repo *repo)
  52 {
  53   xfree(repo->idarraydata);
  54   xfree(repo->rpmdbid);
  55   xfree((char *)repo->name);
  56   xfree(repo);
  57 }
  58
  59 /*
  60  * add Id to repo
  61  * olddeps = old array to extend
  62  *
  63  */
  64
  65 Offset
  66 repo_addid(Repo *repo, Offset olddeps, Id id)
  67 {
  68   Id *idarray;
  69   int idarraysize;
  70   int i;
  71
  72   idarray = repo->idarraydata;
  73   idarraysize = repo->idarraysize;
  74
  75   if (!idarray)                        /* alloc idarray if not done yet */
  76     {
  77       idarray = (Id *)xmalloc((1 + IDARRAY_BLOCK) * sizeof(Id));
  78       idarray[0] = 0;
  79       idarraysize = 1;
  80       repo->lastoff = 0;
  81     }
  82
  83   if (!olddeps)                         /* no deps yet */
  84     {
  85       olddeps = idarraysize;
  86       if ((idarraysize & IDARRAY_BLOCK) == 0)
  87         idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
  88     }
  89   else if (olddeps == repo->lastoff)    /* extend at end */
  90     idarraysize--;
  91   else                                  /* can't extend, copy old */
  92     {
  93       i = olddeps;
  94       olddeps = idarraysize;
  95       for (; idarray[i]; i++)
  96         {
  97           if ((idarraysize & IDARRAY_BLOCK) == 0)
  98             idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
  99           idarray[idarraysize++] = idarray[i];
 100         }
 101       if ((idarraysize & IDARRAY_BLOCK) == 0)
 102         idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
 103     }
 104
 105   idarray[idarraysize++] = id;          /* insert Id into array */
 106
 107   if ((idarraysize & IDARRAY_BLOCK) == 0)   /* realloc if at block boundary */
 108     idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id));
 109
 110   idarray[idarraysize++] = 0;           /* ensure NULL termination */
 111
 112   repo->idarraydata = idarray;
 113   repo->idarraysize = idarraysize;
 114   repo->lastoff = olddeps;
 115
 116   return olddeps;
 117 }
 118
 119
 120 /*
 121  * add dependency (as Id) to repo
 122  * olddeps = offset into idarraydata
 123  * isreq = 0 for normal dep
 124  * isreq = 1 for requires
 125  * isreq = 2 for pre-requires
 126  *
 127  */
 128
 129 Offset
 130 repo_addid_dep(Repo *repo, Offset olddeps, Id id, int isreq)
 131 {
 132   Id oid, *oidp, *marker = 0;
 133
 134   if (!olddeps)
 135     return repo_addid(repo, olddeps, id);
 136
 137   if (!isreq)
 138     {
 139       for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
 140         {
 141           if (oid == id)
 142             return olddeps;
 143         }
 144       return repo_addid(repo, olddeps, id);
 145     }
 146
 147   for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
 148     {
 149       if (oid == SOLVABLE_PREREQMARKER)
 150         marker = oidp;
 151       else if (oid == id)
 152         break;
 153     }
 154
 155   if (oid)
 156     {
 157       if (marker || isreq == 1)
 158         return olddeps;
 159       marker = oidp++;
 160       for (; (oid = *oidp) != ID_NULL; oidp++)
 161         if (oid == SOLVABLE_PREREQMARKER)
 162           break;
 163       if (!oid)
 164         {
 165           oidp--;
 166           if (marker < oidp)
 167             memmove(marker, marker + 1, (oidp - marker) * sizeof(Id));
 168           *oidp = SOLVABLE_PREREQMARKER;
 169           return repo_addid(repo, olddeps, id);
 170         }
 171       while (oidp[1])
 172         oidp++;
 173       memmove(marker, marker + 1, (oidp - marker) * sizeof(Id));
 174       *oidp = id;
 175       return olddeps;
 176     }
 177   if (isreq == 2 && !marker)
 178     olddeps = repo_addid(repo, olddeps, SOLVABLE_PREREQMARKER);
 179   else if (isreq == 1 && marker)
 180     {
 181       *marker++ = id;
 182       id = *--oidp;
 183       if (marker < oidp)
 184         memmove(marker + 1, marker, (oidp - marker) * sizeof(Id));
 185       *marker = SOLVABLE_PREREQMARKER;
 186     }
 187   return repo_addid(repo, olddeps, id);
 188 }
 189
 190
 191 /*
 192  * reserve Ids
 193  * make space for 'num' more dependencies
 194  */
 195
 196 Offset
 197 repo_reserve_ids(Repo *repo, Offset olddeps, int num)
 198 {
 199   num++;        /* room for trailing ID_NULL */
 200
 201   if (!repo->idarraysize)              /* ensure buffer space */
 202     {
 203       repo->idarraysize = 1;
 204       repo->idarraydata = (Id *)xmalloc(((1 + num + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id));
 205       repo->idarraydata[0] = 0;
 206       repo->lastoff = 1;
 207       return 1;
 208     }
 209
 210   if (olddeps && olddeps != repo->lastoff)   /* if not appending */
 211     {
 212       /* can't insert into idarray, this would invalidate all 'larger' offsets
 213        * so create new space at end and move existing deps there.
 214        * Leaving 'hole' at old position.
 215        */
 216
 217       Id *idstart, *idend;
 218       int count;
 219
 220       for (idstart = idend = repo->idarraydata + olddeps; *idend++; )   /* find end */
 221         ;
 222       count = idend - idstart - 1 + num;               /* new size */
 223
 224       /* realloc if crossing block boundary */
 225       if (((repo->idarraysize - 1) | IDARRAY_BLOCK) != ((repo->idarraysize + count - 1) | IDARRAY_BLOCK))
 226         repo->idarraydata = (Id *)xrealloc(repo->idarraydata, ((repo->idarraysize + count + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id));
 227
 228       /* move old deps to end */
 229       olddeps = repo->lastoff = repo->idarraysize;
 230       memcpy(repo->idarraydata + olddeps, idstart, count - num);
 231       repo->idarraysize = olddeps + count - num;
 232
 233       return olddeps;
 234     }
 235
 236   if (olddeps)                         /* appending */
 237     repo->idarraysize--;
 238
 239   /* realloc if crossing block boundary */
 240   if (((repo->idarraysize - 1) | IDARRAY_BLOCK) != ((repo->idarraysize + num - 1) | IDARRAY_BLOCK))
 241     repo->idarraydata = (Id *)xrealloc(repo->idarraydata, ((repo->idarraysize + num + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id));
 242
 243   /* appending or new */
 244   repo->lastoff = olddeps ? olddeps : repo->idarraysize;
 245
 246   return repo->lastoff;
 247 }
 248
 249
 250 /*
 251  * remove repo from pool, zero out solvables
 252  *
 253  */
 254
 255 void
 256 repo_free(Repo *repo, int reuseids)
 257 {
 258   Pool *pool = repo->pool;
 259   Solvable *s;
 260   int i;
 261
 262   pool_freewhatprovides(pool);
 263
 264   if (reuseids && repo->end == pool->nsolvables)
 265     {
 266       /* it's ok to reuse the ids. As this is the last repo, we can
 267          just shrink the solvable array */
 268       for (i = repo->end - 1, s = pool->solvables + i; i >= repo->start; i--, s--)
 269         if (s->repo != repo)
 270           break;
 271       repo->end = i + 1;
 272       pool->nsolvables = i + 1;
 273     }
 274   /* zero out solvables belonging to this repo */
 275   for (i = repo->start, s = pool->solvables + i; i < repo->end; i++, s++)
 276     if (s->repo == repo)
 277       memset(s, 0, sizeof(*s));
 278   for (i = 0; i < pool->nrepos; i++)    /* find repo in pool */
 279     if (pool->repos[i] == repo)
 280       break;
 281   if (i == pool->nrepos)               /* repo not in pool, return */
 282     return;
 283   if (i < pool->nrepos - 1)
 284     memmove(pool->repos + i, pool->repos + i + 1, (pool->nrepos - 1 - i) * sizeof(Repo *));
 285   pool->nrepos--;
 286   repo_freedata(repo);
 287 }
 288
 289 void
 290 repo_freeallrepos(Pool *pool, int reuseids)
 291 {
 292   int i;
 293
 294   pool_freewhatprovides(pool);
 295   for (i = 0; i < pool->nrepos; i++)
 296     repo_freedata(pool->repos[i]);
 297   pool->repos = xfree(pool->repos);
 298   pool->nrepos = 0;
 299   /* the first two solvables don't belong to a repo */
 300   pool_free_solvable_block(pool, 2, pool->nsolvables - 2, reuseids);
 301 }
 302
 303 Offset
 304 repo_fix_legacy(Repo *repo, Offset provides, Offset supplements)
 305 {
 306   Pool *pool = repo->pool;
 307   Id id, idp, idl, idns;
 308   char buf[1024], *p, *dep;
 309   int i;
 310
 311   if (provides)
 312     {
 313       for (i = provides; repo->idarraydata[i]; i++)
 314         {
 315           id = repo->idarraydata[i];
 316           if (ISRELDEP(id))
 317             continue;
 318           dep = (char *)id2str(pool, id);
 319           if (!strncmp(dep, "locale(", 7) && strlen(dep) < sizeof(buf) - 2)
 320             {
 321               idp = 0;
 322               strcpy(buf + 2, dep);
 323               dep = buf + 2 + 7;
 324               if ((p = strchr(dep, ':')) != 0 && p != dep)
 325                 {
 326                   *p++ = 0;
 327                   idp = str2id(pool, dep, 1);
 328                   dep = p;
 329                 }
 330               id = 0;
 331               while ((p = strchr(dep, ';')) != 0)
 332                 {
 333                   if (p == dep)
 334                     {
 335                       dep = p + 1;
 336                       continue;
 337                     }
 338                   strncpy(dep - 9, "language:", 9);
 339                   *p++ = 0;
 340                   idl = str2id(pool, dep - 9, 1);
 341                   if (id)
 342                     id = rel2id(pool, id, idl, REL_OR, 1);
 343                   else
 344                     id = idl;
 345                   dep = p;
 346                 }
 347               if (dep[0] && dep[1])
 348                 {
 349                   for (p = dep; *p && *p != ')'; p++)
 350                     ;
 351                   *p = 0;
 352                   strncpy(dep - 9, "language:", 9);
 353                   idl = str2id(pool, dep - 9, 1);
 354                   if (id)
 355                     id = rel2id(pool, id, idl, REL_OR, 1);
 356                   else
 357                     id = idl;
 358                 }
 359               if (idp)
 360                 id = rel2id(pool, idp, id, REL_AND, 1);
 361               if (id)
 362                 supplements = repo_addid_dep(repo, supplements, id, 0);
 363             }
 364           else if ((p = strchr(dep, ':')) != 0 && p != dep && p[1] == '/' && strlen(dep) < sizeof(buf))
 365             {
 366               strcpy(buf, dep);
 367               p = buf + (p - dep);
 368               *p++ = 0;
 369               idp = str2id(pool, buf, 1);
 370               idns = str2id(pool, "namespace:installed", 1);
 371               id = str2id(pool, p, 1);
 372               id = rel2id(pool, idns, id, REL_NAMESPACE, 1);
 373               id = rel2id(pool, idp, id, REL_AND, 1);
 374               supplements = repo_addid_dep(repo, supplements, id, 0);
 375             }
 376         }
 377     }
 378   if (!supplements)
 379     return 0;
 380   for (i = supplements; repo->idarraydata[i]; i++)
 381     {
 382       id = repo->idarraydata[i];
 383       if (ISRELDEP(id))
 384         continue;
 385       dep = (char *)id2str(pool, id);
 386       if (!strncmp(dep, "system:modalias(", 16))
 387         dep += 7;
 388       if (!strncmp(dep, "modalias(", 9) && dep[9] && dep[10] && strlen(dep) < sizeof(buf))
 389         {
 390           strcpy(buf, dep);
 391           p = strchr(buf + 9, ':');
 392           idns = str2id(pool, "namespace:modalias", 1);
 393           if (p && p != buf + 9 && strchr(p + 1, ':'))
 394             {
 395               *p++ = 0;
 396               idp = str2id(pool, buf + 9, 1);
 397               p[strlen(p) - 1] = 0;
 398               id = str2id(pool, p, 1);
 399               id = rel2id(pool, idns, id, REL_NAMESPACE, 1);
 400               id = rel2id(pool, idp, id, REL_AND, 1);
 401             }
 402           else
 403             {
 404               p = buf + 9;
 405               p[strlen(p) - 1] = 0;
 406               id = str2id(pool, p, 1);
 407               id = rel2id(pool, idns, id, REL_NAMESPACE, 1);
 408             }
 409           if (id)
 410             repo->idarraydata[i] = id;
 411         }
 412       else if (!strncmp(dep, "packageand(", 11) && strlen(dep) < sizeof(buf))
 413         {
 414           strcpy(buf, dep);
 415           id = 0;
 416           dep = buf + 11;
 417           while ((p = strchr(dep, ':')) != 0)
 418             {
 419               if (p == dep)
 420                 {
 421                   dep = p + 1;
 422                   continue;
 423                 }
 424               *p++ = 0;
 425               idp = str2id(pool, dep, 1);
 426               if (id)
 427                 id = rel2id(pool, id, idp, REL_AND, 1);
 428               else
 429                 id = idp;
 430               dep = p;
 431             }
 432           if (dep[0] && dep[1])
 433             {
 434               dep[strlen(dep) - 1] = 0;
 435               idp = str2id(pool, dep, 1);
 436               if (id)
 437                 id = rel2id(pool, id, idp, REL_AND, 1);
 438               else
 439                 id = idp;
 440             }
 441           if (id)
 442             repo->idarraydata[i] = id;
 443         }
 444     }
 445   return supplements;
 446 }
 447
 448 #if 0
 449 void
 450 repodata_search(Repodata *data, Id key)
 451 {
 452 }
 453
 454 const char *
 455 repodata_lookup_id(Repodata *data, Id num, Id key)
 456 {
 457   Id id, k, *kp, *keyp;
 458
 459   fseek(data->fp, data->itemoffsets[num] , SEEK_SET);
 460   Id *keyp = data->schemadata + data->schemata[read_id(data->fp, data->numschemata)];
 461   /* make sure our schema contains the key */
 462   for (kp = keyp; (k = *kp++) != 0)
 463     if (k == key)
 464       break;
 465   if (k == 0)
 466     return 0;
 467   /* get it */
 468   while ((k = *keyp++) != 0)
 469     {
 470       if (k == key)
 471         break;
 472       switch (keys[key].type)
 473         {
 474         case TYPE_ID:
 475           while ((read_u8(data->fp) & 0x80) != 0)
 476             ;
 477           break;
 478         case TYPE_U32:
 479           read_u32(data->fp);
 480           break;
 481         case TYPE_STR:
 482           while(read_u8(data->fp) != 0)
 483             ;
 484           break;
 485         case TYPE_IDARRAY:
 486           while ((read_u8(data->fp) & 0xc0) != 0)
 487             ;
 488           break;
 489         }
 490     }
 491   id = read_id(data->fp, 0);
 492   return data->ss.stringspace + data->ss.strings[id];
 493 }
 494
 495 Id
 496 repo_lookup_id(Solvable *s, Id key)
 497 {
 498   Solvable *rs;
 499   Repo *repo = s->repo;
 500   Repodata *data;
 501   int i, j, n;
 502
 503   switch(key)
 504     {
 505     case SOLVABLE_NAME:
 506       return s->name;
 507     case SOLVABLE_ARCH:
 508       return s->arch;
 509     case SOLVABLE_EVR:
 510       return s->evr;
 511     case SOLVABLE_VENDOR:
 512       return s->vendor;
 513     }
 514   /* convert solvable id into repo item count */
 515   if (repo->end - repo->start + 1 == repo->nsolvables)
 516     {
 517       n = (s - pool->solvables);
 518       if (n < repo->start || n > repo->end)
 519         return 0;
 520       n -= repo->start;
 521     }
 522   else
 523     {
 524       for (i = repo->start, rs = pool->solvables + i, n = 0; i < repo->end; i++, rs++)
 525         {
 526           if (rs->repo != repo)
 527             continue;
 528           if (rs == s)
 529             break;
 530           n++;
 531         }
 532       if (i == repo->end)
 533         return 0;
 534     }
 535   for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
 536     {
 537       for (j = 0; j < data->nkeys; j++)
 538         {
 539           if (data->keys[j].name == key && data->keys[j].type == TYPE_ID)
 540             return repodata_lookup_id(data, n, j);
 541         }
 542     }
 543   return 0;
 544 }
 545 #endif
 546
 547 static int
 548 key_cmp (const void *pa, const void *pb)
 549 {
 550   struct key { Id name; unsigned type; };
 551   struct key *a = (struct key*)pa;
 552   struct key *b = (struct key*)pb;
 553   return a->name - b->name;
 554 }
 555
 556 void
 557 repo_add_attrstore (Repo *repo, Attrstore *s, const char *location)
 558 {
 559   unsigned i;
 560   Repodata *data;
 561   /* If this is meant to be the embedded attributes, make sure we don't
 562      have them already.  */
 563   if (!location)
 564     {
 565       for (i = 0; i < repo->nrepodata; i++)
 566         if (repo->repodata[i].location == 0)
 567           break;
 568       if (i != repo->nrepodata)
 569         {
 570           pool_debug (repo->pool, SAT_FATAL, "embedded attribs added twice\n");
 571           exit (1);
 572         }
 573     }
 574   repo->nrepodata++;
 575   repo->repodata = xrealloc (repo->repodata, repo->nrepodata * sizeof (*data));
 576   data = repo->repodata + repo->nrepodata - 1;
 577   memset (data, 0, sizeof (*data));
 578   data->s = s;
 579   data->nkeys = s->nkeys;
 580   /* Don't store the first key, it's {0,0,0}.  */
 581   data->nkeys--;
 582   if (data->nkeys)
 583     {
 584       data->keys = xmalloc (data->nkeys * sizeof (data->keys[0]));
 585       for (i = 0; i < data->nkeys; i++)
 586         {
 587           data->keys[i].name = s->keys[i + 1].name;
 588           data->keys[i].type = s->keys[i + 1].type;
 589         }
 590       qsort (data->keys, data->nkeys, sizeof (data->keys[0]), key_cmp);
 591     }
 592   if (location)
 593     data->location = strdup(location);
 594 }
 595
 596 // EOF