src/repodata.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  * repodata.c
  10  *
  11  * Manage data coming from one repository
  12  *
  13  */
  14
  15 #define _GNU_SOURCE
  16 #include <string.h>
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <unistd.h>
  21 #include <assert.h>
  22
  23 #include "repo.h"
  24 #include "pool.h"
  25 #include "poolid_private.h"
  26 #include "util.h"
  27
  28 #include "fastlz.c"
  29
  30 unsigned char *
  31 data_read_id(unsigned char *dp, Id *idp)
  32 {
  33   Id x = 0;
  34   unsigned char c;
  35   for (;;)
  36     {
  37       c = *dp++;
  38       if (!(c & 0x80))
  39         {
  40           *idp = (x << 7) ^ c;
  41           return dp;
  42         }
  43       x = (x << 7) ^ c ^ 128;
  44     }
  45 }
  46
  47 static unsigned char *
  48 data_read_ideof(unsigned char *dp, Id *idp, int *eof)
  49 {
  50   Id x = 0;
  51   unsigned char c;
  52   for (;;)
  53     {
  54       c = *dp++;
  55       if (!(c & 0x80))
  56         {
  57           if (c & 0x40)
  58             {
  59               c ^= 0x40;
  60               *eof = 0;
  61             }
  62           else
  63             *eof = 1;
  64           *idp = (x << 6) ^ c;
  65           return dp;
  66         }
  67       x = (x << 7) ^ c ^ 128;
  68     }
  69 }
  70
  71 static unsigned char *
  72 data_skip(unsigned char *dp, int type)
  73 {
  74   unsigned char x;
  75   switch (type)
  76     {
  77     case TYPE_VOID:
  78     case TYPE_CONSTANT:
  79       return dp;
  80     case TYPE_ID:
  81     case TYPE_NUM:
  82     case TYPE_DIR:
  83       while ((*dp & 0x80) != 0)
  84         dp++;
  85       return dp + 1;
  86     case TYPE_IDARRAY:
  87       while ((*dp & 0xc0) != 0)
  88         dp++;
  89       return dp + 1;
  90     case TYPE_STR:
  91       while ((*dp) != 0)
  92         dp++;
  93       return dp + 1;
  94     case TYPE_DIRSTRARRAY:
  95       for (;;)
  96         {
  97           while ((*dp & 0x80) != 0)
  98             dp++;
  99           x = *dp++;
 100           while ((*dp) != 0)
 101             dp++;
 102           dp++;
 103           if (!(x & 0x40))
 104             return dp;
 105         }
 106     case TYPE_DIRNUMNUMARRAY:
 107       for (;;)
 108         {
 109           while ((*dp & 0x80) != 0)
 110             dp++;
 111           dp++;
 112           while ((*dp & 0x80) != 0)
 113             dp++;
 114           dp++;
 115           while ((*dp & 0x80) != 0)
 116             dp++;
 117           if (!(*dp & 0x40))
 118             return dp + 1;
 119           dp++;
 120         }
 121     default:
 122       fprintf(stderr, "unknown type in data_skip\n");
 123       exit(1);
 124     }
 125 }
 126
 127 static unsigned char *
 128 data_fetch(unsigned char *dp, KeyValue *kv, Repokey *key)
 129 {
 130   kv->eof = 1;
 131   if (!dp)
 132     return 0;
 133   switch (key->type)
 134     {
 135     case TYPE_VOID:
 136       return dp;
 137     case TYPE_CONSTANT:
 138       kv->num = key->size;
 139       return dp;
 140     case TYPE_STR:
 141       kv->str = (const char *)dp;
 142       return dp + strlen(kv->str) + 1;
 143     case TYPE_ID:
 144       return data_read_id(dp, &kv->id);
 145     case TYPE_NUM:
 146       return data_read_id(dp, &kv->num);
 147     case TYPE_IDARRAY:
 148       return data_read_ideof(dp, &kv->id, &kv->eof);
 149     case TYPE_DIR:
 150       return data_read_id(dp, &kv->id);
 151     case TYPE_DIRSTRARRAY:
 152       dp = data_read_ideof(dp, &kv->id, &kv->eof);
 153       kv->str = (const char *)dp;
 154       return dp + strlen(kv->str) + 1;
 155     case TYPE_DIRNUMNUMARRAY:
 156       dp = data_read_id(dp, &kv->id);
 157       dp = data_read_id(dp, &kv->num);
 158       return data_read_ideof(dp, &kv->num2, &kv->eof);
 159     default:
 160       return 0;
 161     }
 162 }
 163
 164 static unsigned char *
 165 forward_to_key(Repodata *data, Id key, Id schemaid, unsigned char *dp)
 166 {
 167   Id k, *keyp;
 168
 169   keyp = data->schemadata + data->schemata[schemaid];
 170   while ((k = *keyp++) != 0)
 171     {
 172       if (k == key)
 173         return dp;
 174       if (data->keys[k].storage == KEY_STORAGE_VERTICAL_OFFSET)
 175         {
 176           dp = data_skip(dp, TYPE_ID);  /* skip that offset */
 177           dp = data_skip(dp, TYPE_ID);  /* skip that length */
 178           continue;
 179         }
 180       if (data->keys[k].storage != KEY_STORAGE_INCORE)
 181         continue;
 182       dp = data_skip(dp, data->keys[k].type);
 183     }
 184   return 0;
 185 }
 186
 187 #define BLOB_PAGEBITS 15
 188 #define BLOB_PAGESIZE (1 << BLOB_PAGEBITS)
 189
 190 static unsigned char *
 191 load_page_range(Repodata *data, unsigned int pstart, unsigned int pend)
 192 {
 193 /* Make sure all pages from PSTART to PEND (inclusive) are loaded,
 194    and are consecutive.  Return a pointer to the mapping of PSTART.  */
 195   unsigned char buf[BLOB_PAGESIZE];
 196   unsigned int i;
 197
 198   /* Quick check in case all pages are there already and consecutive.  */
 199   for (i = pstart; i <= pend; i++)
 200     if (data->pages[i].mapped_at == -1
 201         || (i > pstart
 202             && data->pages[i].mapped_at
 203                != data->pages[i-1].mapped_at + BLOB_PAGESIZE))
 204       break;
 205   if (i > pend)
 206     return data->blob_store + data->pages[pstart].mapped_at;
 207
 208   /* Ensure that we can map the numbers of pages we need at all.  */
 209   if (pend - pstart + 1 > data->ncanmap)
 210     {
 211       unsigned int oldcan = data->ncanmap;
 212       data->ncanmap = pend - pstart + 1;
 213       if (data->ncanmap < 4)
 214         data->ncanmap = 4;
 215       data->mapped = sat_realloc2(data->mapped, data->ncanmap, sizeof(data->mapped[0]));
 216       memset (data->mapped + oldcan, 0, (data->ncanmap - oldcan) * sizeof (data->mapped[0]));
 217       data->blob_store = sat_realloc2(data->blob_store, data->ncanmap, BLOB_PAGESIZE);
 218 #ifdef DEBUG_PAGING
 219       fprintf (stderr, "PAGE: can map %d pages\n", data->ncanmap);
 220 #endif
 221     }
 222
 223   /* Now search for "cheap" space in our store.  Space is cheap if it's either
 224      free (very cheap) or contains pages we search for anyway.  */
 225
 226   /* Setup cost array.  */
 227   unsigned int cost[data->ncanmap];
 228   for (i = 0; i < data->ncanmap; i++)
 229     {
 230       unsigned int pnum = data->mapped[i];
 231       if (pnum == 0)
 232         cost[i] = 0;
 233       else
 234         {
 235           pnum--;
 236           Attrblobpage *p = data->pages + pnum;
 237           assert (p->mapped_at != -1);
 238           if (pnum >= pstart && pnum <= pend)
 239             cost[i] = 1;
 240           else
 241             cost[i] = 3;
 242         }
 243     }
 244
 245   /* And search for cheapest space.  */
 246   unsigned int best_cost = -1;
 247   unsigned int best = 0;
 248   unsigned int same_cost = 0;
 249   for (i = 0; i + pend - pstart < data->ncanmap; i++)
 250     {
 251       unsigned int c = cost[i];
 252       unsigned int j;
 253       for (j = 0; j < pend - pstart + 1; j++)
 254         c += cost[i+j];
 255       if (c < best_cost)
 256         best_cost = c, best = i;
 257       else if (c == best_cost)
 258         same_cost++;
 259       /* A null cost won't become better.  */
 260       if (c == 0)
 261         break;
 262     }
 263   /* If all places have the same cost we would thrash on slot 0.  Avoid
 264      this by doing a round-robin strategy in this case.  */
 265   if (same_cost == data->ncanmap - pend + pstart - 1)
 266     best = data->rr_counter++ % (data->ncanmap - pend + pstart);
 267
 268   /* So we want to map our pages from [best] to [best+pend-pstart].
 269      Use a very simple strategy, which doesn't make the best use of
 270      our resources, but works.  Throw away all pages in that range
 271      (even ours) then copy around ours (in case they were outside the
 272      range) or read them in.  */
 273   for (i = best; i < best + pend - pstart + 1; i++)
 274     {
 275       unsigned int pnum = data->mapped[i];
 276       if (pnum--
 277           /* If this page is exactly at the right place already,
 278              no need to evict it.  */
 279           && pnum != pstart + i - best)
 280         {
 281           /* Evict this page.  */
 282 #ifdef DEBUG_PAGING
 283           fprintf (stderr, "PAGE: evict page %d from %d\n", pnum, i);
 284 #endif
 285           cost[i] = 0;
 286           data->mapped[i] = 0;
 287           data->pages[pnum].mapped_at = -1;
 288         }
 289     }
 290
 291   /* Everything is free now.  Read in the pages we want.  */
 292   for (i = pstart; i <= pend; i++)
 293     {
 294       Attrblobpage *p = data->pages + i;
 295       unsigned int pnum = i - pstart + best;
 296       void *dest = data->blob_store + pnum * BLOB_PAGESIZE;
 297       if (p->mapped_at != -1)
 298         {
 299           if (p->mapped_at != pnum * BLOB_PAGESIZE)
 300             {
 301 #ifdef DEBUG_PAGING
 302               fprintf (stderr, "PAGECOPY: %d to %d\n", i, pnum);
 303 #endif
 304               /* Still mapped somewhere else, so just copy it from there.  */
 305               memcpy (dest, data->blob_store + p->mapped_at, BLOB_PAGESIZE);
 306               data->mapped[p->mapped_at / BLOB_PAGESIZE] = 0;
 307             }
 308         }
 309       else
 310         {
 311           unsigned int in_len = p->file_size;
 312           unsigned int compressed = in_len & 1;
 313           in_len >>= 1;
 314 #ifdef DEBUG_PAGING
 315           fprintf (stderr, "PAGEIN: %d to %d", i, pnum);
 316 #endif
 317           /* Not mapped, so read in this page.  */
 318           if (fseek(data->fp, p->file_offset, SEEK_SET) < 0)
 319             {
 320               perror ("mapping fseek");
 321               exit (1);
 322             }
 323           if (fread(compressed ? buf : dest, in_len, 1, data->fp) != 1)
 324             {
 325               perror ("mapping fread");
 326               exit (1);
 327             }
 328           if (compressed)
 329             {
 330               unsigned int out_len;
 331               out_len = unchecked_decompress_buf(buf, in_len,
 332                                                   dest, BLOB_PAGESIZE);
 333               if (out_len != BLOB_PAGESIZE
 334                   && i < data->num_pages - 1)
 335                 {
 336                   fprintf (stderr, "can't decompress\n");
 337                   exit (1);
 338                 }
 339 #ifdef DEBUG_PAGING
 340               fprintf (stderr, " (expand %d to %d)", in_len, out_len);
 341 #endif
 342             }
 343 #ifdef DEBUG_PAGING
 344           fprintf (stderr, "\n");
 345 #endif
 346         }
 347       p->mapped_at = pnum * BLOB_PAGESIZE;
 348       data->mapped[pnum] = i + 1;
 349     }
 350   return data->blob_store + best * BLOB_PAGESIZE;
 351 }
 352
 353 static unsigned char *
 354 make_vertical_available(Repodata *data, Repokey *key, Id off, Id len)
 355 {
 356   unsigned char *dp;
 357   if (key->type == TYPE_VOID)
 358     return 0;
 359   if (off >= data->lastverticaloffset)
 360     {
 361       off -= data->lastverticaloffset;
 362       if (off + len > data->vincorelen)
 363         return 0;
 364       return data->vincore + off;
 365     }
 366   if (!data->fp)
 367     return 0;
 368   if (off + len > key->size)
 369     return 0;
 370   /* we now have the offset, go into vertical */
 371   off += data->verticaloffset[key - data->keys];
 372   dp = load_page_range(data, off / BLOB_PAGESIZE, (off + len - 1) / BLOB_PAGESIZE);
 373   if (dp)
 374     dp += off % BLOB_PAGESIZE;
 375   return dp;
 376 }
 377
 378 static inline unsigned char *
 379 get_data(Repodata *data, Repokey *key, unsigned char **dpp)
 380 {
 381   unsigned char *dp = *dpp;
 382
 383   if (!dp)
 384     return 0;
 385   if (key->storage == KEY_STORAGE_INCORE)
 386     {
 387       /* hmm, this is a bit expensive */
 388       *dpp = data_skip(dp, key->type);
 389       return dp;
 390     }
 391   else if (key->storage == KEY_STORAGE_VERTICAL_OFFSET)
 392     {
 393       Id off, len;
 394       dp = data_read_id(dp, &off);
 395       dp = data_read_id(dp, &len);
 396       *dpp = dp;
 397       return make_vertical_available(data, key, off, len);
 398     }
 399   return 0;
 400 }
 401
 402
 403 const char *
 404 repodata_lookup_str(Repodata *data, Id entry, Id keyid)
 405 {
 406   Id schema;
 407   Repokey *key;
 408   Id id, *keyp;
 409   unsigned char *dp;
 410
 411   if (data->entryschemau8)
 412     schema = data->entryschemau8[entry];
 413   else
 414     schema = data->entryschema[entry];
 415   /* make sure the schema of this solvable contains the key */
 416   for (keyp = data->schemadata + data->schemata[schema]; *keyp != keyid; keyp++)
 417     if (!*keyp)
 418       return 0;
 419   dp = forward_to_key(data, keyid, schema, data->incoredata + data->incoreoffset[entry]);
 420   key = data->keys + keyid;
 421   dp = get_data(data, key, &dp);
 422   if (!dp)
 423     return 0;
 424   if (key->type == TYPE_STR)
 425     return (const char *)dp;
 426   if (key->type != TYPE_ID)
 427     return 0;
 428   /* id type, must either use global or local string strore*/
 429   dp = data_read_id(dp, &id);
 430   if (data->localpool)
 431     return data->spool.stringspace + data->spool.strings[id];
 432   return id2str(data->repo->pool, id);
 433 }
 434
 435 void
 436 repodata_search(Repodata *data, Id entry, Id keyname, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv), void *cbdata)
 437 {
 438   Id schema;
 439   Repokey *key;
 440   Id k, keyid, *kp, *keyp;
 441   unsigned char *dp, *ddp;
 442   int onekey = 0;
 443   int stop;
 444   KeyValue kv;
 445
 446   if (data->entryschemau8)
 447     schema = data->entryschemau8[entry];
 448   else
 449     schema = data->entryschema[entry];
 450   keyp = data->schemadata + data->schemata[schema];
 451   dp = data->incoredata + data->incoreoffset[entry];
 452   if (keyname)
 453     {
 454       /* search in a specific key */
 455       for (kp = keyp; (k = *kp++) != 0; )
 456         if (data->keys[k].name == keyname)
 457           break;
 458       if (k == 0)
 459         return;
 460       dp = forward_to_key(data, k, schema, dp);
 461       if (!dp)
 462         return;
 463       keyp = kp - 1;
 464       onekey = 1;
 465     }
 466   while ((keyid = *keyp++) != 0)
 467     {
 468       stop = 0;
 469       key = data->keys + keyid;
 470       ddp = get_data(data, key, &dp);
 471       do
 472         {
 473           ddp = data_fetch(ddp, &kv, key);
 474           if (!ddp)
 475             break;
 476           stop = callback(cbdata, data->repo->pool->solvables + data->start + entry, data, key, &kv);
 477         }
 478       while (!kv.eof && !stop);
 479       if (onekey || stop > SEARCH_NEXT_KEY)
 480         return;
 481     }
 482 }
 483
 484
 485 /* extend repodata so that it includes solvables p */
 486 void
 487 repodata_extend(Repodata *data, Id p)
 488 {
 489   if (data->start == data->end)
 490     data->start = data->end = p;
 491   if (p >= data->end)
 492     {
 493       int old = data->end - data->start;
 494       int new = p - data->end + 1;
 495       if (data->entryschemau8)
 496         {
 497           data->entryschemau8 = sat_realloc(data->entryschemau8, old + new);
 498           memset(data->entryschemau8 + old, 0, new);
 499         }
 500       if (data->entryschema)
 501         {
 502           data->entryschema = sat_realloc2(data->entryschema, old + new, sizeof(Id));
 503           memset(data->entryschema + old, 0, new * sizeof(Id));
 504         }
 505       if (data->attrs)
 506         {
 507           data->attrs = sat_realloc2(data->attrs, old + new, sizeof(Id *));
 508           memset(data->attrs + old, 0, new * sizeof(Id *));
 509         }
 510       data->incoreoffset = sat_realloc2(data->incoreoffset, old + new, sizeof(Id));
 511       memset(data->incoreoffset + old, 0, new * sizeof(Id));
 512       data->end = p + 1;
 513     }
 514   if (p < data->start)
 515     {
 516       int old = data->end - data->start;
 517       int new = data->start - p;
 518       if (data->entryschemau8)
 519         {
 520           data->entryschemau8 = sat_realloc(data->entryschemau8, old + new);
 521           memmove(data->entryschemau8 + new, data->entryschemau8, old);
 522           memset(data->entryschemau8, 0, new);
 523         }
 524       if (data->entryschema)
 525         {
 526           data->entryschema = sat_realloc2(data->entryschema, old + new, sizeof(Id));
 527           memmove(data->entryschema + new, data->entryschema, old * sizeof(Id));
 528           memset(data->entryschema, 0, new * sizeof(Id));
 529         }
 530       if (data->attrs)
 531         {
 532           data->attrs = sat_realloc2(data->attrs, old + new, sizeof(Id *));
 533           memmove(data->attrs + new, data->attrs, old * sizeof(Id *));
 534           memset(data->attrs, 0, new * sizeof(Id *));
 535         }
 536       data->incoreoffset = sat_realloc2(data->incoreoffset, old + new, sizeof(Id));
 537       memmove(data->incoreoffset + new, data->incoreoffset, old * sizeof(Id));
 538       memset(data->incoreoffset, 0, new * sizeof(Id));
 539       data->start = p;
 540     }
 541 }
 542
 543 void
 544 repodata_set(Repodata *data, Id entry, Repokey *key, Id val)
 545 {
 546   Id keyid, *pp;
 547   int i;
 548
 549   /* find key in keys */
 550   for (keyid = 1; keyid < data->nkeys; keyid++)
 551     if (data->keys[keyid].name == key->name && data->keys[keyid].type == key->type)
 552       {
 553         if (key->type == TYPE_CONSTANT && key->size != data->keys[keyid].size)
 554           continue;
 555         break;
 556       }
 557   if (keyid == data->nkeys)
 558     {
 559       /* allocate new key */
 560       data->keys = sat_realloc2(data->keys, data->nkeys + 1, sizeof(Repokey));
 561       data->keys[data->nkeys++] = *key;
 562       if (data->verticaloffset)
 563         {
 564           data->verticaloffset = sat_realloc2(data->verticaloffset, data->nkeys, sizeof(Id));
 565           data->verticaloffset[data->nkeys - 1] = 0;
 566         }
 567     }
 568   key = data->keys + keyid;
 569   if (!data->attrs)
 570     data->attrs = sat_calloc(data->end - data->start + 1, sizeof(Id *));
 571   i = 0;
 572   if (data->attrs[entry])
 573     {
 574       for (pp = data->attrs[entry]; *pp; pp += 2)
 575         if (*pp == keyid)
 576           break;
 577       if (*pp)
 578         {
 579           pp[1] = val;
 580           return;
 581         }
 582       i = pp - data->attrs[entry];
 583     }
 584   data->attrs[entry] = sat_realloc2(data->attrs[entry], i + 3, sizeof(Id));
 585   pp = data->attrs[entry] + i;
 586   *pp++ = keyid;
 587   *pp++ = val;
 588   *pp = 0;
 589 }
 590
 591 void
 592 repodata_set_id(Repodata *data, Id entry, Id keyname, Id id)
 593 {
 594   Repokey key;
 595   key.name = keyname;
 596   key.type = TYPE_ID;
 597   key.size = 0;
 598   key.storage = KEY_STORAGE_INCORE;
 599   repodata_set(data, entry, &key, id);
 600 }
 601
 602 void
 603 repodata_set_num(Repodata *data, Id entry, Id keyname, Id num)
 604 {
 605   Repokey key;
 606   key.name = keyname;
 607   key.type = TYPE_NUM;
 608   key.size = 0;
 609   key.storage = KEY_STORAGE_INCORE;
 610   repodata_set(data, entry, &key, num);
 611 }
 612
 613 void
 614 repodata_set_poolstr(Repodata *data, Id entry, Id keyname, const char *str)
 615 {
 616   Repokey key;
 617   Id id;
 618   if (data->localpool)
 619     id = stringpool_str2id(&data->spool, str, 1);
 620   else
 621     id = str2id(data->repo->pool, str, 1);
 622   key.name = keyname;
 623   key.type = TYPE_ID;
 624   key.size = 0;
 625   key.storage = KEY_STORAGE_INCORE;
 626   repodata_set(data, entry, &key, id);
 627 }
 628
 629 void
 630 repodata_set_constant(Repodata *data, Id entry, Id keyname, Id constant)
 631 {
 632   Repokey key;
 633   key.name = keyname;
 634   key.type = TYPE_CONSTANT;
 635   key.size = constant;
 636   key.storage = KEY_STORAGE_INCORE;
 637   repodata_set(data, entry, &key, 0);
 638 }
 639
 640 void
 641 repodata_set_void(Repodata *data, Id entry, Id keyname)
 642 {
 643   Repokey key;
 644   key.name = keyname;
 645   key.type = TYPE_VOID;
 646   key.size = 0;
 647   key.storage = KEY_STORAGE_INCORE;
 648   repodata_set(data, entry, &key, 0);
 649 }
 650
 651 void
 652 repodata_set_str(Repodata *data, Id entry, Id keyname, const char *str)
 653 {
 654   Repokey key;
 655   int l;
 656
 657   l = strlen(str) + 1;
 658   key.name = keyname;
 659   key.type = TYPE_STR;
 660   key.size = 0;
 661   key.storage = KEY_STORAGE_INCORE;
 662   data->attrdata = sat_realloc(data->attrdata, data->attrdatalen + l);
 663   memcpy(data->attrdata + data->attrdatalen, str, l);
 664   repodata_set(data, entry, &key, data->attrdatalen);
 665   data->attrdatalen += l;
 666 }
 667
 668 void
 669 repodata_add_dirnumnum(Repodata *data, Id entry, Id keyname, Id dir, Id num, Id num2)
 670 {
 671   Id *ida, *pp;
 672   Repokey key;
 673
 674 #if 0
 675 fprintf(stderr, "repodata_add_dirnumnum %d %d %d %d (%d)\n", entry, dir, num, num2, data->attriddatalen);
 676 #endif
 677   if (data->attrs[entry])
 678     {
 679       for (pp = data->attrs[entry]; *pp; pp += 2)
 680         if (data->keys[*pp].name == keyname && data->keys[*pp].type == TYPE_DIRNUMNUMARRAY)
 681           break;
 682       if (*pp)
 683         {
 684           int oldsize = 0;
 685           for (ida = data->attriddata + pp[1]; *ida; ida += 3)
 686             oldsize += 3;
 687           if (ida + 1 == data->attriddata + data->attriddatalen)
 688             {
 689               /* this was the last entry, just append it */
 690               data->attriddata = sat_realloc2(data->attriddata, data->attriddatalen + 3, sizeof(Id));
 691               data->attriddatalen--;    /* overwrite terminating 0  */
 692             }
 693           else
 694             {
 695               /* too bad. move to back. */
 696               data->attriddata = sat_realloc2(data->attriddata, data->attriddatalen + oldsize + 4, sizeof(Id));
 697               memcpy(data->attriddata + data->attriddatalen, data->attriddata + pp[1], oldsize * sizeof(Id));
 698               pp[1] = data->attriddatalen;
 699               data->attriddatalen += oldsize;
 700             }
 701           data->attriddata[data->attriddatalen++] = dir;
 702           data->attriddata[data->attriddatalen++] = num;
 703           data->attriddata[data->attriddatalen++] = num2;
 704           data->attriddata[data->attriddatalen++] = 0;
 705           return;
 706         }
 707     }
 708   key.name = keyname;
 709   key.type = TYPE_DIRNUMNUMARRAY;
 710   key.size = 0;
 711   key.storage = KEY_STORAGE_INCORE;
 712   data->attriddata = sat_realloc2(data->attriddata, data->attriddatalen + 4, sizeof(Id));
 713   repodata_set(data, entry, &key, data->attriddatalen);
 714   data->attriddata[data->attriddatalen++] = dir;
 715   data->attriddata[data->attriddatalen++] = num;
 716   data->attriddata[data->attriddatalen++] = num2;
 717   data->attriddata[data->attriddatalen++] = 0;
 718 }
 719
 720 /*********************************/
 721
 722 /* unify with repo_write! */
 723
 724 #define EXTDATA_BLOCK 1023
 725 #define SCHEMATA_BLOCK 31
 726 #define SCHEMATADATA_BLOCK 255
 727
 728 struct extdata {
 729   unsigned char *buf;
 730   int len;
 731 };
 732
 733 static void
 734 data_addid(struct extdata *xd, Id x)
 735 {
 736   unsigned char *dp;
 737   xd->buf = sat_extend(xd->buf, xd->len, 5, 1, EXTDATA_BLOCK);
 738   dp = xd->buf + xd->len;
 739
 740   if (x >= (1 << 14))
 741     {
 742       if (x >= (1 << 28))
 743         *dp++ = (x >> 28) | 128;
 744       if (x >= (1 << 21))
 745         *dp++ = (x >> 21) | 128;
 746       *dp++ = (x >> 14) | 128;
 747     }
 748   if (x >= (1 << 7))
 749     *dp++ = (x >> 7) | 128;
 750   *dp++ = x & 127;
 751   xd->len = dp - xd->buf;
 752 }
 753
 754 static void
 755 data_addideof(struct extdata *xd, Id x, int eof)
 756 {
 757   if (x >= 64)
 758     x = (x & 63) | ((x & ~63) << 1);
 759   data_addid(xd, (eof ? x: x | 64));
 760 }
 761
 762 static void
 763 data_addblob(struct extdata *xd, unsigned char *blob, int len)
 764 {
 765   xd->buf = sat_extend(xd->buf, xd->len, len, 1, EXTDATA_BLOCK);
 766   memcpy(xd->buf + xd->len, blob, len);
 767   xd->len += len;
 768 }
 769
 770 /*********************************/
 771
 772 static void
 773 addschema_prepare(Repodata *data, Id *schematacache)
 774 {
 775   int h, len, i;
 776   Id *sp;
 777
 778   memset(schematacache, 0, 256 * sizeof(Id));
 779   for (i = 0; i < data->nschemata; i++)
 780     {
 781       for (sp = data->schemadata + data->schemata[i], h = 0; *sp; len++)
 782         h = h * 7 + *sp++;
 783       h &= 255;
 784       schematacache[h] = i + 1;
 785     }
 786   data->schemadata = sat_extend_resize(data->schemadata, data->schemadatalen, sizeof(Id), SCHEMATADATA_BLOCK);
 787   data->schemata = sat_extend_resize(data->schemata, data->nschemata, sizeof(Id), SCHEMATA_BLOCK);
 788 }
 789
 790 static Id
 791 addschema(Repodata *data, Id *schema, Id *schematacache)
 792 {
 793   int h, len;
 794   Id *sp, cid;
 795
 796   for (sp = schema, len = 0, h = 0; *sp; len++)
 797     h = h * 7 + *sp++;
 798   h &= 255;
 799   len++;
 800
 801   cid = schematacache[h];
 802   if (cid)
 803     {
 804       cid--;
 805       if (!memcmp(data->schemadata + data->schemata[cid], schema, len * sizeof(Id)))
 806         return cid;
 807       /* cache conflict */
 808       for (cid = 0; cid < data->nschemata; cid++)
 809         if (!memcmp(data->schemadata + data->schemata[cid], schema, len * sizeof(Id)))
 810           return cid;
 811     }
 812   /* a new one. make room. */
 813   data->schemadata = sat_extend(data->schemadata, data->schemadatalen, len, sizeof(Id), SCHEMATADATA_BLOCK);
 814   data->schemata = sat_extend(data->schemata, data->nschemata, 1, sizeof(Id), SCHEMATA_BLOCK);
 815   /* add schema */
 816   memcpy(data->schemadata + data->schemadatalen, schema, len * sizeof(Id));
 817   data->schemata[data->nschemata] = data->schemadatalen;
 818   data->schemadatalen += len;
 819   schematacache[h] = data->nschemata + 1;
 820 #if 0
 821 fprintf(stderr, "addschema: new schema\n");
 822 #endif
 823   return data->nschemata++;
 824 }
 825
 826
 827 void
 828 repodata_internalize(Repodata *data)
 829 {
 830   int i;
 831   Repokey *key;
 832   Id id, entry, nentry, *ida;
 833   Id schematacache[256];
 834   Id schemaid, *schema, *sp, oldschema, *keyp, *seen;
 835   unsigned char *dp, *ndp;
 836   int newschema, oldcount;
 837   struct extdata newincore;
 838   struct extdata newvincore;
 839
 840   if (!data->attrs)
 841     return;
 842
 843   newvincore.buf = data->vincore;
 844   newvincore.len = data->vincorelen;
 845
 846   schema = sat_malloc2(data->nkeys, sizeof(Id));
 847   seen = sat_malloc2(data->nkeys, sizeof(Id));
 848
 849   nentry = data->end - data->start;
 850   addschema_prepare(data, schematacache);
 851   memset(&newincore, 0, sizeof(newincore));
 852   for (entry = 0; entry < nentry; entry++)
 853     {
 854       memset(seen, 0, data->nkeys * sizeof(Id));
 855       sp = schema;
 856       if (data->entryschemau8)
 857         oldschema = data->entryschemau8[entry];
 858       else
 859         oldschema = data->entryschema[entry];
 860 #if 0
 861 fprintf(stderr, "oldschema %d\n", oldschema);
 862 fprintf(stderr, "schemata %d\n", data->schemata[oldschema]);
 863 fprintf(stderr, "schemadata %p\n", data->schemadata);
 864 #endif
 865       /* seen: -1: old data  0: skipped  >0: id + 1 */
 866       newschema = 0;
 867       oldcount = 0;
 868       for (keyp = data->schemadata + data->schemata[oldschema]; *keyp; keyp++)
 869         {
 870           if (seen[*keyp])
 871             {
 872               newschema = 1;
 873               continue;
 874             }
 875           seen[*keyp] = -1;
 876           *sp++ = *keyp;
 877           oldcount++;
 878         }
 879       for (keyp = data->attrs[entry]; *keyp; keyp += 2)
 880         {
 881           if (!seen[*keyp])
 882             {
 883               newschema = 1;
 884               *sp++ = *keyp;
 885             }
 886           seen[*keyp] = keyp[1] + 1;
 887         }
 888       *sp++ = 0;
 889       if (newschema)
 890         {
 891           schemaid = addschema(data, schema, schematacache);
 892           if (schemaid > 255 && data->entryschemau8)
 893             {
 894               data->entryschema = sat_malloc2(nentry, sizeof(Id));
 895               for (i = 0; i < nentry; i++)
 896                 data->entryschema[i] = data->entryschemau8[i];
 897               data->entryschemau8 = sat_free(data->entryschemau8);
 898             }
 899           if (data->entryschemau8)
 900             data->entryschemau8[entry] = schemaid;
 901           else
 902             data->entryschema[entry] = schemaid;
 903         }
 904       else
 905         schemaid = oldschema;
 906
 907
 908       /* now create data blob */
 909       dp = data->incoredata + data->incoreoffset[entry];
 910       data->incoreoffset[entry] = newincore.len;
 911       for (keyp = data->schemadata + data->schemata[schemaid]; *keyp; keyp++)
 912         {
 913           key = data->keys + *keyp;
 914           ndp = dp;
 915           if (oldcount)
 916             {
 917               if (key->storage == KEY_STORAGE_VERTICAL_OFFSET)
 918                 {
 919                   ndp = data_skip(dp, TYPE_ID);
 920                   ndp = data_skip(ndp, TYPE_ID);
 921                 }
 922               else if (key->storage == KEY_STORAGE_INCORE)
 923                 ndp = data_skip(dp, key->type);
 924               oldcount--;
 925             }
 926           if (seen[*keyp] == -1)
 927             {
 928               if (dp != ndp)
 929                 data_addblob(&newincore, dp, ndp - dp);
 930               seen[*keyp] = 0;
 931             }
 932           else if (seen[*keyp])
 933             {
 934               struct extdata *xd;
 935               unsigned int oldvincorelen = 0;
 936
 937               xd = &newincore;
 938               if (key->storage == KEY_STORAGE_VERTICAL_OFFSET)
 939                 {
 940                   xd = &newvincore;
 941                   oldvincorelen = xd->len;
 942                 }
 943               id = seen[*keyp] - 1;
 944               switch (key->type)
 945                 {
 946                 case TYPE_VOID:
 947                 case TYPE_CONSTANT:
 948                   break;
 949                 case TYPE_STR:
 950                   data_addblob(xd, data->attrdata + id, strlen((char *)(data->attrdata + id)) + 1);
 951                   break;
 952                 case TYPE_ID:
 953                 case TYPE_NUM:
 954                 case TYPE_DIR:
 955                   data_addid(xd, id);
 956                   break;
 957                 case TYPE_DIRNUMNUMARRAY:
 958                   for (ida = data->attriddata + id; *ida; ida += 3)
 959                     {
 960                       data_addid(xd, ida[0]);
 961                       data_addid(xd, ida[1]);
 962                       data_addideof(xd, ida[2], ida[3] ? 0 : 1);
 963                     }
 964                   break;
 965                 default:
 966                   fprintf(stderr, "don't know how to handle type %d\n", key->type);
 967                   exit(1);
 968                 }
 969               if (key->storage == KEY_STORAGE_VERTICAL_OFFSET)
 970                 {
 971                   /* put offset/len in incore */
 972                   data_addid(&newincore, data->lastverticaloffset + oldvincorelen);
 973                   oldvincorelen = xd->len - oldvincorelen;
 974                   data_addid(&newincore, oldvincorelen);
 975                 }
 976             }
 977           dp = ndp;
 978         }
 979     }
 980   data->incoredata = newincore.buf;
 981   data->incoredatalen = newincore.len;
 982   data->incoredatafree = 0;
 983
 984   data->vincore = newvincore.buf;
 985   data->vincorelen = newvincore.len;
 986
 987   data->attrs = sat_free(data->attrs);
 988   data->attrdata = sat_free(data->attrdata);
 989   data->attrdatalen = 0;
 990 }
 991
 992 Id
 993 repodata_str2dir(Repodata *data, const char *dir, int create)
 994 {
 995   Id id, parent;
 996   const char *dire;
 997
 998   parent = 0;
 999   while (*dir == '/' && dir[1] == '/')
1000     dir++;
1001   while (*dir)
1002     {
1003       dire = strchrnul(dir, '/');
1004       if (data->localpool)
1005         id = stringpool_strn2id(&data->spool, dir, dire - dir, create);
1006       else
1007         id = strn2id(data->repo->pool, dir, dire - dir, create);
1008       if (!id)
1009         return 0;
1010       parent = dirpool_add_dir(&data->dirpool, parent, id, create);
1011       if (!parent)
1012         return 0;
1013       if (!*dire)
1014         break;
1015       dir = dire + 1;
1016       while (*dir == '/')
1017         dir++;
1018     }
1019   return parent;
1020 }
1021
1022 unsigned int
1023 repodata_compress_page(unsigned char *page, unsigned int len, unsigned char *cpage, unsigned int max)
1024 {
1025   return compress_buf(page, len, cpage, max);
1026 }
1027
1028 /* Try to either setup on-demand paging (using FP as backing
1029    file), or in case that doesn't work (FP not seekable) slurps in
1030    all pages and deactivates paging.  */
1031
1032 #define SOLV_ERROR_EOF              3
1033
1034 static inline unsigned int
1035 read_u32(FILE *fp)
1036 {
1037   int c, i;
1038   unsigned int x = 0;
1039
1040   for (i = 0; i < 4; i++)
1041     {
1042       c = getc(fp);
1043       if (c == EOF)
1044         return 0;
1045       x = (x << 8) | c;
1046     }
1047   return x;
1048 }
1049
1050 void
1051 repodata_read_or_setup_pages(Repodata *data, unsigned int pagesz, unsigned int blobsz)
1052 {
1053   FILE *fp = data->fp;
1054   unsigned int npages;
1055   unsigned int i;
1056   unsigned int can_seek;
1057   long cur_file_ofs;
1058   unsigned char buf[BLOB_PAGESIZE];
1059   if (pagesz != BLOB_PAGESIZE)
1060     {
1061       /* We could handle this by slurping in everything.  */
1062       fprintf (stderr, "non matching page size\n");
1063       exit (1);
1064     }
1065   can_seek = 1;
1066   if ((cur_file_ofs = ftell(fp)) < 0)
1067     can_seek = 0;
1068   clearerr (fp);
1069 #ifdef DEBUG_PAGING
1070   fprintf (stderr, "can %sseek\n", can_seek ? "" : "NOT ");
1071 #endif
1072   npages = (blobsz + BLOB_PAGESIZE - 1) / BLOB_PAGESIZE;
1073
1074   data->num_pages = npages;
1075   data->pages = sat_malloc2(npages, sizeof(data->pages[0]));
1076
1077   /* If we can't seek on our input we have to slurp in everything.  */
1078   if (!can_seek)
1079     data->blob_store = sat_malloc(npages * BLOB_PAGESIZE);
1080   for (i = 0; i < npages; i++)
1081     {
1082       unsigned int in_len = read_u32(fp);
1083       unsigned int compressed = in_len & 1;
1084       Attrblobpage *p = data->pages + i;
1085       in_len >>= 1;
1086 #ifdef DEBUG_PAGING
1087       fprintf (stderr, "page %d: len %d (%scompressed)\n",
1088                i, in_len, compressed ? "" : "not ");
1089 #endif
1090       if (can_seek)
1091         {
1092           cur_file_ofs += 4;
1093           p->mapped_at = -1;
1094           p->file_offset = cur_file_ofs;
1095           p->file_size = in_len * 2 + compressed;
1096           if (fseek(fp, in_len, SEEK_CUR) < 0)
1097             {
1098               perror ("fseek");
1099               fprintf (stderr, "can't seek after we thought we can\n");
1100               /* We can't fall back to non-seeking behaviour as we already
1101                  read over some data pages without storing them away.  */
1102               exit (1);
1103             }
1104           cur_file_ofs += in_len;
1105         }
1106       else
1107         {
1108           unsigned int out_len;
1109           void *dest = data->blob_store + i * BLOB_PAGESIZE;
1110           p->mapped_at = i * BLOB_PAGESIZE;
1111           p->file_offset = 0;
1112           p->file_size = 0;
1113           /* We can't seek, so suck everything in.  */
1114           if (fread(compressed ? buf : dest, in_len, 1, fp) != 1)
1115             {
1116               perror ("fread");
1117               exit (1);
1118             }
1119           if (compressed)
1120             {
1121               out_len = unchecked_decompress_buf(buf, in_len, dest, BLOB_PAGESIZE);
1122               if (out_len != BLOB_PAGESIZE
1123                   && i < npages - 1)
1124                 {
1125                   fprintf (stderr, "can't decompress\n");
1126                   exit (1);
1127                 }
1128             }
1129         }
1130     }
1131
1132   if (can_seek)
1133     {
1134       /* If we are here we were able to seek to all page
1135          positions, so activate paging by copying FP into our structure.
1136          We dup() the file, so that our callers can fclose() it and we
1137          still have it open.  But this means that we share file positions
1138          with the input filedesc.  So in case our caller reads it after us,
1139          and calls back into us we might change the file position unexpectedly
1140          to him.  */
1141       int fd = dup (fileno (fp));
1142       if (fd < 0)
1143         {
1144           /* Jeez!  What a bloody system, we can't dup() anymore.  */
1145           perror ("dup");
1146           exit (1);
1147         }
1148       /* XXX we don't close this yet anywhere.  */
1149       data->fp = fdopen (fd, "r");
1150       if (!data->fp)
1151         {
1152           /* My God!  What happened now?  */
1153           perror ("fdopen");
1154           exit (1);
1155         }
1156     }
1157 }