ext/repo_rpmdb.c

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