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