ext/repo_rpmdb.c

   1 /*
   2  * Copyright (c) 2007-2012, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * repo_rpmdb
  10  *
  11  * convert rpm db to repo
  12  *
  13  */
  14
  15 #include <sys/types.h>
  16 #include <sys/stat.h>
  17 #include <limits.h>
  18 #include <fcntl.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <unistd.h>
  23 #include <assert.h>
  24 #include <stdint.h>
  25 #include <errno.h>
  26
  27 #include <rpm/rpmio.h>
  28 #include <rpm/rpmpgp.h>
  29 #ifndef RPM5
  30 #include <rpm/header.h>
  31 #endif
  32 #include <rpm/rpmdb.h>
  33
  34 #ifndef DB_CREATE
  35 # if defined(SUSE) || defined(HAVE_RPM_DB_H)
  36 #  include <rpm/db.h>
  37 # else
  38 #  include <db.h>
  39 # endif
  40 #endif
  41
  42 #include "pool.h"
  43 #include "repo.h"
  44 #include "hash.h"
  45 #include "util.h"
  46 #include "queue.h"
  47 #include "chksum.h"
  48 #include "repo_rpmdb.h"
  49 #include "repo_solv.h"
  50 #ifdef ENABLE_COMPLEX_DEPS
  51 #include "pool_parserpmrichdep.h"
  52 #endif
  53
  54 /* 3: added triggers */
  55 /* 4: fixed triggers */
  56 /* 5: fixed checksum copying */
  57 /* 6: add SOLVABLE_PREREQ_IGNOREINST support */
  58 /* 7: fix bug in ignoreinst logic */
  59 #define RPMDB_COOKIE_VERSION 7
  60
  61 #define TAG_NAME                1000
  62 #define TAG_VERSION             1001
  63 #define TAG_RELEASE             1002
  64 #define TAG_EPOCH               1003
  65 #define TAG_SUMMARY             1004
  66 #define TAG_DESCRIPTION         1005
  67 #define TAG_BUILDTIME           1006
  68 #define TAG_BUILDHOST           1007
  69 #define TAG_INSTALLTIME         1008
  70 #define TAG_SIZE                1009
  71 #define TAG_DISTRIBUTION        1010
  72 #define TAG_VENDOR              1011
  73 #define TAG_LICENSE             1014
  74 #define TAG_PACKAGER            1015
  75 #define TAG_GROUP               1016
  76 #define TAG_URL                 1020
  77 #define TAG_ARCH                1022
  78 #define TAG_FILESIZES           1028
  79 #define TAG_FILEMODES           1030
  80 #define TAG_FILEMD5S            1035
  81 #define TAG_FILELINKTOS         1036
  82 #define TAG_FILEFLAGS           1037
  83 #define TAG_SOURCERPM           1044
  84 #define TAG_PROVIDENAME         1047
  85 #define TAG_REQUIREFLAGS        1048
  86 #define TAG_REQUIRENAME         1049
  87 #define TAG_REQUIREVERSION      1050
  88 #define TAG_NOSOURCE            1051
  89 #define TAG_NOPATCH             1052
  90 #define TAG_CONFLICTFLAGS       1053
  91 #define TAG_CONFLICTNAME        1054
  92 #define TAG_CONFLICTVERSION     1055
  93 #define TAG_TRIGGERNAME         1066
  94 #define TAG_TRIGGERVERSION      1067
  95 #define TAG_TRIGGERFLAGS        1068
  96 #define TAG_CHANGELOGTIME       1080
  97 #define TAG_CHANGELOGNAME       1081
  98 #define TAG_CHANGELOGTEXT       1082
  99 #define TAG_OBSOLETENAME        1090
 100 #define TAG_FILEDEVICES         1095
 101 #define TAG_FILEINODES          1096
 102 #define TAG_SOURCEPACKAGE       1106
 103 #define TAG_PROVIDEFLAGS        1112
 104 #define TAG_PROVIDEVERSION      1113
 105 #define TAG_OBSOLETEFLAGS       1114
 106 #define TAG_OBSOLETEVERSION     1115
 107 #define TAG_DIRINDEXES          1116
 108 #define TAG_BASENAMES           1117
 109 #define TAG_DIRNAMES            1118
 110 #define TAG_PAYLOADFORMAT       1124
 111 #define TAG_PATCHESNAME         1133
 112 #define TAG_FILECOLORS          1140
 113 #define TAG_OLDSUGGESTSNAME     1156
 114 #define TAG_OLDSUGGESTSVERSION  1157
 115 #define TAG_OLDSUGGESTSFLAGS    1158
 116 #define TAG_OLDENHANCESNAME     1159
 117 #define TAG_OLDENHANCESVERSION  1160
 118 #define TAG_OLDENHANCESFLAGS    1161
 119
 120 /* rpm5 tags */
 121 #define TAG_DISTEPOCH           1218
 122
 123 /* rpm4 tags */
 124 #define TAG_LONGFILESIZES       5008
 125 #define TAG_LONGSIZE            5009
 126 #define TAG_RECOMMENDNAME       5046
 127 #define TAG_RECOMMENDVERSION    5047
 128 #define TAG_RECOMMENDFLAGS      5048
 129 #define TAG_SUGGESTNAME         5049
 130 #define TAG_SUGGESTVERSION      5050
 131 #define TAG_SUGGESTFLAGS        5051
 132 #define TAG_SUPPLEMENTNAME      5052
 133 #define TAG_SUPPLEMENTVERSION   5053
 134 #define TAG_SUPPLEMENTFLAGS     5054
 135 #define TAG_ENHANCENAME         5055
 136 #define TAG_ENHANCEVERSION      5056
 137 #define TAG_ENHANCEFLAGS        5057
 138
 139 /* signature tags */
 140 #define TAG_SIGBASE             256
 141 #define TAG_SIGMD5              (TAG_SIGBASE + 5)
 142 #define TAG_SHA1HEADER          (TAG_SIGBASE + 13)
 143
 144 #define SIGTAG_SIZE             1000
 145 #define SIGTAG_PGP              1002    /* RSA signature */
 146 #define SIGTAG_MD5              1004    /* header+payload md5 checksum */
 147 #define SIGTAG_GPG              1005    /* DSA signature */
 148
 149 #define DEP_LESS                (1 << 1)
 150 #define DEP_GREATER             (1 << 2)
 151 #define DEP_EQUAL               (1 << 3)
 152 #define DEP_STRONG              (1 << 27)
 153 #define DEP_PRE_IN              ((1 << 6) | (1 << 9) | (1 << 10))
 154 #define DEP_PRE_UN              ((1 << 6) | (1 << 11) | (1 << 12))
 155
 156 #define FILEFLAG_GHOST          (1 <<  6)
 157
 158
 159 #ifdef RPM5
 160 # define RPM_INDEX_SIZE 4       /* just the rpmdbid */
 161 #else
 162 # define RPM_INDEX_SIZE 8       /* rpmdbid + array index */
 163 #endif
 164
 165
 166 typedef struct rpmhead {
 167   int cnt;
 168   int dcnt;
 169   unsigned char *dp;
 170   int forcebinary;              /* sigh, see rh#478907 */
 171   unsigned char data[1];
 172 } RpmHead;
 173
 174
 175 static inline unsigned char *
 176 headfindtag(RpmHead *h, int tag)
 177 {
 178   unsigned int i;
 179   unsigned char *d, taga[4];
 180   d = h->dp - 16;
 181   taga[0] = tag >> 24;
 182   taga[1] = tag >> 16;
 183   taga[2] = tag >> 8;
 184   taga[3] = tag;
 185   for (i = 0; i < h->cnt; i++, d -= 16)
 186     if (d[3] == taga[3] && d[2] == taga[2] && d[1] == taga[1] && d[0] == taga[0])
 187       return d;
 188   return 0;
 189 }
 190
 191 static int
 192 headexists(RpmHead *h, int tag)
 193 {
 194   return headfindtag(h, tag) ? 1 : 0;
 195 }
 196
 197 static unsigned int *
 198 headint32array(RpmHead *h, int tag, int *cnt)
 199 {
 200   unsigned int i, o, *r;
 201   unsigned char *d = headfindtag(h, tag);
 202
 203   if (!d || d[4] != 0 || d[5] != 0 || d[6] != 0 || d[7] != 4)
 204     return 0;
 205   o = d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11];
 206   i = d[12] << 24 | d[13] << 16 | d[14] << 8 | d[15];
 207   if (o + 4 * i > h->dcnt)
 208     return 0;
 209   d = h->dp + o;
 210   r = solv_calloc(i ? i : 1, sizeof(unsigned int));
 211   if (cnt)
 212     *cnt = i;
 213   for (o = 0; o < i; o++, d += 4)
 214     r[o] = d[0] << 24 | d[1] << 16 | d[2] << 8 | d[3];
 215   return r;
 216 }
 217
 218 /* returns the first entry of an integer array */
 219 static unsigned int
 220 headint32(RpmHead *h, int tag)
 221 {
 222   unsigned int i, o;
 223   unsigned char *d = headfindtag(h, tag);
 224
 225   if (!d || d[4] != 0 || d[5] != 0 || d[6] != 0 || d[7] != 4)
 226     return 0;
 227   o = d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11];
 228   i = d[12] << 24 | d[13] << 16 | d[14] << 8 | d[15];
 229   if (i == 0 || o + 4 * i > h->dcnt)
 230     return 0;
 231   d = h->dp + o;
 232   return d[0] << 24 | d[1] << 16 | d[2] << 8 | d[3];
 233 }
 234
 235 static unsigned long long *
 236 headint64array(RpmHead *h, int tag, int *cnt)
 237 {
 238   unsigned int i, o;
 239   unsigned long long *r;
 240   unsigned char *d = headfindtag(h, tag);
 241
 242   if (!d || d[4] != 0 || d[5] != 0 || d[6] != 0 || d[7] != 5)
 243     return 0;
 244   o = d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11];
 245   i = d[12] << 24 | d[13] << 16 | d[14] << 8 | d[15];
 246   if (o + 8 * i > h->dcnt)
 247     return 0;
 248   d = h->dp + o;
 249   r = solv_calloc(i ? i : 1, sizeof(unsigned long long));
 250   if (cnt)
 251     *cnt = i;
 252   for (o = 0; o < i; o++, d += 8)
 253     {
 254       unsigned int x = d[0] << 24 | d[1] << 16 | d[2] << 8 | d[3];
 255       r[o] = (unsigned long long)x << 32 | (d[4] << 24 | d[5] << 16 | d[6] << 8 | d[7]);
 256     }
 257   return r;
 258 }
 259
 260 /* returns the first entry of an 64bit integer array */
 261 static unsigned long long
 262 headint64(RpmHead *h, int tag)
 263 {
 264   unsigned int i, o;
 265   unsigned char *d = headfindtag(h, tag);
 266   if (!d || d[4] != 0 || d[5] != 0 || d[6] != 0 || d[7] != 5)
 267     return 0;
 268   o = d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11];
 269   i = d[12] << 24 | d[13] << 16 | d[14] << 8 | d[15];
 270   if (i == 0 || o + 8 * i > h->dcnt)
 271     return 0;
 272   d = h->dp + o;
 273   i = d[0] << 24 | d[1] << 16 | d[2] << 8 | d[3];
 274   return (unsigned long long)i << 32 | (d[4] << 24 | d[5] << 16 | d[6] << 8 | d[7]);
 275 }
 276
 277 static unsigned int *
 278 headint16array(RpmHead *h, int tag, int *cnt)
 279 {
 280   unsigned int i, o, *r;
 281   unsigned char *d = headfindtag(h, tag);
 282
 283   if (!d || d[4] != 0 || d[5] != 0 || d[6] != 0 || d[7] != 3)
 284     return 0;
 285   o = d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11];
 286   i = d[12] << 24 | d[13] << 16 | d[14] << 8 | d[15];
 287   if (o + 4 * i > h->dcnt)
 288     return 0;
 289   d = h->dp + o;
 290   r = solv_calloc(i ? i : 1, sizeof(unsigned int));
 291   if (cnt)
 292     *cnt = i;
 293   for (o = 0; o < i; o++, d += 2)
 294     r[o] = d[0] << 8 | d[1];
 295   return r;
 296 }
 297
 298 static char *
 299 headstring(RpmHead *h, int tag)
 300 {
 301   unsigned int o;
 302   unsigned char *d = headfindtag(h, tag);
 303   /* 6: STRING, 9: I18NSTRING */
 304   if (!d || d[4] != 0 || d[5] != 0 || d[6] != 0 || (d[7] != 6 && d[7] != 9))
 305     return 0;
 306   o = d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11];
 307   if (o >= h->dcnt)
 308     return 0;
 309   return (char *)h->dp + o;
 310 }
 311
 312 static char **
 313 headstringarray(RpmHead *h, int tag, int *cnt)
 314 {
 315   unsigned int i, o;
 316   unsigned char *d = headfindtag(h, tag);
 317   char **r;
 318
 319   if (!d || d[4] != 0 || d[5] != 0 || d[6] != 0 || d[7] != 8)
 320     return 0;
 321   o = d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11];
 322   i = d[12] << 24 | d[13] << 16 | d[14] << 8 | d[15];
 323   r = solv_calloc(i ? i : 1, sizeof(char *));
 324   if (cnt)
 325     *cnt = i;
 326   d = h->dp + o;
 327   for (o = 0; o < i; o++)
 328     {
 329       r[o] = (char *)d;
 330       if (o + 1 < i)
 331         d += strlen((char *)d) + 1;
 332       if (d >= h->dp + h->dcnt)
 333         {
 334           solv_free(r);
 335           return 0;
 336         }
 337     }
 338   return r;
 339 }
 340
 341 static unsigned char *
 342 headbinary(RpmHead *h, int tag, unsigned int *sizep)
 343 {
 344   unsigned int i, o;
 345   unsigned char *d = headfindtag(h, tag);
 346   if (!d || d[4] != 0 || d[5] != 0 || d[6] != 0 || d[7] != 7)
 347     return 0;
 348   o = d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11];
 349   i = d[12] << 24 | d[13] << 16 | d[14] << 8 | d[15];
 350   if (o > h->dcnt || o + i < o || o + i > h->dcnt)
 351     return 0;
 352   if (sizep)
 353     *sizep = i;
 354   return h->dp + o;
 355 }
 356
 357 static char *headtoevr(RpmHead *h)
 358 {
 359   unsigned int epoch;
 360   char *version, *v;
 361   char *release;
 362   char *evr;
 363   char *distepoch;
 364
 365   version  = headstring(h, TAG_VERSION);
 366   release  = headstring(h, TAG_RELEASE);
 367   epoch = headint32(h, TAG_EPOCH);
 368   if (!version || !release)
 369     {
 370       fprintf(stderr, "headtoevr: bad rpm header\n");
 371       return 0;
 372     }
 373   for (v = version; *v >= '0' && *v <= '9'; v++)
 374     ;
 375   if (epoch || (v != version && *v == ':'))
 376     {
 377       char epochbuf[11];        /* 32bit decimal will fit in */
 378       sprintf(epochbuf, "%u", epoch);
 379       evr = solv_malloc(strlen(epochbuf) + 1 + strlen(version) + 1 + strlen(release) + 1);
 380       sprintf(evr, "%s:%s-%s", epochbuf, version, release);
 381     }
 382   else
 383     {
 384       evr = solv_malloc(strlen(version) + 1 + strlen(release) + 1);
 385       sprintf(evr, "%s-%s", version, release);
 386     }
 387   distepoch = headstring(h, TAG_DISTEPOCH);
 388   if (distepoch && *distepoch)
 389     {
 390       int l = strlen(evr);
 391       evr = solv_realloc(evr, l + strlen(distepoch) + 2);
 392       evr[l++] = ':';
 393       strcpy(evr + l, distepoch);
 394     }
 395   return evr;
 396 }
 397
 398
 399 static void
 400 setutf8string(Repodata *repodata, Id handle, Id tag, const char *str)
 401 {
 402   if (str[solv_validutf8(str)])
 403     {
 404       char *ustr = solv_latin1toutf8(str);      /* not utf8, assume latin1 */
 405       repodata_set_str(repodata, handle, tag, ustr);
 406       solv_free(ustr);
 407     }
 408   else
 409     repodata_set_str(repodata, handle, tag, str);
 410 }
 411
 412 static int
 413 ignq_sortcmp(const void *va, const void *vb, void *dp)
 414 {
 415   int r = *(Id *)va - *(Id *)vb;
 416   if (!r)
 417     r = ((Id *)va)[1] - ((Id *)vb)[1];
 418   return r;
 419 }
 420
 421 /*
 422  * strong: 0: ignore strongness
 423  *         1: filter to strong
 424  *         2: filter to weak
 425  */
 426 static unsigned int
 427 makedeps(Pool *pool, Repo *repo, RpmHead *rpmhead, int tagn, int tagv, int tagf, int flags, Queue *ignq)
 428 {
 429   char **n, **v;
 430   unsigned int *f;
 431   int i, cc, nc, vc, fc;
 432   int haspre, premask, has_ign;
 433   unsigned int olddeps;
 434   Id *ida;
 435   int strong = 0;
 436
 437   n = headstringarray(rpmhead, tagn, &nc);
 438   if (!n)
 439     {
 440       switch (tagn)
 441         {
 442         case TAG_SUGGESTNAME:
 443           tagn = TAG_OLDSUGGESTSNAME;
 444           tagv = TAG_OLDSUGGESTSVERSION;
 445           tagf = TAG_OLDSUGGESTSFLAGS;
 446           strong = -1;
 447           break;
 448         case TAG_ENHANCENAME:
 449           tagn = TAG_OLDENHANCESNAME;
 450           tagv = TAG_OLDENHANCESVERSION;
 451           tagf = TAG_OLDENHANCESFLAGS;
 452           strong = -1;
 453           break;
 454         case TAG_RECOMMENDNAME:
 455           tagn = TAG_OLDSUGGESTSNAME;
 456           tagv = TAG_OLDSUGGESTSVERSION;
 457           tagf = TAG_OLDSUGGESTSFLAGS;
 458           strong = 1;
 459           break;
 460         case TAG_SUPPLEMENTNAME:
 461           tagn = TAG_OLDENHANCESNAME;
 462           tagv = TAG_OLDENHANCESVERSION;
 463           tagf = TAG_OLDENHANCESFLAGS;
 464           strong = 1;
 465           break;
 466         default:
 467           return 0;
 468         }
 469       n = headstringarray(rpmhead, tagn, &nc);
 470     }
 471   if (!n || !nc)
 472     return 0;
 473   vc = fc = 0;
 474   v = headstringarray(rpmhead, tagv, &vc);
 475   f = headint32array(rpmhead, tagf, &fc);
 476   if (!v || !f || nc != vc || nc != fc)
 477     {
 478       char *pkgname = rpm_query(rpmhead, 0);
 479       pool_error(pool, 0, "bad dependency entries for %s: %d %d %d", pkgname ? pkgname : "<NULL>", nc, vc, fc);
 480       solv_free(pkgname);
 481       solv_free(n);
 482       solv_free(v);
 483       solv_free(f);
 484       return 0;
 485     }
 486
 487   cc = nc;
 488   haspre = 0;   /* add no prereq marker */
 489   premask = tagn == TAG_REQUIRENAME ? DEP_PRE_IN | DEP_PRE_UN : 0;
 490   if ((flags & RPM_ADD_NO_RPMLIBREQS) || strong)
 491     {
 492       /* we do filtering */
 493       cc = 0;
 494       for (i = 0; i < nc; i++)
 495         {
 496           if (strong && (f[i] & DEP_STRONG) != (strong < 0 ? 0 : DEP_STRONG))
 497             continue;
 498           if ((flags & RPM_ADD_NO_RPMLIBREQS) != 0)
 499             if (!strncmp(n[i], "rpmlib(", 7))
 500               continue;
 501           if ((f[i] & premask) != 0)
 502             haspre = 1;
 503           cc++;
 504         }
 505     }
 506   else if (premask)
 507     {
 508       /* no filtering, just look for the first prereq */
 509       for (i = 0; i < nc; i++)
 510         if ((f[i] & premask) != 0)
 511           {
 512             haspre = 1;
 513             break;
 514           }
 515     }
 516   if (cc == 0)
 517     {
 518       solv_free(n);
 519       solv_free(v);
 520       solv_free(f);
 521       return 0;
 522     }
 523   cc += haspre;         /* add slot for the prereq marker */
 524   olddeps = repo_reserve_ids(repo, 0, cc);
 525   ida = repo->idarraydata + olddeps;
 526
 527   has_ign = 0;
 528   for (i = 0; ; i++)
 529     {
 530       Id id;
 531       if (i == nc)
 532         {
 533           if (haspre != 1)
 534             break;
 535           haspre = 2;   /* pass two: prereqs */
 536           i = 0;
 537           *ida++ = SOLVABLE_PREREQMARKER;
 538         }
 539       if (strong && (f[i] & DEP_STRONG) != (strong < 0 ? 0 : DEP_STRONG))
 540         continue;
 541       if (haspre)
 542         {
 543           if (haspre == 1 && (f[i] & premask) != 0)
 544             continue;
 545           if (haspre == 2 && (f[i] & premask) == 0)
 546             continue;
 547         }
 548       if ((flags & RPM_ADD_NO_RPMLIBREQS) != 0)
 549         if (!strncmp(n[i], "rpmlib(", 7))
 550           continue;
 551 #ifdef ENABLE_COMPLEX_DEPS
 552       if ((f[i] & (DEP_LESS|DEP_EQUAL|DEP_GREATER)) == 0 && n[i][0] == '(')
 553         {
 554           id = pool_parserpmrichdep(pool, n[i]);
 555           if (id)
 556             *ida++ = id;
 557           else
 558             cc--;
 559           continue;
 560         }
 561 #endif
 562       id = pool_str2id(pool, n[i], 1);
 563       if (f[i] & (DEP_LESS|DEP_GREATER|DEP_EQUAL))
 564         {
 565           Id evr;
 566           int fl = 0;
 567           if ((f[i] & DEP_LESS) != 0)
 568             fl |= REL_LT;
 569           if ((f[i] & DEP_EQUAL) != 0)
 570             fl |= REL_EQ;
 571           if ((f[i] & DEP_GREATER) != 0)
 572             fl |= REL_GT;
 573           if (v[i][0] == '0' && v[i][1] == ':' && v[i][2])
 574             evr = pool_str2id(pool, v[i] + 2, 1);
 575           else
 576             evr = pool_str2id(pool, v[i], 1);
 577           id = pool_rel2id(pool, id, evr, fl, 1);
 578         }
 579       *ida++ = id;
 580       if (haspre == 2 && ignq)
 581         {
 582           int is_ign = (f[i] & DEP_PRE_IN) != 0 && (f[i] & DEP_PRE_UN) == 0 ? 1 : 0;
 583           has_ign |= is_ign;
 584           queue_push2(ignq, id, is_ign);
 585         }
 586     }
 587   *ida++ = 0;
 588   repo->idarraysize += cc + 1;
 589   solv_free(n);
 590   solv_free(v);
 591   solv_free(f);
 592   if (ignq && ignq->count)
 593     {
 594       int j = 0;
 595       if (has_ign && ignq->count == 2)
 596         j = 1;
 597       else if (has_ign)
 598         {
 599           Id id, lastid = 0;
 600
 601           solv_sort(ignq->elements, ignq->count / 2, sizeof(Id) * 2, ignq_sortcmp, 0);
 602           for (i = j = 0; i < ignq->count; i += 2)
 603             {
 604               id = ignq->elements[i];
 605               if (id != lastid && ignq->elements[i + 1] > 0)
 606                 ignq->elements[j++] = id;
 607               lastid = id;
 608             }
 609         }
 610       queue_truncate(ignq, j);
 611     }
 612   return olddeps;
 613 }
 614
 615
 616 static void
 617 adddudata(Repodata *data, Id handle, RpmHead *rpmhead, char **dn, unsigned int *di, int fc, int dc)
 618 {
 619   Id did;
 620   int i, fszc;
 621   unsigned int *fkb, *fn, *fsz, *fm, *fino;
 622   unsigned long long *fsz64;
 623   unsigned int inotest[256], inotestok;
 624
 625   if (!fc)
 626     return;
 627   if ((fsz64 = headint64array(rpmhead, TAG_LONGFILESIZES, &fszc)) != 0)
 628     {
 629       /* convert to kbyte */
 630       fsz = solv_malloc2(fszc, sizeof(*fsz));
 631       for (i = 0; i < fszc; i++)
 632         fsz[i] = fsz64[i] ? fsz64[i] / 1024 + 1 : 0;
 633       solv_free(fsz64);
 634     }
 635   else if ((fsz = headint32array(rpmhead, TAG_FILESIZES, &fszc)) != 0)
 636     {
 637       /* convert to kbyte */
 638       for (i = 0; i < fszc; i++)
 639         if (fsz[i])
 640           fsz[i] = fsz[i] / 1024 + 1;
 641     }
 642   else
 643     return;
 644   if (fc != fszc)
 645     {
 646       solv_free(fsz);
 647       return;
 648     }
 649
 650   /* stupid rpm records sizes of directories, so we have to check the mode */
 651   fm = headint16array(rpmhead, TAG_FILEMODES, &fszc);
 652   if (!fm || fc != fszc)
 653     {
 654       solv_free(fsz);
 655       solv_free(fm);
 656       return;
 657     }
 658   fino = headint32array(rpmhead, TAG_FILEINODES, &fszc);
 659   if (!fino || fc != fszc)
 660     {
 661       solv_free(fsz);
 662       solv_free(fm);
 663       solv_free(fino);
 664       return;
 665     }
 666
 667   /* kill hardlinked entries */
 668   inotestok = 0;
 669   if (fc < sizeof(inotest))
 670     {
 671       /* quick test just hashing the inode numbers */
 672       memset(inotest, 0, sizeof(inotest));
 673       for (i = 0; i < fc; i++)
 674         {
 675           int off, bit;
 676           if (fsz[i] == 0 || !S_ISREG(fm[i]))
 677             continue;   /* does not matter */
 678           off = (fino[i] >> 5) & (sizeof(inotest)/sizeof(*inotest) - 1);
 679           bit = 1 << (fino[i] & 31);
 680           if ((inotest[off] & bit) != 0)
 681             break;
 682           inotest[off] |= bit;
 683         }
 684       if (i == fc)
 685         inotestok = 1;  /* no conflict found */
 686     }
 687   if (!inotestok)
 688     {
 689       /* hardlinked files are possible, check ino/dev pairs */
 690       unsigned int *fdev = headint32array(rpmhead, TAG_FILEDEVICES, &fszc);
 691       unsigned int *fx, j;
 692       unsigned int mask, hash, hh;
 693       if (!fdev || fc != fszc)
 694         {
 695           solv_free(fsz);
 696           solv_free(fm);
 697           solv_free(fdev);
 698           solv_free(fino);
 699           return;
 700         }
 701       mask = fc;
 702       while ((mask & (mask - 1)) != 0)
 703         mask = mask & (mask - 1);
 704       mask <<= 2;
 705       if (mask > sizeof(inotest)/sizeof(*inotest))
 706         fx = solv_calloc(mask, sizeof(unsigned int));
 707       else
 708         {
 709           fx = inotest;
 710           memset(fx, 0, mask * sizeof(unsigned int));
 711         }
 712       mask--;
 713       for (i = 0; i < fc; i++)
 714         {
 715           if (fsz[i] == 0 || !S_ISREG(fm[i]))
 716             continue;
 717           hash = (fino[i] + fdev[i] * 31) & mask;
 718           hh = 7;
 719           while ((j = fx[hash]) != 0)
 720             {
 721               if (fino[j - 1] == fino[i] && fdev[j - 1] == fdev[i])
 722                 {
 723                   fsz[i] = 0;   /* kill entry */
 724                   break;
 725                 }
 726               hash = (hash + hh++) & mask;
 727             }
 728           if (!j)
 729             fx[hash] = i + 1;
 730         }
 731       if (fx != inotest)
 732         solv_free(fx);
 733       solv_free(fdev);
 734     }
 735   solv_free(fino);
 736
 737   /* sum up inode count and kbytes for each directory */
 738   fn = solv_calloc(dc, sizeof(unsigned int));
 739   fkb = solv_calloc(dc, sizeof(unsigned int));
 740   for (i = 0; i < fc; i++)
 741     {
 742       if (di[i] >= dc)
 743         continue;       /* corrupt entry */
 744       fn[di[i]]++;
 745       if (fsz[i] == 0 || !S_ISREG(fm[i]))
 746         continue;
 747       fkb[di[i]] += fsz[i];
 748     }
 749   solv_free(fsz);
 750   solv_free(fm);
 751   /* commit */
 752   for (i = 0; i < dc; i++)
 753     {
 754       if (!fn[i])
 755         continue;
 756       if (!*dn[i])
 757         {
 758           Solvable *s = data->repo->pool->solvables + handle;
 759           if (s->arch == ARCH_SRC || s->arch == ARCH_NOSRC)
 760             did = repodata_str2dir(data, "/usr/src", 1);
 761           else
 762             continue;   /* work around rpm bug */
 763         }
 764       else
 765         did = repodata_str2dir(data, dn[i], 1);
 766       repodata_add_dirnumnum(data, handle, SOLVABLE_DISKUSAGE, did, fkb[i], fn[i]);
 767     }
 768   solv_free(fn);
 769   solv_free(fkb);
 770 }
 771
 772 static int
 773 is_filtered(const char *dir)
 774 {
 775   if (!dir)
 776     return 1;
 777   /* the dirs always have a trailing / in rpm */
 778   if (strstr(dir, "bin/"))
 779     return 0;
 780   if (!strncmp(dir, "/etc/", 5))
 781     return 0;
 782   if (!strcmp(dir, "/usr/lib/"))
 783     return 2;
 784   return 1;
 785 }
 786
 787 static void
 788 addfilelist(Repodata *data, Id handle, RpmHead *rpmhead, int flags)
 789 {
 790   char **bn;
 791   char **dn;
 792   unsigned int *di;
 793   int bnc, dnc, dic;
 794   int i;
 795   Id lastdid = 0;
 796   unsigned int lastdii = -1;
 797   int lastfiltered = 0;
 798
 799   if (!data)
 800     return;
 801   bn = headstringarray(rpmhead, TAG_BASENAMES, &bnc);
 802   if (!bn)
 803     return;
 804   dn = headstringarray(rpmhead, TAG_DIRNAMES, &dnc);
 805   if (!dn)
 806     {
 807       solv_free(bn);
 808       return;
 809     }
 810   di = headint32array(rpmhead, TAG_DIRINDEXES, &dic);
 811   if (!di)
 812     {
 813       solv_free(bn);
 814       solv_free(dn);
 815       return;
 816     }
 817   if (bnc != dic)
 818     {
 819       pool_error(data->repo->pool, 0, "bad filelist");
 820       return;
 821     }
 822
 823   adddudata(data, handle, rpmhead, dn, di, bnc, dnc);
 824
 825   for (i = 0; i < bnc; i++)
 826     {
 827       Id did;
 828       char *b = bn[i];
 829
 830       if (di[i] == lastdii)
 831         did = lastdid;
 832       else
 833         {
 834           if (di[i] >= dnc)
 835             continue;   /* corrupt entry */
 836           lastdii = di[i];
 837           if ((flags & RPM_ADD_FILTERED_FILELIST) != 0)
 838             {
 839               lastfiltered = is_filtered(dn[di[i]]);
 840               if (lastfiltered == 1)
 841                 continue;
 842             }
 843           did = repodata_str2dir(data, dn[lastdii], 1);
 844           if (!did)
 845             did = repodata_str2dir(data, "/", 1);
 846           lastdid = did;
 847         }
 848       if (b && *b == '/')       /* work around rpm bug */
 849         b++;
 850       if (lastfiltered)
 851         {
 852           if (lastfiltered != 2 || strcmp(b, "sendmail"))
 853             continue;
 854         }
 855       repodata_add_dirstr(data, handle, SOLVABLE_FILELIST, did, b);
 856     }
 857   solv_free(bn);
 858   solv_free(dn);
 859   solv_free(di);
 860 }
 861
 862 static void
 863 addchangelog(Repodata *data, Id handle, RpmHead *rpmhead)
 864 {
 865   char **cn;
 866   char **cx;
 867   unsigned int *ct;
 868   int i, cnc, cxc, ctc;
 869   Queue hq;
 870
 871   ct = headint32array(rpmhead, TAG_CHANGELOGTIME, &ctc);
 872   cx = headstringarray(rpmhead, TAG_CHANGELOGTEXT, &cxc);
 873   cn = headstringarray(rpmhead, TAG_CHANGELOGNAME, &cnc);
 874   if (!ct || !cx || !cn || !ctc || ctc != cxc || ctc != cnc)
 875     {
 876       solv_free(ct);
 877       solv_free(cx);
 878       solv_free(cn);
 879       return;
 880     }
 881   queue_init(&hq);
 882   for (i = 0; i < ctc; i++)
 883     {
 884       Id h = repodata_new_handle(data);
 885       if (ct[i])
 886         repodata_set_num(data, h, SOLVABLE_CHANGELOG_TIME, ct[i]);
 887       if (cn[i])
 888         setutf8string(data, h, SOLVABLE_CHANGELOG_AUTHOR, cn[i]);
 889       if (cx[i])
 890         setutf8string(data, h, SOLVABLE_CHANGELOG_TEXT, cx[i]);
 891       queue_push(&hq, h);
 892     }
 893   for (i = 0; i < hq.count; i++)
 894     repodata_add_flexarray(data, handle, SOLVABLE_CHANGELOG, hq.elements[i]);
 895   queue_free(&hq);
 896   solv_free(ct);
 897   solv_free(cx);
 898   solv_free(cn);
 899 }
 900
 901 static void
 902 set_description_author(Repodata *data, Id handle, char *str)
 903 {
 904   char *aut, *p;
 905   for (aut = str; (aut = strchr(aut, '\n')) != 0; aut++)
 906     if (!strncmp(aut, "\nAuthors:\n--------\n", 19))
 907       break;
 908   if (aut)
 909     {
 910       /* oh my, found SUSE special author section */
 911       int l = aut - str;
 912       str = solv_strdup(str);
 913       aut = str + l;
 914       str[l] = 0;
 915       while (l > 0 && str[l - 1] == '\n')
 916         str[--l] = 0;
 917       if (l)
 918         setutf8string(data, handle, SOLVABLE_DESCRIPTION, str);
 919       p = aut + 19;
 920       aut = str;        /* copy over */
 921       while (*p == ' ' || *p == '\n')
 922         p++;
 923       while (*p)
 924         {
 925           if (*p == '\n')
 926             {
 927               *aut++ = *p++;
 928               while (*p == ' ')
 929                 p++;
 930               continue;
 931             }
 932           *aut++ = *p++;
 933         }
 934       while (aut != str && aut[-1] == '\n')
 935         aut--;
 936       *aut = 0;
 937       if (*str)
 938         setutf8string(data, handle, SOLVABLE_AUTHORS, str);
 939       free(str);
 940     }
 941   else if (*str)
 942     setutf8string(data, handle, SOLVABLE_DESCRIPTION, str);
 943 }
 944
 945 static int
 946 rpm2solv(Pool *pool, Repo *repo, Repodata *data, Solvable *s, RpmHead *rpmhead, int flags)
 947 {
 948   char *name;
 949   char *evr;
 950   char *sourcerpm;
 951   Queue ignq;
 952   Id ignqbuf[64];
 953
 954   name = headstring(rpmhead, TAG_NAME);
 955   if (!name)
 956     {
 957       pool_error(pool, 0, "package has no name");
 958       return 0;
 959     }
 960   if (!strcmp(name, "gpg-pubkey"))
 961     return 0;
 962   s->name = pool_str2id(pool, name, 1);
 963   sourcerpm = headstring(rpmhead, TAG_SOURCERPM);
 964   if (sourcerpm || (rpmhead->forcebinary && !headexists(rpmhead, TAG_SOURCEPACKAGE)))
 965     s->arch = pool_str2id(pool, headstring(rpmhead, TAG_ARCH), 1);
 966   else
 967     {
 968       if (headexists(rpmhead, TAG_NOSOURCE) || headexists(rpmhead, TAG_NOPATCH))
 969         s->arch = ARCH_NOSRC;
 970       else
 971         s->arch = ARCH_SRC;
 972     }
 973   if (!s->arch)
 974     s->arch = ARCH_NOARCH;
 975   evr = headtoevr(rpmhead);
 976   s->evr = pool_str2id(pool, evr, 1);
 977   s->vendor = pool_str2id(pool, headstring(rpmhead, TAG_VENDOR), 1);
 978
 979   queue_init_buffer(&ignq, ignqbuf, sizeof(ignqbuf)/sizeof(*ignqbuf));
 980
 981   s->provides = makedeps(pool, repo, rpmhead, TAG_PROVIDENAME, TAG_PROVIDEVERSION, TAG_PROVIDEFLAGS, 0, 0);
 982   if (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
 983     s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 984   s->requires = makedeps(pool, repo, rpmhead, TAG_REQUIRENAME, TAG_REQUIREVERSION, TAG_REQUIREFLAGS, flags, &ignq);
 985   s->conflicts = makedeps(pool, repo, rpmhead, TAG_CONFLICTNAME, TAG_CONFLICTVERSION, TAG_CONFLICTFLAGS, 0, 0);
 986   s->obsoletes = makedeps(pool, repo, rpmhead, TAG_OBSOLETENAME, TAG_OBSOLETEVERSION, TAG_OBSOLETEFLAGS, 0, 0);
 987
 988   s->recommends = makedeps(pool, repo, rpmhead, TAG_RECOMMENDNAME, TAG_RECOMMENDVERSION, TAG_RECOMMENDFLAGS, 0, 0);
 989   s->suggests = makedeps(pool, repo, rpmhead, TAG_SUGGESTNAME, TAG_SUGGESTVERSION, TAG_SUGGESTFLAGS, 0, 0);
 990   s->supplements = makedeps(pool, repo, rpmhead, TAG_SUPPLEMENTNAME, TAG_SUPPLEMENTVERSION, TAG_SUPPLEMENTFLAGS, 0, 0);
 991   s->enhances  = makedeps(pool, repo, rpmhead, TAG_ENHANCENAME, TAG_ENHANCEVERSION, TAG_ENHANCEFLAGS, 0, 0);
 992
 993   s->supplements = repo_fix_supplements(repo, s->provides, s->supplements, 0);
 994   s->conflicts = repo_fix_conflicts(repo, s->conflicts);
 995
 996   if (data && ignq.count)
 997     repodata_set_idarray(data, s - pool->solvables, SOLVABLE_PREREQ_IGNOREINST, &ignq);
 998   queue_free(&ignq);
 999
1000   if (data)
1001     {
1002       Id handle;
1003       char *str;
1004       unsigned int u32;
1005       unsigned long long u64;
1006
1007       handle = s - pool->solvables;
1008       str = headstring(rpmhead, TAG_SUMMARY);
1009       if (str)
1010         setutf8string(data, handle, SOLVABLE_SUMMARY, str);
1011       str = headstring(rpmhead, TAG_DESCRIPTION);
1012       if (str)
1013         set_description_author(data, handle, str);
1014       str = headstring(rpmhead, TAG_GROUP);
1015       if (str)
1016         repodata_set_poolstr(data, handle, SOLVABLE_GROUP, str);
1017       str = headstring(rpmhead, TAG_LICENSE);
1018       if (str)
1019         repodata_set_poolstr(data, handle, SOLVABLE_LICENSE, str);
1020       str = headstring(rpmhead, TAG_URL);
1021       if (str)
1022         repodata_set_str(data, handle, SOLVABLE_URL, str);
1023       str = headstring(rpmhead, TAG_DISTRIBUTION);
1024       if (str)
1025         repodata_set_poolstr(data, handle, SOLVABLE_DISTRIBUTION, str);
1026       str = headstring(rpmhead, TAG_PACKAGER);
1027       if (str)
1028         repodata_set_poolstr(data, handle, SOLVABLE_PACKAGER, str);
1029       if ((flags & RPM_ADD_WITH_PKGID) != 0)
1030         {
1031           unsigned char *chksum;
1032           unsigned int chksumsize;
1033           chksum = headbinary(rpmhead, TAG_SIGMD5, &chksumsize);
1034           if (chksum && chksumsize == 16)
1035             repodata_set_bin_checksum(data, handle, SOLVABLE_PKGID, REPOKEY_TYPE_MD5, chksum);
1036         }
1037       if ((flags & RPM_ADD_WITH_HDRID) != 0)
1038         {
1039           str = headstring(rpmhead, TAG_SHA1HEADER);
1040           if (str && strlen(str) == 40)
1041             repodata_set_checksum(data, handle, SOLVABLE_HDRID, REPOKEY_TYPE_SHA1, str);
1042           else if (str && strlen(str) == 64)
1043             repodata_set_checksum(data, handle, SOLVABLE_HDRID, REPOKEY_TYPE_SHA256, str);
1044         }
1045       u32 = headint32(rpmhead, TAG_BUILDTIME);
1046       if (u32)
1047         repodata_set_num(data, handle, SOLVABLE_BUILDTIME, u32);
1048       u32 = headint32(rpmhead, TAG_INSTALLTIME);
1049       if (u32)
1050         repodata_set_num(data, handle, SOLVABLE_INSTALLTIME, u32);
1051       u64 = headint64(rpmhead, TAG_LONGSIZE);
1052       if (u64)
1053         repodata_set_num(data, handle, SOLVABLE_INSTALLSIZE, u64);
1054       else
1055         {
1056           u32 = headint32(rpmhead, TAG_SIZE);
1057           if (u32)
1058             repodata_set_num(data, handle, SOLVABLE_INSTALLSIZE, u32);
1059         }
1060       if (sourcerpm)
1061         repodata_set_sourcepkg(data, handle, sourcerpm);
1062       if ((flags & RPM_ADD_TRIGGERS) != 0)
1063         {
1064           unsigned int ida = makedeps(pool, repo, rpmhead, TAG_TRIGGERNAME, TAG_TRIGGERVERSION, TAG_TRIGGERFLAGS, 0, 0);
1065           Id id, lastid = 0;
1066           for (lastid = 0; (id = repo->idarraydata[ida]) != 0; ida++, lastid = id)
1067             if (id != lastid)
1068               repodata_add_idarray(data, handle, SOLVABLE_TRIGGERS, id);
1069         }
1070       if ((flags & RPM_ADD_NO_FILELIST) == 0)
1071         addfilelist(data, handle, rpmhead, flags);
1072       if ((flags & RPM_ADD_WITH_CHANGELOG) != 0)
1073         addchangelog(data, handle, rpmhead);
1074     }
1075   solv_free(evr);
1076   return 1;
1077 }
1078
1079
1080 /******************************************************************/
1081 /*  Rpm Database stuff
1082  */
1083
1084 struct rpmdbstate {
1085   Pool *pool;
1086   char *rootdir;
1087
1088   RpmHead *rpmhead;     /* header storage space */
1089   int rpmheadsize;
1090
1091   int dbopened;
1092   DB_ENV *dbenv;        /* database environment */
1093   DB *db;               /* packages database */
1094   int byteswapped;      /* endianess of packages database */
1095   int is_ostree;        /* read-only db that lives in /usr/share/rpm */
1096 };
1097
1098 struct rpmdbentry {
1099   Id rpmdbid;
1100   Id nameoff;
1101 };
1102
1103 #define ENTRIES_BLOCK 255
1104 #define NAMEDATA_BLOCK 1023
1105
1106
1107 static inline Id db2rpmdbid(unsigned char *db, int byteswapped)
1108 {
1109 #ifdef RPM5
1110   return db[0] << 24 | db[1] << 16 | db[2] << 8 | db[3];
1111 #else
1112 # if defined(WORDS_BIGENDIAN)
1113   if (!byteswapped)
1114 # else
1115   if (byteswapped)
1116 # endif
1117     return db[0] << 24 | db[1] << 16 | db[2] << 8 | db[3];
1118   else
1119     return db[3] << 24 | db[2] << 16 | db[1] << 8 | db[0];
1120 #endif
1121 }
1122
1123 static inline void rpmdbid2db(unsigned char *db, Id id, int byteswapped)
1124 {
1125 #ifdef RPM5
1126   db[0] = id >> 24, db[1] = id >> 16, db[2] = id >> 8, db[3] = id;
1127 #else
1128 # if defined(WORDS_BIGENDIAN)
1129   if (!byteswapped)
1130 # else
1131   if (byteswapped)
1132 # endif
1133     db[0] = id >> 24, db[1] = id >> 16, db[2] = id >> 8, db[3] = id;
1134   else
1135     db[3] = id >> 24, db[2] = id >> 16, db[1] = id >> 8, db[0] = id;
1136 #endif
1137 }
1138
1139 #ifdef FEDORA
1140 int
1141 serialize_dbenv_ops(struct rpmdbstate *state)
1142 {
1143   char lpath[PATH_MAX];
1144   mode_t oldmask;
1145   int fd;
1146   struct flock fl;
1147
1148   snprintf(lpath, PATH_MAX, "%s/var/lib/rpm/.dbenv.lock", state->rootdir ? state->rootdir : "");
1149   oldmask = umask(022);
1150   fd = open(lpath, (O_RDWR|O_CREAT), 0644);
1151   umask(oldmask);
1152   if (fd < 0)
1153     return -1;
1154   memset(&fl, 0, sizeof(fl));
1155   fl.l_type = F_WRLCK;
1156   fl.l_whence = SEEK_SET;
1157   for (;;)
1158     {
1159       if (fcntl(fd, F_SETLKW, &fl) != -1)
1160         return fd;
1161       if (errno != EINTR)
1162         break;
1163     }
1164   close(fd);
1165   return -1;
1166 }
1167 #endif
1168
1169 /* should look in /usr/lib/rpm/macros instead, but we want speed... */
1170 static int
1171 opendbenv(struct rpmdbstate *state)
1172 {
1173   const char *rootdir = state->rootdir;
1174   char dbpath[PATH_MAX];
1175   DB_ENV *dbenv = 0;
1176   int r;
1177
1178   if (db_env_create(&dbenv, 0))
1179     return pool_error(state->pool, 0, "db_env_create: %s", strerror(errno));
1180 #if defined(FEDORA) && (DB_VERSION_MAJOR >= 5 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 5))
1181   dbenv->set_thread_count(dbenv, 8);
1182 #endif
1183   snprintf(dbpath, PATH_MAX, "%s/var/lib/rpm", rootdir ? rootdir : "");
1184   if (access(dbpath, W_OK) == -1)
1185     {
1186       snprintf(dbpath, PATH_MAX, "%s/usr/share/rpm/Packages", rootdir ? rootdir : "");
1187       if (access(dbpath, R_OK) == 0)
1188         state->is_ostree = 1;
1189       snprintf(dbpath, PATH_MAX, "%s%s", rootdir ? rootdir : "", state->is_ostree ? "/usr/share/rpm" : "/var/lib/rpm");
1190       r = dbenv->open(dbenv, dbpath, DB_CREATE|DB_PRIVATE|DB_INIT_MPOOL, 0);
1191     }
1192   else
1193     {
1194 #ifdef FEDORA
1195       int serialize_fd = serialize_dbenv_ops(state);
1196       r = dbenv->open(dbenv, dbpath, DB_CREATE|DB_INIT_CDB|DB_INIT_MPOOL, 0644);
1197       if (serialize_fd >= 0)
1198         close(serialize_fd);
1199 #else
1200       r = dbenv->open(dbenv, dbpath, DB_CREATE|DB_PRIVATE|DB_INIT_MPOOL, 0);
1201 #endif
1202     }
1203   if (r)
1204     {
1205       pool_error(state->pool, 0, "dbenv->open: %s", strerror(errno));
1206       dbenv->close(dbenv, 0);
1207       return 0;
1208     }
1209   state->dbenv = dbenv;
1210   return 1;
1211 }
1212
1213 static void
1214 closedbenv(struct rpmdbstate *state)
1215 {
1216 #ifdef FEDORA
1217   uint32_t eflags = 0;
1218 #endif
1219
1220   if (!state->dbenv)
1221     return;
1222 #ifdef FEDORA
1223   (void)state->dbenv->get_open_flags(state->dbenv, &eflags);
1224   if (!(eflags & DB_PRIVATE))
1225     {
1226       int serialize_fd = serialize_dbenv_ops(state);
1227       state->dbenv->close(state->dbenv, 0);
1228       if (serialize_fd >= 0)
1229         close(serialize_fd);
1230     }
1231   else
1232     state->dbenv->close(state->dbenv, 0);
1233 #else
1234   state->dbenv->close(state->dbenv, 0);
1235 #endif
1236   state->dbenv = 0;
1237 }
1238
1239 static int
1240 openpkgdb(struct rpmdbstate *state)
1241 {
1242   if (state->dbopened)
1243     return state->dbopened > 0 ? 1 : 0;
1244   state->dbopened = -1;
1245   if (!state->dbenv && !opendbenv(state))
1246     return 0;
1247   if (db_create(&state->db, state->dbenv, 0))
1248     {
1249       pool_error(state->pool, 0, "db_create: %s", strerror(errno));
1250       state->db = 0;
1251       closedbenv(state);
1252       return 0;
1253     }
1254   if (state->db->open(state->db, 0, "Packages", 0, DB_UNKNOWN, DB_RDONLY, 0664))
1255     {
1256       pool_error(state->pool, 0, "db->open Packages: %s", strerror(errno));
1257       state->db->close(state->db, 0);
1258       state->db = 0;
1259       closedbenv(state);
1260       return 0;
1261     }
1262   if (state->db->get_byteswapped(state->db, &state->byteswapped))
1263     {
1264       pool_error(state->pool, 0, "db->get_byteswapped: %s", strerror(errno));
1265       state->db->close(state->db, 0);
1266       state->db = 0;
1267       closedbenv(state);
1268       return 0;
1269     }
1270   state->dbopened = 1;
1271   return 1;
1272 }
1273
1274 /* get the rpmdbids of all installed packages from the Name index database.
1275  * This is much faster then querying the big Packages database */
1276 static struct rpmdbentry *
1277 getinstalledrpmdbids(struct rpmdbstate *state, const char *index, const char *match, int *nentriesp, char **namedatap)
1278 {
1279   DB_ENV *dbenv = 0;
1280   DB *db = 0;
1281   DBC *dbc = 0;
1282   int byteswapped;
1283   DBT dbkey;
1284   DBT dbdata;
1285   unsigned char *dp;
1286   int dl;
1287   Id nameoff;
1288
1289   char *namedata = 0;
1290   int namedatal = 0;
1291   struct rpmdbentry *entries = 0;
1292   int nentries = 0;
1293
1294   *nentriesp = 0;
1295   if (namedatap)
1296     *namedatap = 0;
1297
1298   if (!state->dbenv && !opendbenv(state))
1299     return 0;
1300   dbenv = state->dbenv;
1301   if (db_create(&db, dbenv, 0))
1302     {
1303       pool_error(state->pool, 0, "db_create: %s", strerror(errno));
1304       return 0;
1305     }
1306   if (db->open(db, 0, index, 0, DB_UNKNOWN, DB_RDONLY, 0664))
1307     {
1308       pool_error(state->pool, 0, "db->open %s: %s", index, strerror(errno));
1309       db->close(db, 0);
1310       return 0;
1311     }
1312   if (db->get_byteswapped(db, &byteswapped))
1313     {
1314       pool_error(state->pool, 0, "db->get_byteswapped: %s", strerror(errno));
1315       db->close(db, 0);
1316       return 0;
1317     }
1318   if (db->cursor(db, NULL, &dbc, 0))
1319     {
1320       pool_error(state->pool, 0, "db->cursor: %s", strerror(errno));
1321       db->close(db, 0);
1322       return 0;
1323     }
1324   memset(&dbkey, 0, sizeof(dbkey));
1325   memset(&dbdata, 0, sizeof(dbdata));
1326   if (match)
1327     {
1328       dbkey.data = (void *)match;
1329       dbkey.size = strlen(match);
1330     }
1331   while (dbc->c_get(dbc, &dbkey, &dbdata, match ? DB_SET : DB_NEXT) == 0)
1332     {
1333       if (!match && dbkey.size == 10 && !memcmp(dbkey.data, "gpg-pubkey", 10))
1334         continue;
1335       dl = dbdata.size;
1336       dp = dbdata.data;
1337       nameoff = namedatal;
1338       if (namedatap)
1339         {
1340           namedata = solv_extend(namedata, namedatal, dbkey.size + 1, 1, NAMEDATA_BLOCK);
1341           memcpy(namedata + namedatal, dbkey.data, dbkey.size);
1342           namedata[namedatal + dbkey.size] = 0;
1343           namedatal += dbkey.size + 1;
1344         }
1345       while(dl >= RPM_INDEX_SIZE)
1346         {
1347           entries = solv_extend(entries, nentries, 1, sizeof(*entries), ENTRIES_BLOCK);
1348           entries[nentries].rpmdbid = db2rpmdbid(dp, byteswapped);
1349           entries[nentries].nameoff = nameoff;
1350           nentries++;
1351           dp += RPM_INDEX_SIZE;
1352           dl -= RPM_INDEX_SIZE;
1353         }
1354       if (match)
1355         break;
1356     }
1357   dbc->c_close(dbc);
1358   db->close(db, 0);
1359   /* make sure that enteries is != 0 if there was no error */
1360   if (!entries)
1361     entries = solv_extend(entries, 1, 1, sizeof(*entries), ENTRIES_BLOCK);
1362   *nentriesp = nentries;
1363   if (namedatap)
1364     *namedatap = namedata;
1365   return entries;
1366 }
1367
1368 /* retrive header by rpmdbid */
1369 static int
1370 getrpmdbid(struct rpmdbstate *state, Id rpmdbid)
1371 {
1372   unsigned char buf[16];
1373   DBT dbkey;
1374   DBT dbdata;
1375   RpmHead *rpmhead;
1376
1377   if (!rpmdbid)
1378     {
1379       pool_error(state->pool, 0, "illegal rpmdbid");
1380       return -1;
1381     }
1382   if (state->dbopened != 1 && !openpkgdb(state))
1383     return -1;
1384   rpmdbid2db(buf, rpmdbid, state->byteswapped);
1385   memset(&dbkey, 0, sizeof(dbkey));
1386   memset(&dbdata, 0, sizeof(dbdata));
1387   dbkey.data = buf;
1388   dbkey.size = 4;
1389   dbdata.data = 0;
1390   dbdata.size = 0;
1391   if (state->db->get(state->db, NULL, &dbkey, &dbdata, 0))
1392     return 0;
1393   if (dbdata.size < 8)
1394     {
1395       pool_error(state->pool, 0, "corrupt rpm database (size)");
1396       return -1;
1397     }
1398   if (dbdata.size > state->rpmheadsize)
1399     {
1400       state->rpmheadsize = dbdata.size + 128;
1401       state->rpmhead = solv_realloc(state->rpmhead, sizeof(*rpmhead) + state->rpmheadsize);
1402     }
1403   rpmhead = state->rpmhead;
1404   memcpy(buf, dbdata.data, 8);
1405   rpmhead->forcebinary = 1;
1406   rpmhead->cnt = buf[0] << 24  | buf[1] << 16  | buf[2] << 8 | buf[3];
1407   rpmhead->dcnt = buf[4] << 24  | buf[5] << 16  | buf[6] << 8 | buf[7];
1408   if (8 + rpmhead->cnt * 16 + rpmhead->dcnt > dbdata.size)
1409     {
1410       pool_error(state->pool, 0, "corrupt rpm database (data size)");
1411       return -1;
1412     }
1413   memcpy(rpmhead->data, (unsigned char *)dbdata.data + 8, rpmhead->cnt * 16 + rpmhead->dcnt);
1414   rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
1415   return 1;
1416 }
1417
1418 /* retrive header by berkeleydb cursor */
1419 static Id
1420 getrpmcursor(struct rpmdbstate *state, DBC *dbc)
1421 {
1422   unsigned char buf[16];
1423   DBT dbkey;
1424   DBT dbdata;
1425   RpmHead *rpmhead;
1426   Id dbid;
1427
1428   memset(&dbkey, 0, sizeof(dbkey));
1429   memset(&dbdata, 0, sizeof(dbdata));
1430   while (dbc->c_get(dbc, &dbkey, &dbdata, DB_NEXT) == 0)
1431     {
1432       if (dbkey.size != 4)
1433         return pool_error(state->pool, -1, "corrupt Packages database (key size)");
1434       dbid = db2rpmdbid(dbkey.data, state->byteswapped);
1435       if (dbid == 0)            /* the join key */
1436         continue;
1437       if (dbdata.size < 8)
1438         return pool_error(state->pool, -1, "corrupt rpm database (size %u)\n", dbdata.size);
1439       if (dbdata.size > state->rpmheadsize)
1440         {
1441           state->rpmheadsize = dbdata.size + 128;
1442           state->rpmhead = solv_realloc(state->rpmhead, sizeof(*state->rpmhead) + state->rpmheadsize);
1443         }
1444       rpmhead = state->rpmhead;
1445       memcpy(buf, dbdata.data, 8);
1446       rpmhead->forcebinary = 1;
1447       rpmhead->cnt = buf[0] << 24  | buf[1] << 16  | buf[2] << 8 | buf[3];
1448       rpmhead->dcnt = buf[4] << 24  | buf[5] << 16  | buf[6] << 8 | buf[7];
1449       if (8 + rpmhead->cnt * 16 + rpmhead->dcnt > dbdata.size)
1450         return pool_error(state->pool, -1, "corrupt rpm database (data size)\n");
1451       memcpy(rpmhead->data, (unsigned char *)dbdata.data + 8, rpmhead->cnt * 16 + rpmhead->dcnt);
1452       rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
1453       return dbid;
1454     }
1455   return 0;
1456 }
1457
1458 static void
1459 freestate(struct rpmdbstate *state)
1460 {
1461   /* close down */
1462   if (!state)
1463     return;
1464   if (state->db)
1465     state->db->close(state->db, 0);
1466   if (state->dbenv)
1467     closedbenv(state);
1468   if (state->rootdir)
1469     solv_free(state->rootdir);
1470   solv_free(state->rpmhead);
1471 }
1472
1473 void *
1474 rpm_state_create(Pool *pool, const char *rootdir)
1475 {
1476   struct rpmdbstate *state;
1477   state = solv_calloc(1, sizeof(*state));
1478   state->pool = pool;
1479   if (rootdir)
1480     state->rootdir = solv_strdup(rootdir);
1481   return state;
1482 }
1483
1484 void *
1485 rpm_state_free(void *state)
1486 {
1487   freestate(state);
1488   return solv_free(state);
1489 }
1490
1491 static int
1492 count_headers(struct rpmdbstate *state)
1493 {
1494   Pool *pool = state->pool;
1495   char dbpath[PATH_MAX];
1496   struct stat statbuf;
1497   DB *db = 0;
1498   DBC *dbc = 0;
1499   int count = 0;
1500   DBT dbkey;
1501   DBT dbdata;
1502
1503   snprintf(dbpath, PATH_MAX, "%s%s/Name", state->rootdir ? state->rootdir : "", state->is_ostree ? "/usr/share/rpm" : "/var/lib/rpm");
1504   if (stat(dbpath, &statbuf))
1505     return 0;
1506   memset(&dbkey, 0, sizeof(dbkey));
1507   memset(&dbdata, 0, sizeof(dbdata));
1508   if (db_create(&db, state->dbenv, 0))
1509     {
1510       pool_error(pool, 0, "db_create: %s", strerror(errno));
1511       return 0;
1512     }
1513   if (db->open(db, 0, "Name", 0, DB_UNKNOWN, DB_RDONLY, 0664))
1514     {
1515       pool_error(pool, 0, "db->open Name: %s", strerror(errno));
1516       db->close(db, 0);
1517       return 0;
1518     }
1519   if (db->cursor(db, NULL, &dbc, 0))
1520     {
1521       db->close(db, 0);
1522       pool_error(pool, 0, "db->cursor: %s", strerror(errno));
1523       return 0;
1524     }
1525   while (dbc->c_get(dbc, &dbkey, &dbdata, DB_NEXT) == 0)
1526     count += dbdata.size / RPM_INDEX_SIZE;
1527   dbc->c_close(dbc);
1528   db->close(db, 0);
1529   return count;
1530 }
1531
1532 /******************************************************************/
1533
1534 static Offset
1535 copydeps(Pool *pool, Repo *repo, Offset fromoff, Repo *fromrepo)
1536 {
1537   int cc;
1538   Id *ida, *from;
1539   Offset ido;
1540
1541   if (!fromoff)
1542     return 0;
1543   from = fromrepo->idarraydata + fromoff;
1544   for (ida = from, cc = 0; *ida; ida++, cc++)
1545     ;
1546   if (cc == 0)
1547     return 0;
1548   ido = repo_reserve_ids(repo, 0, cc);
1549   ida = repo->idarraydata + ido;
1550   memcpy(ida, from, (cc + 1) * sizeof(Id));
1551   repo->idarraysize += cc + 1;
1552   return ido;
1553 }
1554
1555 #define COPYDIR_DIRCACHE_SIZE 512
1556
1557 static Id copydir_complex(Pool *pool, Repodata *data, Repodata *fromdata, Id did, Id *cache);
1558
1559 static inline Id
1560 copydir(Pool *pool, Repodata *data, Repodata *fromdata, Id did, Id *cache)
1561 {
1562   if (cache && cache[did & 255] == did)
1563     return cache[(did & 255) + 256];
1564   return copydir_complex(pool, data, fromdata, did, cache);
1565 }
1566
1567 static Id
1568 copydir_complex(Pool *pool, Repodata *data, Repodata *fromdata, Id did, Id *cache)
1569 {
1570   Id parent = dirpool_parent(&fromdata->dirpool, did);
1571   Id compid = dirpool_compid(&fromdata->dirpool, did);
1572   if (parent)
1573     parent = copydir(pool, data, fromdata, parent, cache);
1574   if (data->localpool || fromdata->localpool)
1575     compid = repodata_translate_id(data, fromdata, compid, 1);
1576   compid = dirpool_add_dir(&data->dirpool, parent, compid, 1);
1577   if (cache)
1578     {
1579       cache[did & 255] = did;
1580       cache[(did & 255) + 256] = compid;
1581     }
1582   return compid;
1583 }
1584
1585 struct solvable_copy_cbdata {
1586   Repodata *data;
1587   Id handle;
1588   Id subhandle;
1589   Id *dircache;
1590 };
1591
1592 static int
1593 solvable_copy_cb(void *vcbdata, Solvable *r, Repodata *fromdata, Repokey *key, KeyValue *kv)
1594 {
1595   struct solvable_copy_cbdata *cbdata = vcbdata;
1596   Id id, keyname;
1597   Repodata *data = cbdata->data;
1598   Id handle = cbdata->handle;
1599   Pool *pool = data->repo->pool;
1600
1601   keyname = key->name;
1602   switch(key->type)
1603     {
1604     case REPOKEY_TYPE_ID:
1605     case REPOKEY_TYPE_CONSTANTID:
1606     case REPOKEY_TYPE_IDARRAY:  /* used for triggers */
1607       id = kv->id;
1608       if (data->localpool || fromdata->localpool)
1609         id = repodata_translate_id(data, fromdata, id, 1);
1610       if (key->type == REPOKEY_TYPE_ID)
1611         repodata_set_id(data, handle, keyname, id);
1612       else if (key->type == REPOKEY_TYPE_CONSTANTID)
1613         repodata_set_constantid(data, handle, keyname, id);
1614       else
1615         repodata_add_idarray(data, handle, keyname, id);
1616       break;
1617     case REPOKEY_TYPE_STR:
1618       repodata_set_str(data, handle, keyname, kv->str);
1619       break;
1620     case REPOKEY_TYPE_VOID:
1621       repodata_set_void(data, handle, keyname);
1622       break;
1623     case REPOKEY_TYPE_NUM:
1624       repodata_set_num(data, handle, keyname, SOLV_KV_NUM64(kv));
1625       break;
1626     case REPOKEY_TYPE_CONSTANT:
1627       repodata_set_constant(data, handle, keyname, kv->num);
1628       break;
1629     case REPOKEY_TYPE_DIRNUMNUMARRAY:
1630       id = kv->id;
1631       id = copydir(pool, data, fromdata, id, cbdata->dircache);
1632       repodata_add_dirnumnum(data, handle, keyname, id, kv->num, kv->num2);
1633       break;
1634     case REPOKEY_TYPE_DIRSTRARRAY:
1635       id = kv->id;
1636       id = copydir(pool, data, fromdata, id, cbdata->dircache);
1637       repodata_add_dirstr(data, handle, keyname, id, kv->str);
1638       break;
1639     case REPOKEY_TYPE_FLEXARRAY:
1640       if (kv->eof == 2)
1641         {
1642           assert(cbdata->subhandle);
1643           cbdata->handle = cbdata->subhandle;
1644           cbdata->subhandle = 0;
1645           break;
1646         }
1647       if (!kv->entry)
1648         {
1649           assert(!cbdata->subhandle);
1650           cbdata->subhandle = cbdata->handle;
1651         }
1652       cbdata->handle = repodata_new_handle(data);
1653       repodata_add_flexarray(data, cbdata->subhandle, keyname, cbdata->handle);
1654       break;
1655     default:
1656       if (solv_chksum_len(key->type))
1657         {
1658           repodata_set_bin_checksum(data, handle, keyname, key->type, (const unsigned char *)kv->str);
1659           break;
1660         }
1661       break;
1662     }
1663   return 0;
1664 }
1665
1666 static void
1667 solvable_copy(Solvable *s, Solvable *r, Repodata *data, Id *dircache)
1668 {
1669   int p, i;
1670   Repo *repo = s->repo;
1671   Pool *pool = repo->pool;
1672   Repo *fromrepo = r->repo;
1673   struct solvable_copy_cbdata cbdata;
1674
1675   /* copy solvable data */
1676   s->name = r->name;
1677   s->evr = r->evr;
1678   s->arch = r->arch;
1679   s->vendor = r->vendor;
1680   s->provides = copydeps(pool, repo, r->provides, fromrepo);
1681   s->requires = copydeps(pool, repo, r->requires, fromrepo);
1682   s->conflicts = copydeps(pool, repo, r->conflicts, fromrepo);
1683   s->obsoletes = copydeps(pool, repo, r->obsoletes, fromrepo);
1684   s->recommends = copydeps(pool, repo, r->recommends, fromrepo);
1685   s->suggests = copydeps(pool, repo, r->suggests, fromrepo);
1686   s->supplements = copydeps(pool, repo, r->supplements, fromrepo);
1687   s->enhances  = copydeps(pool, repo, r->enhances, fromrepo);
1688
1689   /* copy all attributes */
1690   if (!data)
1691     return;
1692   cbdata.data = data;
1693   cbdata.handle = s - pool->solvables;
1694   cbdata.subhandle = 0;
1695   cbdata.dircache = dircache;
1696   p = r - fromrepo->pool->solvables;
1697 #if 0
1698   repo_search(fromrepo, p, 0, 0, SEARCH_NO_STORAGE_SOLVABLE | SEARCH_SUB | SEARCH_ARRAYSENTINEL, solvable_copy_cb, &cbdata);
1699 #else
1700   FOR_REPODATAS(fromrepo, i, data)
1701     {
1702       if (p >= data->start && p < data->end)
1703         repodata_search(data, p, 0, SEARCH_SUB | SEARCH_ARRAYSENTINEL, solvable_copy_cb, &cbdata);
1704       cbdata.dircache = 0;      /* only for first repodata */
1705     }
1706 #endif
1707 }
1708
1709 /* used to sort entries by package name that got returned in some database order */
1710 static int
1711 rpmids_sort_cmp(const void *va, const void *vb, void *dp)
1712 {
1713   struct rpmdbentry const *a = va, *b = vb;
1714   char *namedata = dp;
1715   int r;
1716   r = strcmp(namedata + a->nameoff, namedata + b->nameoff);
1717   if (r)
1718     return r;
1719   return a->rpmdbid - b->rpmdbid;
1720 }
1721
1722 static int
1723 pkgids_sort_cmp(const void *va, const void *vb, void *dp)
1724 {
1725   Repo *repo = dp;
1726   Pool *pool = repo->pool;
1727   Solvable *a = pool->solvables + *(Id *)va;
1728   Solvable *b = pool->solvables + *(Id *)vb;
1729   Id *rpmdbid;
1730
1731   if (a->name != b->name)
1732     return strcmp(pool_id2str(pool, a->name), pool_id2str(pool, b->name));
1733   rpmdbid = repo->rpmdbid;
1734   return rpmdbid[(a - pool->solvables) - repo->start] - rpmdbid[(b - pool->solvables) - repo->start];
1735 }
1736
1737 static void
1738 swap_solvables(Repo *repo, Repodata *data, Id pa, Id pb)
1739 {
1740   Pool *pool = repo->pool;
1741   Solvable tmp;
1742
1743   tmp = pool->solvables[pa];
1744   pool->solvables[pa] = pool->solvables[pb];
1745   pool->solvables[pb] = tmp;
1746   if (repo->rpmdbid)
1747     {
1748       Id tmpid = repo->rpmdbid[pa - repo->start];
1749       repo->rpmdbid[pa - repo->start] = repo->rpmdbid[pb - repo->start];
1750       repo->rpmdbid[pb - repo->start] = tmpid;
1751     }
1752   /* only works if nothing is already internalized! */
1753   if (data)
1754     repodata_swap_attrs(data, pa, pb);
1755 }
1756
1757 static void
1758 mkrpmdbcookie(struct stat *st, unsigned char *cookie, int flags)
1759 {
1760   int f = 0;
1761   memset(cookie, 0, 32);
1762   cookie[3] = RPMDB_COOKIE_VERSION;
1763   memcpy(cookie + 16, &st->st_ino, sizeof(st->st_ino));
1764   memcpy(cookie + 24, &st->st_dev, sizeof(st->st_dev));
1765   if ((flags & RPM_ADD_WITH_PKGID) != 0)
1766     f |= 1;
1767   if ((flags & RPM_ADD_WITH_HDRID) != 0)
1768     f |= 2;
1769   if ((flags & RPM_ADD_WITH_CHANGELOG) != 0)
1770     f |= 4;
1771   if ((flags & RPM_ADD_NO_FILELIST) == 0)
1772     f |= 8;
1773   if ((flags & RPM_ADD_NO_RPMLIBREQS) != 0)
1774     cookie[1] = 1;
1775   cookie[0] = f;
1776 }
1777
1778 /*
1779  * read rpm db as repo
1780  *
1781  */
1782
1783 int
1784 repo_add_rpmdb(Repo *repo, Repo *ref, int flags)
1785 {
1786   Pool *pool = repo->pool;
1787   char dbpath[PATH_MAX];
1788   struct stat packagesstat;
1789   unsigned char newcookie[32];
1790   const unsigned char *oldcookie = 0;
1791   Id oldcookietype = 0;
1792   Repodata *data;
1793   int count = 0, done = 0;
1794   struct rpmdbstate state;
1795   int i;
1796   Solvable *s;
1797   unsigned int now;
1798
1799   now = solv_timems(0);
1800   memset(&state, 0, sizeof(state));
1801   state.pool = pool;
1802   if (flags & REPO_USE_ROOTDIR)
1803     state.rootdir = solv_strdup(pool_get_rootdir(pool));
1804
1805   data = repo_add_repodata(repo, flags);
1806
1807   if (ref && !(ref->nsolvables && ref->rpmdbid && ref->pool == repo->pool))
1808     {
1809       if ((flags & RPMDB_EMPTY_REFREPO) != 0)
1810         repo_empty(ref, 1);
1811       ref = 0;
1812     }
1813
1814   if (!opendbenv(&state))
1815     {
1816       solv_free(state.rootdir);
1817       return -1;
1818     }
1819
1820   /* XXX: should get ro lock of Packages database! */
1821   snprintf(dbpath, PATH_MAX, "%s%s/Packages", state.rootdir ? state.rootdir : "", state.is_ostree ? "/usr/share/rpm" : "/var/lib/rpm");
1822   if (stat(dbpath, &packagesstat))
1823     {
1824       pool_error(pool, -1, "%s: %s", dbpath, strerror(errno));
1825       freestate(&state);
1826       return -1;
1827     }
1828   mkrpmdbcookie(&packagesstat, newcookie, flags);
1829   repodata_set_bin_checksum(data, SOLVID_META, REPOSITORY_RPMDBCOOKIE, REPOKEY_TYPE_SHA256, newcookie);
1830
1831   if (ref)
1832     oldcookie = repo_lookup_bin_checksum(ref, SOLVID_META, REPOSITORY_RPMDBCOOKIE, &oldcookietype);
1833   if (!ref || !oldcookie || oldcookietype != REPOKEY_TYPE_SHA256 || memcmp(oldcookie, newcookie, 32) != 0)
1834     {
1835       int solvstart = 0, solvend = 0;
1836       Id dbid;
1837       DBC *dbc = 0;
1838
1839       if (ref && (flags & RPMDB_EMPTY_REFREPO) != 0)
1840         repo_empty(ref, 1);     /* get it out of the way */
1841       if ((flags & RPMDB_REPORT_PROGRESS) != 0)
1842         count = count_headers(&state);
1843       if (!openpkgdb(&state))
1844         {
1845           freestate(&state);
1846           return -1;
1847         }
1848       if (state.db->cursor(state.db, NULL, &dbc, 0))
1849         {
1850           freestate(&state);
1851           return pool_error(pool, -1, "db->cursor failed");
1852         }
1853       i = 0;
1854       s = 0;
1855       while ((dbid = getrpmcursor(&state, dbc)) != 0)
1856         {
1857           if (dbid == -1)
1858             {
1859               dbc->c_close(dbc);
1860               freestate(&state);
1861               return -1;
1862             }
1863           if (!s)
1864             {
1865               s = pool_id2solvable(pool, repo_add_solvable(repo));
1866               if (!solvstart)
1867                 solvstart = s - pool->solvables;
1868               solvend = s - pool->solvables + 1;
1869             }
1870           if (!repo->rpmdbid)
1871             repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
1872           repo->rpmdbid[(s - pool->solvables) - repo->start] = dbid;
1873           if (rpm2solv(pool, repo, data, s, state.rpmhead, flags | RPM_ADD_TRIGGERS))
1874             {
1875               i++;
1876               s = 0;
1877             }
1878           else
1879             {
1880               /* We can reuse this solvable, but make sure it's still
1881                  associated with this repo.  */
1882               memset(s, 0, sizeof(*s));
1883               s->repo = repo;
1884             }
1885           if ((flags & RPMDB_REPORT_PROGRESS) != 0)
1886             {
1887               if (done < count)
1888                 done++;
1889               if (done < count && (done - 1) * 100 / count != done * 100 / count)
1890                 pool_debug(pool, SOLV_ERROR, "%%%% %d\n", done * 100 / count);
1891             }
1892         }
1893       dbc->c_close(dbc);
1894       if (s)
1895         {
1896           /* oops, could not reuse. free it instead */
1897           repo_free_solvable(repo, s - pool->solvables, 1);
1898           solvend--;
1899           s = 0;
1900         }
1901       /* now sort all solvables in the new solvstart..solvend block */
1902       if (solvend - solvstart > 1)
1903         {
1904           Id *pkgids = solv_malloc2(solvend - solvstart, sizeof(Id));
1905           for (i = solvstart; i < solvend; i++)
1906             pkgids[i - solvstart] = i;
1907           solv_sort(pkgids, solvend - solvstart, sizeof(Id), pkgids_sort_cmp, repo);
1908           /* adapt order */
1909           for (i = solvstart; i < solvend; i++)
1910             {
1911               int j = pkgids[i - solvstart];
1912               while (j < i)
1913                 j = pkgids[i - solvstart] = pkgids[j - solvstart];
1914               if (j != i)
1915                 swap_solvables(repo, data, i, j);
1916             }
1917           solv_free(pkgids);
1918         }
1919     }
1920   else
1921     {
1922       Id dircache[COPYDIR_DIRCACHE_SIZE];               /* see copydir */
1923       struct rpmdbentry *entries = 0, *rp;
1924       int nentries = 0;
1925       char *namedata = 0;
1926       unsigned int refmask, h;
1927       Id id, *refhash;
1928       int res;
1929
1930       memset(dircache, 0, sizeof(dircache));
1931
1932       /* get ids of installed rpms */
1933       entries = getinstalledrpmdbids(&state, "Name", 0, &nentries, &namedata);
1934       if (!entries)
1935         {
1936           freestate(&state);
1937           return -1;
1938         }
1939
1940       /* sort by name */
1941       if (nentries > 1)
1942         solv_sort(entries, nentries, sizeof(*entries), rpmids_sort_cmp, namedata);
1943
1944       /* create hash from dbid to ref */
1945       refmask = mkmask(ref->nsolvables);
1946       refhash = solv_calloc(refmask + 1, sizeof(Id));
1947       for (i = 0; i < ref->end - ref->start; i++)
1948         {
1949           if (!ref->rpmdbid[i])
1950             continue;
1951           h = ref->rpmdbid[i] & refmask;
1952           while (refhash[h])
1953             h = (h + 317) & refmask;
1954           refhash[h] = i + 1;   /* make it non-zero */
1955         }
1956
1957       /* count the misses, they will cost us time */
1958       if ((flags & RPMDB_REPORT_PROGRESS) != 0)
1959         {
1960           for (i = 0, rp = entries; i < nentries; i++, rp++)
1961             {
1962               if (refhash)
1963                 {
1964                   Id dbid = rp->rpmdbid;
1965                   h = dbid & refmask;
1966                   while ((id = refhash[h]))
1967                     {
1968                       if (ref->rpmdbid[id - 1] == dbid)
1969                         break;
1970                       h = (h + 317) & refmask;
1971                     }
1972                   if (id)
1973                     continue;
1974                 }
1975               count++;
1976             }
1977         }
1978
1979       if (ref && (flags & RPMDB_EMPTY_REFREPO) != 0)
1980         s = pool_id2solvable(pool, repo_add_solvable_block_before(repo, nentries, ref));
1981       else
1982         s = pool_id2solvable(pool, repo_add_solvable_block(repo, nentries));
1983       if (!repo->rpmdbid)
1984         repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
1985
1986       for (i = 0, rp = entries; i < nentries; i++, rp++, s++)
1987         {
1988           Id dbid = rp->rpmdbid;
1989           repo->rpmdbid[(s - pool->solvables) - repo->start] = rp->rpmdbid;
1990           if (refhash)
1991             {
1992               h = dbid & refmask;
1993               while ((id = refhash[h]))
1994                 {
1995                   if (ref->rpmdbid[id - 1] == dbid)
1996                     break;
1997                   h = (h + 317) & refmask;
1998                 }
1999               if (id)
2000                 {
2001                   Solvable *r = ref->pool->solvables + ref->start + (id - 1);
2002                   if (r->repo == ref)
2003                     {
2004                       solvable_copy(s, r, data, dircache);
2005                       continue;
2006                     }
2007                 }
2008             }
2009           res = getrpmdbid(&state, dbid);
2010           if (res <= 0)
2011             {
2012               if (!res)
2013                 pool_error(pool, -1, "inconsistent rpm database, key %d not found. run 'rpm --rebuilddb' to fix.", dbid);
2014               freestate(&state);
2015               solv_free(entries);
2016               solv_free(namedata);
2017               solv_free(refhash);
2018               return -1;
2019             }
2020           rpm2solv(pool, repo, data, s, state.rpmhead, flags | RPM_ADD_TRIGGERS);
2021           if ((flags & RPMDB_REPORT_PROGRESS) != 0)
2022             {
2023               if (done < count)
2024                 done++;
2025               if (done < count && (done - 1) * 100 / count != done * 100 / count)
2026                 pool_debug(pool, SOLV_ERROR, "%%%% %d\n", done * 100 / count);
2027             }
2028         }
2029
2030       solv_free(entries);
2031       solv_free(namedata);
2032       solv_free(refhash);
2033       if (ref && (flags & RPMDB_EMPTY_REFREPO) != 0)
2034         repo_empty(ref, 1);
2035     }
2036
2037   freestate(&state);
2038   if (!(flags & REPO_NO_INTERNALIZE))
2039     repodata_internalize(data);
2040   if ((flags & RPMDB_REPORT_PROGRESS) != 0)
2041     pool_debug(pool, SOLV_ERROR, "%%%% 100\n");
2042   POOL_DEBUG(SOLV_DEBUG_STATS, "repo_add_rpmdb took %d ms\n", solv_timems(now));
2043   POOL_DEBUG(SOLV_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables);
2044   POOL_DEBUG(SOLV_DEBUG_STATS, "repo memory used: %d K incore, %d K idarray\n", repodata_memused(data)/1024, repo->idarraysize / (int)(1024/sizeof(Id)));
2045   return 0;
2046 }
2047
2048 int
2049 repo_add_rpmdb_reffp(Repo *repo, FILE *fp, int flags)
2050 {
2051   int res;
2052   Repo *ref = 0;
2053
2054   if (!fp)
2055     return repo_add_rpmdb(repo, 0, flags);
2056   ref = repo_create(repo->pool, "add_rpmdb_reffp");
2057   if (repo_add_solv(ref, fp, 0) != 0)
2058     {
2059       repo_free(ref, 1);
2060       ref = 0;
2061     }
2062   if (ref && ref->start == ref->end)
2063     {
2064       repo_free(ref, 1);
2065       ref = 0;
2066     }
2067   if (ref)
2068     repo_disable_paging(ref);
2069   res = repo_add_rpmdb(repo, ref, flags | RPMDB_EMPTY_REFREPO);
2070   if (ref)
2071     repo_free(ref, 1);
2072   return res;
2073 }
2074
2075 static inline unsigned int
2076 getu32(const unsigned char *dp)
2077 {
2078   return dp[0] << 24 | dp[1] << 16 | dp[2] << 8 | dp[3];
2079 }
2080
2081
2082 Id
2083 repo_add_rpm(Repo *repo, const char *rpm, int flags)
2084 {
2085   unsigned int sigdsize, sigcnt, l;
2086   Pool *pool = repo->pool;
2087   Solvable *s;
2088   RpmHead *rpmhead = 0;
2089   int rpmheadsize = 0;
2090   char *payloadformat;
2091   FILE *fp;
2092   unsigned char lead[4096];
2093   int headerstart, headerend;
2094   struct stat stb;
2095   Repodata *data;
2096   unsigned char pkgid[16];
2097   unsigned char leadsigid[16];
2098   unsigned char hdrid[32];
2099   int pkgidtype, leadsigidtype, hdridtype;
2100   Id chksumtype = 0;
2101   Chksum *chksumh = 0;
2102   Chksum *leadsigchksumh = 0;
2103   int forcebinary = 0;
2104
2105   data = repo_add_repodata(repo, flags);
2106
2107   if ((flags & RPM_ADD_WITH_SHA256SUM) != 0)
2108     chksumtype = REPOKEY_TYPE_SHA256;
2109   else if ((flags & RPM_ADD_WITH_SHA1SUM) != 0)
2110     chksumtype = REPOKEY_TYPE_SHA1;
2111
2112   if ((fp = fopen(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(pool, rpm) : rpm, "r")) == 0)
2113     {
2114       pool_error(pool, -1, "%s: %s", rpm, strerror(errno));
2115       return 0;
2116     }
2117   if (fstat(fileno(fp), &stb))
2118     {
2119       pool_error(pool, -1, "fstat: %s", strerror(errno));
2120       fclose(fp);
2121       return 0;
2122     }
2123   if (chksumtype)
2124     chksumh = solv_chksum_create(chksumtype);
2125   if ((flags & RPM_ADD_WITH_LEADSIGID) != 0)
2126     leadsigchksumh = solv_chksum_create(REPOKEY_TYPE_MD5);
2127   if (fread(lead, 96 + 16, 1, fp) != 1 || getu32(lead) != 0xedabeedb)
2128     {
2129       pool_error(pool, -1, "%s: not a rpm", rpm);
2130       fclose(fp);
2131       return 0;
2132     }
2133   forcebinary = lead[6] != 0 || lead[7] != 1;
2134   if (chksumh)
2135     solv_chksum_add(chksumh, lead, 96 + 16);
2136   if (leadsigchksumh)
2137     solv_chksum_add(leadsigchksumh, lead, 96 + 16);
2138   if (lead[78] != 0 || lead[79] != 5)
2139     {
2140       pool_error(pool, -1, "%s: not a rpm v5 header", rpm);
2141       fclose(fp);
2142       return 0;
2143     }
2144   if (getu32(lead + 96) != 0x8eade801)
2145     {
2146       pool_error(pool, -1, "%s: bad signature header", rpm);
2147       fclose(fp);
2148       return 0;
2149     }
2150   sigcnt = getu32(lead + 96 + 8);
2151   sigdsize = getu32(lead + 96 + 12);
2152   if (sigcnt >= 0x100000 || sigdsize >= 0x100000)
2153     {
2154       pool_error(pool, -1, "%s: bad signature header", rpm);
2155       fclose(fp);
2156       return 0;
2157     }
2158   sigdsize += sigcnt * 16;
2159   sigdsize = (sigdsize + 7) & ~7;
2160   headerstart = 96 + 16 + sigdsize;
2161   pkgidtype = leadsigidtype = hdridtype = 0;
2162   if ((flags & (RPM_ADD_WITH_PKGID | RPM_ADD_WITH_HDRID)) != 0)
2163     {
2164       /* extract pkgid or hdrid from the signature header */
2165       if (sigdsize > rpmheadsize)
2166         {
2167           rpmheadsize = sigdsize + 128;
2168           rpmhead = solv_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
2169         }
2170       if (fread(rpmhead->data, sigdsize, 1, fp) != 1)
2171         {
2172           pool_error(pool, -1, "%s: unexpected EOF", rpm);
2173           fclose(fp);
2174           return 0;
2175         }
2176       if (chksumh)
2177         solv_chksum_add(chksumh, rpmhead->data, sigdsize);
2178       if (leadsigchksumh)
2179         solv_chksum_add(leadsigchksumh, rpmhead->data, sigdsize);
2180       rpmhead->forcebinary = 0;
2181       rpmhead->cnt = sigcnt;
2182       rpmhead->dcnt = sigdsize - sigcnt * 16;
2183       rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
2184       if ((flags & RPM_ADD_WITH_PKGID) != 0)
2185         {
2186           unsigned char *chksum;
2187           unsigned int chksumsize;
2188           chksum = headbinary(rpmhead, SIGTAG_MD5, &chksumsize);
2189           if (chksum && chksumsize == 16)
2190             {
2191               pkgidtype = REPOKEY_TYPE_MD5;
2192               memcpy(pkgid, chksum, 16);
2193             }
2194         }
2195       if ((flags & RPM_ADD_WITH_HDRID) != 0)
2196         {
2197           const char *str = headstring(rpmhead, TAG_SHA1HEADER);
2198           if (str && strlen(str) == 40)
2199             {
2200               if (solv_hex2bin(&str, hdrid, 20) == 20)
2201                 hdridtype = REPOKEY_TYPE_SHA1;
2202             }
2203           else if (str && strlen(str) == 64)
2204             {
2205               if (solv_hex2bin(&str, hdrid, 32) == 32)
2206                 hdridtype = REPOKEY_TYPE_SHA256;
2207             }
2208         }
2209     }
2210   else
2211     {
2212       /* just skip the signature header */
2213       while (sigdsize)
2214         {
2215           l = sigdsize > 4096 ? 4096 : sigdsize;
2216           if (fread(lead, l, 1, fp) != 1)
2217             {
2218               pool_error(pool, -1, "%s: unexpected EOF", rpm);
2219               fclose(fp);
2220               return 0;
2221             }
2222           if (chksumh)
2223             solv_chksum_add(chksumh, lead, l);
2224           if (leadsigchksumh)
2225             solv_chksum_add(leadsigchksumh, lead, l);
2226           sigdsize -= l;
2227         }
2228     }
2229   if (leadsigchksumh)
2230     {
2231       leadsigchksumh = solv_chksum_free(leadsigchksumh, leadsigid);
2232       leadsigidtype = REPOKEY_TYPE_MD5;
2233     }
2234   if (fread(lead, 16, 1, fp) != 1)
2235     {
2236       pool_error(pool, -1, "%s: unexpected EOF", rpm);
2237       fclose(fp);
2238       return 0;
2239     }
2240   if (chksumh)
2241     solv_chksum_add(chksumh, lead, 16);
2242   if (getu32(lead) != 0x8eade801)
2243     {
2244       pool_error(pool, -1, "%s: bad header", rpm);
2245       fclose(fp);
2246       return 0;
2247     }
2248   sigcnt = getu32(lead + 8);
2249   sigdsize = getu32(lead + 12);
2250   if (sigcnt >= 0x100000 || sigdsize >= 0x2000000)
2251     {
2252       pool_error(pool, -1, "%s: bad header", rpm);
2253       fclose(fp);
2254       return 0;
2255     }
2256   l = sigdsize + sigcnt * 16;
2257   headerend = headerstart + 16 + l;
2258   if (l > rpmheadsize)
2259     {
2260       rpmheadsize = l + 128;
2261       rpmhead = solv_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
2262     }
2263   if (fread(rpmhead->data, l, 1, fp) != 1)
2264     {
2265       pool_error(pool, -1, "%s: unexpected EOF", rpm);
2266       fclose(fp);
2267       return 0;
2268     }
2269   if (chksumh)
2270     solv_chksum_add(chksumh, rpmhead->data, l);
2271   rpmhead->forcebinary = forcebinary;
2272   rpmhead->cnt = sigcnt;
2273   rpmhead->dcnt = sigdsize;
2274   rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
2275   if (headexists(rpmhead, TAG_PATCHESNAME))
2276     {
2277       /* this is a patch rpm, ignore */
2278       pool_error(pool, -1, "%s: is patch rpm", rpm);
2279       fclose(fp);
2280       solv_chksum_free(chksumh, 0);
2281       solv_free(rpmhead);
2282       return 0;
2283     }
2284   payloadformat = headstring(rpmhead, TAG_PAYLOADFORMAT);
2285   if (payloadformat && !strcmp(payloadformat, "drpm"))
2286     {
2287       /* this is a delta rpm */
2288       pool_error(pool, -1, "%s: is delta rpm", rpm);
2289       fclose(fp);
2290       solv_chksum_free(chksumh, 0);
2291       solv_free(rpmhead);
2292       return 0;
2293     }
2294   if (chksumh)
2295     while ((l = fread(lead, 1, sizeof(lead), fp)) > 0)
2296       solv_chksum_add(chksumh, lead, l);
2297   fclose(fp);
2298   s = pool_id2solvable(pool, repo_add_solvable(repo));
2299   if (!rpm2solv(pool, repo, data, s, rpmhead, flags & ~(RPM_ADD_WITH_HDRID | RPM_ADD_WITH_PKGID)))
2300     {
2301       repo_free_solvable(repo, s - pool->solvables, 1);
2302       solv_chksum_free(chksumh, 0);
2303       solv_free(rpmhead);
2304       return 0;
2305     }
2306   if (!(flags & REPO_NO_LOCATION))
2307     repodata_set_location(data, s - pool->solvables, 0, 0, rpm);
2308   if (S_ISREG(stb.st_mode))
2309     repodata_set_num(data, s - pool->solvables, SOLVABLE_DOWNLOADSIZE, (unsigned long long)stb.st_size);
2310   repodata_set_num(data, s - pool->solvables, SOLVABLE_HEADEREND, headerend);
2311   if (pkgidtype)
2312     repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_PKGID, pkgidtype, pkgid);
2313   if (hdridtype)
2314     repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_HDRID, hdridtype, hdrid);
2315   if (leadsigidtype)
2316     repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_LEADSIGID, leadsigidtype, leadsigid);
2317   if (chksumh)
2318     {
2319       repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_CHECKSUM, chksumtype, solv_chksum_get(chksumh, 0));
2320       chksumh = solv_chksum_free(chksumh, 0);
2321     }
2322   solv_free(rpmhead);
2323   if (!(flags & REPO_NO_INTERNALIZE))
2324     repodata_internalize(data);
2325   return s - pool->solvables;
2326 }
2327
2328 Id
2329 repo_add_rpm_handle(Repo *repo, void *rpmhandle, int flags)
2330 {
2331   Pool *pool = repo->pool;
2332   Repodata *data;
2333   RpmHead *rpmhead = rpmhandle;
2334   Solvable *s;
2335   char *payloadformat;
2336
2337   data = repo_add_repodata(repo, flags);
2338   if (headexists(rpmhead, TAG_PATCHESNAME))
2339     {
2340       pool_error(pool, -1, "is a patch rpm");
2341       return 0;
2342     }
2343   payloadformat = headstring(rpmhead, TAG_PAYLOADFORMAT);
2344   if (payloadformat && !strcmp(payloadformat, "drpm"))
2345     {
2346       /* this is a delta rpm */
2347       pool_error(pool, -1, "is a delta rpm");
2348       return 0;
2349     }
2350   s = pool_id2solvable(pool, repo_add_solvable(repo));
2351   if (!rpm2solv(pool, repo, data, s, rpmhead, flags))
2352     {
2353       repo_free_solvable(repo, s - pool->solvables, 1);
2354       return 0;
2355     }
2356   if (!(flags & REPO_NO_INTERNALIZE))
2357     repodata_internalize(data);
2358   return s - pool->solvables;
2359 }
2360
2361 static inline void
2362 linkhash(const char *lt, char *hash)
2363 {
2364   unsigned int r = 0;
2365   const unsigned char *str = (const unsigned char *)lt;
2366   int l, c;
2367
2368   l = strlen(lt);
2369   while ((c = *str++) != 0)
2370     r += (r << 3) + c;
2371   sprintf(hash, "%08x%08x%08x%08x", r, l, 0, 0);
2372 }
2373
2374 void
2375 rpm_iterate_filelist(void *rpmhandle, int flags, void (*cb)(void *, const char *, struct filelistinfo *), void *cbdata)
2376 {
2377   RpmHead *rpmhead = rpmhandle;
2378   char **bn;
2379   char **dn;
2380   char **md = 0;
2381   char **lt = 0;
2382   unsigned int *di, diidx;
2383   unsigned int *co = 0;
2384   unsigned int *ff = 0;
2385   unsigned int lastdir;
2386   int lastdirl;
2387   unsigned int *fm;
2388   int cnt, dcnt, cnt2;
2389   int i, l1, l;
2390   char *space = 0;
2391   int spacen = 0;
2392   char md5[33];
2393   struct filelistinfo info;
2394
2395   dn = headstringarray(rpmhead, TAG_DIRNAMES, &dcnt);
2396   if (!dn)
2397     return;
2398   if ((flags & RPM_ITERATE_FILELIST_ONLYDIRS) != 0)
2399     {
2400       for (i = 0; i < dcnt; i++)
2401         (*cb)(cbdata, dn[i], 0);
2402       solv_free(dn);
2403       return;
2404     }
2405   bn = headstringarray(rpmhead, TAG_BASENAMES, &cnt);
2406   if (!bn)
2407     {
2408       solv_free(dn);
2409       return;
2410     }
2411   di = headint32array(rpmhead, TAG_DIRINDEXES, &cnt2);
2412   if (!di || cnt != cnt2)
2413     {
2414       solv_free(di);
2415       solv_free(bn);
2416       solv_free(dn);
2417       return;
2418     }
2419   fm = headint16array(rpmhead, TAG_FILEMODES, &cnt2);
2420   if (!fm || cnt != cnt2)
2421     {
2422       solv_free(fm);
2423       solv_free(di);
2424       solv_free(bn);
2425       solv_free(dn);
2426       return;
2427     }
2428   if ((flags & RPM_ITERATE_FILELIST_WITHMD5) != 0)
2429     {
2430       md = headstringarray(rpmhead, TAG_FILEMD5S, &cnt2);
2431       if (!md || cnt != cnt2)
2432         {
2433           solv_free(md);
2434           solv_free(fm);
2435           solv_free(di);
2436           solv_free(bn);
2437           solv_free(dn);
2438           return;
2439         }
2440     }
2441   if ((flags & RPM_ITERATE_FILELIST_WITHCOL) != 0)
2442     {
2443       co = headint32array(rpmhead, TAG_FILECOLORS, &cnt2);
2444       if (co && cnt != cnt2)
2445         {
2446           solv_free(co);
2447           solv_free(md);
2448           solv_free(fm);
2449           solv_free(di);
2450           solv_free(bn);
2451           solv_free(dn);
2452           return;
2453         }
2454     }
2455   if ((flags & RPM_ITERATE_FILELIST_NOGHOSTS) != 0)
2456     {
2457       ff = headint32array(rpmhead, TAG_FILEFLAGS, &cnt2);
2458       if (!ff || cnt != cnt2)
2459         {
2460           solv_free(ff);
2461           solv_free(co);
2462           solv_free(md);
2463           solv_free(fm);
2464           solv_free(di);
2465           solv_free(bn);
2466           solv_free(dn);
2467           return;
2468         }
2469     }
2470   lastdir = dcnt;
2471   lastdirl = 0;
2472   memset(&info, 0, sizeof(info));
2473   for (i = 0; i < cnt; i++)
2474     {
2475       if (ff && (ff[i] & FILEFLAG_GHOST) != 0)
2476         continue;
2477       diidx = di[i];
2478       if (diidx >= dcnt)
2479         continue;
2480       l1 = lastdir == diidx ? lastdirl : strlen(dn[diidx]);
2481       l = l1 + strlen(bn[i]) + 1;
2482       if (l > spacen)
2483         {
2484           spacen = l + 16;
2485           space = solv_realloc(space, spacen);
2486         }
2487       if (lastdir != diidx)
2488         {
2489           strcpy(space, dn[diidx]);
2490           lastdir = diidx;
2491           lastdirl = l1;
2492         }
2493       strcpy(space + l1, bn[i]);
2494       info.diridx = diidx;
2495       info.dirlen = l1;
2496       if (fm)
2497         info.mode = fm[i];
2498       if (md)
2499         {
2500           info.digest = md[i];
2501           if (fm && S_ISLNK(fm[i]))
2502             {
2503               info.digest = 0;
2504               if (!lt)
2505                 {
2506                   lt = headstringarray(rpmhead, TAG_FILELINKTOS, &cnt2);
2507                   if (cnt != cnt2)
2508                     lt = solv_free(lt);
2509                 }
2510               if (lt)
2511                 {
2512                   linkhash(lt[i], md5);
2513                   info.digest = md5;
2514                 }
2515             }
2516           if (!info.digest)
2517             {
2518               sprintf(md5, "%08x%08x%08x%08x", (fm[i] >> 12) & 65535, 0, 0, 0);
2519               info.digest = md5;
2520             }
2521         }
2522       info.color = co ? co[i] : 0;
2523       (*cb)(cbdata, space, &info);
2524     }
2525   solv_free(space);
2526   solv_free(lt);
2527   solv_free(md);
2528   solv_free(fm);
2529   solv_free(di);
2530   solv_free(bn);
2531   solv_free(dn);
2532   solv_free(co);
2533   solv_free(ff);
2534 }
2535
2536 char *
2537 rpm_query(void *rpmhandle, Id what)
2538 {
2539   const char *name, *arch, *sourcerpm;
2540   char *evr, *r;
2541   int l;
2542
2543   RpmHead *rpmhead = rpmhandle;
2544   r = 0;
2545   switch (what)
2546     {
2547     case 0:
2548       name = headstring(rpmhead, TAG_NAME);
2549       if (!name)
2550         name = "";
2551       sourcerpm = headstring(rpmhead, TAG_SOURCERPM);
2552       if (sourcerpm || (rpmhead->forcebinary && !headexists(rpmhead, TAG_SOURCEPACKAGE)))
2553         arch = headstring(rpmhead, TAG_ARCH);
2554       else
2555         {
2556           if (headexists(rpmhead, TAG_NOSOURCE) || headexists(rpmhead, TAG_NOPATCH))
2557             arch = "nosrc";
2558           else
2559             arch = "src";
2560         }
2561       if (!arch)
2562         arch = "noarch";
2563       evr = headtoevr(rpmhead);
2564       l = strlen(name) + 1 + strlen(evr ? evr : "") + 1 + strlen(arch) + 1;
2565       r = solv_malloc(l);
2566       sprintf(r, "%s-%s.%s", name, evr ? evr : "", arch);
2567       solv_free(evr);
2568       break;
2569     case SOLVABLE_NAME:
2570       name = headstring(rpmhead, TAG_NAME);
2571       r = solv_strdup(name);
2572       break;
2573     case SOLVABLE_SUMMARY:
2574       name = headstring(rpmhead, TAG_SUMMARY);
2575       r = solv_strdup(name);
2576       break;
2577     case SOLVABLE_DESCRIPTION:
2578       name = headstring(rpmhead, TAG_DESCRIPTION);
2579       r = solv_strdup(name);
2580       break;
2581     case SOLVABLE_EVR:
2582       r = headtoevr(rpmhead);
2583       break;
2584     }
2585   return r;
2586 }
2587
2588 unsigned long long
2589 rpm_query_num(void *rpmhandle, Id what, unsigned long long notfound)
2590 {
2591   RpmHead *rpmhead = rpmhandle;
2592   unsigned int u32;
2593
2594   switch (what)
2595     {
2596     case SOLVABLE_INSTALLTIME:
2597       u32 = headint32(rpmhead, TAG_INSTALLTIME);
2598       return u32 ? u32 : notfound;
2599     }
2600   return notfound;
2601 }
2602
2603 int
2604 rpm_installedrpmdbids(void *rpmstate, const char *index, const char *match, Queue *rpmdbidq)
2605 {
2606   struct rpmdbentry *entries;
2607   int nentries, i;
2608
2609   entries = getinstalledrpmdbids(rpmstate, index ? index : "Name", match, &nentries, 0);
2610   if (rpmdbidq)
2611     {
2612       queue_empty(rpmdbidq);
2613       for (i = 0; i < nentries; i++)
2614         queue_push(rpmdbidq, entries[i].rpmdbid);
2615     }
2616   solv_free(entries);
2617   return nentries;
2618 }
2619
2620 void *
2621 rpm_byrpmdbid(void *rpmstate, Id rpmdbid)
2622 {
2623   struct rpmdbstate *state = rpmstate;
2624   int r;
2625
2626   r = getrpmdbid(state, rpmdbid);
2627   if (!r)
2628     pool_error(state->pool, 0, "header #%d not in database", rpmdbid);
2629   return r <= 0 ? 0 : state->rpmhead;
2630 }
2631
2632 void *
2633 rpm_byfp(void *rpmstate, FILE *fp, const char *name)
2634 {
2635   struct rpmdbstate *state = rpmstate;
2636   /* int headerstart, headerend; */
2637   RpmHead *rpmhead;
2638   unsigned int sigdsize, sigcnt, l;
2639   unsigned char lead[4096];
2640   int forcebinary = 0;
2641
2642   if (fread(lead, 96 + 16, 1, fp) != 1 || getu32(lead) != 0xedabeedb)
2643     {
2644       pool_error(state->pool, 0, "%s: not a rpm", name);
2645       return 0;
2646     }
2647   forcebinary = lead[6] != 0 || lead[7] != 1;
2648   if (lead[78] != 0 || lead[79] != 5)
2649     {
2650       pool_error(state->pool, 0, "%s: not a V5 header", name);
2651       return 0;
2652     }
2653   if (getu32(lead + 96) != 0x8eade801)
2654     {
2655       pool_error(state->pool, 0, "%s: bad signature header", name);
2656       return 0;
2657     }
2658   sigcnt = getu32(lead + 96 + 8);
2659   sigdsize = getu32(lead + 96 + 12);
2660   if (sigcnt >= 0x100000 || sigdsize >= 0x100000)
2661     {
2662       pool_error(state->pool, 0, "%s: bad signature header", name);
2663       return 0;
2664     }
2665   sigdsize += sigcnt * 16;
2666   sigdsize = (sigdsize + 7) & ~7;
2667   /* headerstart = 96 + 16 + sigdsize; */
2668   while (sigdsize)
2669     {
2670       l = sigdsize > 4096 ? 4096 : sigdsize;
2671       if (fread(lead, l, 1, fp) != 1)
2672         {
2673           pool_error(state->pool, 0, "%s: unexpected EOF", name);
2674           return 0;
2675         }
2676       sigdsize -= l;
2677     }
2678   if (fread(lead, 16, 1, fp) != 1)
2679     {
2680       pool_error(state->pool, 0, "%s: unexpected EOF", name);
2681       return 0;
2682     }
2683   if (getu32(lead) != 0x8eade801)
2684     {
2685       pool_error(state->pool, 0, "%s: bad header", name);
2686       return 0;
2687     }
2688   sigcnt = getu32(lead + 8);
2689   sigdsize = getu32(lead + 12);
2690   if (sigcnt >= 0x100000 || sigdsize >= 0x2000000)
2691     {
2692       pool_error(state->pool, 0, "%s: bad header", name);
2693       return 0;
2694     }
2695   l = sigdsize + sigcnt * 16;
2696   /* headerend = headerstart + 16 + l; */
2697   if (l > state->rpmheadsize)
2698     {
2699       state->rpmheadsize = l + 128;
2700       state->rpmhead = solv_realloc(state->rpmhead, sizeof(*state->rpmhead) + state->rpmheadsize);
2701     }
2702   rpmhead = state->rpmhead;
2703   if (fread(rpmhead->data, l, 1, fp) != 1)
2704     {
2705       pool_error(state->pool, 0, "%s: unexpected EOF", name);
2706       return 0;
2707     }
2708   rpmhead->forcebinary = forcebinary;
2709   rpmhead->cnt = sigcnt;
2710   rpmhead->dcnt = sigdsize;
2711   rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
2712   return rpmhead;
2713 }
2714
2715 #ifdef ENABLE_RPMDB_BYRPMHEADER
2716
2717 void *
2718 rpm_byrpmh(void *rpmstate, Header h)
2719 {
2720   struct rpmdbstate *state = rpmstate;
2721   const unsigned char *uh;
2722   unsigned int sigdsize, sigcnt, l;
2723   RpmHead *rpmhead;
2724
2725 #ifndef RPM5
2726   uh = headerUnload(h);
2727 #else
2728   uh = headerUnload(h, NULL);
2729 #endif
2730   if (!uh)
2731     return 0;
2732   sigcnt = getu32(uh);
2733   sigdsize = getu32(uh + 4);
2734   l = sigdsize + sigcnt * 16;
2735   if (l > state->rpmheadsize)
2736     {
2737       state->rpmheadsize = l + 128;
2738       state->rpmhead = solv_realloc(state->rpmhead, sizeof(*state->rpmhead) + state->rpmheadsize);
2739     }
2740   rpmhead = state->rpmhead;
2741   memcpy(rpmhead->data, uh + 8, l - 8);
2742   free((void *)uh);
2743   rpmhead->forcebinary = 0;
2744   rpmhead->cnt = sigcnt;
2745   rpmhead->dcnt = sigdsize;
2746   rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
2747   return rpmhead;
2748 }
2749
2750 #endif
2751