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   repo_rewrite_suse_deps(s, 0);
 994
 995   if (data && ignq.count)
 996     repodata_set_idarray(data, s - pool->solvables, SOLVABLE_PREREQ_IGNOREINST, &ignq);
 997   queue_free(&ignq);
 998
 999   if (data)
1000     {
1001       Id handle;
1002       char *str;
1003       unsigned int u32;
1004       unsigned long long u64;
1005
1006       handle = s - pool->solvables;
1007       str = headstring(rpmhead, TAG_SUMMARY);
1008       if (str)
1009         setutf8string(data, handle, SOLVABLE_SUMMARY, str);
1010       str = headstring(rpmhead, TAG_DESCRIPTION);
1011       if (str)
1012         set_description_author(data, handle, str);
1013       str = headstring(rpmhead, TAG_GROUP);
1014       if (str)
1015         repodata_set_poolstr(data, handle, SOLVABLE_GROUP, str);
1016       str = headstring(rpmhead, TAG_LICENSE);
1017       if (str)
1018         repodata_set_poolstr(data, handle, SOLVABLE_LICENSE, str);
1019       str = headstring(rpmhead, TAG_URL);
1020       if (str)
1021         repodata_set_str(data, handle, SOLVABLE_URL, str);
1022       str = headstring(rpmhead, TAG_DISTRIBUTION);
1023       if (str)
1024         repodata_set_poolstr(data, handle, SOLVABLE_DISTRIBUTION, str);
1025       str = headstring(rpmhead, TAG_PACKAGER);
1026       if (str)
1027         repodata_set_poolstr(data, handle, SOLVABLE_PACKAGER, str);
1028       if ((flags & RPM_ADD_WITH_PKGID) != 0)
1029         {
1030           unsigned char *chksum;
1031           unsigned int chksumsize;
1032           chksum = headbinary(rpmhead, TAG_SIGMD5, &chksumsize);
1033           if (chksum && chksumsize == 16)
1034             repodata_set_bin_checksum(data, handle, SOLVABLE_PKGID, REPOKEY_TYPE_MD5, chksum);
1035         }
1036       if ((flags & RPM_ADD_WITH_HDRID) != 0)
1037         {
1038           str = headstring(rpmhead, TAG_SHA1HEADER);
1039           if (str && strlen(str) == 40)
1040             repodata_set_checksum(data, handle, SOLVABLE_HDRID, REPOKEY_TYPE_SHA1, str);
1041           else if (str && strlen(str) == 64)
1042             repodata_set_checksum(data, handle, SOLVABLE_HDRID, REPOKEY_TYPE_SHA256, str);
1043         }
1044       u32 = headint32(rpmhead, TAG_BUILDTIME);
1045       if (u32)
1046         repodata_set_num(data, handle, SOLVABLE_BUILDTIME, u32);
1047       u32 = headint32(rpmhead, TAG_INSTALLTIME);
1048       if (u32)
1049         repodata_set_num(data, handle, SOLVABLE_INSTALLTIME, u32);
1050       u64 = headint64(rpmhead, TAG_LONGSIZE);
1051       if (u64)
1052         repodata_set_num(data, handle, SOLVABLE_INSTALLSIZE, u64);
1053       else
1054         {
1055           u32 = headint32(rpmhead, TAG_SIZE);
1056           if (u32)
1057             repodata_set_num(data, handle, SOLVABLE_INSTALLSIZE, u32);
1058         }
1059       if (sourcerpm)
1060         repodata_set_sourcepkg(data, handle, sourcerpm);
1061       if ((flags & RPM_ADD_TRIGGERS) != 0)
1062         {
1063           unsigned int ida = makedeps(pool, repo, rpmhead, TAG_TRIGGERNAME, TAG_TRIGGERVERSION, TAG_TRIGGERFLAGS, 0, 0);
1064           Id id, lastid = 0;
1065           for (lastid = 0; (id = repo->idarraydata[ida]) != 0; ida++, lastid = id)
1066             if (id != lastid)
1067               repodata_add_idarray(data, handle, SOLVABLE_TRIGGERS, id);
1068         }
1069       if ((flags & RPM_ADD_NO_FILELIST) == 0)
1070         addfilelist(data, handle, rpmhead, flags);
1071       if ((flags & RPM_ADD_WITH_CHANGELOG) != 0)
1072         addchangelog(data, handle, rpmhead);
1073     }
1074   solv_free(evr);
1075   return 1;
1076 }
1077
1078
1079 /******************************************************************/
1080 /*  Rpm Database stuff
1081  */
1082
1083 struct rpmdbstate {
1084   Pool *pool;
1085   char *rootdir;
1086
1087   RpmHead *rpmhead;     /* header storage space */
1088   int rpmheadsize;
1089
1090   int dbopened;
1091   DB_ENV *dbenv;        /* database environment */
1092   DB *db;               /* packages database */
1093   int byteswapped;      /* endianess of packages database */
1094   int is_ostree;        /* read-only db that lives in /usr/share/rpm */
1095 };
1096
1097 struct rpmdbentry {
1098   Id rpmdbid;
1099   Id nameoff;
1100 };
1101
1102 #define ENTRIES_BLOCK 255
1103 #define NAMEDATA_BLOCK 1023
1104
1105
1106 static inline Id db2rpmdbid(unsigned char *db, int byteswapped)
1107 {
1108 #ifdef RPM5
1109   return db[0] << 24 | db[1] << 16 | db[2] << 8 | db[3];
1110 #else
1111 # if defined(WORDS_BIGENDIAN)
1112   if (!byteswapped)
1113 # else
1114   if (byteswapped)
1115 # endif
1116     return db[0] << 24 | db[1] << 16 | db[2] << 8 | db[3];
1117   else
1118     return db[3] << 24 | db[2] << 16 | db[1] << 8 | db[0];
1119 #endif
1120 }
1121
1122 static inline void rpmdbid2db(unsigned char *db, Id id, int byteswapped)
1123 {
1124 #ifdef RPM5
1125   db[0] = id >> 24, db[1] = id >> 16, db[2] = id >> 8, db[3] = id;
1126 #else
1127 # if defined(WORDS_BIGENDIAN)
1128   if (!byteswapped)
1129 # else
1130   if (byteswapped)
1131 # endif
1132     db[0] = id >> 24, db[1] = id >> 16, db[2] = id >> 8, db[3] = id;
1133   else
1134     db[3] = id >> 24, db[2] = id >> 16, db[1] = id >> 8, db[0] = id;
1135 #endif
1136 }
1137
1138 #ifdef FEDORA
1139 int
1140 serialize_dbenv_ops(struct rpmdbstate *state)
1141 {
1142   char lpath[PATH_MAX];
1143   mode_t oldmask;
1144   int fd;
1145   struct flock fl;
1146
1147   snprintf(lpath, PATH_MAX, "%s/var/lib/rpm/.dbenv.lock", state->rootdir ? state->rootdir : "");
1148   oldmask = umask(022);
1149   fd = open(lpath, (O_RDWR|O_CREAT), 0644);
1150   umask(oldmask);
1151   if (fd < 0)
1152     return -1;
1153   memset(&fl, 0, sizeof(fl));
1154   fl.l_type = F_WRLCK;
1155   fl.l_whence = SEEK_SET;
1156   for (;;)
1157     {
1158       if (fcntl(fd, F_SETLKW, &fl) != -1)
1159         return fd;
1160       if (errno != EINTR)
1161         break;
1162     }
1163   close(fd);
1164   return -1;
1165 }
1166 #endif
1167
1168 /* should look in /usr/lib/rpm/macros instead, but we want speed... */
1169 static int
1170 opendbenv(struct rpmdbstate *state)
1171 {
1172   const char *rootdir = state->rootdir;
1173   char dbpath[PATH_MAX];
1174   DB_ENV *dbenv = 0;
1175   int r;
1176
1177   if (db_env_create(&dbenv, 0))
1178     return pool_error(state->pool, 0, "db_env_create: %s", strerror(errno));
1179 #if defined(FEDORA) && (DB_VERSION_MAJOR >= 5 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 5))
1180   dbenv->set_thread_count(dbenv, 8);
1181 #endif
1182   snprintf(dbpath, PATH_MAX, "%s/var/lib/rpm", rootdir ? rootdir : "");
1183   if (access(dbpath, W_OK) == -1)
1184     {
1185       snprintf(dbpath, PATH_MAX, "%s/usr/share/rpm/Packages", rootdir ? rootdir : "");
1186       if (access(dbpath, R_OK) == 0)
1187         state->is_ostree = 1;
1188       snprintf(dbpath, PATH_MAX, "%s%s", rootdir ? rootdir : "", state->is_ostree ? "/usr/share/rpm" : "/var/lib/rpm");
1189       r = dbenv->open(dbenv, dbpath, DB_CREATE|DB_PRIVATE|DB_INIT_MPOOL, 0);
1190     }
1191   else
1192     {
1193 #ifdef FEDORA
1194       int serialize_fd = serialize_dbenv_ops(state);
1195       r = dbenv->open(dbenv, dbpath, DB_CREATE|DB_INIT_CDB|DB_INIT_MPOOL, 0644);
1196       if (serialize_fd >= 0)
1197         close(serialize_fd);
1198 #else
1199       r = dbenv->open(dbenv, dbpath, DB_CREATE|DB_PRIVATE|DB_INIT_MPOOL, 0);
1200 #endif
1201     }
1202   if (r)
1203     {
1204       pool_error(state->pool, 0, "dbenv->open: %s", strerror(errno));
1205       dbenv->close(dbenv, 0);
1206       return 0;
1207     }
1208   state->dbenv = dbenv;
1209   return 1;
1210 }
1211
1212 static void
1213 closedbenv(struct rpmdbstate *state)
1214 {
1215 #ifdef FEDORA
1216   uint32_t eflags = 0;
1217 #endif
1218
1219   if (!state->dbenv)
1220     return;
1221 #ifdef FEDORA
1222   (void)state->dbenv->get_open_flags(state->dbenv, &eflags);
1223   if (!(eflags & DB_PRIVATE))
1224     {
1225       int serialize_fd = serialize_dbenv_ops(state);
1226       state->dbenv->close(state->dbenv, 0);
1227       if (serialize_fd >= 0)
1228         close(serialize_fd);
1229     }
1230   else
1231     state->dbenv->close(state->dbenv, 0);
1232 #else
1233   state->dbenv->close(state->dbenv, 0);
1234 #endif
1235   state->dbenv = 0;
1236 }
1237
1238 static int
1239 openpkgdb(struct rpmdbstate *state)
1240 {
1241   if (state->dbopened)
1242     return state->dbopened > 0 ? 1 : 0;
1243   state->dbopened = -1;
1244   if (!state->dbenv && !opendbenv(state))
1245     return 0;
1246   if (db_create(&state->db, state->dbenv, 0))
1247     {
1248       pool_error(state->pool, 0, "db_create: %s", strerror(errno));
1249       state->db = 0;
1250       closedbenv(state);
1251       return 0;
1252     }
1253   if (state->db->open(state->db, 0, "Packages", 0, DB_UNKNOWN, DB_RDONLY, 0664))
1254     {
1255       pool_error(state->pool, 0, "db->open Packages: %s", strerror(errno));
1256       state->db->close(state->db, 0);
1257       state->db = 0;
1258       closedbenv(state);
1259       return 0;
1260     }
1261   if (state->db->get_byteswapped(state->db, &state->byteswapped))
1262     {
1263       pool_error(state->pool, 0, "db->get_byteswapped: %s", strerror(errno));
1264       state->db->close(state->db, 0);
1265       state->db = 0;
1266       closedbenv(state);
1267       return 0;
1268     }
1269   state->dbopened = 1;
1270   return 1;
1271 }
1272
1273 /* get the rpmdbids of all installed packages from the Name index database.
1274  * This is much faster then querying the big Packages database */
1275 static struct rpmdbentry *
1276 getinstalledrpmdbids(struct rpmdbstate *state, const char *index, const char *match, int *nentriesp, char **namedatap)
1277 {
1278   DB_ENV *dbenv = 0;
1279   DB *db = 0;
1280   DBC *dbc = 0;
1281   int byteswapped;
1282   DBT dbkey;
1283   DBT dbdata;
1284   unsigned char *dp;
1285   int dl;
1286   Id nameoff;
1287
1288   char *namedata = 0;
1289   int namedatal = 0;
1290   struct rpmdbentry *entries = 0;
1291   int nentries = 0;
1292
1293   *nentriesp = 0;
1294   if (namedatap)
1295     *namedatap = 0;
1296
1297   if (!state->dbenv && !opendbenv(state))
1298     return 0;
1299   dbenv = state->dbenv;
1300   if (db_create(&db, dbenv, 0))
1301     {
1302       pool_error(state->pool, 0, "db_create: %s", strerror(errno));
1303       return 0;
1304     }
1305   if (db->open(db, 0, index, 0, DB_UNKNOWN, DB_RDONLY, 0664))
1306     {
1307       pool_error(state->pool, 0, "db->open %s: %s", index, strerror(errno));
1308       db->close(db, 0);
1309       return 0;
1310     }
1311   if (db->get_byteswapped(db, &byteswapped))
1312     {
1313       pool_error(state->pool, 0, "db->get_byteswapped: %s", strerror(errno));
1314       db->close(db, 0);
1315       return 0;
1316     }
1317   if (db->cursor(db, NULL, &dbc, 0))
1318     {
1319       pool_error(state->pool, 0, "db->cursor: %s", strerror(errno));
1320       db->close(db, 0);
1321       return 0;
1322     }
1323   memset(&dbkey, 0, sizeof(dbkey));
1324   memset(&dbdata, 0, sizeof(dbdata));
1325   if (match)
1326     {
1327       dbkey.data = (void *)match;
1328       dbkey.size = strlen(match);
1329     }
1330   while (dbc->c_get(dbc, &dbkey, &dbdata, match ? DB_SET : DB_NEXT) == 0)
1331     {
1332       if (!match && dbkey.size == 10 && !memcmp(dbkey.data, "gpg-pubkey", 10))
1333         continue;
1334       dl = dbdata.size;
1335       dp = dbdata.data;
1336       nameoff = namedatal;
1337       if (namedatap)
1338         {
1339           namedata = solv_extend(namedata, namedatal, dbkey.size + 1, 1, NAMEDATA_BLOCK);
1340           memcpy(namedata + namedatal, dbkey.data, dbkey.size);
1341           namedata[namedatal + dbkey.size] = 0;
1342           namedatal += dbkey.size + 1;
1343         }
1344       while(dl >= RPM_INDEX_SIZE)
1345         {
1346           entries = solv_extend(entries, nentries, 1, sizeof(*entries), ENTRIES_BLOCK);
1347           entries[nentries].rpmdbid = db2rpmdbid(dp, byteswapped);
1348           entries[nentries].nameoff = nameoff;
1349           nentries++;
1350           dp += RPM_INDEX_SIZE;
1351           dl -= RPM_INDEX_SIZE;
1352         }
1353       if (match)
1354         break;
1355     }
1356   dbc->c_close(dbc);
1357   db->close(db, 0);
1358   /* make sure that enteries is != 0 if there was no error */
1359   if (!entries)
1360     entries = solv_extend(entries, 1, 1, sizeof(*entries), ENTRIES_BLOCK);
1361   *nentriesp = nentries;
1362   if (namedatap)
1363     *namedatap = namedata;
1364   return entries;
1365 }
1366
1367 /* retrive header by rpmdbid */
1368 static int
1369 getrpmdbid(struct rpmdbstate *state, Id rpmdbid)
1370 {
1371   unsigned char buf[16];
1372   DBT dbkey;
1373   DBT dbdata;
1374   RpmHead *rpmhead;
1375
1376   if (!rpmdbid)
1377     {
1378       pool_error(state->pool, 0, "illegal rpmdbid");
1379       return -1;
1380     }
1381   if (state->dbopened != 1 && !openpkgdb(state))
1382     return -1;
1383   rpmdbid2db(buf, rpmdbid, state->byteswapped);
1384   memset(&dbkey, 0, sizeof(dbkey));
1385   memset(&dbdata, 0, sizeof(dbdata));
1386   dbkey.data = buf;
1387   dbkey.size = 4;
1388   dbdata.data = 0;
1389   dbdata.size = 0;
1390   if (state->db->get(state->db, NULL, &dbkey, &dbdata, 0))
1391     return 0;
1392   if (dbdata.size < 8)
1393     {
1394       pool_error(state->pool, 0, "corrupt rpm database (size)");
1395       return -1;
1396     }
1397   if (dbdata.size > state->rpmheadsize)
1398     {
1399       state->rpmheadsize = dbdata.size + 128;
1400       state->rpmhead = solv_realloc(state->rpmhead, sizeof(*rpmhead) + state->rpmheadsize);
1401     }
1402   rpmhead = state->rpmhead;
1403   memcpy(buf, dbdata.data, 8);
1404   rpmhead->forcebinary = 1;
1405   rpmhead->cnt = buf[0] << 24  | buf[1] << 16  | buf[2] << 8 | buf[3];
1406   rpmhead->dcnt = buf[4] << 24  | buf[5] << 16  | buf[6] << 8 | buf[7];
1407   if (8 + rpmhead->cnt * 16 + rpmhead->dcnt > dbdata.size)
1408     {
1409       pool_error(state->pool, 0, "corrupt rpm database (data size)");
1410       return -1;
1411     }
1412   memcpy(rpmhead->data, (unsigned char *)dbdata.data + 8, rpmhead->cnt * 16 + rpmhead->dcnt);
1413   rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
1414   return 1;
1415 }
1416
1417 /* retrive header by berkeleydb cursor */
1418 static Id
1419 getrpmcursor(struct rpmdbstate *state, DBC *dbc)
1420 {
1421   unsigned char buf[16];
1422   DBT dbkey;
1423   DBT dbdata;
1424   RpmHead *rpmhead;
1425   Id dbid;
1426
1427   memset(&dbkey, 0, sizeof(dbkey));
1428   memset(&dbdata, 0, sizeof(dbdata));
1429   while (dbc->c_get(dbc, &dbkey, &dbdata, DB_NEXT) == 0)
1430     {
1431       if (dbkey.size != 4)
1432         return pool_error(state->pool, -1, "corrupt Packages database (key size)");
1433       dbid = db2rpmdbid(dbkey.data, state->byteswapped);
1434       if (dbid == 0)            /* the join key */
1435         continue;
1436       if (dbdata.size < 8)
1437         return pool_error(state->pool, -1, "corrupt rpm database (size %u)\n", dbdata.size);
1438       if (dbdata.size > state->rpmheadsize)
1439         {
1440           state->rpmheadsize = dbdata.size + 128;
1441           state->rpmhead = solv_realloc(state->rpmhead, sizeof(*state->rpmhead) + state->rpmheadsize);
1442         }
1443       rpmhead = state->rpmhead;
1444       memcpy(buf, dbdata.data, 8);
1445       rpmhead->forcebinary = 1;
1446       rpmhead->cnt = buf[0] << 24  | buf[1] << 16  | buf[2] << 8 | buf[3];
1447       rpmhead->dcnt = buf[4] << 24  | buf[5] << 16  | buf[6] << 8 | buf[7];
1448       if (8 + rpmhead->cnt * 16 + rpmhead->dcnt > dbdata.size)
1449         return pool_error(state->pool, -1, "corrupt rpm database (data size)\n");
1450       memcpy(rpmhead->data, (unsigned char *)dbdata.data + 8, rpmhead->cnt * 16 + rpmhead->dcnt);
1451       rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
1452       return dbid;
1453     }
1454   return 0;
1455 }
1456
1457 static void
1458 freestate(struct rpmdbstate *state)
1459 {
1460   /* close down */
1461   if (!state)
1462     return;
1463   if (state->db)
1464     state->db->close(state->db, 0);
1465   if (state->dbenv)
1466     closedbenv(state);
1467   if (state->rootdir)
1468     solv_free(state->rootdir);
1469   solv_free(state->rpmhead);
1470 }
1471
1472 void *
1473 rpm_state_create(Pool *pool, const char *rootdir)
1474 {
1475   struct rpmdbstate *state;
1476   state = solv_calloc(1, sizeof(*state));
1477   state->pool = pool;
1478   if (rootdir)
1479     state->rootdir = solv_strdup(rootdir);
1480   return state;
1481 }
1482
1483 void *
1484 rpm_state_free(void *state)
1485 {
1486   freestate(state);
1487   return solv_free(state);
1488 }
1489
1490 static int
1491 count_headers(struct rpmdbstate *state)
1492 {
1493   Pool *pool = state->pool;
1494   char dbpath[PATH_MAX];
1495   struct stat statbuf;
1496   DB *db = 0;
1497   DBC *dbc = 0;
1498   int count = 0;
1499   DBT dbkey;
1500   DBT dbdata;
1501
1502   snprintf(dbpath, PATH_MAX, "%s%s/Name", state->rootdir ? state->rootdir : "", state->is_ostree ? "/usr/share/rpm" : "/var/lib/rpm");
1503   if (stat(dbpath, &statbuf))
1504     return 0;
1505   memset(&dbkey, 0, sizeof(dbkey));
1506   memset(&dbdata, 0, sizeof(dbdata));
1507   if (db_create(&db, state->dbenv, 0))
1508     {
1509       pool_error(pool, 0, "db_create: %s", strerror(errno));
1510       return 0;
1511     }
1512   if (db->open(db, 0, "Name", 0, DB_UNKNOWN, DB_RDONLY, 0664))
1513     {
1514       pool_error(pool, 0, "db->open Name: %s", strerror(errno));
1515       db->close(db, 0);
1516       return 0;
1517     }
1518   if (db->cursor(db, NULL, &dbc, 0))
1519     {
1520       db->close(db, 0);
1521       pool_error(pool, 0, "db->cursor: %s", strerror(errno));
1522       return 0;
1523     }
1524   while (dbc->c_get(dbc, &dbkey, &dbdata, DB_NEXT) == 0)
1525     count += dbdata.size / RPM_INDEX_SIZE;
1526   dbc->c_close(dbc);
1527   db->close(db, 0);
1528   return count;
1529 }
1530
1531 /******************************************************************/
1532
1533 static Offset
1534 copydeps(Pool *pool, Repo *repo, Offset fromoff, Repo *fromrepo)
1535 {
1536   int cc;
1537   Id *ida, *from;
1538   Offset ido;
1539
1540   if (!fromoff)
1541     return 0;
1542   from = fromrepo->idarraydata + fromoff;
1543   for (ida = from, cc = 0; *ida; ida++, cc++)
1544     ;
1545   if (cc == 0)
1546     return 0;
1547   ido = repo_reserve_ids(repo, 0, cc);
1548   ida = repo->idarraydata + ido;
1549   memcpy(ida, from, (cc + 1) * sizeof(Id));
1550   repo->idarraysize += cc + 1;
1551   return ido;
1552 }
1553
1554 #define COPYDIR_DIRCACHE_SIZE 512
1555
1556 static Id copydir_complex(Pool *pool, Repodata *data, Repodata *fromdata, Id did, Id *cache);
1557
1558 static inline Id
1559 copydir(Pool *pool, Repodata *data, Repodata *fromdata, Id did, Id *cache)
1560 {
1561   if (cache && cache[did & 255] == did)
1562     return cache[(did & 255) + 256];
1563   return copydir_complex(pool, data, fromdata, did, cache);
1564 }
1565
1566 static Id
1567 copydir_complex(Pool *pool, Repodata *data, Repodata *fromdata, Id did, Id *cache)
1568 {
1569   Id parent = dirpool_parent(&fromdata->dirpool, did);
1570   Id compid = dirpool_compid(&fromdata->dirpool, did);
1571   if (parent)
1572     parent = copydir(pool, data, fromdata, parent, cache);
1573   if (data->localpool || fromdata->localpool)
1574     compid = repodata_translate_id(data, fromdata, compid, 1);
1575   compid = dirpool_add_dir(&data->dirpool, parent, compid, 1);
1576   if (cache)
1577     {
1578       cache[did & 255] = did;
1579       cache[(did & 255) + 256] = compid;
1580     }
1581   return compid;
1582 }
1583
1584 struct solvable_copy_cbdata {
1585   Repodata *data;
1586   Id handle;
1587   Id subhandle;
1588   Id *dircache;
1589 };
1590
1591 static int
1592 solvable_copy_cb(void *vcbdata, Solvable *r, Repodata *fromdata, Repokey *key, KeyValue *kv)
1593 {
1594   struct solvable_copy_cbdata *cbdata = vcbdata;
1595   Id id, keyname;
1596   Repodata *data = cbdata->data;
1597   Id handle = cbdata->handle;
1598   Pool *pool = data->repo->pool;
1599
1600   keyname = key->name;
1601   switch(key->type)
1602     {
1603     case REPOKEY_TYPE_ID:
1604     case REPOKEY_TYPE_CONSTANTID:
1605     case REPOKEY_TYPE_IDARRAY:  /* used for triggers */
1606       id = kv->id;
1607       if (data->localpool || fromdata->localpool)
1608         id = repodata_translate_id(data, fromdata, id, 1);
1609       if (key->type == REPOKEY_TYPE_ID)
1610         repodata_set_id(data, handle, keyname, id);
1611       else if (key->type == REPOKEY_TYPE_CONSTANTID)
1612         repodata_set_constantid(data, handle, keyname, id);
1613       else
1614         repodata_add_idarray(data, handle, keyname, id);
1615       break;
1616     case REPOKEY_TYPE_STR:
1617       repodata_set_str(data, handle, keyname, kv->str);
1618       break;
1619     case REPOKEY_TYPE_VOID:
1620       repodata_set_void(data, handle, keyname);
1621       break;
1622     case REPOKEY_TYPE_NUM:
1623       repodata_set_num(data, handle, keyname, SOLV_KV_NUM64(kv));
1624       break;
1625     case REPOKEY_TYPE_CONSTANT:
1626       repodata_set_constant(data, handle, keyname, kv->num);
1627       break;
1628     case REPOKEY_TYPE_DIRNUMNUMARRAY:
1629       id = kv->id;
1630       id = copydir(pool, data, fromdata, id, cbdata->dircache);
1631       repodata_add_dirnumnum(data, handle, keyname, id, kv->num, kv->num2);
1632       break;
1633     case REPOKEY_TYPE_DIRSTRARRAY:
1634       id = kv->id;
1635       id = copydir(pool, data, fromdata, id, cbdata->dircache);
1636       repodata_add_dirstr(data, handle, keyname, id, kv->str);
1637       break;
1638     case REPOKEY_TYPE_FLEXARRAY:
1639       if (kv->eof == 2)
1640         {
1641           assert(cbdata->subhandle);
1642           cbdata->handle = cbdata->subhandle;
1643           cbdata->subhandle = 0;
1644           break;
1645         }
1646       if (!kv->entry)
1647         {
1648           assert(!cbdata->subhandle);
1649           cbdata->subhandle = cbdata->handle;
1650         }
1651       cbdata->handle = repodata_new_handle(data);
1652       repodata_add_flexarray(data, cbdata->subhandle, keyname, cbdata->handle);
1653       break;
1654     default:
1655       if (solv_chksum_len(key->type))
1656         {
1657           repodata_set_bin_checksum(data, handle, keyname, key->type, (const unsigned char *)kv->str);
1658           break;
1659         }
1660       break;
1661     }
1662   return 0;
1663 }
1664
1665 static void
1666 solvable_copy(Solvable *s, Solvable *r, Repodata *data, Id *dircache)
1667 {
1668   int p, i;
1669   Repo *repo = s->repo;
1670   Pool *pool = repo->pool;
1671   Repo *fromrepo = r->repo;
1672   struct solvable_copy_cbdata cbdata;
1673
1674   /* copy solvable data */
1675   s->name = r->name;
1676   s->evr = r->evr;
1677   s->arch = r->arch;
1678   s->vendor = r->vendor;
1679   s->provides = copydeps(pool, repo, r->provides, fromrepo);
1680   s->requires = copydeps(pool, repo, r->requires, fromrepo);
1681   s->conflicts = copydeps(pool, repo, r->conflicts, fromrepo);
1682   s->obsoletes = copydeps(pool, repo, r->obsoletes, fromrepo);
1683   s->recommends = copydeps(pool, repo, r->recommends, fromrepo);
1684   s->suggests = copydeps(pool, repo, r->suggests, fromrepo);
1685   s->supplements = copydeps(pool, repo, r->supplements, fromrepo);
1686   s->enhances  = copydeps(pool, repo, r->enhances, fromrepo);
1687
1688   /* copy all attributes */
1689   if (!data)
1690     return;
1691   cbdata.data = data;
1692   cbdata.handle = s - pool->solvables;
1693   cbdata.subhandle = 0;
1694   cbdata.dircache = dircache;
1695   p = r - fromrepo->pool->solvables;
1696 #if 0
1697   repo_search(fromrepo, p, 0, 0, SEARCH_NO_STORAGE_SOLVABLE | SEARCH_SUB | SEARCH_ARRAYSENTINEL, solvable_copy_cb, &cbdata);
1698 #else
1699   FOR_REPODATAS(fromrepo, i, data)
1700     {
1701       if (p >= data->start && p < data->end)
1702         repodata_search(data, p, 0, SEARCH_SUB | SEARCH_ARRAYSENTINEL, solvable_copy_cb, &cbdata);
1703       cbdata.dircache = 0;      /* only for first repodata */
1704     }
1705 #endif
1706 }
1707
1708 /* used to sort entries by package name that got returned in some database order */
1709 static int
1710 rpmids_sort_cmp(const void *va, const void *vb, void *dp)
1711 {
1712   struct rpmdbentry const *a = va, *b = vb;
1713   char *namedata = dp;
1714   int r;
1715   r = strcmp(namedata + a->nameoff, namedata + b->nameoff);
1716   if (r)
1717     return r;
1718   return a->rpmdbid - b->rpmdbid;
1719 }
1720
1721 static int
1722 pkgids_sort_cmp(const void *va, const void *vb, void *dp)
1723 {
1724   Repo *repo = dp;
1725   Pool *pool = repo->pool;
1726   Solvable *a = pool->solvables + *(Id *)va;
1727   Solvable *b = pool->solvables + *(Id *)vb;
1728   Id *rpmdbid;
1729
1730   if (a->name != b->name)
1731     return strcmp(pool_id2str(pool, a->name), pool_id2str(pool, b->name));
1732   rpmdbid = repo->rpmdbid;
1733   return rpmdbid[(a - pool->solvables) - repo->start] - rpmdbid[(b - pool->solvables) - repo->start];
1734 }
1735
1736 static void
1737 swap_solvables(Repo *repo, Repodata *data, Id pa, Id pb)
1738 {
1739   Pool *pool = repo->pool;
1740   Solvable tmp;
1741
1742   tmp = pool->solvables[pa];
1743   pool->solvables[pa] = pool->solvables[pb];
1744   pool->solvables[pb] = tmp;
1745   if (repo->rpmdbid)
1746     {
1747       Id tmpid = repo->rpmdbid[pa - repo->start];
1748       repo->rpmdbid[pa - repo->start] = repo->rpmdbid[pb - repo->start];
1749       repo->rpmdbid[pb - repo->start] = tmpid;
1750     }
1751   /* only works if nothing is already internalized! */
1752   if (data)
1753     repodata_swap_attrs(data, pa, pb);
1754 }
1755
1756 static void
1757 mkrpmdbcookie(struct stat *st, unsigned char *cookie, int flags)
1758 {
1759   int f = 0;
1760   memset(cookie, 0, 32);
1761   cookie[3] = RPMDB_COOKIE_VERSION;
1762   memcpy(cookie + 16, &st->st_ino, sizeof(st->st_ino));
1763   memcpy(cookie + 24, &st->st_dev, sizeof(st->st_dev));
1764   if ((flags & RPM_ADD_WITH_PKGID) != 0)
1765     f |= 1;
1766   if ((flags & RPM_ADD_WITH_HDRID) != 0)
1767     f |= 2;
1768   if ((flags & RPM_ADD_WITH_CHANGELOG) != 0)
1769     f |= 4;
1770   if ((flags & RPM_ADD_NO_FILELIST) == 0)
1771     f |= 8;
1772   if ((flags & RPM_ADD_NO_RPMLIBREQS) != 0)
1773     cookie[1] = 1;
1774   cookie[0] = f;
1775 }
1776
1777 /*
1778  * read rpm db as repo
1779  *
1780  */
1781
1782 int
1783 repo_add_rpmdb(Repo *repo, Repo *ref, int flags)
1784 {
1785   Pool *pool = repo->pool;
1786   char dbpath[PATH_MAX];
1787   struct stat packagesstat;
1788   unsigned char newcookie[32];
1789   const unsigned char *oldcookie = 0;
1790   Id oldcookietype = 0;
1791   Repodata *data;
1792   int count = 0, done = 0;
1793   struct rpmdbstate state;
1794   int i;
1795   Solvable *s;
1796   unsigned int now;
1797
1798   now = solv_timems(0);
1799   memset(&state, 0, sizeof(state));
1800   state.pool = pool;
1801   if (flags & REPO_USE_ROOTDIR)
1802     state.rootdir = solv_strdup(pool_get_rootdir(pool));
1803
1804   data = repo_add_repodata(repo, flags);
1805
1806   if (ref && !(ref->nsolvables && ref->rpmdbid && ref->pool == repo->pool))
1807     {
1808       if ((flags & RPMDB_EMPTY_REFREPO) != 0)
1809         repo_empty(ref, 1);
1810       ref = 0;
1811     }
1812
1813   if (!opendbenv(&state))
1814     {
1815       solv_free(state.rootdir);
1816       return -1;
1817     }
1818
1819   /* XXX: should get ro lock of Packages database! */
1820   snprintf(dbpath, PATH_MAX, "%s%s/Packages", state.rootdir ? state.rootdir : "", state.is_ostree ? "/usr/share/rpm" : "/var/lib/rpm");
1821   if (stat(dbpath, &packagesstat))
1822     {
1823       pool_error(pool, -1, "%s: %s", dbpath, strerror(errno));
1824       freestate(&state);
1825       return -1;
1826     }
1827   mkrpmdbcookie(&packagesstat, newcookie, flags);
1828   repodata_set_bin_checksum(data, SOLVID_META, REPOSITORY_RPMDBCOOKIE, REPOKEY_TYPE_SHA256, newcookie);
1829
1830   if (ref)
1831     oldcookie = repo_lookup_bin_checksum(ref, SOLVID_META, REPOSITORY_RPMDBCOOKIE, &oldcookietype);
1832   if (!ref || !oldcookie || oldcookietype != REPOKEY_TYPE_SHA256 || memcmp(oldcookie, newcookie, 32) != 0)
1833     {
1834       int solvstart = 0, solvend = 0;
1835       Id dbid;
1836       DBC *dbc = 0;
1837
1838       if (ref && (flags & RPMDB_EMPTY_REFREPO) != 0)
1839         repo_empty(ref, 1);     /* get it out of the way */
1840       if ((flags & RPMDB_REPORT_PROGRESS) != 0)
1841         count = count_headers(&state);
1842       if (!openpkgdb(&state))
1843         {
1844           freestate(&state);
1845           return -1;
1846         }
1847       if (state.db->cursor(state.db, NULL, &dbc, 0))
1848         {
1849           freestate(&state);
1850           return pool_error(pool, -1, "db->cursor failed");
1851         }
1852       i = 0;
1853       s = 0;
1854       while ((dbid = getrpmcursor(&state, dbc)) != 0)
1855         {
1856           if (dbid == -1)
1857             {
1858               dbc->c_close(dbc);
1859               freestate(&state);
1860               return -1;
1861             }
1862           if (!s)
1863             {
1864               s = pool_id2solvable(pool, repo_add_solvable(repo));
1865               if (!solvstart)
1866                 solvstart = s - pool->solvables;
1867               solvend = s - pool->solvables + 1;
1868             }
1869           if (!repo->rpmdbid)
1870             repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
1871           repo->rpmdbid[(s - pool->solvables) - repo->start] = dbid;
1872           if (rpm2solv(pool, repo, data, s, state.rpmhead, flags | RPM_ADD_TRIGGERS))
1873             {
1874               i++;
1875               s = 0;
1876             }
1877           else
1878             {
1879               /* We can reuse this solvable, but make sure it's still
1880                  associated with this repo.  */
1881               memset(s, 0, sizeof(*s));
1882               s->repo = repo;
1883             }
1884           if ((flags & RPMDB_REPORT_PROGRESS) != 0)
1885             {
1886               if (done < count)
1887                 done++;
1888               if (done < count && (done - 1) * 100 / count != done * 100 / count)
1889                 pool_debug(pool, SOLV_ERROR, "%%%% %d\n", done * 100 / count);
1890             }
1891         }
1892       dbc->c_close(dbc);
1893       if (s)
1894         {
1895           /* oops, could not reuse. free it instead */
1896           repo_free_solvable(repo, s - pool->solvables, 1);
1897           solvend--;
1898           s = 0;
1899         }
1900       /* now sort all solvables in the new solvstart..solvend block */
1901       if (solvend - solvstart > 1)
1902         {
1903           Id *pkgids = solv_malloc2(solvend - solvstart, sizeof(Id));
1904           for (i = solvstart; i < solvend; i++)
1905             pkgids[i - solvstart] = i;
1906           solv_sort(pkgids, solvend - solvstart, sizeof(Id), pkgids_sort_cmp, repo);
1907           /* adapt order */
1908           for (i = solvstart; i < solvend; i++)
1909             {
1910               int j = pkgids[i - solvstart];
1911               while (j < i)
1912                 j = pkgids[i - solvstart] = pkgids[j - solvstart];
1913               if (j != i)
1914                 swap_solvables(repo, data, i, j);
1915             }
1916           solv_free(pkgids);
1917         }
1918     }
1919   else
1920     {
1921       Id dircache[COPYDIR_DIRCACHE_SIZE];               /* see copydir */
1922       struct rpmdbentry *entries = 0, *rp;
1923       int nentries = 0;
1924       char *namedata = 0;
1925       unsigned int refmask, h;
1926       Id id, *refhash;
1927       int res;
1928
1929       memset(dircache, 0, sizeof(dircache));
1930
1931       /* get ids of installed rpms */
1932       entries = getinstalledrpmdbids(&state, "Name", 0, &nentries, &namedata);
1933       if (!entries)
1934         {
1935           freestate(&state);
1936           return -1;
1937         }
1938
1939       /* sort by name */
1940       if (nentries > 1)
1941         solv_sort(entries, nentries, sizeof(*entries), rpmids_sort_cmp, namedata);
1942
1943       /* create hash from dbid to ref */
1944       refmask = mkmask(ref->nsolvables);
1945       refhash = solv_calloc(refmask + 1, sizeof(Id));
1946       for (i = 0; i < ref->end - ref->start; i++)
1947         {
1948           if (!ref->rpmdbid[i])
1949             continue;
1950           h = ref->rpmdbid[i] & refmask;
1951           while (refhash[h])
1952             h = (h + 317) & refmask;
1953           refhash[h] = i + 1;   /* make it non-zero */
1954         }
1955
1956       /* count the misses, they will cost us time */
1957       if ((flags & RPMDB_REPORT_PROGRESS) != 0)
1958         {
1959           for (i = 0, rp = entries; i < nentries; i++, rp++)
1960             {
1961               if (refhash)
1962                 {
1963                   Id dbid = rp->rpmdbid;
1964                   h = dbid & refmask;
1965                   while ((id = refhash[h]))
1966                     {
1967                       if (ref->rpmdbid[id - 1] == dbid)
1968                         break;
1969                       h = (h + 317) & refmask;
1970                     }
1971                   if (id)
1972                     continue;
1973                 }
1974               count++;
1975             }
1976         }
1977
1978       if (ref && (flags & RPMDB_EMPTY_REFREPO) != 0)
1979         s = pool_id2solvable(pool, repo_add_solvable_block_before(repo, nentries, ref));
1980       else
1981         s = pool_id2solvable(pool, repo_add_solvable_block(repo, nentries));
1982       if (!repo->rpmdbid)
1983         repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
1984
1985       for (i = 0, rp = entries; i < nentries; i++, rp++, s++)
1986         {
1987           Id dbid = rp->rpmdbid;
1988           repo->rpmdbid[(s - pool->solvables) - repo->start] = rp->rpmdbid;
1989           if (refhash)
1990             {
1991               h = dbid & refmask;
1992               while ((id = refhash[h]))
1993                 {
1994                   if (ref->rpmdbid[id - 1] == dbid)
1995                     break;
1996                   h = (h + 317) & refmask;
1997                 }
1998               if (id)
1999                 {
2000                   Solvable *r = ref->pool->solvables + ref->start + (id - 1);
2001                   if (r->repo == ref)
2002                     {
2003                       solvable_copy(s, r, data, dircache);
2004                       continue;
2005                     }
2006                 }
2007             }
2008           res = getrpmdbid(&state, dbid);
2009           if (res <= 0)
2010             {
2011               if (!res)
2012                 pool_error(pool, -1, "inconsistent rpm database, key %d not found. run 'rpm --rebuilddb' to fix.", dbid);
2013               freestate(&state);
2014               solv_free(entries);
2015               solv_free(namedata);
2016               solv_free(refhash);
2017               return -1;
2018             }
2019           rpm2solv(pool, repo, data, s, state.rpmhead, flags | RPM_ADD_TRIGGERS);
2020           if ((flags & RPMDB_REPORT_PROGRESS) != 0)
2021             {
2022               if (done < count)
2023                 done++;
2024               if (done < count && (done - 1) * 100 / count != done * 100 / count)
2025                 pool_debug(pool, SOLV_ERROR, "%%%% %d\n", done * 100 / count);
2026             }
2027         }
2028
2029       solv_free(entries);
2030       solv_free(namedata);
2031       solv_free(refhash);
2032       if (ref && (flags & RPMDB_EMPTY_REFREPO) != 0)
2033         repo_empty(ref, 1);
2034     }
2035
2036   freestate(&state);
2037   if (!(flags & REPO_NO_INTERNALIZE))
2038     repodata_internalize(data);
2039   if ((flags & RPMDB_REPORT_PROGRESS) != 0)
2040     pool_debug(pool, SOLV_ERROR, "%%%% 100\n");
2041   POOL_DEBUG(SOLV_DEBUG_STATS, "repo_add_rpmdb took %d ms\n", solv_timems(now));
2042   POOL_DEBUG(SOLV_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables);
2043   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)));
2044   return 0;
2045 }
2046
2047 int
2048 repo_add_rpmdb_reffp(Repo *repo, FILE *fp, int flags)
2049 {
2050   int res;
2051   Repo *ref = 0;
2052
2053   if (!fp)
2054     return repo_add_rpmdb(repo, 0, flags);
2055   ref = repo_create(repo->pool, "add_rpmdb_reffp");
2056   if (repo_add_solv(ref, fp, 0) != 0)
2057     {
2058       repo_free(ref, 1);
2059       ref = 0;
2060     }
2061   if (ref && ref->start == ref->end)
2062     {
2063       repo_free(ref, 1);
2064       ref = 0;
2065     }
2066   if (ref)
2067     repo_disable_paging(ref);
2068   res = repo_add_rpmdb(repo, ref, flags | RPMDB_EMPTY_REFREPO);
2069   if (ref)
2070     repo_free(ref, 1);
2071   return res;
2072 }
2073
2074 static inline unsigned int
2075 getu32(const unsigned char *dp)
2076 {
2077   return dp[0] << 24 | dp[1] << 16 | dp[2] << 8 | dp[3];
2078 }
2079
2080
2081 Id
2082 repo_add_rpm(Repo *repo, const char *rpm, int flags)
2083 {
2084   unsigned int sigdsize, sigcnt, l;
2085   Pool *pool = repo->pool;
2086   Solvable *s;
2087   RpmHead *rpmhead = 0;
2088   int rpmheadsize = 0;
2089   char *payloadformat;
2090   FILE *fp;
2091   unsigned char lead[4096];
2092   int headerstart, headerend;
2093   struct stat stb;
2094   Repodata *data;
2095   unsigned char pkgid[16];
2096   unsigned char leadsigid[16];
2097   unsigned char hdrid[32];
2098   int pkgidtype, leadsigidtype, hdridtype;
2099   Id chksumtype = 0;
2100   Chksum *chksumh = 0;
2101   Chksum *leadsigchksumh = 0;
2102   int forcebinary = 0;
2103
2104   data = repo_add_repodata(repo, flags);
2105
2106   if ((flags & RPM_ADD_WITH_SHA256SUM) != 0)
2107     chksumtype = REPOKEY_TYPE_SHA256;
2108   else if ((flags & RPM_ADD_WITH_SHA1SUM) != 0)
2109     chksumtype = REPOKEY_TYPE_SHA1;
2110
2111   if ((fp = fopen(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(pool, rpm) : rpm, "r")) == 0)
2112     {
2113       pool_error(pool, -1, "%s: %s", rpm, strerror(errno));
2114       return 0;
2115     }
2116   if (fstat(fileno(fp), &stb))
2117     {
2118       pool_error(pool, -1, "fstat: %s", strerror(errno));
2119       fclose(fp);
2120       return 0;
2121     }
2122   if (chksumtype)
2123     chksumh = solv_chksum_create(chksumtype);
2124   if ((flags & RPM_ADD_WITH_LEADSIGID) != 0)
2125     leadsigchksumh = solv_chksum_create(REPOKEY_TYPE_MD5);
2126   if (fread(lead, 96 + 16, 1, fp) != 1 || getu32(lead) != 0xedabeedb)
2127     {
2128       pool_error(pool, -1, "%s: not a rpm", rpm);
2129       fclose(fp);
2130       return 0;
2131     }
2132   forcebinary = lead[6] != 0 || lead[7] != 1;
2133   if (chksumh)
2134     solv_chksum_add(chksumh, lead, 96 + 16);
2135   if (leadsigchksumh)
2136     solv_chksum_add(leadsigchksumh, lead, 96 + 16);
2137   if (lead[78] != 0 || lead[79] != 5)
2138     {
2139       pool_error(pool, -1, "%s: not a rpm v5 header", rpm);
2140       fclose(fp);
2141       return 0;
2142     }
2143   if (getu32(lead + 96) != 0x8eade801)
2144     {
2145       pool_error(pool, -1, "%s: bad signature header", rpm);
2146       fclose(fp);
2147       return 0;
2148     }
2149   sigcnt = getu32(lead + 96 + 8);
2150   sigdsize = getu32(lead + 96 + 12);
2151   if (sigcnt >= 0x100000 || sigdsize >= 0x100000)
2152     {
2153       pool_error(pool, -1, "%s: bad signature header", rpm);
2154       fclose(fp);
2155       return 0;
2156     }
2157   sigdsize += sigcnt * 16;
2158   sigdsize = (sigdsize + 7) & ~7;
2159   headerstart = 96 + 16 + sigdsize;
2160   pkgidtype = leadsigidtype = hdridtype = 0;
2161   if ((flags & (RPM_ADD_WITH_PKGID | RPM_ADD_WITH_HDRID)) != 0)
2162     {
2163       /* extract pkgid or hdrid from the signature header */
2164       if (sigdsize > rpmheadsize)
2165         {
2166           rpmheadsize = sigdsize + 128;
2167           rpmhead = solv_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
2168         }
2169       if (fread(rpmhead->data, sigdsize, 1, fp) != 1)
2170         {
2171           pool_error(pool, -1, "%s: unexpected EOF", rpm);
2172           fclose(fp);
2173           return 0;
2174         }
2175       if (chksumh)
2176         solv_chksum_add(chksumh, rpmhead->data, sigdsize);
2177       if (leadsigchksumh)
2178         solv_chksum_add(leadsigchksumh, rpmhead->data, sigdsize);
2179       rpmhead->forcebinary = 0;
2180       rpmhead->cnt = sigcnt;
2181       rpmhead->dcnt = sigdsize - sigcnt * 16;
2182       rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
2183       if ((flags & RPM_ADD_WITH_PKGID) != 0)
2184         {
2185           unsigned char *chksum;
2186           unsigned int chksumsize;
2187           chksum = headbinary(rpmhead, SIGTAG_MD5, &chksumsize);
2188           if (chksum && chksumsize == 16)
2189             {
2190               pkgidtype = REPOKEY_TYPE_MD5;
2191               memcpy(pkgid, chksum, 16);
2192             }
2193         }
2194       if ((flags & RPM_ADD_WITH_HDRID) != 0)
2195         {
2196           const char *str = headstring(rpmhead, TAG_SHA1HEADER);
2197           if (str && strlen(str) == 40)
2198             {
2199               if (solv_hex2bin(&str, hdrid, 20) == 20)
2200                 hdridtype = REPOKEY_TYPE_SHA1;
2201             }
2202           else if (str && strlen(str) == 64)
2203             {
2204               if (solv_hex2bin(&str, hdrid, 32) == 32)
2205                 hdridtype = REPOKEY_TYPE_SHA256;
2206             }
2207         }
2208     }
2209   else
2210     {
2211       /* just skip the signature header */
2212       while (sigdsize)
2213         {
2214           l = sigdsize > 4096 ? 4096 : sigdsize;
2215           if (fread(lead, l, 1, fp) != 1)
2216             {
2217               pool_error(pool, -1, "%s: unexpected EOF", rpm);
2218               fclose(fp);
2219               return 0;
2220             }
2221           if (chksumh)
2222             solv_chksum_add(chksumh, lead, l);
2223           if (leadsigchksumh)
2224             solv_chksum_add(leadsigchksumh, lead, l);
2225           sigdsize -= l;
2226         }
2227     }
2228   if (leadsigchksumh)
2229     {
2230       leadsigchksumh = solv_chksum_free(leadsigchksumh, leadsigid);
2231       leadsigidtype = REPOKEY_TYPE_MD5;
2232     }
2233   if (fread(lead, 16, 1, fp) != 1)
2234     {
2235       pool_error(pool, -1, "%s: unexpected EOF", rpm);
2236       fclose(fp);
2237       return 0;
2238     }
2239   if (chksumh)
2240     solv_chksum_add(chksumh, lead, 16);
2241   if (getu32(lead) != 0x8eade801)
2242     {
2243       pool_error(pool, -1, "%s: bad header", rpm);
2244       fclose(fp);
2245       return 0;
2246     }
2247   sigcnt = getu32(lead + 8);
2248   sigdsize = getu32(lead + 12);
2249   if (sigcnt >= 0x100000 || sigdsize >= 0x2000000)
2250     {
2251       pool_error(pool, -1, "%s: bad header", rpm);
2252       fclose(fp);
2253       return 0;
2254     }
2255   l = sigdsize + sigcnt * 16;
2256   headerend = headerstart + 16 + l;
2257   if (l > rpmheadsize)
2258     {
2259       rpmheadsize = l + 128;
2260       rpmhead = solv_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
2261     }
2262   if (fread(rpmhead->data, l, 1, fp) != 1)
2263     {
2264       pool_error(pool, -1, "%s: unexpected EOF", rpm);
2265       fclose(fp);
2266       return 0;
2267     }
2268   if (chksumh)
2269     solv_chksum_add(chksumh, rpmhead->data, l);
2270   rpmhead->forcebinary = forcebinary;
2271   rpmhead->cnt = sigcnt;
2272   rpmhead->dcnt = sigdsize;
2273   rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
2274   if (headexists(rpmhead, TAG_PATCHESNAME))
2275     {
2276       /* this is a patch rpm, ignore */
2277       pool_error(pool, -1, "%s: is patch rpm", rpm);
2278       fclose(fp);
2279       solv_chksum_free(chksumh, 0);
2280       solv_free(rpmhead);
2281       return 0;
2282     }
2283   payloadformat = headstring(rpmhead, TAG_PAYLOADFORMAT);
2284   if (payloadformat && !strcmp(payloadformat, "drpm"))
2285     {
2286       /* this is a delta rpm */
2287       pool_error(pool, -1, "%s: is delta rpm", rpm);
2288       fclose(fp);
2289       solv_chksum_free(chksumh, 0);
2290       solv_free(rpmhead);
2291       return 0;
2292     }
2293   if (chksumh)
2294     while ((l = fread(lead, 1, sizeof(lead), fp)) > 0)
2295       solv_chksum_add(chksumh, lead, l);
2296   fclose(fp);
2297   s = pool_id2solvable(pool, repo_add_solvable(repo));
2298   if (!rpm2solv(pool, repo, data, s, rpmhead, flags & ~(RPM_ADD_WITH_HDRID | RPM_ADD_WITH_PKGID)))
2299     {
2300       repo_free_solvable(repo, s - pool->solvables, 1);
2301       solv_chksum_free(chksumh, 0);
2302       solv_free(rpmhead);
2303       return 0;
2304     }
2305   if (!(flags & REPO_NO_LOCATION))
2306     repodata_set_location(data, s - pool->solvables, 0, 0, rpm);
2307   if (S_ISREG(stb.st_mode))
2308     repodata_set_num(data, s - pool->solvables, SOLVABLE_DOWNLOADSIZE, (unsigned long long)stb.st_size);
2309   repodata_set_num(data, s - pool->solvables, SOLVABLE_HEADEREND, headerend);
2310   if (pkgidtype)
2311     repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_PKGID, pkgidtype, pkgid);
2312   if (hdridtype)
2313     repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_HDRID, hdridtype, hdrid);
2314   if (leadsigidtype)
2315     repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_LEADSIGID, leadsigidtype, leadsigid);
2316   if (chksumh)
2317     {
2318       repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_CHECKSUM, chksumtype, solv_chksum_get(chksumh, 0));
2319       chksumh = solv_chksum_free(chksumh, 0);
2320     }
2321   solv_free(rpmhead);
2322   if (!(flags & REPO_NO_INTERNALIZE))
2323     repodata_internalize(data);
2324   return s - pool->solvables;
2325 }
2326
2327 Id
2328 repo_add_rpm_handle(Repo *repo, void *rpmhandle, int flags)
2329 {
2330   Pool *pool = repo->pool;
2331   Repodata *data;
2332   RpmHead *rpmhead = rpmhandle;
2333   Solvable *s;
2334   char *payloadformat;
2335
2336   data = repo_add_repodata(repo, flags);
2337   if (headexists(rpmhead, TAG_PATCHESNAME))
2338     {
2339       pool_error(pool, -1, "is a patch rpm");
2340       return 0;
2341     }
2342   payloadformat = headstring(rpmhead, TAG_PAYLOADFORMAT);
2343   if (payloadformat && !strcmp(payloadformat, "drpm"))
2344     {
2345       /* this is a delta rpm */
2346       pool_error(pool, -1, "is a delta rpm");
2347       return 0;
2348     }
2349   s = pool_id2solvable(pool, repo_add_solvable(repo));
2350   if (!rpm2solv(pool, repo, data, s, rpmhead, flags))
2351     {
2352       repo_free_solvable(repo, s - pool->solvables, 1);
2353       return 0;
2354     }
2355   if (!(flags & REPO_NO_INTERNALIZE))
2356     repodata_internalize(data);
2357   return s - pool->solvables;
2358 }
2359
2360 static inline void
2361 linkhash(const char *lt, char *hash)
2362 {
2363   unsigned int r = 0;
2364   const unsigned char *str = (const unsigned char *)lt;
2365   int l, c;
2366
2367   l = strlen(lt);
2368   while ((c = *str++) != 0)
2369     r += (r << 3) + c;
2370   sprintf(hash, "%08x%08x%08x%08x", r, l, 0, 0);
2371 }
2372
2373 void
2374 rpm_iterate_filelist(void *rpmhandle, int flags, void (*cb)(void *, const char *, struct filelistinfo *), void *cbdata)
2375 {
2376   RpmHead *rpmhead = rpmhandle;
2377   char **bn;
2378   char **dn;
2379   char **md = 0;
2380   char **lt = 0;
2381   unsigned int *di, diidx;
2382   unsigned int *co = 0;
2383   unsigned int *ff = 0;
2384   unsigned int lastdir;
2385   int lastdirl;
2386   unsigned int *fm;
2387   int cnt, dcnt, cnt2;
2388   int i, l1, l;
2389   char *space = 0;
2390   int spacen = 0;
2391   char md5[33];
2392   struct filelistinfo info;
2393
2394   dn = headstringarray(rpmhead, TAG_DIRNAMES, &dcnt);
2395   if (!dn)
2396     return;
2397   if ((flags & RPM_ITERATE_FILELIST_ONLYDIRS) != 0)
2398     {
2399       for (i = 0; i < dcnt; i++)
2400         (*cb)(cbdata, dn[i], 0);
2401       solv_free(dn);
2402       return;
2403     }
2404   bn = headstringarray(rpmhead, TAG_BASENAMES, &cnt);
2405   if (!bn)
2406     {
2407       solv_free(dn);
2408       return;
2409     }
2410   di = headint32array(rpmhead, TAG_DIRINDEXES, &cnt2);
2411   if (!di || cnt != cnt2)
2412     {
2413       solv_free(di);
2414       solv_free(bn);
2415       solv_free(dn);
2416       return;
2417     }
2418   fm = headint16array(rpmhead, TAG_FILEMODES, &cnt2);
2419   if (!fm || cnt != cnt2)
2420     {
2421       solv_free(fm);
2422       solv_free(di);
2423       solv_free(bn);
2424       solv_free(dn);
2425       return;
2426     }
2427   if ((flags & RPM_ITERATE_FILELIST_WITHMD5) != 0)
2428     {
2429       md = headstringarray(rpmhead, TAG_FILEMD5S, &cnt2);
2430       if (!md || cnt != cnt2)
2431         {
2432           solv_free(md);
2433           solv_free(fm);
2434           solv_free(di);
2435           solv_free(bn);
2436           solv_free(dn);
2437           return;
2438         }
2439     }
2440   if ((flags & RPM_ITERATE_FILELIST_WITHCOL) != 0)
2441     {
2442       co = headint32array(rpmhead, TAG_FILECOLORS, &cnt2);
2443       if (co && cnt != cnt2)
2444         {
2445           solv_free(co);
2446           solv_free(md);
2447           solv_free(fm);
2448           solv_free(di);
2449           solv_free(bn);
2450           solv_free(dn);
2451           return;
2452         }
2453     }
2454   if ((flags & RPM_ITERATE_FILELIST_NOGHOSTS) != 0)
2455     {
2456       ff = headint32array(rpmhead, TAG_FILEFLAGS, &cnt2);
2457       if (!ff || cnt != cnt2)
2458         {
2459           solv_free(ff);
2460           solv_free(co);
2461           solv_free(md);
2462           solv_free(fm);
2463           solv_free(di);
2464           solv_free(bn);
2465           solv_free(dn);
2466           return;
2467         }
2468     }
2469   lastdir = dcnt;
2470   lastdirl = 0;
2471   memset(&info, 0, sizeof(info));
2472   for (i = 0; i < cnt; i++)
2473     {
2474       if (ff && (ff[i] & FILEFLAG_GHOST) != 0)
2475         continue;
2476       diidx = di[i];
2477       if (diidx >= dcnt)
2478         continue;
2479       l1 = lastdir == diidx ? lastdirl : strlen(dn[diidx]);
2480       l = l1 + strlen(bn[i]) + 1;
2481       if (l > spacen)
2482         {
2483           spacen = l + 16;
2484           space = solv_realloc(space, spacen);
2485         }
2486       if (lastdir != diidx)
2487         {
2488           strcpy(space, dn[diidx]);
2489           lastdir = diidx;
2490           lastdirl = l1;
2491         }
2492       strcpy(space + l1, bn[i]);
2493       info.diridx = diidx;
2494       info.dirlen = l1;
2495       if (fm)
2496         info.mode = fm[i];
2497       if (md)
2498         {
2499           info.digest = md[i];
2500           if (fm && S_ISLNK(fm[i]))
2501             {
2502               info.digest = 0;
2503               if (!lt)
2504                 {
2505                   lt = headstringarray(rpmhead, TAG_FILELINKTOS, &cnt2);
2506                   if (cnt != cnt2)
2507                     lt = solv_free(lt);
2508                 }
2509               if (lt)
2510                 {
2511                   linkhash(lt[i], md5);
2512                   info.digest = md5;
2513                 }
2514             }
2515           if (!info.digest)
2516             {
2517               sprintf(md5, "%08x%08x%08x%08x", (fm[i] >> 12) & 65535, 0, 0, 0);
2518               info.digest = md5;
2519             }
2520         }
2521       info.color = co ? co[i] : 0;
2522       (*cb)(cbdata, space, &info);
2523     }
2524   solv_free(space);
2525   solv_free(lt);
2526   solv_free(md);
2527   solv_free(fm);
2528   solv_free(di);
2529   solv_free(bn);
2530   solv_free(dn);
2531   solv_free(co);
2532   solv_free(ff);
2533 }
2534
2535 char *
2536 rpm_query(void *rpmhandle, Id what)
2537 {
2538   const char *name, *arch, *sourcerpm;
2539   char *evr, *r;
2540   int l;
2541
2542   RpmHead *rpmhead = rpmhandle;
2543   r = 0;
2544   switch (what)
2545     {
2546     case 0:
2547       name = headstring(rpmhead, TAG_NAME);
2548       if (!name)
2549         name = "";
2550       sourcerpm = headstring(rpmhead, TAG_SOURCERPM);
2551       if (sourcerpm || (rpmhead->forcebinary && !headexists(rpmhead, TAG_SOURCEPACKAGE)))
2552         arch = headstring(rpmhead, TAG_ARCH);
2553       else
2554         {
2555           if (headexists(rpmhead, TAG_NOSOURCE) || headexists(rpmhead, TAG_NOPATCH))
2556             arch = "nosrc";
2557           else
2558             arch = "src";
2559         }
2560       if (!arch)
2561         arch = "noarch";
2562       evr = headtoevr(rpmhead);
2563       l = strlen(name) + 1 + strlen(evr ? evr : "") + 1 + strlen(arch) + 1;
2564       r = solv_malloc(l);
2565       sprintf(r, "%s-%s.%s", name, evr ? evr : "", arch);
2566       solv_free(evr);
2567       break;
2568     case SOLVABLE_NAME:
2569       name = headstring(rpmhead, TAG_NAME);
2570       r = solv_strdup(name);
2571       break;
2572     case SOLVABLE_SUMMARY:
2573       name = headstring(rpmhead, TAG_SUMMARY);
2574       r = solv_strdup(name);
2575       break;
2576     case SOLVABLE_DESCRIPTION:
2577       name = headstring(rpmhead, TAG_DESCRIPTION);
2578       r = solv_strdup(name);
2579       break;
2580     case SOLVABLE_EVR:
2581       r = headtoevr(rpmhead);
2582       break;
2583     }
2584   return r;
2585 }
2586
2587 unsigned long long
2588 rpm_query_num(void *rpmhandle, Id what, unsigned long long notfound)
2589 {
2590   RpmHead *rpmhead = rpmhandle;
2591   unsigned int u32;
2592
2593   switch (what)
2594     {
2595     case SOLVABLE_INSTALLTIME:
2596       u32 = headint32(rpmhead, TAG_INSTALLTIME);
2597       return u32 ? u32 : notfound;
2598     }
2599   return notfound;
2600 }
2601
2602 int
2603 rpm_installedrpmdbids(void *rpmstate, const char *index, const char *match, Queue *rpmdbidq)
2604 {
2605   struct rpmdbentry *entries;
2606   int nentries, i;
2607
2608   entries = getinstalledrpmdbids(rpmstate, index ? index : "Name", match, &nentries, 0);
2609   if (rpmdbidq)
2610     {
2611       queue_empty(rpmdbidq);
2612       for (i = 0; i < nentries; i++)
2613         queue_push(rpmdbidq, entries[i].rpmdbid);
2614     }
2615   solv_free(entries);
2616   return nentries;
2617 }
2618
2619 void *
2620 rpm_byrpmdbid(void *rpmstate, Id rpmdbid)
2621 {
2622   struct rpmdbstate *state = rpmstate;
2623   int r;
2624
2625   r = getrpmdbid(state, rpmdbid);
2626   if (!r)
2627     pool_error(state->pool, 0, "header #%d not in database", rpmdbid);
2628   return r <= 0 ? 0 : state->rpmhead;
2629 }
2630
2631 void *
2632 rpm_byfp(void *rpmstate, FILE *fp, const char *name)
2633 {
2634   struct rpmdbstate *state = rpmstate;
2635   /* int headerstart, headerend; */
2636   RpmHead *rpmhead;
2637   unsigned int sigdsize, sigcnt, l;
2638   unsigned char lead[4096];
2639   int forcebinary = 0;
2640
2641   if (fread(lead, 96 + 16, 1, fp) != 1 || getu32(lead) != 0xedabeedb)
2642     {
2643       pool_error(state->pool, 0, "%s: not a rpm", name);
2644       return 0;
2645     }
2646   forcebinary = lead[6] != 0 || lead[7] != 1;
2647   if (lead[78] != 0 || lead[79] != 5)
2648     {
2649       pool_error(state->pool, 0, "%s: not a V5 header", name);
2650       return 0;
2651     }
2652   if (getu32(lead + 96) != 0x8eade801)
2653     {
2654       pool_error(state->pool, 0, "%s: bad signature header", name);
2655       return 0;
2656     }
2657   sigcnt = getu32(lead + 96 + 8);
2658   sigdsize = getu32(lead + 96 + 12);
2659   if (sigcnt >= 0x100000 || sigdsize >= 0x100000)
2660     {
2661       pool_error(state->pool, 0, "%s: bad signature header", name);
2662       return 0;
2663     }
2664   sigdsize += sigcnt * 16;
2665   sigdsize = (sigdsize + 7) & ~7;
2666   /* headerstart = 96 + 16 + sigdsize; */
2667   while (sigdsize)
2668     {
2669       l = sigdsize > 4096 ? 4096 : sigdsize;
2670       if (fread(lead, l, 1, fp) != 1)
2671         {
2672           pool_error(state->pool, 0, "%s: unexpected EOF", name);
2673           return 0;
2674         }
2675       sigdsize -= l;
2676     }
2677   if (fread(lead, 16, 1, fp) != 1)
2678     {
2679       pool_error(state->pool, 0, "%s: unexpected EOF", name);
2680       return 0;
2681     }
2682   if (getu32(lead) != 0x8eade801)
2683     {
2684       pool_error(state->pool, 0, "%s: bad header", name);
2685       return 0;
2686     }
2687   sigcnt = getu32(lead + 8);
2688   sigdsize = getu32(lead + 12);
2689   if (sigcnt >= 0x100000 || sigdsize >= 0x2000000)
2690     {
2691       pool_error(state->pool, 0, "%s: bad header", name);
2692       return 0;
2693     }
2694   l = sigdsize + sigcnt * 16;
2695   /* headerend = headerstart + 16 + l; */
2696   if (l > state->rpmheadsize)
2697     {
2698       state->rpmheadsize = l + 128;
2699       state->rpmhead = solv_realloc(state->rpmhead, sizeof(*state->rpmhead) + state->rpmheadsize);
2700     }
2701   rpmhead = state->rpmhead;
2702   if (fread(rpmhead->data, l, 1, fp) != 1)
2703     {
2704       pool_error(state->pool, 0, "%s: unexpected EOF", name);
2705       return 0;
2706     }
2707   rpmhead->forcebinary = forcebinary;
2708   rpmhead->cnt = sigcnt;
2709   rpmhead->dcnt = sigdsize;
2710   rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
2711   return rpmhead;
2712 }
2713
2714 #ifdef ENABLE_RPMDB_BYRPMHEADER
2715
2716 void *
2717 rpm_byrpmh(void *rpmstate, Header h)
2718 {
2719   struct rpmdbstate *state = rpmstate;
2720   const unsigned char *uh;
2721   unsigned int sigdsize, sigcnt, l;
2722   RpmHead *rpmhead;
2723
2724 #ifndef RPM5
2725   uh = headerUnload(h);
2726 #else
2727   uh = headerUnload(h, NULL);
2728 #endif
2729   if (!uh)
2730     return 0;
2731   sigcnt = getu32(uh);
2732   sigdsize = getu32(uh + 4);
2733   l = sigdsize + sigcnt * 16;
2734   if (l > state->rpmheadsize)
2735     {
2736       state->rpmheadsize = l + 128;
2737       state->rpmhead = solv_realloc(state->rpmhead, sizeof(*state->rpmhead) + state->rpmheadsize);
2738     }
2739   rpmhead = state->rpmhead;
2740   memcpy(rpmhead->data, uh + 8, l - 8);
2741   free((void *)uh);
2742   rpmhead->forcebinary = 0;
2743   rpmhead->cnt = sigcnt;
2744   rpmhead->dcnt = sigdsize;
2745   rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
2746   return rpmhead;
2747 }
2748
2749 #endif
2750