3 * Routines to handle file info tag sets.
8 #include <rpm/rpmlog.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>
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() */
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
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;
39 static scidx_t strcachePut(strcache cache, const char *str)
44 for (scidx_t i = 0; i < cache->num; i++) {
45 if (strcmp(str, cache->uniq[i]) == 0) {
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);
63 static const char *strcacheGet(strcache cache, scidx_t idx)
65 const char *name = NULL;
66 if (idx >= 0 && idx < cache->num && cache->uniq != NULL)
67 name = cache->uniq[idx];
71 static strcache strcacheNew(void)
73 strcache cache = xcalloc(1, sizeof(*cache));
77 static strcache strcacheFree(strcache cache)
80 for (scidx_t i = 0; i < cache->num; i++) {
83 cache->uniq = _free(cache->uniq);
92 rpmfi rpmfiUnlink(rpmfi fi, const char * msg)
94 if (fi == NULL) return NULL;
95 if (_rpmfi_debug && msg != NULL)
96 fprintf(stderr, "--> fi %p -- %d %s\n", fi, fi->nrefs, msg);
101 rpmfi rpmfiLink(rpmfi fi, const char * msg)
103 if (fi == NULL) return NULL;
105 if (_rpmfi_debug && msg != NULL)
106 fprintf(stderr, "--> fi %p ++ %d %s\n", fi, fi->nrefs, msg);
110 rpm_count_t rpmfiFC(rpmfi fi)
112 return (fi != NULL ? fi->fc : 0);
115 rpm_count_t rpmfiDC(rpmfi fi)
117 return (fi != NULL ? fi->dc : 0);
121 int rpmfiDI(rpmfi fi)
126 int rpmfiFX(rpmfi fi)
128 return (fi != NULL ? fi->i : -1);
131 int rpmfiSetFX(rpmfi fi, int fx)
135 if (fi != NULL && fx >= 0 && fx < fi->fc) {
138 fi->j = fi->dil[fi->i];
143 int rpmfiDX(rpmfi fi)
145 return (fi != NULL ? fi->j : -1);
148 int rpmfiSetDX(rpmfi fi, int dx)
152 if (fi != NULL && dx >= 0 && dx < fi->dc) {
159 int rpmfiDIIndex(rpmfi fi, int dx)
162 if (fi != NULL && dx >= 0 && dx < fi->fc) {
169 const char * rpmfiBNIndex(rpmfi fi, int ix)
171 const char * BN = NULL;
173 if (fi != NULL && ix >= 0 && ix < fi->fc) {
180 const char * rpmfiDNIndex(rpmfi fi, int jx)
182 const char * DN = NULL;
184 if (fi != NULL && jx >= 0 && jx < fi->dc) {
191 const char * rpmfiFNIndex(rpmfi fi, int ix)
193 const char * FN = "";
195 if (fi != NULL && ix >= 0 && ix < fi->fc) {
197 if (fi->fn == NULL) {
198 size_t dnlmax = 0, bnlmax = 0, len;
199 for (int i = 0; i < fi->dc; i++) {
200 if ((len = strlen(fi->dnl[i])) > dnlmax)
203 for (int i = 0; i < fi->fc; i++) {
204 if ((len = strlen(fi->bnl[i])) > bnlmax)
207 fi->fn = xmalloc(dnlmax + bnlmax + 1);
211 t = stpcpy(t, fi->dnl[fi->dil[ix]]);
212 t = stpcpy(t, fi->bnl[ix]);
217 rpmfileAttrs rpmfiFFlagsIndex(rpmfi fi, int ix)
219 rpmfileAttrs FFlags = 0;
221 if (fi != NULL && ix >= 0 && ix < fi->fc) {
222 if (fi->fflags != NULL)
223 FFlags = fi->fflags[ix];
228 rpmVerifyAttrs rpmfiVFlagsIndex(rpmfi fi, int ix)
230 rpmVerifyAttrs VFlags = 0;
232 if (fi != NULL && ix >= 0 && ix < fi->fc) {
233 if (fi->vflags != NULL)
234 VFlags = fi->vflags[ix];
239 rpm_mode_t rpmfiFModeIndex(rpmfi fi, int ix)
241 rpm_mode_t fmode = 0;
243 if (fi != NULL && ix >= 0 && ix < fi->fc) {
244 if (fi->fmodes != NULL)
245 fmode = fi->fmodes[ix];
250 rpmfileState rpmfiFStateIndex(rpmfi fi, int ix)
252 rpmfileState fstate = RPMFILE_STATE_MISSING;
254 if (fi != NULL && ix >= 0 && ix < fi->fc) {
255 if (fi->fstates != NULL)
256 fstate = fi->fstates[ix];
261 const unsigned char * rpmfiMD5(rpmfi fi)
263 const unsigned char *digest;
264 pgpHashAlgo algo = 0;
266 digest = rpmfiFDigest(fi, &algo, NULL);
267 return (algo == PGPHASHALGO_MD5) ? digest : NULL;
270 pgpHashAlgo rpmfiDigestAlgo(rpmfi fi)
272 return fi ? fi->digestalgo : 0;
275 const unsigned char * rpmfiFDigestIndex(rpmfi fi, int ix, pgpHashAlgo *algo, size_t *len)
277 const unsigned char *digest = NULL;
279 if (fi != NULL && ix >= 0 && ix < fi->fc) {
280 size_t diglen = rpmDigestLength(fi->digestalgo);
281 if (fi->digests != NULL)
282 digest = fi->digests + (diglen * ix);
286 *algo = fi->digestalgo;
291 char * rpmfiFDigestHex(rpmfi fi, pgpHashAlgo *algo)
294 char *fdigest = NULL;
295 const unsigned char *digest = rpmfiFDigest(fi, algo, &diglen);
297 fdigest = pgpHexStr(digest, diglen);
302 const char * rpmfiFLinkIndex(rpmfi fi, int ix)
304 const char * flink = NULL;
306 if (fi != NULL && ix >= 0 && ix < fi->fc) {
307 if (fi->flinks != NULL)
308 flink = strcacheGet(fi->flinkcache, fi->flinks[ix]);
313 rpm_loff_t rpmfiFSizeIndex(rpmfi fi, int ix)
315 rpm_loff_t fsize = 0;
317 if (fi != NULL && ix >= 0 && ix < fi->fc) {
318 if (fi->fsizes != NULL)
319 fsize = fi->fsizes[ix];
324 rpm_rdev_t rpmfiFRdevIndex(rpmfi fi, int ix)
326 rpm_rdev_t frdev = 0;
328 if (fi != NULL && ix >= 0 && ix < fi->fc) {
329 if (fi->frdevs != NULL)
330 frdev = fi->frdevs[ix];
335 rpm_ino_t rpmfiFInodeIndex(rpmfi fi, int ix)
337 rpm_ino_t finode = 0;
339 if (fi != NULL && ix >= 0 && ix < fi->fc) {
340 if (fi->finodes != NULL)
341 finode = fi->finodes[ix];
346 rpm_color_t rpmfiColor(rpmfi fi)
348 rpm_color_t color = 0;
350 if (fi != NULL && fi->fcolors != NULL) {
351 for (int i = 0; i < fi->fc; i++)
352 color |= fi->fcolors[i];
353 /* XXX ignore all but lsnibble for now. */
359 rpm_color_t rpmfiFColorIndex(rpmfi fi, int ix)
361 rpm_color_t fcolor = 0;
363 if (fi != NULL && ix >= 0 && ix < fi->fc) {
364 if (fi->fcolors != NULL)
365 /* XXX ignore all but lsnibble for now. */
366 fcolor = (fi->fcolors[ix] & 0x0f);
371 const char * rpmfiFClassIndex(rpmfi fi, int ix)
373 const char * fclass = NULL;
376 if (fi != NULL && fi->fcdictx != NULL && ix >= 0 && ix < fi->fc) {
377 cdictx = fi->fcdictx[ix];
378 if (fi->cdict != NULL && cdictx >= 0 && cdictx < fi->ncdict)
379 fclass = fi->cdict[cdictx];
384 uint32_t rpmfiFDependsIndex(rpmfi fi, int ix, const uint32_t ** fddictp)
388 const uint32_t * fddict = NULL;
390 if (fi != NULL && ix >= 0 && ix < fi->fc) {
391 if (fi->fddictn != NULL)
392 fddictn = fi->fddictn[ix];
393 if (fddictn > 0 && fi->fddictx != NULL)
394 fddictx = fi->fddictx[ix];
395 if (fi->ddict != NULL && fddictx >= 0 && (fddictx+fddictn) <= fi->nddict)
396 fddict = fi->ddict + fddictx;
403 uint32_t rpmfiFNlinkIndex(rpmfi fi, int ix)
407 if (fi != NULL && ix >= 0 && ix < fi->fc) {
408 /* XXX rpm-2.3.12 has not RPMTAG_FILEINODES */
409 if (fi->finodes && fi->frdevs) {
410 rpm_ino_t finode = fi->finodes[ix];
411 rpm_rdev_t frdev = fi->frdevs[ix];
414 for (j = 0; j < fi->fc; j++) {
415 if (fi->frdevs[j] == frdev && fi->finodes[j] == finode)
423 rpm_time_t rpmfiFMtimeIndex(rpmfi fi, int ix)
425 rpm_time_t fmtime = 0;
427 if (fi != NULL && ix >= 0 && ix < fi->fc) {
428 if (fi->fmtimes != NULL)
429 fmtime = fi->fmtimes[ix];
434 const char * rpmfiFUserIndex(rpmfi fi, int ix)
436 const char * fuser = NULL;
438 if (fi != NULL && ix >= 0 && ix < fi->fc) {
439 if (fi->fuser != NULL)
440 fuser = strcacheGet(ugcache, fi->fuser[ix]);
445 const char * rpmfiFGroupIndex(rpmfi fi, int ix)
447 const char * fgroup = NULL;
449 if (fi != NULL && ix >= 0 && ix < fi->fc) {
450 if (fi->fgroup != NULL)
451 fgroup = strcacheGet(ugcache, fi->fgroup[ix]);
456 const char * rpmfiFCapsIndex(rpmfi fi, int ix)
458 const char *fcaps = NULL;
459 if (fi != NULL && ix >= 0 && ix < fi->fc) {
460 fcaps = fi->fcaps ? fi->fcaps[ix] : "";
465 const char * rpmfiFLangsIndex(rpmfi fi, int ix)
467 const char *flangs = NULL;
468 if (fi != NULL && fi->flangs != NULL && ix >= 0 && ix < fi->fc) {
469 flangs = strcacheGet(langcache, fi->flangs[ix]);
474 int rpmfiNext(rpmfi fi)
478 if (fi != NULL && ++fi->i >= 0) {
479 if (fi->i < fi->fc) {
482 fi->j = fi->dil[fi->i];
486 if (_rpmfi_debug < 0 && i != -1)
487 fprintf(stderr, "*** fi %p\t%s[%d] %s%s\n", fi, (fi->Type ? fi->Type : "?Type?"), i, (i >= 0 ? fi->dnl[fi->j] : ""), (i >= 0 ? fi->bnl[fi->i] : ""));
494 rpmfi rpmfiInit(rpmfi fi, int fx)
497 if (fx >= 0 && fx < fi->fc) {
506 int rpmfiNextD(rpmfi fi)
510 if (fi != NULL && ++fi->j >= 0) {
516 if (_rpmfi_debug < 0 && j != -1)
517 fprintf(stderr, "*** fi %p\t%s[%d]\n", fi, (fi->Type ? fi->Type : "?Type?"), j);
524 rpmfi rpmfiInitD(rpmfi fi, int dx)
527 if (dx >= 0 && dx < fi->fc)
537 * Identify a file type.
538 * @param ft file type
539 * @return string to identify a file type
542 const char * ftstring (rpmFileTypes ft)
545 case XDIR: return "directory";
546 case CDEV: return "char dev";
547 case BDEV: return "block dev";
548 case LINK: return "link";
549 case SOCK: return "sock";
550 case PIPE: return "fifo/pipe";
551 case REG: return "file";
552 default: return "unknown file type";
556 rpmFileTypes rpmfiWhatis(rpm_mode_t mode)
558 if (S_ISDIR(mode)) return XDIR;
559 if (S_ISCHR(mode)) return CDEV;
560 if (S_ISBLK(mode)) return BDEV;
561 if (S_ISLNK(mode)) return LINK;
562 if (S_ISSOCK(mode)) return SOCK;
563 if (S_ISFIFO(mode)) return PIPE;
567 int rpmfiCompare(const rpmfi afi, const rpmfi bfi)
569 rpmFileTypes awhat = rpmfiWhatis(rpmfiFMode(afi));
570 rpmFileTypes bwhat = rpmfiWhatis(rpmfiFMode(bfi));
572 if ((rpmfiFFlags(afi) & RPMFILE_GHOST) ||
573 (rpmfiFFlags(bfi) & RPMFILE_GHOST)) return 0;
575 if (awhat != bwhat) return 1;
578 const char * alink = rpmfiFLink(afi);
579 const char * blink = rpmfiFLink(bfi);
580 if (alink == blink) return 0;
581 if (alink == NULL) return 1;
582 if (blink == NULL) return -1;
583 return strcmp(alink, blink);
584 } else if (awhat == REG) {
585 size_t adiglen, bdiglen;
586 pgpHashAlgo aalgo, balgo;
587 const unsigned char * adigest = rpmfiFDigest(afi, &aalgo, &adiglen);
588 const unsigned char * bdigest = rpmfiFDigest(bfi, &balgo, &bdiglen);
589 if (adigest == bdigest) return 0;
590 if (adigest == NULL) return 1;
591 if (bdigest == NULL) return -1;
592 /* can't meaningfully compare different hash types */
593 if (aalgo != balgo || adiglen != bdiglen) return -1;
594 return memcmp(adigest, bdigest, adiglen);
600 rpmFileAction rpmfiDecideFate(const rpmfi ofi, rpmfi nfi, int skipMissing)
602 const char * fn = rpmfiFN(nfi);
603 rpmfileAttrs newFlags = rpmfiFFlags(nfi);
605 rpmFileTypes dbWhat, newWhat, diskWhat;
607 int save = (newFlags & RPMFILE_NOREPLACE) ? FA_ALTNAME : FA_SAVE;
609 if (lstat(fn, &sb)) {
611 * The file doesn't exist on the disk. Create it unless the new
612 * package has marked it as missingok, or allfiles is requested.
614 if (skipMissing && (newFlags & RPMFILE_MISSINGOK)) {
615 rpmlog(RPMLOG_DEBUG, "%s skipped due to missingok flag\n",
623 diskWhat = rpmfiWhatis((rpm_mode_t)sb.st_mode);
624 dbWhat = rpmfiWhatis(rpmfiFMode(ofi));
625 newWhat = rpmfiWhatis(rpmfiFMode(nfi));
628 * RPM >= 2.3.10 shouldn't create config directories -- we'll ignore
629 * them in older packages as well.
634 if (diskWhat != newWhat && dbWhat != REG && dbWhat != LINK)
636 else if (newWhat != dbWhat && diskWhat != dbWhat)
638 else if (dbWhat != newWhat)
640 else if (dbWhat != LINK && dbWhat != REG)
644 * This order matters - we'd prefer to CREATE the file if at all
645 * possible in case something else (like the timestamp) has changed.
647 memset(buffer, 0, sizeof(buffer));
649 pgpHashAlgo oalgo, nalgo;
650 size_t odiglen, ndiglen;
651 const unsigned char * odigest, * ndigest;
652 odigest = rpmfiFDigest(ofi, &oalgo, &odiglen);
653 if (diskWhat == REG) {
654 if (rpmDoDigest(oalgo, fn, 0,
655 (unsigned char *)buffer, NULL))
656 return FA_CREATE; /* assume file has been removed */
657 if (odigest && !memcmp(odigest, buffer, odiglen))
658 return FA_CREATE; /* unmodified config file, replace. */
660 ndigest = rpmfiFDigest(nfi, &nalgo, &ndiglen);
661 /* XXX can't compare different hash types, what should we do here? */
662 if (oalgo != nalgo || odiglen != ndiglen)
664 if (odigest && ndigest && !memcmp(odigest, ndigest, odiglen))
665 return FA_SKIP; /* identical file, don't bother. */
666 } else /* dbWhat == LINK */ {
667 const char * oFLink, * nFLink;
668 oFLink = rpmfiFLink(ofi);
669 if (diskWhat == LINK) {
670 if (readlink(fn, buffer, sizeof(buffer) - 1) == -1)
671 return FA_CREATE; /* assume file has been removed */
672 if (oFLink && !strcmp(oFLink, buffer))
673 return FA_CREATE; /* unmodified config file, replace. */
675 nFLink = rpmfiFLink(nfi);
676 if (oFLink && nFLink && !strcmp(oFLink, nFLink))
677 return FA_SKIP; /* identical file, don't bother. */
681 * The config file on the disk has been modified, but
682 * the ones in the two packages are different. It would
683 * be nice if RPM was smart enough to at least try and
684 * merge the difference ala CVS, but...
689 int rpmfiConfigConflict(const rpmfi fi)
691 const char * fn = rpmfiFN(fi);
692 rpmfileAttrs flags = rpmfiFFlags(fi);
694 rpmFileTypes newWhat, diskWhat;
697 if (!(flags & RPMFILE_CONFIG) || lstat(fn, &sb)) {
701 diskWhat = rpmfiWhatis((rpm_mode_t)sb.st_mode);
702 newWhat = rpmfiWhatis(rpmfiFMode(fi));
704 if (newWhat != LINK && newWhat != REG)
707 if (diskWhat != newWhat)
710 memset(buffer, 0, sizeof(buffer));
711 if (newWhat == REG) {
714 const unsigned char *ndigest = rpmfiFDigest(fi, &algo, &diglen);
715 if (rpmDoDigest(algo, fn, 0, (unsigned char *)buffer, NULL))
716 return 0; /* assume file has been removed */
717 if (ndigest && !memcmp(ndigest, buffer, diglen))
718 return 0; /* unmodified config file */
719 } else /* newWhat == LINK */ {
721 if (readlink(fn, buffer, sizeof(buffer) - 1) == -1)
722 return 0; /* assume file has been removed */
723 nFLink = rpmfiFLink(fi);
724 if (nFLink && !strcmp(nFLink, buffer))
725 return 0; /* unmodified config file */
731 static char **duparray(char ** src, int size)
733 char **dest = xmalloc((size+1) * sizeof(*dest));
734 for (int i = 0; i < size; i++) {
735 dest[i] = xstrdup(src[i]);
742 * Relocate files in header.
743 * @todo multilib file dispositions need to be checked.
744 * @param ts transaction set
745 * @param fi transaction element file info
746 * @param origH package header
747 * @return header with relocated files
750 Header relocateFileList(const rpmts ts, rpmfi fi,
753 rpmte p = rpmtsRelocateElement(ts);
754 static int _printed = 0;
755 int allowBadRelocate = (rpmtsFilterFlags(ts) & RPMPROB_FILTER_FORCERELOCATE);
756 rpmRelocation * relocations = NULL;
760 uint32_t * dirIndexes;
761 uint32_t * newDirIndexes;
762 rpm_count_t fileCount, dirCount, numValid = 0;
763 rpm_color_t * fColors = NULL;
764 rpm_color_t * dColors = NULL;
765 rpm_mode_t * fModes = NULL;
770 int haveRelocatedBase = 0;
774 struct rpmtd_s validRelocs;
775 struct rpmtd_s bnames, dnames, dindexes, fcolors, fmodes;
778 if (headerGet(origH, RPMTAG_PREFIXES, &validRelocs, HEADERGET_MINMEM))
779 numValid = rpmtdCount(&validRelocs);
784 while (p->relocs[numRelocations].newPath ||
785 p->relocs[numRelocations].oldPath)
789 * If no relocations are specified (usually the case), then return the
790 * original header. If there are prefixes, however, then INSTPREFIXES
791 * should be added, but, since relocateFileList() can be called more
792 * than once for the same header, don't bother if already present.
794 if (p->relocs == NULL || numRelocations == 0) {
796 if (!headerIsEntry(origH, RPMTAG_INSTPREFIXES)) {
797 rpmtdSetTag(&validRelocs, RPMTAG_INSTPREFIXES);
798 headerPut(origH, &validRelocs, HEADERPUT_DEFAULT);
800 rpmtdFreeData(&validRelocs);
802 /* XXX FIXME multilib file actions need to be checked. */
803 return headerLink(origH);
806 h = headerLink(origH);
808 relocations = xmalloc(sizeof(*relocations) * numRelocations);
810 /* Build sorted relocation list from raw relocations. */
811 for (i = 0; i < numRelocations; i++) {
815 * Default relocations (oldPath == NULL) are handled in the UI,
818 if (p->relocs[i].oldPath == NULL) continue; /* XXX can't happen */
820 /* FIXME: Trailing /'s will confuse us greatly. Internal ones will
821 too, but those are more trouble to fix up. :-( */
822 t = xstrdup(p->relocs[i].oldPath);
823 relocations[i].oldPath = (t[0] == '/' && t[1] == '\0')
825 : stripTrailingChar(t, '/');
827 /* An old path w/o a new path is valid, and indicates exclusion */
828 if (p->relocs[i].newPath) {
831 const char *validprefix;
833 t = xstrdup(p->relocs[i].newPath);
834 relocations[i].newPath = (t[0] == '/' && t[1] == '\0')
836 : stripTrailingChar(t, '/');
838 /* FIX: relocations[i].oldPath == NULL */
839 /* Verify that the relocation's old path is in the header. */
840 rpmtdInit(&validRelocs);
841 while ((validprefix = rpmtdNextString(&validRelocs))) {
842 if (strcmp(validprefix, relocations[i].oldPath) == 0) {
848 if (!valid && !allowBadRelocate) {
849 rpmps ps = rpmtsProblems(ts);
850 rpmpsAppend(ps, RPMPROB_BADRELOCATE,
851 rpmteNEVRA(p), rpmteKey(p),
852 relocations[i].oldPath, NULL, NULL, 0);
856 strlen(relocations[i].newPath) - strlen(relocations[i].oldPath);
861 relocations[i].newPath = NULL;
865 /* stupid bubble sort, but it's probably faster here */
866 for (i = 0; i < numRelocations; i++) {
869 for (j = 1; j < numRelocations; j++) {
870 rpmRelocation tmpReloc;
871 if (relocations[j - 1].oldPath == NULL || /* XXX can't happen */
872 relocations[j ].oldPath == NULL || /* XXX can't happen */
873 strcmp(relocations[j - 1].oldPath, relocations[j].oldPath) <= 0)
876 tmpReloc = relocations[j - 1];
877 relocations[j - 1] = relocations[j];
878 relocations[j] = tmpReloc;
881 if (!madeSwap) break;
886 rpmlog(RPMLOG_DEBUG, "========== relocations\n");
887 for (i = 0; i < numRelocations; i++) {
888 if (relocations[i].oldPath == NULL) continue; /* XXX can't happen */
889 if (relocations[i].newPath == NULL)
890 rpmlog(RPMLOG_DEBUG, "%5d exclude %s\n",
891 i, relocations[i].oldPath);
893 rpmlog(RPMLOG_DEBUG, "%5d relocate %s -> %s\n",
894 i, relocations[i].oldPath, relocations[i].newPath);
898 /* Add relocation values to the header */
900 const char *validprefix;
901 const char ** actualRelocations;
902 rpm_count_t numActual;
904 actualRelocations = xmalloc(numValid * sizeof(*actualRelocations));
906 rpmtdInit(&validRelocs);
907 while ((validprefix = rpmtdNextString(&validRelocs))) {
908 for (j = 0; j < numRelocations; j++) {
909 if (relocations[j].oldPath == NULL || /* XXX can't happen */
910 strcmp(validprefix, relocations[j].oldPath))
912 /* On install, a relocate to NULL means skip the path. */
913 if (relocations[j].newPath) {
914 actualRelocations[numActual] = relocations[j].newPath;
919 if (j == numRelocations) {
920 actualRelocations[numActual] = validprefix;
926 headerPutStringArray(h, RPMTAG_INSTPREFIXES,
927 actualRelocations, numActual);
930 actualRelocations = _free(actualRelocations);
931 rpmtdFreeData(&validRelocs);
934 headerGet(h, RPMTAG_BASENAMES, &bnames, fi->scareFlags);
935 headerGet(h, RPMTAG_DIRINDEXES, &dindexes, fi->scareFlags);
936 headerGet(h, RPMTAG_DIRNAMES, &dnames, fi->scareFlags);
937 headerGet(h, RPMTAG_FILECOLORS, &fcolors, fi->scareFlags);
938 headerGet(h, RPMTAG_FILEMODES, &fmodes, fi->scareFlags);
939 /* TODO XXX ugh.. use rpmtd iterators & friends instead */
940 baseNames = bnames.data;
941 dirIndexes = dindexes.data;
942 fColors = fcolors.data;
943 fModes = fmodes.data;
944 fileCount = rpmtdCount(&bnames);
945 dirCount = rpmtdCount(&dnames);
946 /* XXX TODO: use rpmtdDup() instead */
947 dirNames = dnames.data = duparray(dnames.data, dirCount);
948 dnames.flags |= RPMTD_PTR_ALLOCED;
950 dColors = xcalloc(dirCount, sizeof(*dColors));
952 newDirIndexes = xmalloc(sizeof(*newDirIndexes) * fileCount);
953 memcpy(newDirIndexes, dirIndexes, sizeof(*newDirIndexes) * fileCount);
954 dirIndexes = newDirIndexes;
957 * For all relocations, we go through sorted file/relocation lists
958 * backwards so that /usr/local relocations take precedence over /usr
962 /* Relocate individual paths. */
964 for (i = fileCount - 1; i >= 0; i--) {
969 strlen(dirNames[dirIndexes[i]]) + strlen(baseNames[i]) + 1;
970 if (len >= fileAlloced) {
971 fileAlloced = len * 2;
972 fn = xrealloc(fn, fileAlloced);
975 assert(fn != NULL); /* XXX can't happen */
977 fnlen = stpcpy( stpcpy(fn, dirNames[dirIndexes[i]]), baseNames[i]) - fn;
979 if (fColors != NULL) {
980 /* XXX pkgs may not have unique dirNames, so color all dirNames that match. */
981 for (j = 0; j < dirCount; j++) {
982 if (strcmp(dirNames[dirIndexes[i]], dirNames[j])) continue;
983 dColors[j] |= fColors[i];
988 * See if this file path needs relocating.
991 * XXX FIXME: Would a bsearch of the (already sorted)
992 * relocation list be a good idea?
994 for (j = numRelocations - 1; j >= 0; j--) {
995 if (relocations[j].oldPath == NULL) /* XXX can't happen */
997 len = strcmp(relocations[j].oldPath, "/")
998 ? strlen(relocations[j].oldPath)
1004 * Only subdirectories or complete file paths may be relocated. We
1005 * don't check for '\0' as our directory names all end in '/'.
1007 if (!(fn[len] == '/' || fnlen == len))
1010 if (strncmp(relocations[j].oldPath, fn, len))
1014 if (j < 0) continue;
1016 /* FIX: fModes may be NULL */
1017 ft = rpmfiWhatis(fModes[i]);
1019 /* On install, a relocate to NULL means skip the path. */
1020 if (relocations[j].newPath == NULL) {
1022 /* Start with the parent, looking for directory to exclude. */
1023 for (j = dirIndexes[i]; j < dirCount; j++) {
1024 len = strlen(dirNames[j]) - 1;
1025 while (len > 0 && dirNames[j][len-1] == '/') len--;
1028 if (strncmp(fn, dirNames[j], fnlen))
1033 rpmfsSetAction(rpmteGetFileStates(p), i, FA_SKIPNSTATE);
1034 rpmlog(RPMLOG_DEBUG, "excluding %s %s\n",
1039 /* Relocation on full paths only, please. */
1040 if (fnlen != len) continue;
1042 rpmlog(RPMLOG_DEBUG, "relocating %s to %s\n",
1043 fn, relocations[j].newPath);
1046 strcpy(fn, relocations[j].newPath);
1047 { char * te = strrchr(fn, '/');
1049 if (te > fn) te++; /* root is special */
1052 te = fn + strlen(fn);
1053 if (strcmp(baseNames[i], te)) { /* basename changed too? */
1054 if (!haveRelocatedBase) {
1055 /* XXX TODO: use rpmtdDup() instead */
1056 bnames.data = baseNames = duparray(baseNames, fileCount);
1057 bnames.flags |= RPMTD_PTR_ALLOCED;
1058 haveRelocatedBase = 1;
1061 baseNames[i] = xstrdup(te);
1063 *te = '\0'; /* terminate new directory name */
1066 /* Does this directory already exist in the directory list? */
1067 for (j = 0; j < dirCount; j++) {
1068 if (fnlen != strlen(dirNames[j]))
1070 if (strncmp(fn, dirNames[j], fnlen))
1080 /* Creating new paths is a pita */
1081 dirNames = dnames.data = xrealloc(dnames.data,
1082 sizeof(*dirNames) * (dirCount + 1));
1084 dirNames[dirCount] = xstrdup(fn);
1085 dirIndexes[i] = dirCount;
1090 /* Finish off by relocating directories. */
1091 for (i = dirCount - 1; i >= 0; i--) {
1092 for (j = numRelocations - 1; j >= 0; j--) {
1094 if (relocations[j].oldPath == NULL) /* XXX can't happen */
1096 len = strcmp(relocations[j].oldPath, "/")
1097 ? strlen(relocations[j].oldPath)
1100 if (len && strncmp(relocations[j].oldPath, dirNames[i], len))
1104 * Only subdirectories or complete file paths may be relocated. We
1105 * don't check for '\0' as our directory names all end in '/'.
1107 if (dirNames[i][len] != '/')
1110 if (relocations[j].newPath) { /* Relocate the path */
1112 rstrscat(&t, relocations[j].newPath, (dirNames[i] + len), NULL);
1113 /* Unfortunatly rpmCleanPath strips the trailing slash.. */
1114 (void) rpmCleanPath(t);
1117 rpmlog(RPMLOG_DEBUG,
1118 "relocating directory %s to %s\n", dirNames[i], t);
1126 /* Save original filenames in header and replace (relocated) filenames. */
1130 headerGet(h, RPMTAG_BASENAMES, &td, HEADERGET_MINMEM);
1131 rpmtdSetTag(&td, RPMTAG_ORIGBASENAMES);
1132 headerPut(h, &td, HEADERPUT_DEFAULT);
1135 headerGet(h, RPMTAG_DIRNAMES, &td, HEADERGET_MINMEM);
1136 rpmtdSetTag(&td, RPMTAG_ORIGDIRNAMES);
1137 headerPut(h, &td, HEADERPUT_DEFAULT);
1140 headerGet(h, RPMTAG_DIRINDEXES, &td, HEADERGET_MINMEM);
1141 rpmtdSetTag(&td, RPMTAG_ORIGDIRINDEXES);
1142 headerPut(h, &td, HEADERPUT_DEFAULT);
1145 if (rpmtdFromStringArray(&td, RPMTAG_BASENAMES, (const char**) baseNames, fileCount)) {
1149 headerGet(h, RPMTAG_BASENAMES, &td, fi->scareFlags);
1150 fi->fc = rpmtdCount(&td);
1153 if (rpmtdFromStringArray(&td, RPMTAG_DIRNAMES, (const char**) dirNames, dirCount)) {
1157 headerGet(h, RPMTAG_DIRNAMES, &td, fi->scareFlags);
1158 fi->dc = rpmtdCount(&td);
1161 if (rpmtdFromUint32(&td, RPMTAG_DIRINDEXES, dirIndexes, fileCount)) {
1164 headerGet(h, RPMTAG_DIRINDEXES, &td, fi->scareFlags);
1165 /* Ugh, nasty games with how dil is alloced depending on scareMem */
1166 if (fi->scareFlags & HEADERGET_ALLOC)
1171 rpmtdFreeData(&bnames);
1172 rpmtdFreeData(&dnames);
1173 rpmtdFreeData(&dindexes);
1174 rpmtdFreeData(&fcolors);
1175 rpmtdFreeData(&fmodes);
1177 for (i = 0; i < numRelocations; i++) {
1178 free(relocations[i].oldPath);
1179 free(relocations[i].newPath);
1182 free(newDirIndexes);
1188 rpmfi rpmfiFree(rpmfi fi)
1190 if (fi == NULL) return NULL;
1193 return rpmfiUnlink(fi, fi->Type);
1195 if (_rpmfi_debug < 0)
1196 fprintf(stderr, "*** fi %p\t%s[%d]\n", fi, fi->Type, fi->fc);
1199 fi->bnl = _free(fi->bnl);
1200 fi->dnl = _free(fi->dnl);
1202 fi->flinkcache = strcacheFree(fi->flinkcache);
1203 fi->flinks = _free(fi->flinks);
1204 fi->flangs = _free(fi->flangs);
1205 fi->digests = _free(fi->digests);
1206 fi->fcaps = _free(fi->fcaps);
1208 fi->cdict = _free(fi->cdict);
1210 fi->fuser = _free(fi->fuser);
1211 fi->fgroup = _free(fi->fgroup);
1213 fi->fstates = _free(fi->fstates);
1214 fi->fps = _free(fi->fps);
1216 if (!(fi->fiflags & RPMFI_KEEPHEADER) && fi->h == NULL) {
1217 fi->fmtimes = _constfree(fi->fmtimes);
1218 fi->fmodes = _free(fi->fmodes);
1219 fi->fflags = _constfree(fi->fflags);
1220 fi->vflags = _constfree(fi->vflags);
1221 fi->fsizes = _constfree(fi->fsizes);
1222 fi->frdevs = _constfree(fi->frdevs);
1223 fi->finodes = _constfree(fi->finodes);
1224 fi->dil = _free(fi->dil);
1226 fi->fcolors = _constfree(fi->fcolors);
1227 fi->fcdictx = _constfree(fi->fcdictx);
1228 fi->ddict = _constfree(fi->ddict);
1229 fi->fddictx = _constfree(fi->fddictx);
1230 fi->fddictn = _constfree(fi->fddictn);
1235 fi->fsm = freeFSM(fi->fsm);
1237 fi->fn = _free(fi->fn);
1238 fi->apath = _free(fi->apath);
1240 fi->replacedSizes = _free(fi->replacedSizes);
1242 fi->h = headerFree(fi->h);
1244 (void) rpmfiUnlink(fi, fi->Type);
1245 memset(fi, 0, sizeof(*fi)); /* XXX trash and burn */
1251 /* Helper to push header tag data into a string cache */
1252 static scidx_t *cacheTag(strcache cache, Header h, rpmTag tag)
1254 scidx_t *idx = NULL;
1256 if (headerGet(h, tag, &td, HEADERGET_MINMEM)) {
1257 idx = xmalloc(sizeof(*idx) * rpmtdCount(&td));
1260 while ((str = rpmtdNextString(&td))) {
1261 idx[i++] = strcachePut(cache, str);
1268 #define _hgfi(_h, _tag, _td, _flags, _data) \
1269 if (headerGet((_h), (_tag), (_td), (_flags))) \
1272 rpmfi rpmfiNew(const rpmts ts, Header h, rpmTag tagN, rpmfiFlags flags)
1277 rpm_loff_t *asize = NULL;
1279 int isBuild, isSource;
1280 struct rpmtd_s fdigests, digalgo;
1282 headerGetFlags scareFlags = (flags & RPMFI_KEEPHEADER) ?
1283 HEADERGET_MINMEM : HEADERGET_ALLOC;
1284 headerGetFlags defFlags = HEADERGET_ALLOC;
1286 if (tagN == RPMTAG_BASENAMES) {
1293 fi = xcalloc(1, sizeof(*fi));
1294 if (fi == NULL) /* XXX can't happen */
1297 fi->magic = RPMFIMAGIC;
1302 fi->fiflags = flags;
1303 fi->scareFlags = scareFlags;
1305 fi->h = (fi->fiflags & RPMFI_KEEPHEADER) ? headerLink(h) : NULL;
1307 if (headerGet(h, RPMTAG_LONGARCHIVESIZE, &td, HEADERGET_EXT)) {
1308 asize = rpmtdGetUint64(&td);
1310 /* 0 means unknown */
1311 fi->archiveSize = asize ? *asize : 0;
1314 /* Archive size is not set when this gets called from build */
1315 isBuild = (asize == NULL);
1316 isSource = headerIsSource(h);
1317 if (isBuild) fi->fiflags |= RPMFI_ISBUILD;
1318 if (isSource) fi->fiflags |= RPMFI_ISSOURCE;
1320 _hgfi(h, RPMTAG_BASENAMES, &td, defFlags, fi->bnl);
1321 fi->fc = rpmtdCount(&td);
1326 _hgfi(h, RPMTAG_DIRNAMES, &td, defFlags, fi->dnl);
1327 fi->dc = rpmtdCount(&td);
1328 _hgfi(h, RPMTAG_DIRINDEXES, &td, scareFlags, fi->dil);
1329 if (!(flags & RPMFI_NOFILEMODES))
1330 _hgfi(h, RPMTAG_FILEMODES, &td, scareFlags, fi->fmodes);
1331 if (!(flags & RPMFI_NOFILEFLAGS))
1332 _hgfi(h, RPMTAG_FILEFLAGS, &td, scareFlags, fi->fflags);
1333 if (!(flags & RPMFI_NOFILEVERIFYFLAGS))
1334 _hgfi(h, RPMTAG_FILEVERIFYFLAGS, &td, scareFlags, fi->vflags);
1335 if (!(flags & RPMFI_NOFILESIZES))
1336 _hgfi(h, RPMTAG_FILESIZES, &td, scareFlags, fi->fsizes);
1338 if (!(flags & RPMFI_NOFILECOLORS))
1339 _hgfi(h, RPMTAG_FILECOLORS, &td, scareFlags, fi->fcolors);
1341 if (!(flags & RPMFI_NOFILECLASS)) {
1342 _hgfi(h, RPMTAG_CLASSDICT, &td, scareFlags, fi->cdict);
1343 fi->ncdict = rpmtdCount(&td);
1344 _hgfi(h, RPMTAG_FILECLASS, &td, scareFlags, fi->fcdictx);
1346 if (!(flags & RPMFI_NOFILEDEPS)) {
1347 _hgfi(h, RPMTAG_DEPENDSDICT, &td, scareFlags, fi->ddict);
1348 fi->nddict = rpmtdCount(&td);
1349 _hgfi(h, RPMTAG_FILEDEPENDSX, &td, scareFlags, fi->fddictx);
1350 _hgfi(h, RPMTAG_FILEDEPENDSN, &td, scareFlags, fi->fddictn);
1353 if (!(flags & RPMFI_NOFILESTATES))
1354 _hgfi(h, RPMTAG_FILESTATES, &td, defFlags, fi->fstates);
1356 if (!(flags & RPMFI_NOFILECAPS))
1357 _hgfi(h, RPMTAG_FILECAPS, &td, defFlags, fi->fcaps);
1359 if (!(flags & RPMFI_NOFILELINKTOS)) {
1360 fi->flinkcache = strcacheNew();
1361 fi->flinks = cacheTag(fi->flinkcache, h, RPMTAG_FILELINKTOS);
1363 /* FILELANGS are only interesting when installing */
1364 if ((headerGetInstance(h) == 0) && !(flags & RPMFI_NOFILELANGS))
1365 fi->flangs = cacheTag(langcache, h, RPMTAG_FILELANGS);
1367 /* See if the package has non-md5 file digests */
1368 fi->digestalgo = PGPHASHALGO_MD5;
1369 if (headerGet(h, RPMTAG_FILEDIGESTALGO, &digalgo, HEADERGET_MINMEM)) {
1370 pgpHashAlgo *algo = rpmtdGetUint32(&digalgo);
1371 /* Hmm, what to do with unknown digest algorithms? */
1372 if (algo && rpmDigestLength(*algo) != 0) {
1373 fi->digestalgo = *algo;
1378 /* grab hex digests from header and store in binary format */
1379 if (!(flags & RPMFI_NOFILEDIGESTS) &&
1380 headerGet(h, RPMTAG_FILEDIGESTS, &fdigests, HEADERGET_MINMEM)) {
1381 const char *fdigest;
1382 size_t diglen = rpmDigestLength(fi->digestalgo);
1383 fi->digests = t = xmalloc(rpmtdCount(&fdigests) * diglen);
1385 while ((fdigest = rpmtdNextString(&fdigests))) {
1386 if (!(fdigest && *fdigest != '\0')) {
1387 memset(t, 0, diglen);
1391 for (int j = 0; j < diglen; j++, t++, fdigest += 2)
1392 *t = (rnibble(fdigest[0]) << 4) | rnibble(fdigest[1]);
1394 rpmtdFreeData(&fdigests);
1397 /* XXX TR_REMOVED doesn;t need fmtimes, frdevs, finodes */
1398 if (!(flags & RPMFI_NOFILEMTIMES))
1399 _hgfi(h, RPMTAG_FILEMTIMES, &td, scareFlags, fi->fmtimes);
1400 if (!(flags & RPMFI_NOFILERDEVS))
1401 _hgfi(h, RPMTAG_FILERDEVS, &td, scareFlags, fi->frdevs);
1402 if (!(flags & RPMFI_NOFILEINODES))
1403 _hgfi(h, RPMTAG_FILEINODES, &td, scareFlags, fi->finodes);
1405 if (!(flags & RPMFI_NOFILEUSER))
1406 fi->fuser = cacheTag(ugcache, h, RPMTAG_FILEUSERNAME);
1407 if (!(flags & RPMFI_NOFILEGROUP))
1408 fi->fgroup = cacheTag(ugcache, h, RPMTAG_FILEGROUPNAME);
1412 if ((p = rpmtsRelocateElement(ts)) != NULL && rpmteType(p) == TR_ADDED
1413 && !headerIsSource(h)
1414 && !headerIsEntry(h, RPMTAG_ORIGBASENAMES))
1418 /* FIX: fi-digests undefined */
1419 foo = relocateFileList(ts, fi, h);
1420 fi->h = headerFree(fi->h);
1421 fi->h = headerLink(foo);
1422 foo = headerFree(foo);
1425 if (!(fi->fiflags & RPMFI_KEEPHEADER)) {
1426 fi->h = headerFree(fi->h);
1429 /* lazily alloced from rpmfiFN() */
1433 if (_rpmfi_debug < 0)
1434 fprintf(stderr, "*** fi %p\t%s[%d]\n", fi, Type, (fi ? fi->fc : 0));
1436 /* FIX: rpmfi null annotations */
1437 return rpmfiLink(fi, (fi ? fi->Type : NULL));
1440 void rpmfiSetFReplacedSize(rpmfi fi, rpm_loff_t newsize)
1442 if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
1443 if (fi->replacedSizes == NULL) {
1444 fi->replacedSizes = xcalloc(fi->fc, sizeof(*fi->replacedSizes));
1446 /* XXX watch out, replacedSizes is not rpm_loff_t (yet) */
1447 fi->replacedSizes[fi->i] = (rpm_off_t) newsize;
1451 rpm_loff_t rpmfiFReplacedSize(rpmfi fi)
1453 rpm_loff_t rsize = 0;
1454 if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
1455 if (fi->replacedSizes) {
1456 rsize = fi->replacedSizes[fi->i];
1463 FSM_t rpmfiFSM(rpmfi fi)
1465 if (fi != NULL && fi->fsm == NULL) {
1466 cpioMapFlags mapflags;
1467 /* Figure out mapflags:
1468 * - path, mode, uid and gid are used by everything
1469 * - all binary packages get SBIT_CHECK set
1470 * - if archive size is not known, we're only building this package,
1471 * different rules apply
1473 mapflags = CPIO_MAP_PATH | CPIO_MAP_MODE | CPIO_MAP_UID | CPIO_MAP_GID;
1474 if (fi->fiflags & RPMFI_ISBUILD) {
1475 mapflags |= CPIO_MAP_TYPE;
1476 if (fi->fiflags & RPMFI_ISSOURCE) mapflags |= CPIO_FOLLOW_SYMLINKS;
1478 if (!(fi->fiflags & RPMFI_ISSOURCE)) mapflags |= CPIO_SBIT_CHECK;
1480 fi->fsm = newFSM(mapflags);
1482 return (fi != NULL) ? fi->fsm : NULL;
1486 * Generate iterator accessors function wrappers, these do nothing but
1487 * call the corresponding rpmfiFooIndex(fi, fi->[ij])
1490 #define RPMFI_ITERFUNC(TYPE, NAME, IXV) \
1491 TYPE rpmfi ## NAME(rpmfi fi) { return rpmfi ## NAME ## Index(fi, fi ? fi->IXV : -1); }
1493 RPMFI_ITERFUNC(const char *, BN, i)
1494 RPMFI_ITERFUNC(const char *, DN, j)
1495 RPMFI_ITERFUNC(const char *, FN, i)
1496 RPMFI_ITERFUNC(const char *, FLink, i)
1497 RPMFI_ITERFUNC(const char *, FUser, i)
1498 RPMFI_ITERFUNC(const char *, FGroup, i)
1499 RPMFI_ITERFUNC(const char *, FCaps, i)
1500 RPMFI_ITERFUNC(const char *, FLangs, i)
1501 RPMFI_ITERFUNC(const char *, FClass, i)
1502 RPMFI_ITERFUNC(rpmfileState, FState, i)
1503 RPMFI_ITERFUNC(rpmfileAttrs, FFlags, i)
1504 RPMFI_ITERFUNC(rpmVerifyAttrs, VFlags, i)
1505 RPMFI_ITERFUNC(rpm_mode_t, FMode, i)
1506 RPMFI_ITERFUNC(rpm_rdev_t, FRdev, i)
1507 RPMFI_ITERFUNC(rpm_time_t, FMtime, i)
1508 RPMFI_ITERFUNC(rpm_ino_t, FInode, i)
1509 RPMFI_ITERFUNC(rpm_loff_t, FSize, i)
1510 RPMFI_ITERFUNC(rpm_color_t, FColor, i)
1511 RPMFI_ITERFUNC(uint32_t, FNlink, i)
1513 const unsigned char * rpmfiFDigest(rpmfi fi, pgpHashAlgo *algo, size_t *len)
1515 return rpmfiFDigestIndex(fi, fi ? fi->i : -1, algo, len);
1518 uint32_t rpmfiFDepends(rpmfi fi, const uint32_t ** fddictp)
1520 return rpmfiFDependsIndex(fi, fi ? fi->i : -1, fddictp);