/* Add fingerprint for each file not skipped. */
static void addFingerprints(rpmts ts, uint64_t fileCount, rpmFpHash ht, fingerPrintCache fpc)
{
rpmtsi pi;
rpmte p;
rpmfi fi;
int i;
rpmFpHash symlinks = rpmFpHashCreate(fileCount/16+16, fpHashFunction, fpEqual, NULL, NULL);
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
(void) rpmdbCheckSignals();
if ((fi = rpmteFI(p)) == NULL)
continue; /* XXX can't happen */
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
rpmfiFpLookup(fi, fpc);
/* collect symbolic links */
fi = rpmfiInit(fi, 0);
while ((i = rpmfiNext(fi)) >= 0) {
struct rpmffi_s ffi;
char const *linktarget;
linktarget = rpmfiFLink(fi);
if (!(linktarget && *linktarget != '\0'))
continue;
if (XFA_SKIPPING(rpmfsGetAction(rpmteGetFileStates(p), i)))
continue;
ffi.p = p;
ffi.fileno = i;
rpmFpHashAddEntry(symlinks, rpmfiFpsIndex(fi, i), ffi);
}
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), rpmfiFC(fi));
}
rpmtsiFree(pi);
/* ===============================================
* Check fingerprints if they contain symlinks
* and add them to the hash table
*/
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
(void) rpmdbCheckSignals();
fi = rpmfiInit(rpmteFI(p), 0);
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
while ((i = rpmfiNext(fi)) >= 0) {
if (XFA_SKIPPING(rpmfsGetAction(rpmteGetFileStates(p), i)))
continue;
fpLookupSubdir(symlinks, ht, fpc, p, i);
}
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
}
rpmtsiFree(pi);
rpmFpHashFree(symlinks);
}
/* Get a rpmdbMatchIterator containing all files in
* the rpmdb that share the basename with one from
* the transaction.
* @param ts transaction set
* @return rpmdbMatchIterator sorted
by (package, fileNum)
*/
static
rpmdbMatchIterator rpmFindBaseNamesInDB(rpmts ts)
{
rpmtsi pi; rpmte p;
rpmfi fi;
int fc=0;
rpmdbMatchIterator mi;
int i, xx;
const char * baseName;
/* get number of files in transaction */
// XXX move to ts
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
if ((fi = rpmteFI(p)) == NULL)
continue; /* XXX can't happen */
fc += rpmfiFC(fi);
}
pi = rpmtsiFree(pi);
rpmStringSet baseNames = rpmStringSetCreate(fc, hashFunctionString, strcmp, NULL);
mi = rpmdbInitIterator(rpmtsGetRdb(ts), RPMTAG_BASENAMES, NULL, 0);
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
(void) rpmdbCheckSignals();
if ((fi = rpmteFI(p)) == NULL)
continue; /* XXX can't happen */
rpmtsNotify(ts, NULL, RPMCALLBACK_TRANS_PROGRESS, rpmtsiOc(pi),
ts->orderCount);
/* Gather all installed headers with matching basename's. */
fi = rpmfiInit(fi, 0);
while ((i = rpmfiNext(fi)) >= 0) {
size_t keylen;
baseName = rpmfiBN(fi);
if (rpmStringSetHasEntry(baseNames, baseName))
continue;
keylen = strlen(baseName);
if (keylen == 0)
keylen++; /* XXX "/" fixup. */
xx = rpmdbExtendIterator(mi, baseName, keylen);
rpmStringSetAddEntry(baseNames, baseName);
}
}
pi = rpmtsiFree(pi);
rpmStringSetFree(baseNames);
rpmdbSortIterator(mi);
/* iterator is now sorted by (recnum, filenum) */
return mi;
}
static rpmRC ima_psm_post(rpmPlugin plugin, rpmte te, int res)
{
rpmfi fi = rpmteFI(te);
const char *fpath;
const unsigned char * fsig = NULL;
size_t len;
int rc = 0;
if (fi == NULL) {
rc = RPMERR_BAD_MAGIC;
goto exit;
}
while (!rc) {
rc = rpmfiNext(fi);
if (rc < 0) {
if (rc == RPMERR_ITER_END)
rc = 0;
break;
}
/* Don't install signatures for (mutable) config files */
if (!(rpmfiFFlags(fi) & RPMFILE_CONFIG)) {
fpath = rpmfiFN(fi);
fsig = rpmfiFSignature(fi, &len);
if (fsig) {
lsetxattr(fpath, XATTR_NAME_IMA, fsig, len, 0);
}
}
}
exit:
return rc;
}
void rpmalAdd(rpmal al, rpmte p)
{
rpmalNum pkgNum;
availablePackage alp;
if (al->size == al->alloced) {
al->alloced += al->delta;
al->list = xrealloc(al->list, sizeof(*al->list) * al->alloced);
}
pkgNum = al->size++;
alp = al->list + pkgNum;
alp->p = p;
alp->provides = rpmdsLink(rpmteDS(p, RPMTAG_PROVIDENAME));
alp->fi = rpmfiLink(rpmteFI(p));
if (al->providesHash != NULL) { // index is already created
rpmalAddProvides(al, pkgNum, alp->provides);
rpmalAddFiles(al, pkgNum, alp->fi);
}
assert(((rpmalNum)(alp - al->list)) == pkgNum);
}
static void rpmtsCheckDSIProblems(const rpmts ts, const rpmte te)
{
rpmDiskSpaceInfo dsi = ts->dsi;
if (dsi == NULL || !dsi->bsize)
return;
if (rpmfiFC(rpmteFI(te)) <= 0)
return;
for (; dsi->bsize; dsi++) {
if (dsi->bavail >= 0 && adj_fs_blocks(dsi->bneeded) > dsi->bavail) {
if (dsi->bneeded > dsi->obneeded) {
rpmteAddProblem(te, RPMPROB_DISKSPACE, NULL, dsi->mntPoint,
(adj_fs_blocks(dsi->bneeded) - dsi->bavail) * dsi->bsize);
dsi->obneeded = dsi->bneeded;
}
}
if (dsi->iavail >= 0 && adj_fs_blocks(dsi->ineeded) > dsi->iavail) {
if (dsi->ineeded > dsi->oineeded) {
rpmteAddProblem(te, RPMPROB_DISKNODES, NULL, dsi->mntPoint,
(adj_fs_blocks(dsi->ineeded) - dsi->iavail));
dsi->oineeded = dsi->ineeded;
}
}
}
}
static JSBool
rpmte_fi(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
void * ptr = JS_GetInstancePrivate(cx, obj, &rpmteClass, NULL);
rpmte te = ptr;
rpmTag tagN = RPMTAG_BASENAMES;
JSBool ok = JS_FALSE;
_METHOD_DEBUG_ENTRY(_debug);
if (!(ok = JS_ConvertArguments(cx, argc, argv, "/i", &tagN)))
goto exit;
{ rpmfi fi = NULL;
JSObject *fio = NULL;
if ((fi = rpmteFI(te, tagN)) == NULL)
*rval = JSVAL_NULL;
else
if ((fio = JS_NewObject(cx, &rpmfiClass, NULL, NULL)) != NULL
&& JS_SetPrivate(cx, fio, rpmfiLink(fi, __FUNCTION__)))
*rval = OBJECT_TO_JSVAL(fio);
else {
fi = rpmfiFree(fi);
*rval = JSVAL_VOID;
}
}
ok = JS_TRUE;
exit:
return ok;
}
static rpmpsm rpmpsmNew(rpmts ts, rpmte te)
{
rpmpsm psm = xcalloc(1, sizeof(*psm));
psm->ts = rpmtsLink(ts);
psm->fi = rpmfiLink(rpmteFI(te));
psm->te = te; /* XXX rpmte not refcounted yet */
return psm;
}
/* Calculate total number of files involved in transaction */
static uint64_t countFiles(rpmts ts)
{
uint64_t fc = 0;
rpmtsi pi = rpmtsiInit(ts);
rpmte p;
while ((p = rpmtsiNext(pi, 0)) != NULL)
fc += rpmfiFC(rpmteFI(p));
rpmtsiFree(pi);
return fc;
}
/* Get a rpmdbMatchIterator containing all files in
* the rpmdb that share the basename with one from
* the transaction.
* @param ts transaction set
* @return rpmdbMatchIterator sorted
by (package, fileNum)
*/
static
rpmdbMatchIterator rpmFindBaseNamesInDB(rpmts ts, uint64_t fileCount)
{
tsMembers tsmem = rpmtsMembers(ts);
rpmtsi pi; rpmte p;
rpmfi fi;
rpmdbMatchIterator mi;
int xx;
int oc = 0;
const char * baseName;
rpmStringSet baseNames = rpmStringSetCreate(fileCount,
hashFunctionString, strcmp, NULL);
mi = rpmdbNewIterator(rpmtsGetRdb(ts), RPMDBI_BASENAMES);
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
(void) rpmdbCheckSignals();
rpmtsNotify(ts, NULL, RPMCALLBACK_TRANS_PROGRESS, oc++, tsmem->orderCount);
/* Gather all installed headers with matching basename's. */
fi = rpmfiInit(rpmteFI(p), 0);
while (rpmfiNext(fi) >= 0) {
size_t keylen;
baseName = rpmfiBN(fi);
if (rpmStringSetHasEntry(baseNames, baseName))
continue;
keylen = strlen(baseName);
if (keylen == 0)
keylen++; /* XXX "/" fixup. */
xx = rpmdbExtendIterator(mi, baseName, keylen);
rpmStringSetAddEntry(baseNames, baseName);
}
}
pi = rpmtsiFree(pi);
rpmStringSetFree(baseNames);
rpmdbSortIterator(mi);
/* iterator is now sorted by (recnum, filenum) */
return mi;
}
static void skipEraseFiles(const rpmts ts, rpmte p)
{
rpmfi fi = rpmteFI(p);
rpmfs fs = rpmteGetFileStates(p);
int i;
char ** nsp;
/*
* Skip net shared paths.
* Net shared paths are not relative to the current root (though
* they do need to take package relocations into account).
*/
fi = rpmfiInit(fi, 0);
while ((i = rpmfiNext(fi)) >= 0)
{
nsp = matchNetsharedpath(ts, fi);
if (nsp && *nsp) {
rpmfsSetAction(fs, i, FA_SKIPNETSHARED);
}
}
}
int rpmtsRun(rpmts ts, rpmps okProbs, rpmprobFilterFlags ignoreSet)
{
rpm_color_t tscolor = rpmtsColor(ts);
int i;
int rc = 0;
int totalFileCount = 0;
rpmfi fi;
fingerPrintCache fpc;
rpmps ps;
rpmtsi pi; rpmte p;
int numAdded;
int numRemoved;
void * lock = NULL;
int xx;
/* XXX programmer error segfault avoidance. */
if (rpmtsNElements(ts) <= 0)
return -1;
/* If we are in test mode, then there's no need for transaction lock. */
if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_TEST)) {
lock = rpmtsAcquireLock(ts);
if (lock == NULL)
return -1; /* XXX W2DO? */
}
if (rpmtsFlags(ts) & RPMTRANS_FLAG_NOSCRIPTS)
(void) rpmtsSetFlags(ts, (rpmtsFlags(ts) | _noTransScripts | _noTransTriggers));
if (rpmtsFlags(ts) & RPMTRANS_FLAG_NOTRIGGERS)
(void) rpmtsSetFlags(ts, (rpmtsFlags(ts) | _noTransTriggers));
if (rpmtsFlags(ts) & RPMTRANS_FLAG_JUSTDB)
(void) rpmtsSetFlags(ts, (rpmtsFlags(ts) | _noTransScripts | _noTransTriggers));
/* if SELinux isn't enabled or init fails, don't bother... */
if (!rpmtsSELinuxEnabled(ts)) {
rpmtsSetFlags(ts, (rpmtsFlags(ts) | RPMTRANS_FLAG_NOCONTEXTS));
}
if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_NOCONTEXTS)) {
char *fn = rpmGetPath("%{?_install_file_context_path}", NULL);
if (matchpathcon_init(fn) == -1) {
rpmtsSetFlags(ts, (rpmtsFlags(ts) | RPMTRANS_FLAG_NOCONTEXTS));
}
free(fn);
}
ts->probs = rpmpsFree(ts->probs);
ts->probs = rpmpsCreate();
/* XXX Make sure the database is open RDWR for package install/erase. */
{ int dbmode = (rpmtsFlags(ts) & RPMTRANS_FLAG_TEST)
? O_RDONLY : (O_RDWR|O_CREAT);
/* Open database RDWR for installing packages. */
if (rpmtsOpenDB(ts, dbmode)) {
rpmtsFreeLock(lock);
return -1; /* XXX W2DO? */
}
}
ts->ignoreSet = ignoreSet;
{ char * currDir = rpmGetCwd();
rpmtsSetCurrDir(ts, currDir);
currDir = _free(currDir);
}
(void) rpmtsSetChrootDone(ts, 0);
{ rpm_tid_t tid = (rpm_tid_t) time(NULL);
(void) rpmtsSetTid(ts, tid);
}
/* Get available space on mounted file systems. */
xx = rpmtsInitDSI(ts);
/* ===============================================
* For packages being installed:
* - verify package arch/os.
* - verify package epoch:version-release is newer.
* - count files.
* For packages being removed:
* - count files.
*/
rpmlog(RPMLOG_DEBUG, "sanity checking %d elements\n", rpmtsNElements(ts));
ps = rpmtsProblems(ts);
/* The ordering doesn't matter here */
pi = rpmtsiInit(ts);
/* XXX Only added packages need be checked. */
while ((p = rpmtsiNext(pi, TR_ADDED)) != NULL) {
rpmdbMatchIterator mi;
int fc;
if ((fi = rpmteFI(p)) == NULL)
continue; /* XXX can't happen */
fc = rpmfiFC(fi);
if (!(rpmtsFilterFlags(ts) & RPMPROB_FILTER_IGNOREARCH))
if (!archOkay(rpmteA(p)))
rpmpsAppend(ps, RPMPROB_BADARCH,
rpmteNEVRA(p), rpmteKey(p),
rpmteA(p), NULL,
NULL, 0);
if (!(rpmtsFilterFlags(ts) & RPMPROB_FILTER_IGNOREOS))
if (!osOkay(rpmteO(p)))
rpmpsAppend(ps, RPMPROB_BADOS,
rpmteNEVRA(p), rpmteKey(p),
rpmteO(p), NULL,
NULL, 0);
if (!(rpmtsFilterFlags(ts) & RPMPROB_FILTER_OLDPACKAGE)) {
Header h;
mi = rpmtsInitIterator(ts, RPMTAG_NAME, rpmteN(p), 0);
while ((h = rpmdbNextIterator(mi)) != NULL)
xx = ensureOlder(ts, p, h);
mi = rpmdbFreeIterator(mi);
}
if (!(rpmtsFilterFlags(ts) & RPMPROB_FILTER_REPLACEPKG)) {
mi = rpmtsInitIterator(ts, RPMTAG_NAME, rpmteN(p), 0);
xx = rpmdbSetIteratorRE(mi, RPMTAG_EPOCH, RPMMIRE_STRCMP,
rpmteE(p));
xx = rpmdbSetIteratorRE(mi, RPMTAG_VERSION, RPMMIRE_STRCMP,
rpmteV(p));
xx = rpmdbSetIteratorRE(mi, RPMTAG_RELEASE, RPMMIRE_STRCMP,
rpmteR(p));
if (tscolor) {
xx = rpmdbSetIteratorRE(mi, RPMTAG_ARCH, RPMMIRE_STRCMP,
rpmteA(p));
xx = rpmdbSetIteratorRE(mi, RPMTAG_OS, RPMMIRE_STRCMP,
rpmteO(p));
}
while (rpmdbNextIterator(mi) != NULL) {
rpmpsAppend(ps, RPMPROB_PKG_INSTALLED,
rpmteNEVRA(p), rpmteKey(p),
NULL, NULL,
NULL, 0);
break;
}
mi = rpmdbFreeIterator(mi);
}
/* Count no. of files (if any). */
totalFileCount += fc;
}
pi = rpmtsiFree(pi);
ps = rpmpsFree(ps);
/* The ordering doesn't matter here */
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, TR_REMOVED)) != NULL) {
int fc;
if ((fi = rpmteFI(p)) == NULL)
continue; /* XXX can't happen */
fc = rpmfiFC(fi);
totalFileCount += fc;
}
pi = rpmtsiFree(pi);
/* Run pre-transaction scripts, but only if there are no known
* problems up to this point and not disabled otherwise. */
if (!((rpmtsFlags(ts) & (RPMTRANS_FLAG_BUILD_PROBS|RPMTRANS_FLAG_TEST|RPMTRANS_FLAG_NOPRE))
|| (rpmpsNumProblems(ts->probs) &&
(okProbs == NULL || rpmpsTrim(ts->probs, okProbs))))) {
rpmlog(RPMLOG_DEBUG, "running pre-transaction scripts\n");
runTransScripts(ts, RPMTAG_PRETRANS);
}
/* ===============================================
* Initialize transaction element file info for package:
*/
/*
* FIXME?: we'd be better off assembling one very large file list and
* calling fpLookupList only once. I'm not sure that the speedup is
* worth the trouble though.
*/
rpmlog(RPMLOG_DEBUG, "computing %d file fingerprints\n", totalFileCount);
numAdded = numRemoved = 0;
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
int fc;
if ((fi = rpmteFI(p)) == NULL)
continue; /* XXX can't happen */
fc = rpmfiFC(fi);
switch (rpmteType(p)) {
case TR_ADDED:
numAdded++;
/* Skip netshared paths, not our i18n files, and excluded docs */
if (fc > 0)
skipFiles(ts, p);
break;
case TR_REMOVED:
numRemoved++;
break;
}
}
pi = rpmtsiFree(pi);
if (!rpmtsChrootDone(ts)) {
const char * rootDir = rpmtsRootDir(ts);
xx = chdir("/");
if (rootDir != NULL && strcmp(rootDir, "/") && *rootDir == '/') {
/* opening db before chroot not optimal, see rhbz#103852 c#3 */
xx = rpmdbOpenAll(ts->rdb);
if (chroot(rootDir) == -1) {
rpmlog(RPMLOG_ERR, _("Unable to change root directory: %m\n"));
return -1;
}
}
(void) rpmtsSetChrootDone(ts, 1);
}
ts->ht = rpmFpHashCreate(totalFileCount/2+1, fpHashFunction, fpEqual,
NULL, NULL);
rpmFpHash symlinks = rpmFpHashCreate(totalFileCount/16+16, fpHashFunction, fpEqual, NULL, NULL);
fpc = fpCacheCreate(totalFileCount/2 + 10001);
/* ===============================================
* Add fingerprint for each file not skipped.
*/
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
int fc;
(void) rpmdbCheckSignals();
if ((fi = rpmteFI(p)) == NULL)
continue; /* XXX can't happen */
fc = rpmfiFC(fi);
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
rpmfiFpLookup(fi, fpc);
/* collect symbolic links */
fi = rpmfiInit(fi, 0);
if (fi != NULL) /* XXX lclint */
while ((i = rpmfiNext(fi)) >= 0) {
struct rpmffi_s ffi;
char const *linktarget;
linktarget = rpmfiFLink(fi);
if (!(linktarget && *linktarget != '\0'))
continue;
if (XFA_SKIPPING(rpmfsGetAction(rpmteGetFileStates(p), i)))
continue;
ffi.p = p;
ffi.fileno = i;
rpmFpHashAddEntry(symlinks, rpmfiFpsIndex(fi, i), ffi);
}
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), fc);
}
pi = rpmtsiFree(pi);
/* ===============================================
* Check fingerprints if they contain symlinks
* and add them to the ts->ht hash table
*/
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
(void) rpmdbCheckSignals();
if ((fi = rpmteFI(p)) == NULL)
continue; /* XXX can't happen */
fi = rpmfiInit(fi, 0);
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
if (fi != NULL) /* XXX lclint */
while ((i = rpmfiNext(fi)) >= 0) {
if (XFA_SKIPPING(rpmfsGetAction(rpmteGetFileStates(p), i)))
continue;
fpLookupSubdir(symlinks, ts->ht, fpc, p, i);
}
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
}
pi = rpmtsiFree(pi);
rpmFpHashFree(symlinks);
/* ===============================================
* Compute file disposition for each package in transaction set.
*/
rpmtsNotify(ts, NULL, RPMCALLBACK_TRANS_START, 6, ts->orderCount);
/* check against files in the rpmdb */
checkInstalledFiles(ts, fpc);
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
if ((fi = rpmteFI(p)) == NULL)
continue; /* XXX can't happen */
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
/* check files in ts against each other and update disk space
needs on each partition for this package. */
handleOverlappedFiles(ts, p, fi);
/* Check added package has sufficient space on each partition used. */
if (rpmteType(p) == TR_ADDED) {
rpmtsCheckDSIProblems(ts, p);
}
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
}
pi = rpmtsiFree(pi);
if (rpmtsChrootDone(ts)) {
const char * rootDir = rpmtsRootDir(ts);
const char * currDir = rpmtsCurrDir(ts);
if (rootDir != NULL && strcmp(rootDir, "/") && *rootDir == '/')
xx = chroot(".");
(void) rpmtsSetChrootDone(ts, 0);
if (currDir != NULL)
xx = chdir(currDir);
}
rpmtsNotify(ts, NULL, RPMCALLBACK_TRANS_STOP, 6, ts->orderCount);
/* ===============================================
* Free unused memory as soon as possible.
*/
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
rpmteSetFI(p, NULL);
}
pi = rpmtsiFree(pi);
fpc = fpCacheFree(fpc);
ts->ht = rpmFpHashFree(ts->ht);
/* ===============================================
* If unfiltered problems exist, free memory and return.
*/
if ((rpmtsFlags(ts) & RPMTRANS_FLAG_BUILD_PROBS)
|| (rpmpsNumProblems(ts->probs) &&
(okProbs == NULL || rpmpsTrim(ts->probs, okProbs)))
)
{
rpmtsFreeLock(lock);
return ts->orderCount;
}
/* Actually install and remove packages */
rc = rpmtsProcess(ts);
if (!(rpmtsFlags(ts) & (RPMTRANS_FLAG_TEST|RPMTRANS_FLAG_NOPOST))) {
rpmlog(RPMLOG_DEBUG, "running post-transaction scripts\n");
runTransScripts(ts, RPMTAG_POSTTRANS);
}
if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_NOCONTEXTS)) {
matchpathcon_fini();
}
rpmtsFreeLock(lock);
/* FIX: ts->flList may be NULL */
if (rc)
return -1;
else
return 0;
}
/* Check files in the transactions against the rpmdb
* Lookup all files with the same basename in the rpmdb
* and then check for matching finger prints
* @param ts transaction set
* @param fpc global finger print cache
*/
static
void checkInstalledFiles(rpmts ts, fingerPrintCache fpc)
{
rpmps ps;
rpmte p;
rpmfi fi;
rpmfs fs;
rpmfi otherFi=NULL;
int j;
int xx;
unsigned int fileNum;
const char * oldDir;
rpmdbMatchIterator mi;
Header h, newheader;
int beingRemoved;
rpmlog(RPMLOG_DEBUG, "computing file dispositions\n");
mi = rpmFindBaseNamesInDB(ts);
/* For all installed headers with matching basename's ... */
if (mi == NULL)
return;
if (rpmdbGetIteratorCount(mi) == 0) {
mi = rpmdbFreeIterator(mi);
return;
}
ps = rpmtsProblems(ts);
/* Loop over all packages from the rpmdb */
h = newheader = rpmdbNextIterator(mi);
while (h != NULL) {
headerGetFlags hgflags = HEADERGET_MINMEM;
struct rpmtd_s bnames, dnames, dindexes, ostates;
fingerPrint fp;
unsigned int installedPkg;
/* Is this package being removed? */
installedPkg = rpmdbGetIteratorOffset(mi);
beingRemoved = 0;
if (ts->removedPackages != NULL)
for (j = 0; j < ts->numRemovedPackages; j++) {
if (ts->removedPackages[j] != installedPkg)
continue;
beingRemoved = 1;
break;
}
h = headerLink(h);
headerGet(h, RPMTAG_BASENAMES, &bnames, hgflags);
headerGet(h, RPMTAG_DIRNAMES, &dnames, hgflags);
headerGet(h, RPMTAG_DIRINDEXES, &dindexes, hgflags);
headerGet(h, RPMTAG_FILESTATES, &ostates, hgflags);
oldDir = NULL;
/* loop over all interesting files in that package */
do {
int gotRecs;
struct rpmffi_s * recs;
int numRecs;
const char * dirName;
const char * baseName;
fileNum = rpmdbGetIteratorFileNum(mi);
rpmtdSetIndex(&bnames, fileNum);
rpmtdSetIndex(&dindexes, fileNum);
rpmtdSetIndex(&dnames, *rpmtdGetUint32(&dindexes));
rpmtdSetIndex(&ostates, fileNum);
dirName = rpmtdGetString(&dnames);
baseName = rpmtdGetString(&bnames);
/* lookup finger print for this file */
if ( dirName == oldDir) {
/* directory is the same as last round */
fp.baseName = baseName;
} else {
fp = fpLookup(fpc, dirName, baseName, 1);
oldDir = dirName;
}
/* search for files in the transaction with same finger print */
gotRecs = rpmFpHashGetEntry(ts->ht, &fp, &recs, &numRecs, NULL);
for (j=0; (j<numRecs)&&gotRecs; j++) {
p = recs[j].p;
fi = rpmteFI(p);
fs = rpmteGetFileStates(p);
/* Determine the fate of each file. */
switch (rpmteType(p)) {
case TR_ADDED:
if (!otherFi) {
otherFi = rpmfiNew(ts, h, RPMTAG_BASENAMES, RPMFI_KEEPHEADER);
}
rpmfiSetFX(fi, recs[j].fileno);
rpmfiSetFX(otherFi, fileNum);
xx = handleInstInstalledFile(ts, p, fi, h, otherFi, beingRemoved);
break;
case TR_REMOVED:
if (!beingRemoved) {
rpmfiSetFX(fi, recs[j].fileno);
if (*rpmtdGetChar(&ostates) == RPMFILE_STATE_NORMAL)
rpmfsSetAction(fs, recs[j].fileno, FA_SKIP);
}
break;
}
}
newheader = rpmdbNextIterator(mi);
} while (newheader==h);
otherFi = rpmfiFree(otherFi);
rpmtdFreeData(&ostates);
rpmtdFreeData(&bnames);
rpmtdFreeData(&dnames);
rpmtdFreeData(&dindexes);
headerFree(h);
h = newheader;
}
mi = rpmdbFreeIterator(mi);
}
static int rpmtsPrepare(rpmts ts)
{
tsMembers tsmem = rpmtsMembers(ts);
rpmtsi pi;
rpmte p;
rpmfi fi;
int rc = 0;
uint64_t fileCount = countFiles(ts);
fingerPrintCache fpc = fpCacheCreate(fileCount/2 + 10001);
rpmFpHash ht = rpmFpHashCreate(fileCount/2+1, fpHashFunction, fpEqual,
NULL, NULL);
rpmDiskSpaceInfo dsi;
rpmlog(RPMLOG_DEBUG, "computing %" PRIu64 " file fingerprints\n", fileCount);
/* Skip netshared paths, not our i18n files, and excluded docs */
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
if (rpmfiFC(rpmteFI(p)) == 0)
continue;
if (rpmteType(p) == TR_ADDED) {
skipInstallFiles(ts, p);
} else {
skipEraseFiles(ts, p);
}
}
rpmtsiFree(pi);
/* Open rpmdb & enter chroot for fingerprinting if necessary */
if (rpmdbOpenAll(ts->rdb) || rpmChrootIn()) {
rc = -1;
goto exit;
}
rpmtsNotify(ts, NULL, RPMCALLBACK_TRANS_START, 6, tsmem->orderCount);
addFingerprints(ts, fileCount, ht, fpc);
/* check against files in the rpmdb */
checkInstalledFiles(ts, fileCount, ht, fpc);
dsi = rpmtsDbDSI(ts);
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
if ((fi = rpmteFI(p)) == NULL)
continue; /* XXX can't happen */
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
/* check files in ts against each other and update disk space
needs on each partition for this package. */
handleOverlappedFiles(ts, ht, p, fi);
rpmtsUpdateDSIrpmDBSize(p, dsi);
/* Check added package has sufficient space on each partition used. */
if (rpmteType(p) == TR_ADDED) {
rpmtsCheckDSIProblems(ts, p);
}
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
}
rpmtsiFree(pi);
rpmtsNotify(ts, NULL, RPMCALLBACK_TRANS_STOP, 6, tsmem->orderCount);
/* return from chroot if done earlier */
if (rpmChrootOut())
rc = -1;
/* File info sets, fp caches etc not needed beyond here, free 'em up. */
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
rpmteSetFI(p, NULL);
}
rpmtsiFree(pi);
exit:
rpmFpHashFree(ht);
fpCacheFree(fpc);
rpmtsFreeDSI(ts);
return rc;
}
/**
* 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);
}
/* XXX only ts->{probs,di} modified */
static void handleOverlappedFiles(const rpmts ts, const rpmte p, rpmfi fi)
{
rpm_loff_t fixupSize = 0;
rpmps ps;
const char * fn;
int i, j;
rpm_color_t tscolor = rpmtsColor(ts);
rpm_color_t prefcolor = rpmtsPrefColor(ts);
rpmfs fs = rpmteGetFileStates(p);
rpmfs otherFs;
ps = rpmtsProblems(ts);
fi = rpmfiInit(fi, 0);
if (fi != NULL)
while ((i = rpmfiNext(fi)) >= 0) {
rpm_color_t oFColor, FColor;
struct fingerPrint_s * fiFps;
int otherPkgNum, otherFileNum;
rpmfi otherFi;
rpmte otherTe;
rpmfileAttrs FFlags;
rpm_mode_t FMode;
struct rpmffi_s * recs;
int numRecs;
if (XFA_SKIPPING(rpmfsGetAction(fs, i)))
continue;
fn = rpmfiFN(fi);
fiFps = rpmfiFpsIndex(fi, i);
FFlags = rpmfiFFlags(fi);
FMode = rpmfiFMode(fi);
FColor = rpmfiFColor(fi);
FColor &= tscolor;
fixupSize = 0;
/*
* Retrieve all records that apply to this file. Note that the
* file info records were built in the same order as the packages
* will be installed and removed so the records for an overlapped
* files will be sorted in exactly the same order.
*/
(void) rpmFpHashGetEntry(ts->ht, fiFps, &recs, &numRecs, NULL);
/*
* If this package is being added, look only at other packages
* being added -- removed packages dance to a different tune.
*
* If both this and the other package are being added, overlapped
* files must be identical (or marked as a conflict). The
* disposition of already installed config files leads to
* a small amount of extra complexity.
*
* If this package is being removed, then there are two cases that
* need to be worried about:
* If the other package is being added, then skip any overlapped files
* so that this package removal doesn't nuke the overlapped files
* that were just installed.
* If both this and the other package are being removed, then each
* file removal from preceding packages needs to be skipped so that
* the file removal occurs only on the last occurence of an overlapped
* file in the transaction set.
*
*/
/* Locate this overlapped file in the set of added/removed packages. */
for (j = 0; j < numRecs && recs[j].p != p; j++)
{};
/* Find what the previous disposition of this file was. */
otherFileNum = -1; /* keep gcc quiet */
otherFi = NULL;
otherTe = NULL;
otherFs = NULL;
for (otherPkgNum = j - 1; otherPkgNum >= 0; otherPkgNum--) {
otherTe = recs[otherPkgNum].p;
otherFi = rpmteFI(otherTe);
otherFileNum = recs[otherPkgNum].fileno;
otherFs = rpmteGetFileStates(otherTe);
/* Added packages need only look at other added packages. */
if (rpmteType(p) == TR_ADDED && rpmteType(otherTe) != TR_ADDED)
continue;
(void) rpmfiSetFX(otherFi, otherFileNum);
/* XXX Happens iff fingerprint for incomplete package install. */
if (rpmfsGetAction(otherFs, otherFileNum) != FA_UNKNOWN);
break;
}
oFColor = rpmfiFColor(otherFi);
oFColor &= tscolor;
switch (rpmteType(p)) {
case TR_ADDED:
{
int reportConflicts =
!(rpmtsFilterFlags(ts) & RPMPROB_FILTER_REPLACENEWFILES);
int done = 0;
if (otherPkgNum < 0) {
/* XXX is this test still necessary? */
rpmFileAction action;
if (rpmfsGetAction(fs, i) != FA_UNKNOWN)
break;
if (rpmfiConfigConflict(fi)) {
/* Here is a non-overlapped pre-existing config file. */
action = (FFlags & RPMFILE_NOREPLACE) ?
FA_ALTNAME : FA_BACKUP;
} else {
action = FA_CREATE;
}
rpmfsSetAction(fs, i, action);
break;
}
assert(otherFi != NULL);
/* Mark added overlapped non-identical files as a conflict. */
if (rpmfiCompare(otherFi, fi)) {
int rConflicts;
rConflicts = reportConflicts;
/* Resolve file conflicts to prefer Elf64 (if not forced) ... */
if (tscolor != 0) {
if (FColor & prefcolor) {
/* ... last file of preferred colour is installed ... */
if (!XFA_SKIPPING(rpmfsGetAction(fs, i))) {
/* XXX static helpers are order dependent. Ick. */
if (strcmp(fn, "/usr/sbin/libgcc_post_upgrade")
&& strcmp(fn, "/usr/sbin/glibc_post_upgrade"))
rpmfsSetAction(otherFs, otherFileNum, FA_SKIPCOLOR);
}
rpmfsSetAction(fs, i, FA_CREATE);
rConflicts = 0;
} else
if (oFColor & prefcolor) {
/* ... first file of preferred colour is installed ... */
if (XFA_SKIPPING(rpmfsGetAction(fs, i)))
rpmfsSetAction(otherFs, otherFileNum, FA_CREATE);
rpmfsSetAction(fs, i, FA_SKIPCOLOR);
rConflicts = 0;
}
done = 1;
}
if (rConflicts) {
rpmpsAppend(ps, RPMPROB_NEW_FILE_CONFLICT,
rpmteNEVRA(p), rpmteKey(p),
fn, NULL,
rpmteNEVRA(otherTe),
0);
}
}
/* Try to get the disk accounting correct even if a conflict. */
fixupSize = rpmfiFSize(otherFi);
if (rpmfiConfigConflict(fi)) {
/* Here is an overlapped pre-existing config file. */
rpmFileAction action;
action = (FFlags & RPMFILE_NOREPLACE) ? FA_ALTNAME : FA_SKIP;
rpmfsSetAction(fs, i, action);
} else {
if (!done)
rpmfsSetAction(fs, i, FA_CREATE);
}
} break;
case TR_REMOVED:
if (otherPkgNum >= 0) {
assert(otherFi != NULL);
/* Here is an overlapped added file we don't want to nuke. */
if (rpmfsGetAction(otherFs, otherFileNum) != FA_ERASE) {
/* On updates, don't remove files. */
rpmfsSetAction(fs, i, FA_SKIP);
break;
}
/* Here is an overlapped removed file: skip in previous. */
rpmfsSetAction(otherFs, otherFileNum, FA_SKIP);
}
if (XFA_SKIPPING(rpmfsGetAction(fs, i)))
break;
if (rpmfiFState(fi) != RPMFILE_STATE_NORMAL)
break;
if (!(S_ISREG(FMode) && (FFlags & RPMFILE_CONFIG))) {
rpmfsSetAction(fs, i, FA_ERASE);
break;
}
/* Here is a pre-existing modified config file that needs saving. */
{ pgpHashAlgo algo = 0;
size_t diglen = 0;
const unsigned char *digest;
if ((digest = rpmfiFDigest(fi, &algo, &diglen))) {
unsigned char fdigest[diglen];
if (!rpmDoDigest(algo, fn, 0, fdigest, NULL) &&
memcmp(digest, fdigest, diglen)) {
rpmfsSetAction(fs, i, FA_BACKUP);
break;
}
}
}
rpmfsSetAction(fs, i, FA_ERASE);
break;
}
/* Update disk space info for a file. */
rpmtsUpdateDSI(ts, fiFps->entry->dev, rpmfiFSize(fi),
rpmfiFReplacedSize(fi), fixupSize, rpmfsGetAction(fs, i));
}
ps = rpmpsFree(ps);
}
void fpCachePopulate(fingerPrintCache fpc, rpmts ts, int fileCount)
{
rpmtsi pi;
rpmte p;
rpmfs fs;
rpmfi fi;
int i, fc;
if (fpc->fp == NULL)
fpc->fp = rpmFpHashCreate(fileCount/2 + 10001, fpHashFunction, fpEqual,
NULL, NULL);
rpmFpHash symlinks = rpmFpHashCreate(fileCount/16+16, fpHashFunction, fpEqual, NULL, NULL);
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
fingerPrint *fpList;
(void) rpmdbCheckSignals();
if ((fi = rpmteFI(p)) == NULL)
continue; /* XXX can't happen */
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
rpmfiFpLookup(fi, fpc);
fs = rpmteGetFileStates(p);
fc = rpmfsFC(fs);
fpList = rpmfiFps(fi);
/* collect symbolic links */
for (i = 0; i < fc; i++) {
struct rpmffi_s ffi;
char const *linktarget;
if (XFA_SKIPPING(rpmfsGetAction(fs, i)))
continue;
linktarget = rpmfiFLinkIndex(fi, i);
if (!(linktarget && *linktarget != '\0'))
continue;
ffi.p = p;
ffi.fileno = i;
rpmFpHashAddEntry(symlinks, fpList + i, ffi);
}
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), fc);
}
rpmtsiFree(pi);
/* ===============================================
* Check fingerprints if they contain symlinks
* and add them to the hash table
*/
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, 0)) != NULL) {
(void) rpmdbCheckSignals();
fs = rpmteGetFileStates(p);
fc = rpmfsFC(fs);
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
for (i = 0; i < fc; i++) {
if (XFA_SKIPPING(rpmfsGetAction(fs, i)))
continue;
fpLookupSubdir(symlinks, fpc, p, i);
}
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_FINGERPRINT), 0);
}
rpmtsiFree(pi);
rpmFpHashFree(symlinks);
}
/* Check file for to be installed symlinks in their path and correct their fp */
static void fpLookupSubdir(rpmFpHash symlinks, fingerPrintCache fpc, rpmte p, int filenr)
{
rpmfi fi = rpmteFI(p);
struct fingerPrint_s current_fp;
const char *currentsubdir;
size_t lensubDir, bnStart, bnEnd;
struct rpmffi_s * recs;
int numRecs;
int i;
fingerPrint *fp = rpmfiFps(fi) + filenr;
int symlinkcount = 0;
struct rpmffi_s ffi = { p, filenr};
if (fp->subDirId == 0) {
rpmFpHashAddEntry(fpc->fp, fp, ffi);
return;
}
currentsubdir = rpmstrPoolStr(fpc->pool, fp->subDirId);
lensubDir = rpmstrPoolStrlen(fpc->pool, fp->subDirId);
current_fp = *fp;
/* Set baseName to the upper most dir */
bnStart = bnEnd = 1;
while (bnEnd < lensubDir && currentsubdir[bnEnd] != '/')
bnEnd++;
/* no subDir for now */
current_fp.subDirId = 0;
while (bnEnd < lensubDir) {
char found = 0;
current_fp.baseNameId = rpmstrPoolIdn(fpc->pool,
currentsubdir + bnStart,
bnEnd - bnStart, 1);
rpmFpHashGetEntry(symlinks, ¤t_fp, &recs, &numRecs, NULL);
for (i=0; i<numRecs; i++) {
rpmfi foundfi = rpmteFI(recs[i].p);
char const *linktarget = rpmfiFLinkIndex(foundfi, recs[i].fileno);
char *link;
if (linktarget && *linktarget != '\0') {
const char *bn;
/* this "directory" is a symlink */
link = NULL;
if (*linktarget != '/') {
const char *dn, *subDir = NULL;
dn = rpmstrPoolStr(fpc->pool, current_fp.entry->dirId);
if (current_fp.subDirId) {
subDir = rpmstrPoolStr(fpc->pool,
current_fp.subDirId);
}
rstrscat(&link, dn,
subDir ? subDir : "",
"/", NULL);
}
rstrscat(&link, linktarget, "/", NULL);
if (strlen(currentsubdir + bnEnd)) {
rstrscat(&link, currentsubdir + bnEnd, NULL);
}
bn = rpmstrPoolStr(fpc->pool, fp->baseNameId);
doLookup(fpc, link, bn, fp);
free(link);
symlinkcount++;
/* setup current_fp for the new path */
found = 1;
current_fp = *fp;
if (fp->subDirId == 0) {
/* directory exists - no need to look for symlinks */
rpmFpHashAddEntry(fpc->fp, fp, ffi);
return;
}
currentsubdir = rpmstrPoolStr(fpc->pool, fp->subDirId);
lensubDir = rpmstrPoolStrlen(fpc->pool, fp->subDirId);
/* no subDir for now */
current_fp.subDirId = 0;
/* Set baseName to the upper most dir */
bnStart = bnEnd = 1;
while (bnEnd < lensubDir && currentsubdir[bnEnd] != '/')
bnEnd++;
break;
}
}
if (symlinkcount>50) {
// found too many symlinks in the path
// most likley a symlink cicle
// giving up
// TODO warning/error
break;
}
if (found) {
continue; // restart loop after symlink
}
/* Set former baseName as subDir */
bnEnd++;
current_fp.subDirId = rpmstrPoolIdn(fpc->pool, currentsubdir, bnEnd, 1);
/* set baseName to the next lower dir */
bnStart = bnEnd;
while (bnEnd < lensubDir && currentsubdir[bnEnd] != '/')
bnEnd++;
}
rpmFpHashAddEntry(fpc->fp, fp, ffi);
}
int rpmtsCheck(rpmts ts)
{
rpm_color_t tscolor = rpmtsColor(ts);
rpmtsi pi = NULL; rpmte p;
int closeatexit = 0;
int rc = 0;
depCache dcache = NULL;
conflictsCache confcache = NULL;
(void) rpmswEnter(rpmtsOp(ts, RPMTS_OP_CHECK), 0);
/* Do lazy, readonly, open of rpm database. */
if (rpmtsGetRdb(ts) == NULL && rpmtsGetDBMode(ts) != -1) {
if ((rc = rpmtsOpenDB(ts, rpmtsGetDBMode(ts))) != 0)
goto exit;
closeatexit = 1;
}
/* XXX FIXME: figure some kind of heuristic for the cache size */
dcache = depCacheCreate(5001, rstrhash, strcmp,
(depCacheFreeKey)rfree, NULL);
confcache = conflictsCacheCreate(257, rstrhash, strcmp,
(depCacheFreeKey)rfree);
if (confcache) {
rpmdbIndexIterator ii = rpmdbIndexIteratorInit(rpmtsGetRdb(ts), RPMTAG_CONFLICTNAME);
if (ii) {
char *key;
size_t keylen;
while ((rpmdbIndexIteratorNext(ii, (const void**)&key, &keylen)) == 0) {
char *k;
if (!key || keylen == 0 || key[0] != '/')
continue;
k = rmalloc(keylen + 1);
memcpy(k, key, keylen);
k[keylen] = 0;
conflictsCacheAddEntry(confcache, k);
}
rpmdbIndexIteratorFree(ii);
}
}
/*
* Look at all of the added packages and make sure their dependencies
* are satisfied.
*/
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, TR_ADDED)) != NULL) {
rpmds provides = rpmdsInit(rpmteDS(p, RPMTAG_PROVIDENAME));
rpmlog(RPMLOG_DEBUG, "========== +++ %s %s/%s 0x%x\n",
rpmteNEVR(p), rpmteA(p), rpmteO(p), rpmteColor(p));
checkDS(ts, dcache, p, rpmteNEVRA(p), rpmteDS(p, RPMTAG_REQUIRENAME),
NULL, tscolor);
checkDS(ts, dcache, p, rpmteNEVRA(p), rpmteDS(p, RPMTAG_CONFLICTNAME),
NULL, tscolor);
checkDS(ts, dcache, p, rpmteNEVRA(p), rpmteDS(p, RPMTAG_OBSOLETENAME),
NULL, tscolor);
/* Check provides against conflicts in installed packages. */
while (rpmdsNext(provides) >= 0) {
checkInstDeps(ts, dcache, p, RPMTAG_CONFLICTNAME, rpmdsN(provides));
}
/* Skip obsoletion checks for source packages (ie build) */
if (rpmteIsSource(p))
continue;
/* Check package name (not provides!) against installed obsoletes */
checkInstDeps(ts, dcache, p, RPMTAG_OBSOLETENAME, rpmteN(p));
/* Check filenames against installed conflicts */
if (conflictsCacheNumKeys(confcache)) {
rpmfi fi = rpmfiInit(rpmteFI(p), 0);
while (rpmfiNext(fi) >= 0) {
const char *fn = rpmfiFN(fi);
if (!conflictsCacheHasEntry(confcache, fn))
continue;
checkInstDeps(ts, dcache, p, RPMTAG_CONFLICTNAME, fn);
}
}
}
rpmtsiFree(pi);
/*
* Look at the removed packages and make sure they aren't critical.
*/
pi = rpmtsiInit(ts);
while ((p = rpmtsiNext(pi, TR_REMOVED)) != NULL) {
rpmds provides = rpmdsInit(rpmteDS(p, RPMTAG_PROVIDENAME));
rpmfi fi = rpmfiInit(rpmteFI(p), 0);
rpmlog(RPMLOG_DEBUG, "========== --- %s %s/%s 0x%x\n",
rpmteNEVR(p), rpmteA(p), rpmteO(p), rpmteColor(p));
/* Check provides and filenames against installed dependencies. */
while (rpmdsNext(provides) >= 0) {
checkInstDeps(ts, dcache, p, RPMTAG_REQUIRENAME, rpmdsN(provides));
}
while (rpmfiNext(fi) >= 0) {
if (RPMFILE_IS_INSTALLED(rpmfiFState(fi)))
checkInstDeps(ts, dcache, p, RPMTAG_REQUIRENAME, rpmfiFN(fi));
}
}
rpmtsiFree(pi);
exit:
depCacheFree(dcache);
conflictsCacheFree(confcache);
(void) rpmswExit(rpmtsOp(ts, RPMTS_OP_CHECK), 0);
if (closeatexit)
(void) rpmtsCloseDB(ts);
return rc;
}
