int rpmfiCompare(const rpmfi afi, const rpmfi bfi)
{
rpmFileTypes awhat = rpmfiWhatis(rpmfiFMode(afi));
rpmFileTypes bwhat = rpmfiWhatis(rpmfiFMode(bfi));
if ((rpmfiFFlags(afi) & RPMFILE_GHOST) ||
(rpmfiFFlags(bfi) & RPMFILE_GHOST)) return 0;
if (awhat != bwhat) return 1;
if (awhat == LINK) {
const char * alink = rpmfiFLink(afi);
const char * blink = rpmfiFLink(bfi);
if (alink == blink) return 0;
if (alink == NULL) return 1;
if (blink == NULL) return -1;
return strcmp(alink, blink);
} else if (awhat == REG) {
size_t adiglen, bdiglen;
pgpHashAlgo aalgo, balgo;
const unsigned char * adigest = rpmfiFDigest(afi, &aalgo, &adiglen);
const unsigned char * bdigest = rpmfiFDigest(bfi, &balgo, &bdiglen);
if (adigest == bdigest) return 0;
if (adigest == NULL) return 1;
if (bdigest == NULL) return -1;
/* can't meaningfully compare different hash types */
if (aalgo != balgo || adiglen != bdiglen) return -1;
return memcmp(adigest, bdigest, adiglen);
}
return 0;
}
static int handleRemovalConflict(rpmfiles fi, int fx, rpmfiles ofi, int ofx)
{
int rConflicts = 0; /* Removed files don't conflict, normally */
rpmFileTypes ft = rpmfiWhatis(rpmfilesFMode(fi, fx));
rpmFileTypes oft = rpmfiWhatis(rpmfilesFMode(ofi, ofx));
struct stat sb;
char *fn = NULL;
if (oft == XDIR) {
/* We can't handle directory changing to anything else */
if (ft != XDIR)
rConflicts = 1;
} else if (oft == LINK) {
/* We can't correctly handle directory symlink changing to directory */
if (ft == XDIR) {
fn = rpmfilesFN(fi, fx);
if (stat(fn, &sb) == 0 && S_ISDIR(sb.st_mode))
rConflicts = 1;
}
}
/*
* ...but if the conflicting item is either not on disk, or has
* already been changed to the new type, we should be ok afterall.
*/
if (rConflicts) {
if (fn == NULL)
fn = rpmfilesFN(fi, fx);
if (lstat(fn, &sb) || rpmfiWhatis(sb.st_mode) == ft)
rConflicts = 0;
}
free(fn);
return rConflicts;
}
int rpmfiCompareIndex(rpmfi afi, int aix, rpmfi bfi, int bix)
{
mode_t amode = rpmfiFModeIndex(afi, aix);
mode_t bmode = rpmfiFModeIndex(bfi, bix);
rpmFileTypes awhat = rpmfiWhatis(amode);
if ((rpmfiFFlagsIndex(afi, aix) & RPMFILE_GHOST) ||
(rpmfiFFlagsIndex(bfi, bix) & RPMFILE_GHOST)) return 0;
/* Mode difference is a conflict, except for symlinks */
if (!(awhat == LINK && rpmfiWhatis(bmode) == LINK) && amode != bmode)
return 1;
if (awhat == LINK || awhat == REG) {
if (rpmfiFSizeIndex(afi, aix) != rpmfiFSizeIndex(bfi, bix))
return 1;
}
if (!rstreq(rpmfiFUserIndex(afi, aix), rpmfiFUserIndex(bfi, bix)))
return 1;
if (!rstreq(rpmfiFGroupIndex(afi, aix), rpmfiFGroupIndex(bfi, bix)))
return 1;
if (awhat == LINK) {
const char * alink = rpmfiFLinkIndex(afi, aix);
const char * blink = rpmfiFLinkIndex(bfi, bix);
if (alink == blink) return 0;
if (alink == NULL) return 1;
if (blink == NULL) return -1;
return strcmp(alink, blink);
} else if (awhat == REG) {
size_t adiglen, bdiglen;
int aalgo, balgo;
const unsigned char * adigest, * bdigest;
adigest = rpmfiFDigestIndex(afi, aix, &aalgo, &adiglen);
bdigest = rpmfiFDigestIndex(bfi, bix, &balgo, &bdiglen);
if (adigest == bdigest) return 0;
if (adigest == NULL) return 1;
if (bdigest == NULL) return -1;
/* can't meaningfully compare different hash types */
if (aalgo != balgo || adiglen != bdiglen) return -1;
return memcmp(adigest, bdigest, adiglen);
} else if (awhat == CDEV || awhat == BDEV) {
if (rpmfiFRdevIndex(afi, aix) != rpmfiFRdevIndex(bfi, bix))
return 1;
}
return 0;
}
int rpmfiConfigConflict(const rpmfi fi)
{
const char * fn = rpmfiFN(fi);
rpmfileAttrs flags = rpmfiFFlags(fi);
char buffer[1024];
rpmFileTypes newWhat, diskWhat;
struct stat sb;
if (!(flags & RPMFILE_CONFIG) || lstat(fn, &sb)) {
return 0;
}
diskWhat = rpmfiWhatis((rpm_mode_t)sb.st_mode);
newWhat = rpmfiWhatis(rpmfiFMode(fi));
if (newWhat != LINK && newWhat != REG)
return 1;
if (diskWhat != newWhat)
return 1;
memset(buffer, 0, sizeof(buffer));
if (newWhat == REG) {
int algo;
size_t diglen;
const unsigned char *ndigest = rpmfiFDigest(fi, &algo, &diglen);
if (rpmDoDigest(algo, fn, 0, (unsigned char *)buffer, NULL))
return 0; /* assume file has been removed */
if (ndigest && !memcmp(ndigest, buffer, diglen))
return 0; /* unmodified config file */
} else /* newWhat == LINK */ {
const char * nFLink;
ssize_t link_len = readlink(fn, buffer, sizeof(buffer) - 1);
if (link_len == -1)
return 0; /* assume file has been removed */
buffer[link_len] = '\0';
nFLink = rpmfiFLink(fi);
if (nFLink && rstreq(nFLink, buffer))
return 0; /* unmodified config file */
}
return 1;
}
void rpmRelocateFileList(rpmRelocation *relocations, int numRelocations,
rpmfs fs, Header h)
{
char ** baseNames;
char ** dirNames;
uint32_t * dirIndexes;
rpm_count_t fileCount, dirCount;
int nrelocated = 0;
int fileAlloced = 0;
char * fn = NULL;
int haveRelocatedBase = 0;
size_t maxlen = 0;
int i, j;
struct rpmtd_s bnames, dnames, dindexes, fmodes;
if (!addPrefixes(h, relocations, numRelocations))
return;
if (rpmIsDebug()) {
rpmlog(RPMLOG_DEBUG, "========== relocations\n");
for (i = 0; i < numRelocations; i++) {
if (relocations[i].oldPath == NULL) continue; /* XXX can't happen */
if (relocations[i].newPath == NULL)
rpmlog(RPMLOG_DEBUG, "%5d exclude %s\n",
i, relocations[i].oldPath);
else
rpmlog(RPMLOG_DEBUG, "%5d relocate %s -> %s\n",
i, relocations[i].oldPath, relocations[i].newPath);
}
}
for (i = 0; i < numRelocations; i++) {
if (relocations[i].newPath == NULL) continue;
size_t len = strlen(relocations[i].newPath);
if (len > maxlen) maxlen = len;
}
headerGet(h, RPMTAG_BASENAMES, &bnames, HEADERGET_MINMEM);
headerGet(h, RPMTAG_DIRINDEXES, &dindexes, HEADERGET_ALLOC);
headerGet(h, RPMTAG_DIRNAMES, &dnames, HEADERGET_MINMEM);
headerGet(h, RPMTAG_FILEMODES, &fmodes, HEADERGET_MINMEM);
/* TODO XXX ugh.. use rpmtd iterators & friends instead */
baseNames = bnames.data;
dirIndexes = dindexes.data;
fileCount = rpmtdCount(&bnames);
dirCount = rpmtdCount(&dnames);
/* XXX TODO: use rpmtdDup() instead */
dirNames = dnames.data = duparray(dnames.data, dirCount);
dnames.flags |= RPMTD_PTR_ALLOCED;
/*
* For all relocations, we go through sorted file/relocation lists
* backwards so that /usr/local relocations take precedence over /usr
* ones.
*/
/* Relocate individual paths. */
for (i = fileCount - 1; i >= 0; i--) {
rpmFileTypes ft;
int fnlen;
size_t len = maxlen +
strlen(dirNames[dirIndexes[i]]) + strlen(baseNames[i]) + 1;
if (len >= fileAlloced) {
fileAlloced = len * 2;
fn = xrealloc(fn, fileAlloced);
}
assert(fn != NULL); /* XXX can't happen */
*fn = '\0';
fnlen = stpcpy( stpcpy(fn, dirNames[dirIndexes[i]]), baseNames[i]) - fn;
/*
* See if this file path needs relocating.
*/
/*
* XXX FIXME: Would a bsearch of the (already sorted)
* relocation list be a good idea?
*/
for (j = numRelocations - 1; j >= 0; j--) {
if (relocations[j].oldPath == NULL) /* XXX can't happen */
continue;
len = !rstreq(relocations[j].oldPath, "/")
? strlen(relocations[j].oldPath)
: 0;
if (fnlen < len)
continue;
/*
* Only subdirectories or complete file paths may be relocated. We
* don't check for '\0' as our directory names all end in '/'.
*/
if (!(fn[len] == '/' || fnlen == len))
continue;
if (!rstreqn(relocations[j].oldPath, fn, len))
continue;
break;
}
if (j < 0) continue;
rpmtdSetIndex(&fmodes, i);
ft = rpmfiWhatis(rpmtdGetNumber(&fmodes));
/* On install, a relocate to NULL means skip the path. */
if (relocations[j].newPath == NULL) {
if (ft == XDIR) {
/* Start with the parent, looking for directory to exclude. */
for (j = dirIndexes[i]; j < dirCount; j++) {
len = strlen(dirNames[j]) - 1;
while (len > 0 && dirNames[j][len-1] == '/') len--;
if (fnlen != len)
continue;
if (!rstreqn(fn, dirNames[j], fnlen))
continue;
break;
}
}
rpmfsSetAction(fs, i, FA_SKIPNSTATE);
rpmlog(RPMLOG_DEBUG, "excluding %s %s\n",
ftstring(ft), fn);
continue;
}
/* Relocation on full paths only, please. */
if (fnlen != len) continue;
rpmlog(RPMLOG_DEBUG, "relocating %s to %s\n",
fn, relocations[j].newPath);
nrelocated++;
strcpy(fn, relocations[j].newPath);
{ char * te = strrchr(fn, '/');
if (te) {
if (te > fn) te++; /* root is special */
fnlen = te - fn;
} else
te = fn + strlen(fn);
if (!rstreq(baseNames[i], te)) { /* basename changed too? */
if (!haveRelocatedBase) {
/* XXX TODO: use rpmtdDup() instead */
bnames.data = baseNames = duparray(baseNames, fileCount);
bnames.flags |= RPMTD_PTR_ALLOCED;
haveRelocatedBase = 1;
}
free(baseNames[i]);
baseNames[i] = xstrdup(te);
}
*te = '\0'; /* terminate new directory name */
}
/* Does this directory already exist in the directory list? */
for (j = 0; j < dirCount; j++) {
if (fnlen != strlen(dirNames[j]))
continue;
if (!rstreqn(fn, dirNames[j], fnlen))
continue;
break;
}
if (j < dirCount) {
dirIndexes[i] = j;
continue;
}
/* Creating new paths is a pita */
dirNames = dnames.data = xrealloc(dnames.data,
sizeof(*dirNames) * (dirCount + 1));
dirNames[dirCount] = xstrdup(fn);
dirIndexes[i] = dirCount;
dirCount++;
dnames.count++;
}
/* Finish off by relocating directories. */
for (i = dirCount - 1; i >= 0; i--) {
for (j = numRelocations - 1; j >= 0; j--) {
if (relocations[j].oldPath == NULL) /* XXX can't happen */
continue;
size_t len = !rstreq(relocations[j].oldPath, "/")
? strlen(relocations[j].oldPath)
: 0;
if (len && !rstreqn(relocations[j].oldPath, dirNames[i], len))
continue;
/*
* Only subdirectories or complete file paths may be relocated. We
* don't check for '\0' as our directory names all end in '/'.
*/
if (dirNames[i][len] != '/')
continue;
if (relocations[j].newPath) { /* Relocate the path */
char *t = NULL;
rstrscat(&t, relocations[j].newPath, (dirNames[i] + len), NULL);
/* Unfortunately rpmCleanPath strips the trailing slash.. */
(void) rpmCleanPath(t);
rstrcat(&t, "/");
rpmlog(RPMLOG_DEBUG,
"relocating directory %s to %s\n", dirNames[i], t);
free(dirNames[i]);
dirNames[i] = t;
nrelocated++;
}
}
}
/* Save original filenames in header and replace (relocated) filenames. */
if (nrelocated) {
saveOrig(h);
headerMod(h, &bnames);
headerMod(h, &dnames);
headerMod(h, &dindexes);
}
rpmtdFreeData(&bnames);
rpmtdFreeData(&dnames);
rpmtdFreeData(&dindexes);
rpmtdFreeData(&fmodes);
free(fn);
}
rpmFileAction rpmfiDecideFate(const rpmfi ofi, rpmfi nfi, int skipMissing)
{
const char * fn = rpmfiFN(nfi);
rpmfileAttrs newFlags = rpmfiFFlags(nfi);
char buffer[1024];
rpmFileTypes dbWhat, newWhat, diskWhat;
struct stat sb;
int save = (newFlags & RPMFILE_NOREPLACE) ? FA_ALTNAME : FA_SAVE;
if (lstat(fn, &sb)) {
/*
* The file doesn't exist on the disk. Create it unless the new
* package has marked it as missingok, or allfiles is requested.
*/
if (skipMissing && (newFlags & RPMFILE_MISSINGOK)) {
rpmlog(RPMLOG_DEBUG, "%s skipped due to missingok flag\n",
fn);
return FA_SKIP;
} else {
return FA_CREATE;
}
}
diskWhat = rpmfiWhatis((rpm_mode_t)sb.st_mode);
dbWhat = rpmfiWhatis(rpmfiFMode(ofi));
newWhat = rpmfiWhatis(rpmfiFMode(nfi));
/*
* RPM >= 2.3.10 shouldn't create config directories -- we'll ignore
* them in older packages as well.
*/
if (newWhat == XDIR)
return FA_CREATE;
if (diskWhat != newWhat && dbWhat != REG && dbWhat != LINK)
return save;
else if (newWhat != dbWhat && diskWhat != dbWhat)
return save;
else if (dbWhat != newWhat)
return FA_CREATE;
else if (dbWhat != LINK && dbWhat != REG)
return FA_CREATE;
/*
* This order matters - we'd prefer to CREATE the file if at all
* possible in case something else (like the timestamp) has changed.
*/
memset(buffer, 0, sizeof(buffer));
if (dbWhat == REG) {
pgpHashAlgo oalgo, nalgo;
size_t odiglen, ndiglen;
const unsigned char * odigest, * ndigest;
odigest = rpmfiFDigest(ofi, &oalgo, &odiglen);
if (diskWhat == REG) {
if (rpmDoDigest(oalgo, fn, 0,
(unsigned char *)buffer, NULL))
return FA_CREATE; /* assume file has been removed */
if (odigest && !memcmp(odigest, buffer, odiglen))
return FA_CREATE; /* unmodified config file, replace. */
}
ndigest = rpmfiFDigest(nfi, &nalgo, &ndiglen);
/* Can't compare different hash types, backup to avoid data loss */
if (oalgo != nalgo || odiglen != ndiglen)
return save;
if (odigest && ndigest && !memcmp(odigest, ndigest, odiglen))
return FA_SKIP; /* identical file, don't bother. */
} else /* dbWhat == LINK */ {
const char * oFLink, * nFLink;
oFLink = rpmfiFLink(ofi);
if (diskWhat == LINK) {
if (readlink(fn, buffer, sizeof(buffer) - 1) == -1)
return FA_CREATE; /* assume file has been removed */
if (oFLink && rstreq(oFLink, buffer))
return FA_CREATE; /* unmodified config file, replace. */
}
nFLink = rpmfiFLink(nfi);
if (oFLink && nFLink && rstreq(oFLink, nFLink))
return FA_SKIP; /* identical file, don't bother. */
}
/*
* The config file on the disk has been modified, but
* the ones in the two packages are different. It would
* be nice if RPM was smart enough to at least try and
* merge the difference ala CVS, but...
*/
return save;
}
/**
* Skip any files that do not match install policies.
* @param ts transaction set
* @param files file info set
* @param fs file states
*/
static void skipInstallFiles(const rpmts ts, rpmfiles files, rpmfs fs)
{
rpm_color_t tscolor = rpmtsColor(ts);
rpm_color_t FColor;
int noConfigs = (rpmtsFlags(ts) & RPMTRANS_FLAG_NOCONFIGS);
int noDocs = (rpmtsFlags(ts) & RPMTRANS_FLAG_NODOCS);
int * drc;
char * dff;
int dc;
int i, j, ix;
rpmfi fi = rpmfilesIter(files, RPMFI_ITER_FWD);
if (!noDocs)
noDocs = rpmExpandNumeric("%{_excludedocs}");
/* Compute directory refcount, skip directory if now empty. */
dc = rpmfiDC(fi);
drc = xcalloc(dc, sizeof(*drc));
dff = xcalloc(dc, sizeof(*dff));
fi = rpmfiInit(fi, 0);
while ((i = rpmfiNext(fi)) >= 0) {
char ** nsp;
const char *flangs;
ix = rpmfiDX(fi);
drc[ix]++;
/* Don't bother with skipped files */
if (XFA_SKIPPING(rpmfsGetAction(fs, i))) {
drc[ix]--; dff[ix] = 1;
continue;
}
/* Ignore colored files not in our rainbow. */
FColor = rpmfiFColor(fi);
if (tscolor && FColor && !(tscolor & FColor)) {
drc[ix]--; dff[ix] = 1;
rpmfsSetAction(fs, i, FA_SKIPCOLOR);
continue;
}
/*
* Skip net shared paths.
* Net shared paths are not relative to the current root (though
* they do need to take package relocations into account).
*/
if (ts->netsharedPaths) {
nsp = matchNetsharedpath(ts, fi);
if (nsp && *nsp) {
drc[ix]--; dff[ix] = 1;
rpmfsSetAction(fs, i, FA_SKIPNETSHARED);
continue;
}
}
/*
* Skip i18n language specific files.
*/
flangs = (ts->installLangs != NULL) ? rpmfiFLangs(fi) : NULL;
if (flangs != NULL && *flangs != '\0') {
const char *l, *le;
char **lang;
for (lang = ts->installLangs; *lang != NULL; lang++) {
for (l = flangs; *l != '\0'; l = le) {
for (le = l; *le != '\0' && *le != '|'; le++)
{};
if ((le-l) > 0 && rstreqn(*lang, l, (le-l)))
break;
if (*le == '|') le++; /* skip over | */
}
if (*l != '\0')
break;
}
if (*lang == NULL) {
drc[ix]--; dff[ix] = 1;
rpmfsSetAction(fs, i, FA_SKIPNSTATE);
continue;
}
}
/*
* Skip config files if requested.
*/
if (noConfigs && (rpmfiFFlags(fi) & RPMFILE_CONFIG)) {
drc[ix]--; dff[ix] = 1;
rpmfsSetAction(fs, i, FA_SKIPNSTATE);
continue;
}
/*
* Skip documentation if requested.
*/
if (noDocs && (rpmfiFFlags(fi) & RPMFILE_DOC)) {
drc[ix]--; dff[ix] = 1;
rpmfsSetAction(fs, i, FA_SKIPNSTATE);
continue;
}
}
/* Skip (now empty) directories that had skipped files. */
/* Iterate over dirs in reversed order to solve subdirs at first */
for (j = dc - 1; j >= 0; j--) {
const char * dn, * bn;
size_t dnlen, bnlen;
if (drc[j]) continue; /* dir still has files. */
if (!dff[j]) continue; /* dir was not emptied here. */
/* Find parent directory and basename. */
dn = rpmfilesDN(files, j); dnlen = strlen(dn) - 1;
bn = dn + dnlen; bnlen = 0;
while (bn > dn && bn[-1] != '/') {
bnlen++;
dnlen--;
bn--;
}
/* If explicitly included in the package, skip the directory. */
fi = rpmfiInit(fi, 0);
while ((i = rpmfiNext(fi)) >= 0) {
const char * fdn, * fbn;
rpm_mode_t fFMode;
if (XFA_SKIPPING(rpmfsGetAction(fs, i)))
continue;
fFMode = rpmfiFMode(fi);
if (rpmfiWhatis(fFMode) != XDIR)
continue;
fdn = rpmfiDN(fi);
if (strlen(fdn) != dnlen)
continue;
if (!rstreqn(fdn, dn, dnlen))
continue;
fbn = rpmfiBN(fi);
if (strlen(fbn) != bnlen)
continue;
if (!rstreqn(fbn, bn, bnlen))
continue;
rpmlog(RPMLOG_DEBUG, "excluding directory %s\n", dn);
rpmfsSetAction(fs, i, FA_SKIPNSTATE);
ix = rpmfiDX(fi);
/* Decrease count of files for parent directory */
drc[ix]--;
/* Mark directory because something was removed from them */
dff[ix] = 1;
break;
}
}
free(drc);
free(dff);
rpmfiFree(fi);
}
/**
* Skip any files that do not match install policies.
* @param ts transaction set
* @param fi file info set
*/
static void skipFiles(const rpmts ts, rpmte p)
{
rpm_color_t tscolor = rpmtsColor(ts);
rpm_color_t FColor;
int noConfigs = (rpmtsFlags(ts) & RPMTRANS_FLAG_NOCONFIGS);
int noDocs = (rpmtsFlags(ts) & RPMTRANS_FLAG_NODOCS);
const char * dn, * bn;
size_t dnlen, bnlen;
char * s;
int * drc;
char * dff;
int dc;
int i, j, ix;
rpmfi fi = rpmteFI(p);
rpmfs fs = rpmteGetFileStates(p);
if (!noDocs)
noDocs = rpmExpandNumeric("%{_excludedocs}");
/* Compute directory refcount, skip directory if now empty. */
dc = rpmfiDC(fi);
drc = xcalloc(dc, sizeof(*drc));
dff = xcalloc(dc, sizeof(*dff));
fi = rpmfiInit(fi, 0);
if (fi != NULL) /* XXX lclint */
while ((i = rpmfiNext(fi)) >= 0)
{
char ** nsp;
const char *flangs;
bn = rpmfiBN(fi);
bnlen = strlen(bn);
ix = rpmfiDX(fi);
dn = rpmfiDN(fi);
dnlen = strlen(dn);
if (dn == NULL)
continue; /* XXX can't happen */
drc[ix]++;
/* Don't bother with skipped files */
if (XFA_SKIPPING(rpmfsGetAction(fs, i))) {
drc[ix]--; dff[ix] = 1;
continue;
}
/* Ignore colored files not in our rainbow. */
FColor = rpmfiFColor(fi);
if (tscolor && FColor && !(tscolor & FColor)) {
drc[ix]--; dff[ix] = 1;
rpmfsSetAction(fs, i, FA_SKIPCOLOR);
continue;
}
/*
* Skip net shared paths.
* Net shared paths are not relative to the current root (though
* they do need to take package relocations into account).
*/
for (nsp = ts->netsharedPaths; nsp && *nsp; nsp++) {
size_t len;
len = strlen(*nsp);
if (dnlen >= len) {
if (strncmp(dn, *nsp, len))
continue;
/* Only directories or complete file paths can be net shared */
if (!(dn[len] == '/' || dn[len] == '\0'))
continue;
} else {
if (len < (dnlen + bnlen))
continue;
if (strncmp(dn, *nsp, dnlen))
continue;
/* Insure that only the netsharedpath basename is compared. */
if ((s = strchr((*nsp) + dnlen, '/')) != NULL && s[1] != '\0')
continue;
if (strncmp(bn, (*nsp) + dnlen, bnlen))
continue;
len = dnlen + bnlen;
/* Only directories or complete file paths can be net shared */
if (!((*nsp)[len] == '/' || (*nsp)[len] == '\0'))
continue;
}
break;
}
if (nsp && *nsp) {
drc[ix]--; dff[ix] = 1;
rpmfsSetAction(fs, i, FA_SKIPNETSHARED);
continue;
}
/*
* Skip i18n language specific files.
*/
if (ts->installLangs != NULL && (flangs = rpmfiFLangs(fi)) != NULL) {
const char *l, *le;
char **lang;
for (lang = ts->installLangs; *lang != NULL; lang++) {
for (l = flangs; *l != '\0'; l = le) {
for (le = l; *le != '\0' && *le != '|'; le++)
{};
if ((le-l) > 0 && !strncmp(*lang, l, (le-l)))
break;
if (*le == '|') le++; /* skip over | */
}
if (*l != '\0')
break;
}
if (*lang == NULL) {
drc[ix]--; dff[ix] = 1;
rpmfsSetAction(fs, i, FA_SKIPNSTATE);
continue;
}
}
/*
* Skip config files if requested.
*/
if (noConfigs && (rpmfiFFlags(fi) & RPMFILE_CONFIG)) {
drc[ix]--; dff[ix] = 1;
rpmfsSetAction(fs, i, FA_SKIPNSTATE);
continue;
}
/*
* Skip documentation if requested.
*/
if (noDocs && (rpmfiFFlags(fi) & RPMFILE_DOC)) {
drc[ix]--; dff[ix] = 1;
rpmfsSetAction(fs, i, FA_SKIPNSTATE);
continue;
}
}
/* Skip (now empty) directories that had skipped files. */
#ifndef NOTYET
if (fi != NULL) /* XXX can't happen */
for (j = 0; j < dc; j++)
#else
if ((fi = rpmfiInitD(fi)) != NULL)
while (j = rpmfiNextD(fi) >= 0)
#endif
{
if (drc[j]) continue; /* dir still has files. */
if (!dff[j]) continue; /* dir was not emptied here. */
/* Find parent directory and basename. */
dn = rpmfiDNIndex(fi, j); dnlen = strlen(dn) - 1;
bn = dn + dnlen; bnlen = 0;
while (bn > dn && bn[-1] != '/') {
bnlen++;
dnlen--;
bn--;
}
/* If explicitly included in the package, skip the directory. */
fi = rpmfiInit(fi, 0);
if (fi != NULL) /* XXX lclint */
while ((i = rpmfiNext(fi)) >= 0) {
const char * fdn, * fbn;
rpm_mode_t fFMode;
if (XFA_SKIPPING(rpmfsGetAction(fs, i)))
continue;
fFMode = rpmfiFMode(fi);
if (rpmfiWhatis(fFMode) != XDIR)
continue;
fdn = rpmfiDN(fi);
if (strlen(fdn) != dnlen)
continue;
if (strncmp(fdn, dn, dnlen))
continue;
fbn = rpmfiBN(fi);
if (strlen(fbn) != bnlen)
continue;
if (strncmp(fbn, bn, bnlen))
continue;
rpmlog(RPMLOG_DEBUG, "excluding directory %s\n", dn);
rpmfsSetAction(fs, i, FA_SKIPNSTATE);
break;
}
}
free(drc);
free(dff);
}
int rpmfiConfigConflictIndex(rpmfi fi, int ix)
{
char * fn = NULL;
rpmfileAttrs flags = rpmfiFFlagsIndex(fi, ix);
char buffer[1024];
rpmFileTypes newWhat, diskWhat;
struct stat sb;
int rc = 0;
/* Non-configs are not config conflicts. */
if (!(flags & RPMFILE_CONFIG))
return 0;
/* Only links and regular files can be %config, this is kinda moot */
/* XXX: Why are we returning 1 here? */
newWhat = rpmfiWhatis(rpmfiFModeIndex(fi, ix));
if (newWhat != LINK && newWhat != REG)
return 1;
/* If it's not on disk, there's nothing to be saved */
fn = rpmfiFNIndex(fi, ix);
if (lstat(fn, &sb))
goto exit;
/*
* Preserve legacy behavior: an existing %ghost %config is considered
* "modified" but unlike regular %config, its never removed and
* never backed up. Whether this actually makes sense is a whole
* another question, but this is very long-standing behavior that
* people might be depending on. The resulting FA_ALTNAME etc action
* is special-cased in FSM to avoid actually creating backups on ghosts.
*/
if (flags & RPMFILE_GHOST) {
rc = 1;
goto exit;
}
/* Files of different types obviously are not identical */
diskWhat = rpmfiWhatis((rpm_mode_t)sb.st_mode);
if (diskWhat != newWhat) {
rc = 1;
goto exit;
}
/* Files of different sizes obviously are not identical */
if (rpmfiFSizeIndex(fi, ix) != sb.st_size) {
rc = 1;
goto exit;
}
memset(buffer, 0, sizeof(buffer));
if (newWhat == REG) {
int algo;
size_t diglen;
const unsigned char *ndigest = rpmfiFDigestIndex(fi,ix, &algo, &diglen);
if (rpmDoDigest(algo, fn, 0, (unsigned char *)buffer, NULL))
goto exit; /* assume file has been removed */
if (ndigest && memcmp(ndigest, buffer, diglen) == 0)
goto exit; /* unmodified config file */
} else /* newWhat == LINK */ {
const char * nFLink;
ssize_t link_len = readlink(fn, buffer, sizeof(buffer) - 1);
if (link_len == -1)
goto exit; /* assume file has been removed */
buffer[link_len] = '\0';
nFLink = rpmfiFLinkIndex(fi, ix);
if (nFLink && rstreq(nFLink, buffer))
goto exit; /* unmodified config file */
}
rc = 1;
exit:
free(fn);
return rc;
}
rpmFileAction rpmfiDecideFateIndex(rpmfi ofi, int oix, rpmfi nfi, int nix,
int skipMissing)
{
char * fn = rpmfiFNIndex(nfi, nix);
rpmfileAttrs newFlags = rpmfiFFlagsIndex(nfi, nix);
char buffer[1024];
rpmFileTypes dbWhat, newWhat, diskWhat;
struct stat sb;
int save = (newFlags & RPMFILE_NOREPLACE) ? FA_ALTNAME : FA_SAVE;
int action = FA_CREATE; /* assume we can create */
/* If the new file is a ghost, leave whatever might be on disk alone. */
if (newFlags & RPMFILE_GHOST) {
action = FA_SKIP;
goto exit;
}
if (lstat(fn, &sb)) {
/*
* The file doesn't exist on the disk. Create it unless the new
* package has marked it as missingok, or allfiles is requested.
*/
if (skipMissing && (newFlags & RPMFILE_MISSINGOK)) {
rpmlog(RPMLOG_DEBUG, "%s skipped due to missingok flag\n",
fn);
action = FA_SKIP;
goto exit;
} else {
goto exit;
}
}
diskWhat = rpmfiWhatis((rpm_mode_t)sb.st_mode);
dbWhat = rpmfiWhatis(rpmfiFModeIndex(ofi, oix));
newWhat = rpmfiWhatis(rpmfiFModeIndex(nfi, nix));
/*
* This order matters - we'd prefer to CREATE the file if at all
* possible in case something else (like the timestamp) has changed.
* Only regular files and symlinks might need a backup, everything
* else falls through here with FA_CREATE.
*/
memset(buffer, 0, sizeof(buffer));
if (dbWhat == REG) {
int oalgo, nalgo;
size_t odiglen, ndiglen;
const unsigned char * odigest, * ndigest;
/* See if the file on disk is identical to the one in old pkg */
odigest = rpmfiFDigestIndex(ofi, oix, &oalgo, &odiglen);
if (diskWhat == REG) {
if (rpmDoDigest(oalgo, fn, 0, (unsigned char *)buffer, NULL))
goto exit; /* assume file has been removed */
if (odigest && memcmp(odigest, buffer, odiglen) == 0)
goto exit; /* unmodified config file, replace. */
}
/* See if the file on disk is identical to the one in new pkg */
ndigest = rpmfiFDigestIndex(nfi, nix, &nalgo, &ndiglen);
if (diskWhat == REG && newWhat == REG) {
/* hash algo changed in new, recalculate digest */
if (oalgo != nalgo)
if (rpmDoDigest(nalgo, fn, 0, (unsigned char *)buffer, NULL))
goto exit; /* assume file has been removed */
if (ndigest && memcmp(ndigest, buffer, ndiglen) == 0)
goto exit; /* file identical in new, replace. */
}
/* If file can be determined identical in old and new pkg, let it be */
if (newWhat == REG && oalgo == nalgo && odiglen == ndiglen) {
if (odigest && ndigest && memcmp(odigest, ndigest, odiglen) == 0) {
action = FA_SKIP; /* identical file, dont bother */
goto exit;
}
}
/* ...but otherwise a backup will be needed */
action = save;
} else if (dbWhat == LINK) {
const char * oFLink, * nFLink;
/* See if the link on disk is identical to the one in old pkg */
oFLink = rpmfiFLinkIndex(ofi, oix);
if (diskWhat == LINK) {
ssize_t link_len = readlink(fn, buffer, sizeof(buffer) - 1);
if (link_len == -1)
goto exit; /* assume file has been removed */
buffer[link_len] = '\0';
if (oFLink && rstreq(oFLink, buffer))
goto exit; /* unmodified config file, replace. */
}
/* See if the link on disk is identical to the one in new pkg */
nFLink = rpmfiFLinkIndex(nfi, nix);
if (diskWhat == LINK && newWhat == LINK) {
if (nFLink && rstreq(nFLink, buffer))
goto exit; /* unmodified config file, replace. */
}
/* If link is identical in old and new pkg, let it be */
if (newWhat == LINK && oFLink && nFLink && rstreq(oFLink, nFLink)) {
action = FA_SKIP; /* identical file, don't bother. */
goto exit;
}
/* ...but otherwise a backup will be needed */
action = save;
}
exit:
free(fn);
return action;
}
