lib/rpmfi.c

   1 /** \ingroup rpmdep
   2  * \file lib/rpmfi.c
   3  * Routines to handle file info tag sets.
   4  */
   5
   6 #include "system.h"
   7
   8 #include <rpm/rpmlog.h>
   9 #include <rpm/rpmts.h>
  10 #include <rpm/rpmfileutil.h>    /* XXX rpmDoDigest */
  11 #include <rpm/rpmstring.h>
  12 #include <rpm/rpmmacro.h>       /* XXX rpmCleanPath */
  13 #include <rpm/rpmds.h>
  14
  15 #include "lib/rpmfi_internal.h"
  16 #include "lib/rpmte_internal.h" /* relocations */
  17 #include "lib/cpio.h"   /* XXX CPIO_FOO */
  18 #include "lib/fsm.h"    /* XXX newFSM() */
  19
  20 #include "debug.h"
  21
  22 /*
  23  * Simple and stupid string "cache."
  24  * Store each unique string just once, retrieve by index value.
  25  * For data where number of unique names is typically very low,
  26  * the dumb linear lookup appears to be fast enough and hash table seems
  27  * like an overkill.
  28  */
  29 struct strcache_s {
  30     char **uniq;
  31     scidx_t num;
  32 };
  33
  34 static struct strcache_s _ugcache = { NULL, 0 };
  35 static strcache ugcache = &_ugcache;
  36 static struct strcache_s _langcache = { NULL, 0 };
  37 static strcache langcache = &_langcache;
  38
  39 static scidx_t strcachePut(strcache cache, const char *str)
  40 {
  41     int found = 0;
  42     scidx_t ret;
  43
  44     for (scidx_t i = 0; i < cache->num; i++) {
  45         if (rstreq(str, cache->uniq[i])) {
  46             ret = i;
  47             found = 1;
  48             break;
  49         }
  50     }
  51     if (!found) {
  52         /* blow up on index wraparound */
  53         assert((scidx_t)(cache->num + 1) > cache->num);
  54         cache->uniq = xrealloc(cache->uniq,
  55                                 sizeof(*cache->uniq) * (cache->num+1));
  56         cache->uniq[cache->num] = xstrdup(str);
  57         ret = cache->num;
  58         cache->num++;
  59     }
  60     return ret;
  61 }
  62
  63 static const char *strcacheGet(strcache cache, scidx_t idx)
  64 {
  65     const char *name = NULL;
  66     if (idx >= 0 && idx < cache->num && cache->uniq != NULL)
  67         name = cache->uniq[idx];
  68     return name;
  69 }
  70
  71 static strcache strcacheNew(void)
  72 {
  73     strcache cache = xcalloc(1, sizeof(*cache));
  74     return cache;
  75 }
  76
  77 static strcache strcacheFree(strcache cache)
  78 {
  79     if (cache != NULL) {
  80         for (scidx_t i = 0; i < cache->num; i++) {
  81             free(cache->uniq[i]);
  82         }
  83         cache->uniq = _free(cache->uniq);
  84         free(cache);
  85     }
  86     return NULL;
  87 }
  88
  89 static rpmfi rpmfiUnlink(rpmfi fi)
  90 {
  91     if (fi)
  92         fi->nrefs--;
  93     return NULL;
  94 }
  95
  96 rpmfi rpmfiLink(rpmfi fi)
  97 {
  98     if (fi)
  99         fi->nrefs++;
 100     return fi;
 101 }
 102
 103 rpm_count_t rpmfiFC(rpmfi fi)
 104 {
 105     return (fi != NULL ? fi->fc : 0);
 106 }
 107
 108 rpm_count_t rpmfiDC(rpmfi fi)
 109 {
 110     return (fi != NULL ? fi->dc : 0);
 111 }
 112
 113 #ifdef  NOTYET
 114 int rpmfiDI(rpmfi fi)
 115 {
 116 }
 117 #endif
 118
 119 int rpmfiFX(rpmfi fi)
 120 {
 121     return (fi != NULL ? fi->i : -1);
 122 }
 123
 124 int rpmfiSetFX(rpmfi fi, int fx)
 125 {
 126     int i = -1;
 127
 128     if (fi != NULL && fx >= 0 && fx < fi->fc) {
 129         i = fi->i;
 130         fi->i = fx;
 131         fi->j = fi->dil[fi->i];
 132     }
 133     return i;
 134 }
 135
 136 int rpmfiDX(rpmfi fi)
 137 {
 138     return (fi != NULL ? fi->j : -1);
 139 }
 140
 141 int rpmfiSetDX(rpmfi fi, int dx)
 142 {
 143     int j = -1;
 144
 145     if (fi != NULL && dx >= 0 && dx < fi->dc) {
 146         j = fi->j;
 147         fi->j = dx;
 148     }
 149     return j;
 150 }
 151
 152 int rpmfiDIIndex(rpmfi fi, int dx)
 153 {
 154     int j = -1;
 155     if (fi != NULL && dx >= 0 && dx < fi->fc) {
 156         if (fi->dil != NULL)
 157             j = fi->dil[dx];
 158     }
 159     return j;
 160 }
 161
 162 const char * rpmfiBNIndex(rpmfi fi, int ix)
 163 {
 164     const char * BN = NULL;
 165
 166     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 167         if (fi->bnl != NULL)
 168             BN = fi->bnl[ix];
 169     }
 170     return BN;
 171 }
 172
 173 const char * rpmfiDNIndex(rpmfi fi, int jx)
 174 {
 175     const char * DN = NULL;
 176
 177     if (fi != NULL && jx >= 0 && jx < fi->dc) {
 178         if (fi->dnl != NULL)
 179             DN = fi->dnl[jx];
 180     }
 181     return DN;
 182 }
 183
 184 const char * rpmfiFNIndex(rpmfi fi, int ix)
 185 {
 186     const char * FN = "";
 187
 188     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 189         char * t;
 190         if (fi->fn == NULL) {
 191             size_t dnlmax = 0, bnlmax = 0, len;
 192             for (int i = 0; i < fi->dc; i++) {
 193                 if ((len = strlen(fi->dnl[i])) > dnlmax)
 194                     dnlmax = len;
 195             }
 196             for (int i = 0; i < fi->fc; i++) {
 197                 if ((len = strlen(fi->bnl[i])) > bnlmax)
 198                     bnlmax = len;
 199             }
 200             fi->fn = xmalloc(dnlmax + bnlmax + 1);
 201         }
 202         FN = t = fi->fn;
 203         *t = '\0';
 204         t = stpcpy(t, fi->dnl[fi->dil[ix]]);
 205         t = stpcpy(t, fi->bnl[ix]);
 206     }
 207     return FN;
 208 }
 209
 210 rpmfileAttrs rpmfiFFlagsIndex(rpmfi fi, int ix)
 211 {
 212     rpmfileAttrs FFlags = 0;
 213
 214     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 215         if (fi->fflags != NULL)
 216             FFlags = fi->fflags[ix];
 217     }
 218     return FFlags;
 219 }
 220
 221 rpmVerifyAttrs rpmfiVFlagsIndex(rpmfi fi, int ix)
 222 {
 223     rpmVerifyAttrs VFlags = 0;
 224
 225     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 226         if (fi->vflags != NULL)
 227             VFlags = fi->vflags[ix];
 228     }
 229     return VFlags;
 230 }
 231
 232 rpm_mode_t rpmfiFModeIndex(rpmfi fi, int ix)
 233 {
 234     rpm_mode_t fmode = 0;
 235
 236     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 237         if (fi->fmodes != NULL)
 238             fmode = fi->fmodes[ix];
 239     }
 240     return fmode;
 241 }
 242
 243 rpmfileState rpmfiFStateIndex(rpmfi fi, int ix)
 244 {
 245     rpmfileState fstate = RPMFILE_STATE_MISSING;
 246
 247     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 248         if (fi->fstates != NULL)
 249             fstate = fi->fstates[ix];
 250     }
 251     return fstate;
 252 }
 253
 254 const unsigned char * rpmfiMD5(rpmfi fi)
 255 {
 256     const unsigned char *digest;
 257     int algo = 0;
 258
 259     digest = rpmfiFDigest(fi, &algo, NULL);
 260     return (algo == PGPHASHALGO_MD5) ? digest : NULL;
 261 }
 262
 263 int rpmfiDigestAlgo(rpmfi fi)
 264 {
 265     return fi ? fi->digestalgo : 0;
 266 }
 267
 268 const unsigned char * rpmfiFDigestIndex(rpmfi fi, int ix, int *algo, size_t *len)
 269 {
 270     const unsigned char *digest = NULL;
 271
 272     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 273         size_t diglen = rpmDigestLength(fi->digestalgo);
 274         if (fi->digests != NULL)
 275             digest = fi->digests + (diglen * ix);
 276         if (len)
 277             *len = diglen;
 278         if (algo)
 279             *algo = fi->digestalgo;
 280     }
 281     return digest;
 282 }
 283
 284 char * rpmfiFDigestHex(rpmfi fi, int *algo)
 285 {
 286     size_t diglen = 0;
 287     char *fdigest = NULL;
 288     const unsigned char *digest = rpmfiFDigest(fi, algo, &diglen);
 289     if (digest) {
 290         fdigest = pgpHexStr(digest, diglen);
 291     }
 292     return fdigest;
 293 }
 294
 295 const char * rpmfiFLinkIndex(rpmfi fi, int ix)
 296 {
 297     const char * flink = NULL;
 298
 299     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 300         if (fi->flinks != NULL)
 301             flink = strcacheGet(fi->flinkcache, fi->flinks[ix]);
 302     }
 303     return flink;
 304 }
 305
 306 rpm_loff_t rpmfiFSizeIndex(rpmfi fi, int ix)
 307 {
 308     rpm_loff_t fsize = 0;
 309
 310     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 311         if (fi->fsizes != NULL)
 312             fsize = fi->fsizes[ix];
 313     }
 314     return fsize;
 315 }
 316
 317 rpm_rdev_t rpmfiFRdevIndex(rpmfi fi, int ix)
 318 {
 319     rpm_rdev_t frdev = 0;
 320
 321     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 322         if (fi->frdevs != NULL)
 323             frdev = fi->frdevs[ix];
 324     }
 325     return frdev;
 326 }
 327
 328 rpm_ino_t rpmfiFInodeIndex(rpmfi fi, int ix)
 329 {
 330     rpm_ino_t finode = 0;
 331
 332     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 333         if (fi->finodes != NULL)
 334             finode = fi->finodes[ix];
 335     }
 336     return finode;
 337 }
 338
 339 rpm_color_t rpmfiColor(rpmfi fi)
 340 {
 341     rpm_color_t color = 0;
 342
 343     if (fi != NULL && fi->fcolors != NULL) {
 344         for (int i = 0; i < fi->fc; i++)
 345             color |= fi->fcolors[i];
 346         /* XXX ignore all but lsnibble for now. */
 347         color &= 0xf;
 348     }
 349     return color;
 350 }
 351
 352 rpm_color_t rpmfiFColorIndex(rpmfi fi, int ix)
 353 {
 354     rpm_color_t fcolor = 0;
 355
 356     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 357         if (fi->fcolors != NULL)
 358             /* XXX ignore all but lsnibble for now. */
 359             fcolor = (fi->fcolors[ix] & 0x0f);
 360     }
 361     return fcolor;
 362 }
 363
 364 const char * rpmfiFClassIndex(rpmfi fi, int ix)
 365 {
 366     const char * fclass = NULL;
 367     int cdictx;
 368
 369     if (fi != NULL && fi->fcdictx != NULL && ix >= 0 && ix < fi->fc) {
 370         cdictx = fi->fcdictx[ix];
 371         if (fi->cdict != NULL && cdictx >= 0 && cdictx < fi->ncdict)
 372             fclass = fi->cdict[cdictx];
 373     }
 374     return fclass;
 375 }
 376
 377 uint32_t rpmfiFDependsIndex(rpmfi fi, int ix, const uint32_t ** fddictp)
 378 {
 379     int fddictx = -1;
 380     int fddictn = 0;
 381     const uint32_t * fddict = NULL;
 382
 383     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 384         if (fi->fddictn != NULL)
 385             fddictn = fi->fddictn[ix];
 386         if (fddictn > 0 && fi->fddictx != NULL)
 387             fddictx = fi->fddictx[ix];
 388         if (fi->ddict != NULL && fddictx >= 0 && (fddictx+fddictn) <= fi->nddict)
 389             fddict = fi->ddict + fddictx;
 390     }
 391     if (fddictp)
 392         *fddictp = fddict;
 393     return fddictn;
 394 }
 395
 396 uint32_t rpmfiFNlinkIndex(rpmfi fi, int ix)
 397 {
 398     uint32_t nlink = 0;
 399
 400     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 401         /* XXX rpm-2.3.12 has not RPMTAG_FILEINODES */
 402         if (fi->finodes && fi->frdevs) {
 403             rpm_ino_t finode = fi->finodes[ix];
 404             rpm_rdev_t frdev = fi->frdevs[ix];
 405             int j;
 406
 407             for (j = 0; j < fi->fc; j++) {
 408                 if (fi->frdevs[j] == frdev && fi->finodes[j] == finode)
 409                     nlink++;
 410             }
 411         }
 412     }
 413     return nlink;
 414 }
 415
 416 rpm_time_t rpmfiFMtimeIndex(rpmfi fi, int ix)
 417 {
 418     rpm_time_t fmtime = 0;
 419
 420     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 421         if (fi->fmtimes != NULL)
 422             fmtime = fi->fmtimes[ix];
 423     }
 424     return fmtime;
 425 }
 426
 427 const char * rpmfiFUserIndex(rpmfi fi, int ix)
 428 {
 429     const char * fuser = NULL;
 430
 431     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 432         if (fi->fuser != NULL)
 433             fuser = strcacheGet(ugcache, fi->fuser[ix]);
 434     }
 435     return fuser;
 436 }
 437
 438 const char * rpmfiFGroupIndex(rpmfi fi, int ix)
 439 {
 440     const char * fgroup = NULL;
 441
 442     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 443         if (fi->fgroup != NULL)
 444             fgroup = strcacheGet(ugcache, fi->fgroup[ix]);
 445     }
 446     return fgroup;
 447 }
 448
 449 const char * rpmfiFCapsIndex(rpmfi fi, int ix)
 450 {
 451     const char *fcaps = NULL;
 452     if (fi != NULL && ix >= 0 && ix < fi->fc) {
 453         fcaps = fi->fcapcache ? strcacheGet(fi->fcapcache, fi->fcaps[ix]) : "";
 454     }
 455     return fcaps;
 456 }
 457
 458 const char * rpmfiFLangsIndex(rpmfi fi, int ix)
 459 {
 460     const char *flangs = NULL;
 461     if (fi != NULL && fi->flangs != NULL && ix >= 0 && ix < fi->fc) {
 462         flangs = strcacheGet(langcache, fi->flangs[ix]);
 463     }
 464     return flangs;
 465 }
 466
 467 struct fingerPrint_s *rpmfiFpsIndex(rpmfi fi, int ix)
 468 {
 469     struct fingerPrint_s * fps = NULL;
 470     if (fi != NULL && fi->fps != NULL && ix >= 0 && ix < fi->fc) {
 471         fps = fi->fps + ix;
 472     }
 473     return fps;
 474 }
 475
 476 int rpmfiNext(rpmfi fi)
 477 {
 478     int i = -1;
 479
 480     if (fi != NULL && ++fi->i >= 0) {
 481         if (fi->i < fi->fc) {
 482             i = fi->i;
 483             if (fi->dil != NULL)
 484                 fi->j = fi->dil[fi->i];
 485         } else
 486             fi->i = -1;
 487     }
 488
 489     return i;
 490 }
 491
 492 rpmfi rpmfiInit(rpmfi fi, int fx)
 493 {
 494     if (fi != NULL) {
 495         if (fx >= 0 && fx < fi->fc) {
 496             fi->i = fx - 1;
 497             fi->j = -1;
 498         }
 499     }
 500
 501     return fi;
 502 }
 503
 504 int rpmfiNextD(rpmfi fi)
 505 {
 506     int j = -1;
 507
 508     if (fi != NULL && ++fi->j >= 0) {
 509         if (fi->j < fi->dc)
 510             j = fi->j;
 511         else
 512             fi->j = -1;
 513     }
 514
 515     return j;
 516 }
 517
 518 rpmfi rpmfiInitD(rpmfi fi, int dx)
 519 {
 520     if (fi != NULL) {
 521         if (dx >= 0 && dx < fi->fc)
 522             fi->j = dx - 1;
 523         else
 524             fi = NULL;
 525     }
 526
 527     return fi;
 528 }
 529
 530 /**
 531  * Identify a file type.
 532  * @param ft            file type
 533  * @return              string to identify a file type
 534  */
 535 static
 536 const char * ftstring (rpmFileTypes ft)
 537 {
 538     switch (ft) {
 539     case XDIR:  return "directory";
 540     case CDEV:  return "char dev";
 541     case BDEV:  return "block dev";
 542     case LINK:  return "link";
 543     case SOCK:  return "sock";
 544     case PIPE:  return "fifo/pipe";
 545     case REG:   return "file";
 546     default:    return "unknown file type";
 547     }
 548 }
 549
 550 rpmFileTypes rpmfiWhatis(rpm_mode_t mode)
 551 {
 552     if (S_ISDIR(mode))  return XDIR;
 553     if (S_ISCHR(mode))  return CDEV;
 554     if (S_ISBLK(mode))  return BDEV;
 555     if (S_ISLNK(mode))  return LINK;
 556     if (S_ISSOCK(mode)) return SOCK;
 557     if (S_ISFIFO(mode)) return PIPE;
 558     return REG;
 559 }
 560
 561 int rpmfiCompare(const rpmfi afi, const rpmfi bfi)
 562 {
 563     rpmFileTypes awhat = rpmfiWhatis(rpmfiFMode(afi));
 564     rpmFileTypes bwhat = rpmfiWhatis(rpmfiFMode(bfi));
 565
 566     if ((rpmfiFFlags(afi) & RPMFILE_GHOST) ||
 567         (rpmfiFFlags(bfi) & RPMFILE_GHOST)) return 0;
 568
 569     if (awhat != bwhat) return 1;
 570
 571     if (awhat == LINK) {
 572         const char * alink = rpmfiFLink(afi);
 573         const char * blink = rpmfiFLink(bfi);
 574         if (alink == blink) return 0;
 575         if (alink == NULL) return 1;
 576         if (blink == NULL) return -1;
 577         return strcmp(alink, blink);
 578     } else if (awhat == REG) {
 579         size_t adiglen, bdiglen;
 580         int aalgo, balgo;
 581         const unsigned char * adigest = rpmfiFDigest(afi, &aalgo, &adiglen);
 582         const unsigned char * bdigest = rpmfiFDigest(bfi, &balgo, &bdiglen);
 583         if (adigest == bdigest) return 0;
 584         if (adigest == NULL) return 1;
 585         if (bdigest == NULL) return -1;
 586         /* can't meaningfully compare different hash types */
 587         if (aalgo != balgo || adiglen != bdiglen) return -1;
 588         return memcmp(adigest, bdigest, adiglen);
 589     }
 590
 591     return 0;
 592 }
 593
 594 rpmFileAction rpmfiDecideFate(const rpmfi ofi, rpmfi nfi, int skipMissing)
 595 {
 596     const char * fn = rpmfiFN(nfi);
 597     rpmfileAttrs newFlags = rpmfiFFlags(nfi);
 598     char buffer[1024];
 599     rpmFileTypes dbWhat, newWhat, diskWhat;
 600     struct stat sb;
 601     int save = (newFlags & RPMFILE_NOREPLACE) ? FA_ALTNAME : FA_SAVE;
 602
 603     if (lstat(fn, &sb)) {
 604         /*
 605          * The file doesn't exist on the disk. Create it unless the new
 606          * package has marked it as missingok, or allfiles is requested.
 607          */
 608         if (skipMissing && (newFlags & RPMFILE_MISSINGOK)) {
 609             rpmlog(RPMLOG_DEBUG, "%s skipped due to missingok flag\n",
 610                         fn);
 611             return FA_SKIP;
 612         } else {
 613             return FA_CREATE;
 614         }
 615     }
 616
 617     diskWhat = rpmfiWhatis((rpm_mode_t)sb.st_mode);
 618     dbWhat = rpmfiWhatis(rpmfiFMode(ofi));
 619     newWhat = rpmfiWhatis(rpmfiFMode(nfi));
 620
 621     /*
 622      * RPM >= 2.3.10 shouldn't create config directories -- we'll ignore
 623      * them in older packages as well.
 624      */
 625     if (newWhat == XDIR)
 626         return FA_CREATE;
 627
 628     if (diskWhat != newWhat && dbWhat != REG && dbWhat != LINK)
 629         return save;
 630     else if (newWhat != dbWhat && diskWhat != dbWhat)
 631         return save;
 632     else if (dbWhat != newWhat)
 633         return FA_CREATE;
 634     else if (dbWhat != LINK && dbWhat != REG)
 635         return FA_CREATE;
 636
 637     /*
 638      * This order matters - we'd prefer to CREATE the file if at all
 639      * possible in case something else (like the timestamp) has changed.
 640      */
 641     memset(buffer, 0, sizeof(buffer));
 642     if (dbWhat == REG) {
 643         int oalgo, nalgo;
 644         size_t odiglen, ndiglen;
 645         const unsigned char * odigest, * ndigest;
 646         odigest = rpmfiFDigest(ofi, &oalgo, &odiglen);
 647         if (diskWhat == REG) {
 648             if (rpmDoDigest(oalgo, fn, 0,
 649                 (unsigned char *)buffer, NULL))
 650                 return FA_CREATE;       /* assume file has been removed */
 651             if (odigest && !memcmp(odigest, buffer, odiglen))
 652                 return FA_CREATE;       /* unmodified config file, replace. */
 653         }
 654         ndigest = rpmfiFDigest(nfi, &nalgo, &ndiglen);
 655         /* Can't compare different hash types, backup to avoid data loss */
 656         if (oalgo != nalgo || odiglen != ndiglen)
 657             return save;
 658         if (odigest && ndigest && !memcmp(odigest, ndigest, odiglen))
 659             return FA_SKIP;     /* identical file, don't bother. */
 660     } else /* dbWhat == LINK */ {
 661         const char * oFLink, * nFLink;
 662         oFLink = rpmfiFLink(ofi);
 663         if (diskWhat == LINK) {
 664             ssize_t link_len = readlink(fn, buffer, sizeof(buffer) - 1);
 665             if (link_len == -1)
 666                 return FA_CREATE;       /* assume file has been removed */
 667             buffer[link_len] = '\0';
 668             if (oFLink && rstreq(oFLink, buffer))
 669                 return FA_CREATE;       /* unmodified config file, replace. */
 670         }
 671         nFLink = rpmfiFLink(nfi);
 672         if (oFLink && nFLink && rstreq(oFLink, nFLink))
 673             return FA_SKIP;     /* identical file, don't bother. */
 674     }
 675
 676     /*
 677      * The config file on the disk has been modified, but
 678      * the ones in the two packages are different. It would
 679      * be nice if RPM was smart enough to at least try and
 680      * merge the difference ala CVS, but...
 681      */
 682     return save;
 683 }
 684
 685 int rpmfiConfigConflict(const rpmfi fi)
 686 {
 687     const char * fn = rpmfiFN(fi);
 688     rpmfileAttrs flags = rpmfiFFlags(fi);
 689     char buffer[1024];
 690     rpmFileTypes newWhat, diskWhat;
 691     struct stat sb;
 692
 693     if (!(flags & RPMFILE_CONFIG) || lstat(fn, &sb)) {
 694         return 0;
 695     }
 696
 697     diskWhat = rpmfiWhatis((rpm_mode_t)sb.st_mode);
 698     newWhat = rpmfiWhatis(rpmfiFMode(fi));
 699
 700     if (newWhat != LINK && newWhat != REG)
 701         return 1;
 702
 703     if (diskWhat != newWhat)
 704         return 1;
 705
 706     memset(buffer, 0, sizeof(buffer));
 707     if (newWhat == REG) {
 708         int algo;
 709         size_t diglen;
 710         const unsigned char *ndigest = rpmfiFDigest(fi, &algo, &diglen);
 711         if (rpmDoDigest(algo, fn, 0, (unsigned char *)buffer, NULL))
 712             return 0;   /* assume file has been removed */
 713         if (ndigest && !memcmp(ndigest, buffer, diglen))
 714             return 0;   /* unmodified config file */
 715     } else /* newWhat == LINK */ {
 716         const char * nFLink;
 717         ssize_t link_len = readlink(fn, buffer, sizeof(buffer) - 1);
 718         if (link_len == -1)
 719             return 0;   /* assume file has been removed */
 720         buffer[link_len] = '\0';
 721         nFLink = rpmfiFLink(fi);
 722         if (nFLink && rstreq(nFLink, buffer))
 723             return 0;   /* unmodified config file */
 724     }
 725
 726     return 1;
 727 }
 728
 729 static char **duparray(char ** src, int size)
 730 {
 731     char **dest = xmalloc((size+1) * sizeof(*dest));
 732     for (int i = 0; i < size; i++) {
 733         dest[i] = xstrdup(src[i]);
 734     }
 735     free(src);
 736     return dest;
 737 }
 738
 739 static int addPrefixes(Header h, rpmRelocation *relocations, int numRelocations)
 740 {
 741     struct rpmtd_s validRelocs;
 742     const char *validprefix;
 743     const char ** actualRelocations;
 744     int numActual = 0;
 745
 746     headerGet(h, RPMTAG_PREFIXES, &validRelocs, HEADERGET_MINMEM);
 747     /*
 748      * If no relocations are specified (usually the case), then return the
 749      * original header. If there are prefixes, however, then INSTPREFIXES
 750      * should be added for RPM_INSTALL_PREFIX environ variables in scriptlets,
 751      * but, since relocateFileList() can be called more than once for
 752      * the same header, don't bother if already present.
 753      */
 754     if (relocations == NULL || numRelocations == 0) {
 755         if (rpmtdCount(&validRelocs) > 0) {
 756             if (!headerIsEntry(h, RPMTAG_INSTPREFIXES)) {
 757                 rpmtdSetTag(&validRelocs, RPMTAG_INSTPREFIXES);
 758                 headerPut(h, &validRelocs, HEADERPUT_DEFAULT);
 759             }
 760             rpmtdFreeData(&validRelocs);
 761         }
 762         return 0;
 763     }
 764
 765     actualRelocations = xmalloc(rpmtdCount(&validRelocs) * sizeof(*actualRelocations));
 766     rpmtdInit(&validRelocs);
 767     while ((validprefix = rpmtdNextString(&validRelocs))) {
 768         int j;
 769         for (j = 0; j < numRelocations; j++) {
 770             if (relocations[j].oldPath == NULL || /* XXX can't happen */
 771                 !rstreq(validprefix, relocations[j].oldPath))
 772                 continue;
 773             /* On install, a relocate to NULL means skip the path. */
 774             if (relocations[j].newPath) {
 775                 actualRelocations[numActual] = relocations[j].newPath;
 776                 numActual++;
 777             }
 778             break;
 779         }
 780         if (j == numRelocations) {
 781             actualRelocations[numActual] = validprefix;
 782             numActual++;
 783         }
 784     }
 785     rpmtdFreeData(&validRelocs);
 786
 787     if (numActual) {
 788         headerPutStringArray(h, RPMTAG_INSTPREFIXES, actualRelocations, numActual);
 789     }
 790     free(actualRelocations);
 791     return numActual;
 792 }
 793
 794 static void saveRelocs(Header h, rpmtd bnames, rpmtd dnames, rpmtd dindexes)
 795 {
 796         struct rpmtd_s td;
 797         headerGet(h, RPMTAG_BASENAMES, &td, HEADERGET_MINMEM);
 798         rpmtdSetTag(&td, RPMTAG_ORIGBASENAMES);
 799         headerPut(h, &td, HEADERPUT_DEFAULT);
 800         rpmtdFreeData(&td);
 801
 802         headerGet(h, RPMTAG_DIRNAMES, &td, HEADERGET_MINMEM);
 803         rpmtdSetTag(&td, RPMTAG_ORIGDIRNAMES);
 804         headerPut(h, &td, HEADERPUT_DEFAULT);
 805         rpmtdFreeData(&td);
 806
 807         headerGet(h, RPMTAG_DIRINDEXES, &td, HEADERGET_MINMEM);
 808         rpmtdSetTag(&td, RPMTAG_ORIGDIRINDEXES);
 809         headerPut(h, &td, HEADERPUT_DEFAULT);
 810         rpmtdFreeData(&td);
 811
 812         headerMod(h, bnames);
 813         headerMod(h, dnames);
 814         headerMod(h, dindexes);
 815 }
 816
 817 void rpmRelocateFileList(rpmRelocation *relocations, int numRelocations,
 818                          rpmfs fs, Header h)
 819 {
 820     static int _printed = 0;
 821     char ** baseNames;
 822     char ** dirNames;
 823     uint32_t * dirIndexes;
 824     rpm_count_t fileCount, dirCount;
 825     int nrelocated = 0;
 826     int fileAlloced = 0;
 827     char * fn = NULL;
 828     int haveRelocatedBase = 0;
 829     size_t maxlen = 0;
 830     int i, j;
 831     struct rpmtd_s bnames, dnames, dindexes, fmodes;
 832
 833     addPrefixes(h, relocations, numRelocations);
 834
 835     if (!_printed) {
 836         _printed = 1;
 837         rpmlog(RPMLOG_DEBUG, "========== relocations\n");
 838         for (i = 0; i < numRelocations; i++) {
 839             if (relocations[i].oldPath == NULL) continue; /* XXX can't happen */
 840             if (relocations[i].newPath == NULL)
 841                 rpmlog(RPMLOG_DEBUG, "%5d exclude  %s\n",
 842                         i, relocations[i].oldPath);
 843             else
 844                 rpmlog(RPMLOG_DEBUG, "%5d relocate %s -> %s\n",
 845                         i, relocations[i].oldPath, relocations[i].newPath);
 846         }
 847     }
 848
 849     for (i = 0; i < numRelocations; i++) {
 850         if (relocations[i].newPath == NULL) continue;
 851         size_t len = strlen(relocations[i].newPath);
 852         if (len > maxlen) maxlen = len;
 853     }
 854
 855     headerGet(h, RPMTAG_BASENAMES, &bnames, HEADERGET_MINMEM);
 856     headerGet(h, RPMTAG_DIRINDEXES, &dindexes, HEADERGET_ALLOC);
 857     headerGet(h, RPMTAG_DIRNAMES, &dnames, HEADERGET_MINMEM);
 858     headerGet(h, RPMTAG_FILEMODES, &fmodes, HEADERGET_MINMEM);
 859     /* TODO XXX ugh.. use rpmtd iterators & friends instead */
 860     baseNames = bnames.data;
 861     dirIndexes = dindexes.data;
 862     fileCount = rpmtdCount(&bnames);
 863     dirCount = rpmtdCount(&dnames);
 864     /* XXX TODO: use rpmtdDup() instead */
 865     dirNames = dnames.data = duparray(dnames.data, dirCount);
 866     dnames.flags |= RPMTD_PTR_ALLOCED;
 867
 868     /*
 869      * For all relocations, we go through sorted file/relocation lists
 870      * backwards so that /usr/local relocations take precedence over /usr
 871      * ones.
 872      */
 873
 874     /* Relocate individual paths. */
 875
 876     for (i = fileCount - 1; i >= 0; i--) {
 877         rpmFileTypes ft;
 878         int fnlen;
 879
 880         size_t len = maxlen +
 881                 strlen(dirNames[dirIndexes[i]]) + strlen(baseNames[i]) + 1;
 882         if (len >= fileAlloced) {
 883             fileAlloced = len * 2;
 884             fn = xrealloc(fn, fileAlloced);
 885         }
 886
 887 assert(fn != NULL);             /* XXX can't happen */
 888         *fn = '\0';
 889         fnlen = stpcpy( stpcpy(fn, dirNames[dirIndexes[i]]), baseNames[i]) - fn;
 890
 891         /*
 892          * See if this file path needs relocating.
 893          */
 894         /*
 895          * XXX FIXME: Would a bsearch of the (already sorted)
 896          * relocation list be a good idea?
 897          */
 898         for (j = numRelocations - 1; j >= 0; j--) {
 899             if (relocations[j].oldPath == NULL) /* XXX can't happen */
 900                 continue;
 901             len = !rstreq(relocations[j].oldPath, "/")
 902                 ? strlen(relocations[j].oldPath)
 903                 : 0;
 904
 905             if (fnlen < len)
 906                 continue;
 907             /*
 908              * Only subdirectories or complete file paths may be relocated. We
 909              * don't check for '\0' as our directory names all end in '/'.
 910              */
 911             if (!(fn[len] == '/' || fnlen == len))
 912                 continue;
 913
 914             if (!rstreqn(relocations[j].oldPath, fn, len))
 915                 continue;
 916             break;
 917         }
 918         if (j < 0) continue;
 919
 920         rpmtdSetIndex(&fmodes, i);
 921         ft = rpmfiWhatis(rpmtdGetNumber(&fmodes));
 922
 923         /* On install, a relocate to NULL means skip the path. */
 924         if (relocations[j].newPath == NULL) {
 925             if (ft == XDIR) {
 926                 /* Start with the parent, looking for directory to exclude. */
 927                 for (j = dirIndexes[i]; j < dirCount; j++) {
 928                     len = strlen(dirNames[j]) - 1;
 929                     while (len > 0 && dirNames[j][len-1] == '/') len--;
 930                     if (fnlen != len)
 931                         continue;
 932                     if (!rstreqn(fn, dirNames[j], fnlen))
 933                         continue;
 934                     break;
 935                 }
 936             }
 937             rpmfsSetAction(fs, i, FA_SKIPNSTATE);
 938             rpmlog(RPMLOG_DEBUG, "excluding %s %s\n",
 939                    ftstring(ft), fn);
 940             continue;
 941         }
 942
 943         /* Relocation on full paths only, please. */
 944         if (fnlen != len) continue;
 945
 946         rpmlog(RPMLOG_DEBUG, "relocating %s to %s\n",
 947                fn, relocations[j].newPath);
 948         nrelocated++;
 949
 950         strcpy(fn, relocations[j].newPath);
 951         {   char * te = strrchr(fn, '/');
 952             if (te) {
 953                 if (te > fn) te++;      /* root is special */
 954                 fnlen = te - fn;
 955             } else
 956                 te = fn + strlen(fn);
 957             if (!rstreq(baseNames[i], te)) { /* basename changed too? */
 958                 if (!haveRelocatedBase) {
 959                     /* XXX TODO: use rpmtdDup() instead */
 960                     bnames.data = baseNames = duparray(baseNames, fileCount);
 961                     bnames.flags |= RPMTD_PTR_ALLOCED;
 962                     haveRelocatedBase = 1;
 963                 }
 964                 free(baseNames[i]);
 965                 baseNames[i] = xstrdup(te);
 966             }
 967             *te = '\0';                 /* terminate new directory name */
 968         }
 969
 970         /* Does this directory already exist in the directory list? */
 971         for (j = 0; j < dirCount; j++) {
 972             if (fnlen != strlen(dirNames[j]))
 973                 continue;
 974             if (!rstreqn(fn, dirNames[j], fnlen))
 975                 continue;
 976             break;
 977         }
 978
 979         if (j < dirCount) {
 980             dirIndexes[i] = j;
 981             continue;
 982         }
 983
 984         /* Creating new paths is a pita */
 985         dirNames = dnames.data = xrealloc(dnames.data,
 986                                sizeof(*dirNames) * (dirCount + 1));
 987
 988         dirNames[dirCount] = xstrdup(fn);
 989         dirIndexes[i] = dirCount;
 990         dirCount++;
 991         dnames.count++;
 992     }
 993
 994     /* Finish off by relocating directories. */
 995     for (i = dirCount - 1; i >= 0; i--) {
 996         for (j = numRelocations - 1; j >= 0; j--) {
 997
 998             if (relocations[j].oldPath == NULL) /* XXX can't happen */
 999                 continue;
1000             size_t len = !rstreq(relocations[j].oldPath, "/")
1001                 ? strlen(relocations[j].oldPath)
1002                 : 0;
1003
1004             if (len && !rstreqn(relocations[j].oldPath, dirNames[i], len))
1005                 continue;
1006
1007             /*
1008              * Only subdirectories or complete file paths may be relocated. We
1009              * don't check for '\0' as our directory names all end in '/'.
1010              */
1011             if (dirNames[i][len] != '/')
1012                 continue;
1013
1014             if (relocations[j].newPath) { /* Relocate the path */
1015                 char *t = NULL;
1016                 rstrscat(&t, relocations[j].newPath, (dirNames[i] + len), NULL);
1017                 /* Unfortunatly rpmCleanPath strips the trailing slash.. */
1018                 (void) rpmCleanPath(t);
1019                 rstrcat(&t, "/");
1020
1021                 rpmlog(RPMLOG_DEBUG,
1022                        "relocating directory %s to %s\n", dirNames[i], t);
1023                 free(dirNames[i]);
1024                 dirNames[i] = t;
1025                 nrelocated++;
1026             }
1027         }
1028     }
1029
1030     /* Save original filenames in header and replace (relocated) filenames. */
1031     if (nrelocated) {
1032         saveRelocs(h, &bnames, &dnames, &dindexes);
1033     }
1034
1035     rpmtdFreeData(&bnames);
1036     rpmtdFreeData(&dnames);
1037     rpmtdFreeData(&dindexes);
1038     rpmtdFreeData(&fmodes);
1039     free(fn);
1040 }
1041
1042 rpmfi rpmfiFree(rpmfi fi)
1043 {
1044     if (fi == NULL) return NULL;
1045
1046     if (fi->nrefs > 1)
1047         return rpmfiUnlink(fi);
1048
1049     if (fi->fc > 0) {
1050         fi->bnl = _free(fi->bnl);
1051         fi->dnl = _free(fi->dnl);
1052
1053         fi->flinkcache = strcacheFree(fi->flinkcache);
1054         fi->flinks = _free(fi->flinks);
1055         fi->flangs = _free(fi->flangs);
1056         fi->digests = _free(fi->digests);
1057         fi->fcapcache = strcacheFree(fi->fcapcache);
1058         fi->fcaps = _free(fi->fcaps);
1059
1060         fi->cdict = _free(fi->cdict);
1061
1062         fi->fuser = _free(fi->fuser);
1063         fi->fgroup = _free(fi->fgroup);
1064
1065         fi->fstates = _free(fi->fstates);
1066         fi->fps = _free(fi->fps);
1067
1068         /* these point to header memory if KEEPHEADER is used, dont free */
1069         if (!(fi->fiflags & RPMFI_KEEPHEADER) && fi->h == NULL) {
1070             fi->fmtimes = _free(fi->fmtimes);
1071             fi->fmodes = _free(fi->fmodes);
1072             fi->fflags = _free(fi->fflags);
1073             fi->vflags = _free(fi->vflags);
1074             fi->fsizes = _free(fi->fsizes);
1075             fi->frdevs = _free(fi->frdevs);
1076             fi->finodes = _free(fi->finodes);
1077             fi->dil = _free(fi->dil);
1078
1079             fi->fcolors = _free(fi->fcolors);
1080             fi->fcdictx = _free(fi->fcdictx);
1081             fi->ddict = _free(fi->ddict);
1082             fi->fddictx = _free(fi->fddictx);
1083             fi->fddictn = _free(fi->fddictn);
1084
1085         }
1086     }
1087
1088     fi->fsm = freeFSM(fi->fsm);
1089
1090     fi->fn = _free(fi->fn);
1091     fi->apath = _free(fi->apath);
1092
1093     fi->replacedSizes = _free(fi->replacedSizes);
1094
1095     fi->h = headerFree(fi->h);
1096
1097     (void) rpmfiUnlink(fi);
1098     memset(fi, 0, sizeof(*fi));         /* XXX trash and burn */
1099     fi = _free(fi);
1100
1101     return NULL;
1102 }
1103
1104 /* Helper to push header tag data into a string cache */
1105 static scidx_t *cacheTag(strcache cache, Header h, rpmTag tag)
1106 {
1107     scidx_t *idx = NULL;
1108     struct rpmtd_s td;
1109     if (headerGet(h, tag, &td, HEADERGET_MINMEM)) {
1110        idx = xmalloc(sizeof(*idx) * rpmtdCount(&td));
1111        int i = 0;
1112        const char *str;
1113        while ((str = rpmtdNextString(&td))) {
1114            idx[i++] = strcachePut(cache, str);
1115        }
1116        rpmtdFreeData(&td);
1117     }
1118     return idx;
1119 }
1120
1121 #define _hgfi(_h, _tag, _td, _flags, _data) \
1122     if (headerGet((_h), (_tag), (_td), (_flags))) \
1123         _data = (td.data)
1124
1125 rpmfi rpmfiNew(const rpmts ts, Header h, rpmTagVal tagN, rpmfiFlags flags)
1126 {
1127     rpmfi fi = NULL;
1128     rpm_loff_t *asize = NULL;
1129     unsigned char * t;
1130     struct rpmtd_s fdigests, digalgo;
1131     struct rpmtd_s td;
1132     headerGetFlags scareFlags = (flags & RPMFI_KEEPHEADER) ?
1133                                 HEADERGET_MINMEM : HEADERGET_ALLOC;
1134     headerGetFlags defFlags = HEADERGET_ALLOC;
1135
1136     fi = xcalloc(1, sizeof(*fi));
1137     if (fi == NULL)     /* XXX can't happen */
1138         goto exit;
1139
1140     fi->magic = RPMFIMAGIC;
1141     fi->i = -1;
1142
1143     fi->fiflags = flags;
1144     fi->scareFlags = scareFlags;
1145
1146     if (headerGet(h, RPMTAG_LONGARCHIVESIZE, &td, HEADERGET_EXT)) {
1147         asize = rpmtdGetUint64(&td);
1148     }
1149     /* 0 means unknown */
1150     fi->archiveSize = asize ? *asize : 0;
1151     rpmtdFreeData(&td);
1152
1153     if (headerIsSource(h)) fi->fiflags |= RPMFI_ISSOURCE;
1154
1155     _hgfi(h, RPMTAG_BASENAMES, &td, defFlags, fi->bnl);
1156     fi->fc = rpmtdCount(&td);
1157     if (fi->fc == 0) {
1158         goto exit;
1159     }
1160
1161     _hgfi(h, RPMTAG_DIRNAMES, &td, defFlags, fi->dnl);
1162     fi->dc = rpmtdCount(&td);
1163     _hgfi(h, RPMTAG_DIRINDEXES, &td, scareFlags, fi->dil);
1164     if (!(flags & RPMFI_NOFILEMODES))
1165         _hgfi(h, RPMTAG_FILEMODES, &td, scareFlags, fi->fmodes);
1166     if (!(flags & RPMFI_NOFILEFLAGS))
1167         _hgfi(h, RPMTAG_FILEFLAGS, &td, scareFlags, fi->fflags);
1168     if (!(flags & RPMFI_NOFILEVERIFYFLAGS))
1169         _hgfi(h, RPMTAG_FILEVERIFYFLAGS, &td, scareFlags, fi->vflags);
1170     if (!(flags & RPMFI_NOFILESIZES))
1171         _hgfi(h, RPMTAG_FILESIZES, &td, scareFlags, fi->fsizes);
1172
1173     if (!(flags & RPMFI_NOFILECOLORS))
1174         _hgfi(h, RPMTAG_FILECOLORS, &td, scareFlags, fi->fcolors);
1175
1176     if (!(flags & RPMFI_NOFILECLASS)) {
1177         _hgfi(h, RPMTAG_CLASSDICT, &td, scareFlags, fi->cdict);
1178         fi->ncdict = rpmtdCount(&td);
1179         _hgfi(h, RPMTAG_FILECLASS, &td, scareFlags, fi->fcdictx);
1180     }
1181     if (!(flags & RPMFI_NOFILEDEPS)) {
1182         _hgfi(h, RPMTAG_DEPENDSDICT, &td, scareFlags, fi->ddict);
1183         fi->nddict = rpmtdCount(&td);
1184         _hgfi(h, RPMTAG_FILEDEPENDSX, &td, scareFlags, fi->fddictx);
1185         _hgfi(h, RPMTAG_FILEDEPENDSN, &td, scareFlags, fi->fddictn);
1186     }
1187
1188     if (!(flags & RPMFI_NOFILESTATES))
1189         _hgfi(h, RPMTAG_FILESTATES, &td, defFlags, fi->fstates);
1190
1191     if (!(flags & RPMFI_NOFILECAPS) && headerIsEntry(h, RPMTAG_FILECAPS)) {
1192         fi->fcapcache = strcacheNew();
1193         fi->fcaps = cacheTag(fi->fcapcache, h, RPMTAG_FILECAPS);
1194     }
1195
1196     if (!(flags & RPMFI_NOFILELINKTOS)) {
1197         fi->flinkcache = strcacheNew();
1198         fi->flinks = cacheTag(fi->flinkcache, h, RPMTAG_FILELINKTOS);
1199     }
1200     /* FILELANGS are only interesting when installing */
1201     if ((headerGetInstance(h) == 0) && !(flags & RPMFI_NOFILELANGS))
1202         fi->flangs = cacheTag(langcache, h, RPMTAG_FILELANGS);
1203
1204     /* See if the package has non-md5 file digests */
1205     fi->digestalgo = PGPHASHALGO_MD5;
1206     if (headerGet(h, RPMTAG_FILEDIGESTALGO, &digalgo, HEADERGET_MINMEM)) {
1207         uint32_t *algo = rpmtdGetUint32(&digalgo);
1208         /* Hmm, what to do with unknown digest algorithms? */
1209         if (algo && rpmDigestLength(*algo) != 0) {
1210             fi->digestalgo = *algo;
1211         }
1212     }
1213
1214     fi->digests = NULL;
1215     /* grab hex digests from header and store in binary format */
1216     if (!(flags & RPMFI_NOFILEDIGESTS) &&
1217         headerGet(h, RPMTAG_FILEDIGESTS, &fdigests, HEADERGET_MINMEM)) {
1218         const char *fdigest;
1219         size_t diglen = rpmDigestLength(fi->digestalgo);
1220         fi->digests = t = xmalloc(rpmtdCount(&fdigests) * diglen);
1221
1222         while ((fdigest = rpmtdNextString(&fdigests))) {
1223             if (!(fdigest && *fdigest != '\0')) {
1224                 memset(t, 0, diglen);
1225                 t += diglen;
1226                 continue;
1227             }
1228             for (int j = 0; j < diglen; j++, t++, fdigest += 2)
1229                 *t = (rnibble(fdigest[0]) << 4) | rnibble(fdigest[1]);
1230         }
1231         rpmtdFreeData(&fdigests);
1232     }
1233
1234     /* XXX TR_REMOVED doesn;t need fmtimes, frdevs, finodes */
1235     if (!(flags & RPMFI_NOFILEMTIMES))
1236         _hgfi(h, RPMTAG_FILEMTIMES, &td, scareFlags, fi->fmtimes);
1237     if (!(flags & RPMFI_NOFILERDEVS))
1238         _hgfi(h, RPMTAG_FILERDEVS, &td, scareFlags, fi->frdevs);
1239     if (!(flags & RPMFI_NOFILEINODES))
1240         _hgfi(h, RPMTAG_FILEINODES, &td, scareFlags, fi->finodes);
1241
1242     if (!(flags & RPMFI_NOFILEUSER))
1243         fi->fuser = cacheTag(ugcache, h, RPMTAG_FILEUSERNAME);
1244     if (!(flags & RPMFI_NOFILEGROUP))
1245         fi->fgroup = cacheTag(ugcache, h, RPMTAG_FILEGROUPNAME);
1246
1247     /* lazily alloced from rpmfiFN() */
1248     fi->fn = NULL;
1249
1250 exit:
1251
1252     if (fi != NULL) {
1253         fi->h = (fi->fiflags & RPMFI_KEEPHEADER) ? headerLink(h) : NULL;
1254     }
1255
1256     /* FIX: rpmfi null annotations */
1257     return rpmfiLink(fi);
1258 }
1259
1260 void rpmfiSetFReplacedSize(rpmfi fi, rpm_loff_t newsize)
1261 {
1262     if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
1263         if (fi->replacedSizes == NULL) {
1264             fi->replacedSizes = xcalloc(fi->fc, sizeof(*fi->replacedSizes));
1265         }
1266         /* XXX watch out, replacedSizes is not rpm_loff_t (yet) */
1267         fi->replacedSizes[fi->i] = (rpm_off_t) newsize;
1268     }
1269 }
1270
1271 rpm_loff_t rpmfiFReplacedSize(rpmfi fi)
1272 {
1273     rpm_loff_t rsize = 0;
1274     if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
1275         if (fi->replacedSizes) {
1276             rsize = fi->replacedSizes[fi->i];
1277         }
1278     }
1279     return rsize;
1280 }
1281
1282 void rpmfiFpLookup(rpmfi fi, fingerPrintCache fpc)
1283 {
1284     if (fi->fc > 0 && fi->fps == NULL) {
1285         fi->fps = xcalloc(fi->fc, sizeof(*fi->fps));
1286     }
1287     fpLookupList(fpc, fi->dnl, fi->bnl, fi->dil, fi->fc, fi->fps);
1288 }
1289
1290 FSM_t rpmfiFSM(rpmfi fi)
1291 {
1292     if (fi != NULL && fi->fsm == NULL) {
1293         cpioMapFlags mapflags;
1294         /* Figure out mapflags:
1295          * - path, mode, uid and gid are used by everything
1296          * - all binary packages get SBIT_CHECK set
1297          * - if archive size is not known, we're only building this package,
1298          *   different rules apply
1299          */
1300         mapflags = CPIO_MAP_PATH | CPIO_MAP_MODE | CPIO_MAP_UID | CPIO_MAP_GID;
1301         if (fi->fiflags & RPMFI_ISBUILD) {
1302             mapflags |= CPIO_MAP_TYPE;
1303             if (fi->fiflags & RPMFI_ISSOURCE) mapflags |= CPIO_FOLLOW_SYMLINKS;
1304         } else {
1305             if (!(fi->fiflags & RPMFI_ISSOURCE)) mapflags |= CPIO_SBIT_CHECK;
1306         }
1307         fi->fsm = newFSM(mapflags);
1308     }
1309     return (fi != NULL) ? fi->fsm : NULL;
1310 }
1311
1312 /*
1313  * Generate iterator accessors function wrappers, these do nothing but
1314  * call the corresponding rpmfiFooIndex(fi, fi->[ij])
1315  */
1316
1317 #define RPMFI_ITERFUNC(TYPE, NAME, IXV) \
1318     TYPE rpmfi ## NAME(rpmfi fi) { return rpmfi ## NAME ## Index(fi, fi ? fi->IXV : -1); }
1319
1320 RPMFI_ITERFUNC(const char *, BN, i)
1321 RPMFI_ITERFUNC(const char *, DN, j)
1322 RPMFI_ITERFUNC(const char *, FN, i)
1323 RPMFI_ITERFUNC(const char *, FLink, i)
1324 RPMFI_ITERFUNC(const char *, FUser, i)
1325 RPMFI_ITERFUNC(const char *, FGroup, i)
1326 RPMFI_ITERFUNC(const char *, FCaps, i)
1327 RPMFI_ITERFUNC(const char *, FLangs, i)
1328 RPMFI_ITERFUNC(const char *, FClass, i)
1329 RPMFI_ITERFUNC(rpmfileState, FState, i)
1330 RPMFI_ITERFUNC(rpmfileAttrs, FFlags, i)
1331 RPMFI_ITERFUNC(rpmVerifyAttrs, VFlags, i)
1332 RPMFI_ITERFUNC(rpm_mode_t, FMode, i)
1333 RPMFI_ITERFUNC(rpm_rdev_t, FRdev, i)
1334 RPMFI_ITERFUNC(rpm_time_t, FMtime, i)
1335 RPMFI_ITERFUNC(rpm_ino_t, FInode, i)
1336 RPMFI_ITERFUNC(rpm_loff_t, FSize, i)
1337 RPMFI_ITERFUNC(rpm_color_t, FColor, i)
1338 RPMFI_ITERFUNC(uint32_t, FNlink, i)
1339
1340 const unsigned char * rpmfiFDigest(rpmfi fi, int *algo, size_t *len)
1341 {
1342     return rpmfiFDigestIndex(fi, fi ? fi->i : -1, algo, len);
1343 }
1344
1345 uint32_t rpmfiFDepends(rpmfi fi, const uint32_t ** fddictp)
1346 {
1347     return rpmfiFDependsIndex(fi,  fi ? fi->i : -1, fddictp);
1348 }