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 struct fingerPrint_s *rpmfiFpsIndex(rpmfi fi, int ix)
476 struct fingerPrint_s * fps = NULL;
477 if (fi != NULL && fi->fps != NULL && ix >= 0 && ix < fi->fc) {
483 int rpmfiNext(rpmfi fi)
487 if (fi != NULL && ++fi->i >= 0) {
488 if (fi->i < fi->fc) {
491 fi->j = fi->dil[fi->i];
495 if (_rpmfi_debug < 0 && i != -1)
496 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] : ""));
503 rpmfi rpmfiInit(rpmfi fi, int fx)
506 if (fx >= 0 && fx < fi->fc) {
515 int rpmfiNextD(rpmfi fi)
519 if (fi != NULL && ++fi->j >= 0) {
525 if (_rpmfi_debug < 0 && j != -1)
526 fprintf(stderr, "*** fi %p\t%s[%d]\n", fi, (fi->Type ? fi->Type : "?Type?"), j);
533 rpmfi rpmfiInitD(rpmfi fi, int dx)
536 if (dx >= 0 && dx < fi->fc)
546 * Identify a file type.
547 * @param ft file type
548 * @return string to identify a file type
551 const char * ftstring (rpmFileTypes ft)
554 case XDIR: return "directory";
555 case CDEV: return "char dev";
556 case BDEV: return "block dev";
557 case LINK: return "link";
558 case SOCK: return "sock";
559 case PIPE: return "fifo/pipe";
560 case REG: return "file";
561 default: return "unknown file type";
565 rpmFileTypes rpmfiWhatis(rpm_mode_t mode)
567 if (S_ISDIR(mode)) return XDIR;
568 if (S_ISCHR(mode)) return CDEV;
569 if (S_ISBLK(mode)) return BDEV;
570 if (S_ISLNK(mode)) return LINK;
571 if (S_ISSOCK(mode)) return SOCK;
572 if (S_ISFIFO(mode)) return PIPE;
576 int rpmfiCompare(const rpmfi afi, const rpmfi bfi)
578 rpmFileTypes awhat = rpmfiWhatis(rpmfiFMode(afi));
579 rpmFileTypes bwhat = rpmfiWhatis(rpmfiFMode(bfi));
581 if ((rpmfiFFlags(afi) & RPMFILE_GHOST) ||
582 (rpmfiFFlags(bfi) & RPMFILE_GHOST)) return 0;
584 if (awhat != bwhat) return 1;
587 const char * alink = rpmfiFLink(afi);
588 const char * blink = rpmfiFLink(bfi);
589 if (alink == blink) return 0;
590 if (alink == NULL) return 1;
591 if (blink == NULL) return -1;
592 return strcmp(alink, blink);
593 } else if (awhat == REG) {
594 size_t adiglen, bdiglen;
595 pgpHashAlgo aalgo, balgo;
596 const unsigned char * adigest = rpmfiFDigest(afi, &aalgo, &adiglen);
597 const unsigned char * bdigest = rpmfiFDigest(bfi, &balgo, &bdiglen);
598 if (adigest == bdigest) return 0;
599 if (adigest == NULL) return 1;
600 if (bdigest == NULL) return -1;
601 /* can't meaningfully compare different hash types */
602 if (aalgo != balgo || adiglen != bdiglen) return -1;
603 return memcmp(adigest, bdigest, adiglen);
609 rpmFileAction rpmfiDecideFate(const rpmfi ofi, rpmfi nfi, int skipMissing)
611 const char * fn = rpmfiFN(nfi);
612 rpmfileAttrs newFlags = rpmfiFFlags(nfi);
614 rpmFileTypes dbWhat, newWhat, diskWhat;
616 int save = (newFlags & RPMFILE_NOREPLACE) ? FA_ALTNAME : FA_SAVE;
618 if (lstat(fn, &sb)) {
620 * The file doesn't exist on the disk. Create it unless the new
621 * package has marked it as missingok, or allfiles is requested.
623 if (skipMissing && (newFlags & RPMFILE_MISSINGOK)) {
624 rpmlog(RPMLOG_DEBUG, "%s skipped due to missingok flag\n",
632 diskWhat = rpmfiWhatis((rpm_mode_t)sb.st_mode);
633 dbWhat = rpmfiWhatis(rpmfiFMode(ofi));
634 newWhat = rpmfiWhatis(rpmfiFMode(nfi));
637 * RPM >= 2.3.10 shouldn't create config directories -- we'll ignore
638 * them in older packages as well.
643 if (diskWhat != newWhat && dbWhat != REG && dbWhat != LINK)
645 else if (newWhat != dbWhat && diskWhat != dbWhat)
647 else if (dbWhat != newWhat)
649 else if (dbWhat != LINK && dbWhat != REG)
653 * This order matters - we'd prefer to CREATE the file if at all
654 * possible in case something else (like the timestamp) has changed.
656 memset(buffer, 0, sizeof(buffer));
658 pgpHashAlgo oalgo, nalgo;
659 size_t odiglen, ndiglen;
660 const unsigned char * odigest, * ndigest;
661 odigest = rpmfiFDigest(ofi, &oalgo, &odiglen);
662 if (diskWhat == REG) {
663 if (rpmDoDigest(oalgo, fn, 0,
664 (unsigned char *)buffer, NULL))
665 return FA_CREATE; /* assume file has been removed */
666 if (odigest && !memcmp(odigest, buffer, odiglen))
667 return FA_CREATE; /* unmodified config file, replace. */
669 ndigest = rpmfiFDigest(nfi, &nalgo, &ndiglen);
670 /* XXX can't compare different hash types, what should we do here? */
671 if (oalgo != nalgo || odiglen != ndiglen)
673 if (odigest && ndigest && !memcmp(odigest, ndigest, odiglen))
674 return FA_SKIP; /* identical file, don't bother. */
675 } else /* dbWhat == LINK */ {
676 const char * oFLink, * nFLink;
677 oFLink = rpmfiFLink(ofi);
678 if (diskWhat == LINK) {
679 if (readlink(fn, buffer, sizeof(buffer) - 1) == -1)
680 return FA_CREATE; /* assume file has been removed */
681 if (oFLink && !strcmp(oFLink, buffer))
682 return FA_CREATE; /* unmodified config file, replace. */
684 nFLink = rpmfiFLink(nfi);
685 if (oFLink && nFLink && !strcmp(oFLink, nFLink))
686 return FA_SKIP; /* identical file, don't bother. */
690 * The config file on the disk has been modified, but
691 * the ones in the two packages are different. It would
692 * be nice if RPM was smart enough to at least try and
693 * merge the difference ala CVS, but...
698 int rpmfiConfigConflict(const rpmfi fi)
700 const char * fn = rpmfiFN(fi);
701 rpmfileAttrs flags = rpmfiFFlags(fi);
703 rpmFileTypes newWhat, diskWhat;
706 if (!(flags & RPMFILE_CONFIG) || lstat(fn, &sb)) {
710 diskWhat = rpmfiWhatis((rpm_mode_t)sb.st_mode);
711 newWhat = rpmfiWhatis(rpmfiFMode(fi));
713 if (newWhat != LINK && newWhat != REG)
716 if (diskWhat != newWhat)
719 memset(buffer, 0, sizeof(buffer));
720 if (newWhat == REG) {
723 const unsigned char *ndigest = rpmfiFDigest(fi, &algo, &diglen);
724 if (rpmDoDigest(algo, fn, 0, (unsigned char *)buffer, NULL))
725 return 0; /* assume file has been removed */
726 if (ndigest && !memcmp(ndigest, buffer, diglen))
727 return 0; /* unmodified config file */
728 } else /* newWhat == LINK */ {
730 if (readlink(fn, buffer, sizeof(buffer) - 1) == -1)
731 return 0; /* assume file has been removed */
732 nFLink = rpmfiFLink(fi);
733 if (nFLink && !strcmp(nFLink, buffer))
734 return 0; /* unmodified config file */
740 static char **duparray(char ** src, int size)
742 char **dest = xmalloc((size+1) * sizeof(*dest));
743 for (int i = 0; i < size; i++) {
744 dest[i] = xstrdup(src[i]);
750 static int addPrefixes(Header h, rpmRelocation *relocations, int numRelocations)
752 struct rpmtd_s validRelocs;
753 const char *validprefix;
754 const char ** actualRelocations;
757 headerGet(h, RPMTAG_PREFIXES, &validRelocs, HEADERGET_MINMEM);
759 * If no relocations are specified (usually the case), then return the
760 * original header. If there are prefixes, however, then INSTPREFIXES
761 * should be added for RPM_INSTALL_PREFIX environ variables in scriptlets,
762 * but, since relocateFileList() can be called more than once for
763 * the same header, don't bother if already present.
765 if (relocations == NULL || numRelocations == 0) {
766 if (rpmtdCount(&validRelocs) > 0) {
767 if (!headerIsEntry(h, RPMTAG_INSTPREFIXES)) {
768 rpmtdSetTag(&validRelocs, RPMTAG_INSTPREFIXES);
769 headerPut(h, &validRelocs, HEADERPUT_DEFAULT);
771 rpmtdFreeData(&validRelocs);
776 actualRelocations = xmalloc(rpmtdCount(&validRelocs) * sizeof(*actualRelocations));
777 rpmtdInit(&validRelocs);
778 while ((validprefix = rpmtdNextString(&validRelocs))) {
780 for (j = 0; j < numRelocations; j++) {
781 if (relocations[j].oldPath == NULL || /* XXX can't happen */
782 strcmp(validprefix, relocations[j].oldPath))
784 /* On install, a relocate to NULL means skip the path. */
785 if (relocations[j].newPath) {
786 actualRelocations[numActual] = relocations[j].newPath;
791 if (j == numRelocations) {
792 actualRelocations[numActual] = validprefix;
796 rpmtdFreeData(&validRelocs);
799 headerPutStringArray(h, RPMTAG_INSTPREFIXES, actualRelocations, numActual);
801 actualRelocations = _free(actualRelocations);
805 static void saveRelocs(Header h, rpmtd bnames, rpmtd dnames, rpmtd dindexes)
808 headerGet(h, RPMTAG_BASENAMES, &td, HEADERGET_MINMEM);
809 rpmtdSetTag(&td, RPMTAG_ORIGBASENAMES);
810 headerPut(h, &td, HEADERPUT_DEFAULT);
813 headerGet(h, RPMTAG_DIRNAMES, &td, HEADERGET_MINMEM);
814 rpmtdSetTag(&td, RPMTAG_ORIGDIRNAMES);
815 headerPut(h, &td, HEADERPUT_DEFAULT);
818 headerGet(h, RPMTAG_DIRINDEXES, &td, HEADERGET_MINMEM);
819 rpmtdSetTag(&td, RPMTAG_ORIGDIRINDEXES);
820 headerPut(h, &td, HEADERPUT_DEFAULT);
823 headerMod(h, bnames);
824 headerMod(h, dnames);
825 headerMod(h, dindexes);
828 void rpmRelocateFileList(rpmRelocation *relocations, int numRelocations,
831 static int _printed = 0;
834 uint32_t * dirIndexes;
835 rpm_count_t fileCount, dirCount;
839 int haveRelocatedBase = 0;
842 struct rpmtd_s bnames, dnames, dindexes, fmodes;
844 if (addPrefixes(h, relocations, numRelocations) == 0)
849 rpmlog(RPMLOG_DEBUG, "========== relocations\n");
850 for (i = 0; i < numRelocations; i++) {
851 if (relocations[i].oldPath == NULL) continue; /* XXX can't happen */
852 if (relocations[i].newPath == NULL)
853 rpmlog(RPMLOG_DEBUG, "%5d exclude %s\n",
854 i, relocations[i].oldPath);
856 rpmlog(RPMLOG_DEBUG, "%5d relocate %s -> %s\n",
857 i, relocations[i].oldPath, relocations[i].newPath);
861 for (i = 0; i < numRelocations; i++) {
862 if (relocations[i].newPath == NULL) continue;
863 size_t len = strlen(relocations[i].newPath);
864 if (len > maxlen) maxlen = len;
867 headerGet(h, RPMTAG_BASENAMES, &bnames, HEADERGET_MINMEM);
868 headerGet(h, RPMTAG_DIRINDEXES, &dindexes, HEADERGET_ALLOC);
869 headerGet(h, RPMTAG_DIRNAMES, &dnames, HEADERGET_MINMEM);
870 headerGet(h, RPMTAG_FILEMODES, &fmodes, HEADERGET_MINMEM);
871 /* TODO XXX ugh.. use rpmtd iterators & friends instead */
872 baseNames = bnames.data;
873 dirIndexes = dindexes.data;
874 fileCount = rpmtdCount(&bnames);
875 dirCount = rpmtdCount(&dnames);
876 /* XXX TODO: use rpmtdDup() instead */
877 dirNames = dnames.data = duparray(dnames.data, dirCount);
878 dnames.flags |= RPMTD_PTR_ALLOCED;
881 * For all relocations, we go through sorted file/relocation lists
882 * backwards so that /usr/local relocations take precedence over /usr
886 /* Relocate individual paths. */
888 for (i = fileCount - 1; i >= 0; i--) {
892 size_t len = maxlen +
893 strlen(dirNames[dirIndexes[i]]) + strlen(baseNames[i]) + 1;
894 if (len >= fileAlloced) {
895 fileAlloced = len * 2;
896 fn = xrealloc(fn, fileAlloced);
899 assert(fn != NULL); /* XXX can't happen */
901 fnlen = stpcpy( stpcpy(fn, dirNames[dirIndexes[i]]), baseNames[i]) - fn;
904 * See if this file path needs relocating.
907 * XXX FIXME: Would a bsearch of the (already sorted)
908 * relocation list be a good idea?
910 for (j = numRelocations - 1; j >= 0; j--) {
911 if (relocations[j].oldPath == NULL) /* XXX can't happen */
913 len = strcmp(relocations[j].oldPath, "/")
914 ? strlen(relocations[j].oldPath)
920 * Only subdirectories or complete file paths may be relocated. We
921 * don't check for '\0' as our directory names all end in '/'.
923 if (!(fn[len] == '/' || fnlen == len))
926 if (strncmp(relocations[j].oldPath, fn, len))
932 rpmtdSetIndex(&fmodes, i);
933 ft = rpmfiWhatis(rpmtdGetNumber(&fmodes));
935 /* On install, a relocate to NULL means skip the path. */
936 if (relocations[j].newPath == NULL) {
938 /* Start with the parent, looking for directory to exclude. */
939 for (j = dirIndexes[i]; j < dirCount; j++) {
940 len = strlen(dirNames[j]) - 1;
941 while (len > 0 && dirNames[j][len-1] == '/') len--;
944 if (strncmp(fn, dirNames[j], fnlen))
949 rpmfsSetAction(fs, i, FA_SKIPNSTATE);
950 rpmlog(RPMLOG_DEBUG, "excluding %s %s\n",
955 /* Relocation on full paths only, please. */
956 if (fnlen != len) continue;
958 rpmlog(RPMLOG_DEBUG, "relocating %s to %s\n",
959 fn, relocations[j].newPath);
962 strcpy(fn, relocations[j].newPath);
963 { char * te = strrchr(fn, '/');
965 if (te > fn) te++; /* root is special */
968 te = fn + strlen(fn);
969 if (strcmp(baseNames[i], te)) { /* basename changed too? */
970 if (!haveRelocatedBase) {
971 /* XXX TODO: use rpmtdDup() instead */
972 bnames.data = baseNames = duparray(baseNames, fileCount);
973 bnames.flags |= RPMTD_PTR_ALLOCED;
974 haveRelocatedBase = 1;
977 baseNames[i] = xstrdup(te);
979 *te = '\0'; /* terminate new directory name */
982 /* Does this directory already exist in the directory list? */
983 for (j = 0; j < dirCount; j++) {
984 if (fnlen != strlen(dirNames[j]))
986 if (strncmp(fn, dirNames[j], fnlen))
996 /* Creating new paths is a pita */
997 dirNames = dnames.data = xrealloc(dnames.data,
998 sizeof(*dirNames) * (dirCount + 1));
1000 dirNames[dirCount] = xstrdup(fn);
1001 dirIndexes[i] = dirCount;
1006 /* Finish off by relocating directories. */
1007 for (i = dirCount - 1; i >= 0; i--) {
1008 for (j = numRelocations - 1; j >= 0; j--) {
1010 if (relocations[j].oldPath == NULL) /* XXX can't happen */
1012 size_t len = strcmp(relocations[j].oldPath, "/")
1013 ? strlen(relocations[j].oldPath)
1016 if (len && strncmp(relocations[j].oldPath, dirNames[i], len))
1020 * Only subdirectories or complete file paths may be relocated. We
1021 * don't check for '\0' as our directory names all end in '/'.
1023 if (dirNames[i][len] != '/')
1026 if (relocations[j].newPath) { /* Relocate the path */
1028 rstrscat(&t, relocations[j].newPath, (dirNames[i] + len), NULL);
1029 /* Unfortunatly rpmCleanPath strips the trailing slash.. */
1030 (void) rpmCleanPath(t);
1033 rpmlog(RPMLOG_DEBUG,
1034 "relocating directory %s to %s\n", dirNames[i], t);
1042 /* Save original filenames in header and replace (relocated) filenames. */
1044 saveRelocs(h, &bnames, &dnames, &dindexes);
1047 rpmtdFreeData(&bnames);
1048 rpmtdFreeData(&dnames);
1049 rpmtdFreeData(&dindexes);
1050 rpmtdFreeData(&fmodes);
1054 rpmfi rpmfiFree(rpmfi fi)
1056 if (fi == NULL) return NULL;
1059 return rpmfiUnlink(fi, fi->Type);
1061 if (_rpmfi_debug < 0)
1062 fprintf(stderr, "*** fi %p\t%s[%d]\n", fi, fi->Type, fi->fc);
1065 fi->bnl = _free(fi->bnl);
1066 fi->dnl = _free(fi->dnl);
1068 fi->flinkcache = strcacheFree(fi->flinkcache);
1069 fi->flinks = _free(fi->flinks);
1070 fi->flangs = _free(fi->flangs);
1071 fi->digests = _free(fi->digests);
1072 fi->fcaps = _free(fi->fcaps);
1074 fi->cdict = _free(fi->cdict);
1076 fi->fuser = _free(fi->fuser);
1077 fi->fgroup = _free(fi->fgroup);
1079 fi->fstates = _free(fi->fstates);
1080 fi->fps = _free(fi->fps);
1082 if (!(fi->fiflags & RPMFI_KEEPHEADER) && fi->h == NULL) {
1083 fi->fmtimes = _constfree(fi->fmtimes);
1084 fi->fmodes = _free(fi->fmodes);
1085 fi->fflags = _constfree(fi->fflags);
1086 fi->vflags = _constfree(fi->vflags);
1087 fi->fsizes = _constfree(fi->fsizes);
1088 fi->frdevs = _constfree(fi->frdevs);
1089 fi->finodes = _constfree(fi->finodes);
1090 fi->dil = _free(fi->dil);
1092 fi->fcolors = _constfree(fi->fcolors);
1093 fi->fcdictx = _constfree(fi->fcdictx);
1094 fi->ddict = _constfree(fi->ddict);
1095 fi->fddictx = _constfree(fi->fddictx);
1096 fi->fddictn = _constfree(fi->fddictn);
1101 fi->fsm = freeFSM(fi->fsm);
1103 fi->fn = _free(fi->fn);
1104 fi->apath = _free(fi->apath);
1106 fi->replacedSizes = _free(fi->replacedSizes);
1108 fi->h = headerFree(fi->h);
1110 (void) rpmfiUnlink(fi, fi->Type);
1111 memset(fi, 0, sizeof(*fi)); /* XXX trash and burn */
1117 /* Helper to push header tag data into a string cache */
1118 static scidx_t *cacheTag(strcache cache, Header h, rpmTag tag)
1120 scidx_t *idx = NULL;
1122 if (headerGet(h, tag, &td, HEADERGET_MINMEM)) {
1123 idx = xmalloc(sizeof(*idx) * rpmtdCount(&td));
1126 while ((str = rpmtdNextString(&td))) {
1127 idx[i++] = strcachePut(cache, str);
1134 #define _hgfi(_h, _tag, _td, _flags, _data) \
1135 if (headerGet((_h), (_tag), (_td), (_flags))) \
1138 rpmfi rpmfiNew(const rpmts ts, Header h, rpmTag tagN, rpmfiFlags flags)
1142 rpm_loff_t *asize = NULL;
1144 int isBuild, isSource;
1145 struct rpmtd_s fdigests, digalgo;
1147 headerGetFlags scareFlags = (flags & RPMFI_KEEPHEADER) ?
1148 HEADERGET_MINMEM : HEADERGET_ALLOC;
1149 headerGetFlags defFlags = HEADERGET_ALLOC;
1151 if (tagN == RPMTAG_BASENAMES) {
1158 fi = xcalloc(1, sizeof(*fi));
1159 if (fi == NULL) /* XXX can't happen */
1162 fi->magic = RPMFIMAGIC;
1167 fi->fiflags = flags;
1168 fi->scareFlags = scareFlags;
1170 if (headerGet(h, RPMTAG_LONGARCHIVESIZE, &td, HEADERGET_EXT)) {
1171 asize = rpmtdGetUint64(&td);
1173 /* 0 means unknown */
1174 fi->archiveSize = asize ? *asize : 0;
1177 /* Archive size is not set when this gets called from build */
1178 isBuild = (asize == NULL);
1179 isSource = headerIsSource(h);
1180 if (isBuild) fi->fiflags |= RPMFI_ISBUILD;
1181 if (isSource) fi->fiflags |= RPMFI_ISSOURCE;
1183 _hgfi(h, RPMTAG_BASENAMES, &td, defFlags, fi->bnl);
1184 fi->fc = rpmtdCount(&td);
1189 _hgfi(h, RPMTAG_DIRNAMES, &td, defFlags, fi->dnl);
1190 fi->dc = rpmtdCount(&td);
1191 _hgfi(h, RPMTAG_DIRINDEXES, &td, scareFlags, fi->dil);
1192 if (!(flags & RPMFI_NOFILEMODES))
1193 _hgfi(h, RPMTAG_FILEMODES, &td, scareFlags, fi->fmodes);
1194 if (!(flags & RPMFI_NOFILEFLAGS))
1195 _hgfi(h, RPMTAG_FILEFLAGS, &td, scareFlags, fi->fflags);
1196 if (!(flags & RPMFI_NOFILEVERIFYFLAGS))
1197 _hgfi(h, RPMTAG_FILEVERIFYFLAGS, &td, scareFlags, fi->vflags);
1198 if (!(flags & RPMFI_NOFILESIZES))
1199 _hgfi(h, RPMTAG_FILESIZES, &td, scareFlags, fi->fsizes);
1201 if (!(flags & RPMFI_NOFILECOLORS))
1202 _hgfi(h, RPMTAG_FILECOLORS, &td, scareFlags, fi->fcolors);
1204 if (!(flags & RPMFI_NOFILECLASS)) {
1205 _hgfi(h, RPMTAG_CLASSDICT, &td, scareFlags, fi->cdict);
1206 fi->ncdict = rpmtdCount(&td);
1207 _hgfi(h, RPMTAG_FILECLASS, &td, scareFlags, fi->fcdictx);
1209 if (!(flags & RPMFI_NOFILEDEPS)) {
1210 _hgfi(h, RPMTAG_DEPENDSDICT, &td, scareFlags, fi->ddict);
1211 fi->nddict = rpmtdCount(&td);
1212 _hgfi(h, RPMTAG_FILEDEPENDSX, &td, scareFlags, fi->fddictx);
1213 _hgfi(h, RPMTAG_FILEDEPENDSN, &td, scareFlags, fi->fddictn);
1216 if (!(flags & RPMFI_NOFILESTATES))
1217 _hgfi(h, RPMTAG_FILESTATES, &td, defFlags, fi->fstates);
1219 if (!(flags & RPMFI_NOFILECAPS))
1220 _hgfi(h, RPMTAG_FILECAPS, &td, defFlags, fi->fcaps);
1222 if (!(flags & RPMFI_NOFILELINKTOS)) {
1223 fi->flinkcache = strcacheNew();
1224 fi->flinks = cacheTag(fi->flinkcache, h, RPMTAG_FILELINKTOS);
1226 /* FILELANGS are only interesting when installing */
1227 if ((headerGetInstance(h) == 0) && !(flags & RPMFI_NOFILELANGS))
1228 fi->flangs = cacheTag(langcache, h, RPMTAG_FILELANGS);
1230 /* See if the package has non-md5 file digests */
1231 fi->digestalgo = PGPHASHALGO_MD5;
1232 if (headerGet(h, RPMTAG_FILEDIGESTALGO, &digalgo, HEADERGET_MINMEM)) {
1233 pgpHashAlgo *algo = rpmtdGetUint32(&digalgo);
1234 /* Hmm, what to do with unknown digest algorithms? */
1235 if (algo && rpmDigestLength(*algo) != 0) {
1236 fi->digestalgo = *algo;
1241 /* grab hex digests from header and store in binary format */
1242 if (!(flags & RPMFI_NOFILEDIGESTS) &&
1243 headerGet(h, RPMTAG_FILEDIGESTS, &fdigests, HEADERGET_MINMEM)) {
1244 const char *fdigest;
1245 size_t diglen = rpmDigestLength(fi->digestalgo);
1246 fi->digests = t = xmalloc(rpmtdCount(&fdigests) * diglen);
1248 while ((fdigest = rpmtdNextString(&fdigests))) {
1249 if (!(fdigest && *fdigest != '\0')) {
1250 memset(t, 0, diglen);
1254 for (int j = 0; j < diglen; j++, t++, fdigest += 2)
1255 *t = (rnibble(fdigest[0]) << 4) | rnibble(fdigest[1]);
1257 rpmtdFreeData(&fdigests);
1260 /* XXX TR_REMOVED doesn;t need fmtimes, frdevs, finodes */
1261 if (!(flags & RPMFI_NOFILEMTIMES))
1262 _hgfi(h, RPMTAG_FILEMTIMES, &td, scareFlags, fi->fmtimes);
1263 if (!(flags & RPMFI_NOFILERDEVS))
1264 _hgfi(h, RPMTAG_FILERDEVS, &td, scareFlags, fi->frdevs);
1265 if (!(flags & RPMFI_NOFILEINODES))
1266 _hgfi(h, RPMTAG_FILEINODES, &td, scareFlags, fi->finodes);
1268 if (!(flags & RPMFI_NOFILEUSER))
1269 fi->fuser = cacheTag(ugcache, h, RPMTAG_FILEUSERNAME);
1270 if (!(flags & RPMFI_NOFILEGROUP))
1271 fi->fgroup = cacheTag(ugcache, h, RPMTAG_FILEGROUPNAME);
1273 /* lazily alloced from rpmfiFN() */
1277 if (_rpmfi_debug < 0)
1278 fprintf(stderr, "*** fi %p\t%s[%d]\n", fi, Type, (fi ? fi->fc : 0));
1281 fi->h = (fi->fiflags & RPMFI_KEEPHEADER) ? headerLink(h) : NULL;
1284 /* FIX: rpmfi null annotations */
1285 return rpmfiLink(fi, (fi ? fi->Type : NULL));
1288 void rpmfiSetFReplacedSize(rpmfi fi, rpm_loff_t newsize)
1290 if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
1291 if (fi->replacedSizes == NULL) {
1292 fi->replacedSizes = xcalloc(fi->fc, sizeof(*fi->replacedSizes));
1294 /* XXX watch out, replacedSizes is not rpm_loff_t (yet) */
1295 fi->replacedSizes[fi->i] = (rpm_off_t) newsize;
1299 rpm_loff_t rpmfiFReplacedSize(rpmfi fi)
1301 rpm_loff_t rsize = 0;
1302 if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
1303 if (fi->replacedSizes) {
1304 rsize = fi->replacedSizes[fi->i];
1310 void rpmfiFpLookup(rpmfi fi, fingerPrintCache fpc)
1312 if (fi->fc > 0 && fi->fps == NULL) {
1313 fi->fps = xcalloc(fi->fc, sizeof(*fi->fps));
1315 fpLookupList(fpc, fi->dnl, fi->bnl, fi->dil, fi->fc, fi->fps);
1318 FSM_t rpmfiFSM(rpmfi fi)
1320 if (fi != NULL && fi->fsm == NULL) {
1321 cpioMapFlags mapflags;
1322 /* Figure out mapflags:
1323 * - path, mode, uid and gid are used by everything
1324 * - all binary packages get SBIT_CHECK set
1325 * - if archive size is not known, we're only building this package,
1326 * different rules apply
1328 mapflags = CPIO_MAP_PATH | CPIO_MAP_MODE | CPIO_MAP_UID | CPIO_MAP_GID;
1329 if (fi->fiflags & RPMFI_ISBUILD) {
1330 mapflags |= CPIO_MAP_TYPE;
1331 if (fi->fiflags & RPMFI_ISSOURCE) mapflags |= CPIO_FOLLOW_SYMLINKS;
1333 if (!(fi->fiflags & RPMFI_ISSOURCE)) mapflags |= CPIO_SBIT_CHECK;
1335 fi->fsm = newFSM(mapflags);
1337 return (fi != NULL) ? fi->fsm : NULL;
1341 * Generate iterator accessors function wrappers, these do nothing but
1342 * call the corresponding rpmfiFooIndex(fi, fi->[ij])
1345 #define RPMFI_ITERFUNC(TYPE, NAME, IXV) \
1346 TYPE rpmfi ## NAME(rpmfi fi) { return rpmfi ## NAME ## Index(fi, fi ? fi->IXV : -1); }
1348 RPMFI_ITERFUNC(const char *, BN, i)
1349 RPMFI_ITERFUNC(const char *, DN, j)
1350 RPMFI_ITERFUNC(const char *, FN, i)
1351 RPMFI_ITERFUNC(const char *, FLink, i)
1352 RPMFI_ITERFUNC(const char *, FUser, i)
1353 RPMFI_ITERFUNC(const char *, FGroup, i)
1354 RPMFI_ITERFUNC(const char *, FCaps, i)
1355 RPMFI_ITERFUNC(const char *, FLangs, i)
1356 RPMFI_ITERFUNC(const char *, FClass, i)
1357 RPMFI_ITERFUNC(rpmfileState, FState, i)
1358 RPMFI_ITERFUNC(rpmfileAttrs, FFlags, i)
1359 RPMFI_ITERFUNC(rpmVerifyAttrs, VFlags, i)
1360 RPMFI_ITERFUNC(rpm_mode_t, FMode, i)
1361 RPMFI_ITERFUNC(rpm_rdev_t, FRdev, i)
1362 RPMFI_ITERFUNC(rpm_time_t, FMtime, i)
1363 RPMFI_ITERFUNC(rpm_ino_t, FInode, i)
1364 RPMFI_ITERFUNC(rpm_loff_t, FSize, i)
1365 RPMFI_ITERFUNC(rpm_color_t, FColor, i)
1366 RPMFI_ITERFUNC(uint32_t, FNlink, i)
1368 const unsigned char * rpmfiFDigest(rpmfi fi, pgpHashAlgo *algo, size_t *len)
1370 return rpmfiFDigestIndex(fi, fi ? fi->i : -1, algo, len);
1373 uint32_t rpmfiFDepends(rpmfi fi, const uint32_t ** fddictp)
1375 return rpmfiFDependsIndex(fi, fi ? fi->i : -1, fddictp);