static int isNewDep(rpmds *dsp, rpmds bds,
Header h, rpmTagVal indextag, uint32_t index)
{
int isnew = 1;
if (!indextag) {
/* With normal deps, we can just merge and see if anything got added */
isnew = (rpmdsMerge(dsp, bds) > 0);
} else {
struct rpmtd_s idx;
rpmds ads = *dsp;
headerGet(h, indextag, &idx, HEADERGET_MINMEM);
/* rpmdsFind/Merge() probably isn't realiable with triggers... */
rpmdsInit(ads);
while (isnew && rpmdsNext(ads) >= 0) {
if (!rstreq(rpmdsN(ads), rpmdsN(bds))) continue;
if (!rstreq(rpmdsEVR(ads), rpmdsEVR(bds))) continue;
if (rpmdsFlags(ads) != rpmdsFlags(bds)) continue;
if (indextag && rpmtdSetIndex(&idx, rpmdsIx(ads)) >= 0 &&
rpmtdGetNumber(&idx) != index) continue;
isnew = 0;
}
rpmtdFreeData(&idx);
rpmdsMerge(dsp, bds);
}
return isnew;
}
rpmRC rpmdsParseRichDep(rpmds dep, rpmds *leftds, rpmds *rightds, rpmrichOp *op, char **emsg)
{
rpmRC rc;
struct rpmdsParseRichDepData data;
const char *depstr = rpmdsN(dep);
memset(&data, 0, sizeof(data));
data.dep = dep;
data.op = RPMRICHOP_SINGLE;
data.depflags = rpmdsFlags(dep) & ~(RPMSENSE_SENSEMASK | RPMSENSE_RICH | RPMSENSE_MISSINGOK);
rc = rpmrichParse(&depstr, emsg, rpmdsParseRichDepCB, &data);
if (rc == RPMRC_OK && *depstr) {
if (emsg)
rasprintf(emsg, _("Junk after rich dependency"));
rc = RPMRC_FAIL;
}
if (rc != RPMRC_OK) {
rpmdsFree(data.leftds);
rpmdsFree(data.rightds);
} else {
*leftds = data.leftds;
*rightds = data.rightds;
*op = data.op;
}
return rc;
}
static int depnevrsTagFiltered(Header h, rpmtd td, headerGetFlags hgflags,
rpmTagVal tag, int strong)
{
rpmds ds = rpmdsNew(h, tag, 0);
int ndeps = rpmdsCount(ds);
if (ndeps > 0) {
char **deps = xmalloc(sizeof(*deps) * ndeps);
ndeps = 0;
while (rpmdsNext(ds) >= 0) {
if ((rpmdsFlags(ds) & RPMSENSE_STRONG) == (strong ? RPMSENSE_STRONG : 0))
deps[ndeps++] = rpmdsNewDNEVR(NULL, ds);
}
if (ndeps) {
td->data = deps;
td->type = RPM_STRING_ARRAY_TYPE;
td->count = ndeps;
td->flags |= (RPMTD_ALLOCED | RPMTD_PTR_ALLOCED);
} else {
_free(deps);
}
}
rpmdsFree(ds);
return (ndeps > 0);
}
static int
rpmts_SolveCallback(rpmts ts, rpmds ds, const void * data)
{
struct rpmtsCallbackType_s * cbInfo = (struct rpmtsCallbackType_s *) data;
PyObject * args, * result;
int res = 1;
if (cbInfo->tso == NULL) return res;
if (cbInfo->cb == Py_None) return res;
PyEval_RestoreThread(cbInfo->_save);
args = Py_BuildValue("(Oissi)", cbInfo->tso,
rpmdsTagN(ds), rpmdsN(ds), rpmdsEVR(ds), rpmdsFlags(ds));
result = PyEval_CallObject(cbInfo->cb, args);
Py_DECREF(args);
if (!result) {
die(cbInfo->cb);
} else {
if (PyInt_Check(result))
res = PyInt_AsLong(result);
Py_DECREF(result);
}
cbInfo->_save = PyEval_SaveThread();
return res;
}
static VALUE
rpmds_Flags_get(VALUE s)
{
rpmds ds = rpmds_ptr(s);
if (_debug)
fprintf(stderr, "==> %s(0x%lx) ptr %p\n", __FUNCTION__, s, ds);
return INT2FIX(rpmdsFlags(ds));
}
static int doFind(rpmds ds, const rpmds ods, unsigned int *he)
{
int comparison;
const char *N, *ON = rpmdsN(ods);
const char *EVR, *OEVR = rpmdsEVR(ods);
rpmsenseFlags Flags, OFlags = rpmdsFlags(ods);
int index, Oindex = rpmdsTi(ods);
int rc = -1; /* assume not found */
if (ds == NULL || ods == NULL)
return -1;
unsigned int l = 0;
unsigned int u = ds->Count;
while (l < u) {
ds->i = (l + u) / 2;
N = rpmdsN(ds);
EVR = rpmdsEVR(ds);
Flags = rpmdsFlags(ds);
index = rpmdsTi(ds);
comparison = strcmp(ON, N);
/* XXX rpm prior to 3.0.2 did not always supply EVR and Flags. */
if (comparison == 0 && OEVR && EVR)
comparison = strcmp(OEVR, EVR);
if (comparison == 0)
comparison = OFlags - Flags;
if (comparison == 0)
comparison = Oindex - index;
if (comparison < 0)
u = ds->i;
else if (comparison > 0)
l = ds->i + 1;
else {
rc = ds->i;
break;
}
}
if (he)
*he = u;
return rc;
}
void rpmtriggersPrepPostUnTransFileTrigs(rpmts ts, rpmte te)
{
rpmdbMatchIterator mi;
rpmdbIndexIterator ii;
Header trigH;
const void *key;
size_t keylen;
rpmfiles files;
rpmds rpmdsTriggers;
rpmds rpmdsTrigger;
int tix = 0;
ii = rpmdbIndexIteratorInit(rpmtsGetRdb(ts), RPMDBI_TRANSFILETRIGGERNAME);
mi = rpmdbNewIterator(rpmtsGetRdb(ts), RPMDBI_PACKAGES);
files = rpmteFiles(te);
/* Iterate over file triggers in rpmdb */
while ((rpmdbIndexIteratorNext(ii, &key, &keylen)) == 0) {
char pfx[keylen + 1];
memcpy(pfx, key, keylen);
pfx[keylen] = '\0';
/* Check if file trigger matches any file in this te */
rpmfi fi = rpmfilesFindPrefix(files, pfx);
if (rpmfiFC(fi) > 0) {
/* If yes then store it */
rpmdbAppendIterator(mi, rpmdbIndexIteratorPkgOffsets(ii),
rpmdbIndexIteratorNumPkgs(ii));
}
rpmfiFree(fi);
}
rpmdbIndexIteratorFree(ii);
if (rpmdbGetIteratorCount(mi)) {
/* Filter triggers and save only trans postun triggers into ts */
while((trigH = rpmdbNextIterator(mi)) != NULL) {
rpmdsTriggers = rpmdsNew(trigH, RPMTAG_TRANSFILETRIGGERNAME, 0);
while ((rpmdsTrigger = rpmdsFilterTi(rpmdsTriggers, tix))) {
if ((rpmdsNext(rpmdsTrigger) >= 0) &&
(rpmdsFlags(rpmdsTrigger) & RPMSENSE_TRIGGERPOSTUN)) {
struct rpmtd_s priorities;
headerGet(trigH, RPMTAG_TRANSFILETRIGGERPRIORITIES,
&priorities, HEADERGET_MINMEM);
rpmtdSetIndex(&priorities, tix);
rpmtriggersAdd(ts->trigs2run, rpmdbGetIteratorOffset(mi),
tix, *rpmtdGetUint32(&priorities));
}
rpmdsFree(rpmdsTrigger);
tix++;
}
rpmdsFree(rpmdsTriggers);
}
}
rpmdbFreeIterator(mi);
}
rpmds rpmdsCurrent(rpmds ds)
{
rpmds cds = NULL;
int ti = -1;
if (ds != NULL && ds->i >= 0 && ds->i < ds->Count) {
if (ds->ti)
ti = ds->ti[ds->i];
/* Using parent's pool so we can just use the same id's */
cds = singleDSPool(ds->pool, ds->tagN, ds->N[ds->i], ds->EVR[ds->i],
rpmdsFlags(ds), ds->instance, rpmdsColor(ds), ti);
}
return cds;
}
char * rpmdsNewDNEVR(const char * dspfx, const rpmds ds)
{
const char * N = rpmdsN(ds);
const char * EVR = rpmdsEVR(ds);
rpmsenseFlags Flags = rpmdsFlags(ds);
char * tbuf, * t;
size_t nb;
nb = 0;
if (dspfx) nb += strlen(dspfx) + 1;
if (N) nb += strlen(N);
/* XXX rpm prior to 3.0.2 did not always supply EVR and Flags. */
if (Flags & RPMSENSE_SENSEMASK) {
if (nb) nb++;
if (Flags & RPMSENSE_LESS) nb++;
if (Flags & RPMSENSE_GREATER) nb++;
if (Flags & RPMSENSE_EQUAL) nb++;
}
/* XXX rpm prior to 3.0.2 did not always supply EVR and Flags. */
if (EVR && *EVR) {
if (nb) nb++;
nb += strlen(EVR);
}
t = tbuf = xmalloc(nb + 1);
if (dspfx) {
t = stpcpy(t, dspfx);
*t++ = ' ';
}
if (N)
t = stpcpy(t, N);
/* XXX rpm prior to 3.0.2 did not always supply EVR and Flags. */
if (Flags & RPMSENSE_SENSEMASK) {
if (t != tbuf) *t++ = ' ';
if (Flags & RPMSENSE_LESS) *t++ = '<';
if (Flags & RPMSENSE_GREATER) *t++ = '>';
if (Flags & RPMSENSE_EQUAL) *t++ = '=';
}
/* XXX rpm prior to 3.0.2 did not always supply EVR and Flags. */
if (EVR && *EVR) {
if (t != tbuf) *t++ = ' ';
t = stpcpy(t, EVR);
}
*t = '\0';
return tbuf;
}
static matchFilesIter matchDBFilesIterator(rpmds trigger, rpmts ts,
int inTransaction)
{
matchFilesIter mfi = xcalloc(1, sizeof(*mfi));
rpmsenseFlags sense;
rpmdsSetIx(trigger, 0);
sense = rpmdsFlags(trigger);
rpmdsInit(trigger);
mfi->rpmdsTrigger = trigger;
mfi->ts = ts;
/* If inTransaction is set then filter out packages that aren't in transaction */
if (inTransaction) {
if (sense & RPMSENSE_TRIGGERIN)
mfi->tranPkgs = ts->members->installedPackages;
else
mfi->tranPkgs = ts->members->removedPackages;
}
return mfi;
}
int rpmdsPutToHeader(rpmds ds, Header h)
{
rpmTagVal tagN = rpmdsTagN(ds);
rpmTagVal tagEVR = rpmdsTagEVR(ds);
rpmTagVal tagF = rpmdsTagF(ds);
rpmTagVal tagTi = rpmdsTagTi(ds);
if (!tagN)
return -1;
rpmds pi = rpmdsInit(ds);
while (rpmdsNext(pi) >= 0) {
rpmsenseFlags flags = rpmdsFlags(pi);
uint32_t index = rpmdsTi(pi);
headerPutString(h, tagN, rpmdsN(pi));
headerPutString(h, tagEVR, rpmdsEVR(pi));
headerPutUint32(h, tagF, &flags, 1);
if (tagTi != RPMTAG_NOT_FOUND) {
headerPutUint32(h, tagTi, &index, 1);
}
}
return 0;
}
static void rpmalAddProvides(rpmal al, rpmalNum pkgNum, rpmds provides)
{
struct availableIndexEntry_s indexEntry;
rpm_color_t dscolor;
int skipconf = (al->tsflags & RPMTRANS_FLAG_NOCONFIGS);
indexEntry.pkgNum = pkgNum;
if (rpmdsInit(provides) != NULL)
while (rpmdsNext(provides) >= 0) {
/* Ignore colored provides not in our rainbow. */
dscolor = rpmdsColor(provides);
if (al->tscolor && dscolor && !(al->tscolor & dscolor))
continue;
/* Ignore config() provides if the files wont be installed */
if (skipconf & (rpmdsFlags(provides) & RPMSENSE_CONFIG))
continue;
indexEntry.entryIx = rpmdsIx(provides);
rpmalProvidesHashAddEntry(al->providesHash, rpmdsN(provides), indexEntry);
}
}
static int rpmlibDeps(Header h)
{
rpmds req = rpmdsInit(rpmdsNew(h, RPMTAG_REQUIRENAME, 0));
rpmds rpmlib = NULL;
rpmdsRpmlib(&rpmlib, NULL);
int rc = 1;
char *nvr = NULL;
while (rpmdsNext(req) >= 0) {
if (!(rpmdsFlags(req) & RPMSENSE_RPMLIB))
continue;
if (rpmdsSearch(rpmlib, req) < 0) {
if (!nvr) {
nvr = headerGetAsString(h, RPMTAG_NEVRA);
rpmlog(RPMLOG_ERR, _("Missing rpmlib features for %s:\n"), nvr);
}
rpmlog(RPMLOG_ERR, "\t%s\n", rpmdsDNEVR(req)+2);
rc = 0;
}
}
rpmdsFree(req);
rpmdsFree(rpmlib);
free(nvr);
return rc;
}
int rpmdsMerge(rpmds * dsp, rpmds ods)
{
rpmds ds;
int save;
int ocount;
if (dsp == NULL || ods == NULL)
return -1;
ocount = rpmdsCount(*dsp);
/* If not initialized yet, dup the 1st entry. */
if (*dsp == NULL) {
save = ods->Count;
ods->Count = 1;
*dsp = rpmdsDup(ods);
ods->Count = save;
}
ds = *dsp;
if (ds == NULL)
return -1;
/* Ensure EVR and Flags exist */
if (ds->EVR == NULL)
ds->EVR = xcalloc(ds->Count, sizeof(*ds->EVR));
if (ds->Flags == NULL)
ds->Flags = xcalloc(ds->Count, sizeof(*ds->Flags));
if (ds->ti == NULL && ods->ti) {
int i;
ds->ti = xcalloc(ds->Count, sizeof(*ds->ti));
for (i = 0; i < ds->Count; i++)
ds->ti[i] = -1;
}
/*
* Add new entries.
*/
save = ods->i;
ods = rpmdsInit(ods);
while (rpmdsNext(ods) >= 0) {
const char *OEVR;
unsigned int u;
/*
* If this entry is already present, don't bother.
*/
if (doFind(ds, ods, &u) >= 0)
continue;
/*
* Insert new entry. Ensure pool is unfrozen to allow additions.
*/
rpmstrPoolUnfreeze(ds->pool);
ds->N = xrealloc(ds->N, (ds->Count+1) * sizeof(*ds->N));
if (u < ds->Count) {
memmove(ds->N + u + 1, ds->N + u,
(ds->Count - u) * sizeof(*ds->N));
}
ds->N[u] = rpmstrPoolId(ds->pool, rpmdsN(ods), 1);
ds->EVR = xrealloc(ds->EVR, (ds->Count+1) * sizeof(*ds->EVR));
if (u < ds->Count) {
memmove(ds->EVR + u + 1, ds->EVR + u,
(ds->Count - u) * sizeof(*ds->EVR));
}
OEVR = rpmdsEVR(ods);
ds->EVR[u] = rpmstrPoolId(ds->pool, OEVR ? OEVR : "", 1);
ds->Flags = xrealloc(ds->Flags, (ds->Count+1) * sizeof(*ds->Flags));
if (u < ds->Count) {
memmove(ds->Flags + u + 1, ds->Flags + u,
(ds->Count - u) * sizeof(*ds->Flags));
}
ds->Flags[u] = rpmdsFlags(ods);
if (ds->ti || ods->ti) {
ds->ti = xrealloc(ds->ti, (ds->Count+1) * sizeof(*ds->ti));
if (u < ds->Count) {
memmove(ds->ti + u + 1, ds->ti + u,
(ds->Count - u) * sizeof(*ds->ti));
}
ds->ti[u] = rpmdsTi(ods);
}
ds->i = ds->Count;
ds->Count++;
}
ods->i = save;
return (ds->Count - ocount);
}
/**
* Check dep for an unsatisfied dependency.
* @param ts transaction set
* @param dep dependency
* @return 0 if satisfied, 1 if not satisfied
*/
static int unsatisfiedDepend(rpmts ts, depCache dcache, rpmds dep)
{
tsMembers tsmem = rpmtsMembers(ts);
int rc;
int retrying = 0;
int adding = (rpmdsInstance(dep) == 0);
rpmsenseFlags dsflags = rpmdsFlags(dep);
retry:
rc = 0; /* assume dependency is satisfied */
/*
* New features in rpm packaging implicitly add versioned dependencies
* on rpmlib provides. The dependencies look like "rpmlib(YaddaYadda)".
* Check those dependencies now.
*/
if (dsflags & RPMSENSE_RPMLIB) {
if (tsmem->rpmlib == NULL)
rpmdsRpmlibPool(rpmtsPool(ts), &(tsmem->rpmlib), NULL);
if (tsmem->rpmlib != NULL && rpmdsSearch(tsmem->rpmlib, dep) >= 0) {
rpmdsNotify(dep, "(rpmlib provides)", rc);
goto exit;
}
goto unsatisfied;
}
/* Dont look at pre-requisites of already installed packages */
if (!adding && isInstallPreReq(dsflags) && !isErasePreReq(dsflags))
goto exit;
/* Pretrans dependencies can't be satisfied by added packages. */
if (!(dsflags & RPMSENSE_PRETRANS)) {
rpmte *matches = rpmalAllSatisfiesDepend(tsmem->addedPackages, dep);
int match = 0;
/*
* Handle definitive matches within the added package set.
* Self-obsoletes and -conflicts fall through here as we need to
* check for possible other matches in the rpmdb.
*/
for (rpmte *m = matches; m && *m; m++) {
rpmTagVal dtag = rpmdsTagN(dep);
/* Requires match, look no further */
if (dtag == RPMTAG_REQUIRENAME) {
match = 1;
break;
}
/* Conflicts/obsoletes match on another package, look no further */
if (rpmteDS(*m, dtag) != dep) {
match = 1;
break;
}
}
free(matches);
if (match)
goto exit;
}
/* See if the rpmdb provides it */
if (rpmdbProvides(ts, dcache, dep) == 0)
goto exit;
/* Search for an unsatisfied dependency. */
if (adding && !retrying && !(dsflags & RPMSENSE_PRETRANS)) {
int xx = rpmtsSolve(ts, dep);
if (xx == 0)
goto exit;
if (xx == -1) {
retrying = 1;
goto retry;
}
}
unsatisfied:
if (dsflags & RPMSENSE_MISSINGOK) {
/* note the result, but missingok deps are never unsatisfied */
rpmdsNotify(dep, "(missingok)", 1);
} else {
/* dependency is unsatisfied */
rc = 1;
rpmdsNotify(dep, NULL, rc);
}
exit:
return rc;
}
/**
* Execute triggers.
* @todo Trigger on any provides, not just package NVR.
* @param ts transaction set
* @param te transaction element
* @param sense trigger type
* @param sourceH header of trigger source
* @param trigH header of triggered package
* @param arg2
* @param triggersAlreadyRun
* @return
*/
static rpmRC handleOneTrigger(rpmts ts, rpmte te, rpmsenseFlags sense,
Header sourceH, Header trigH, int countCorrection,
int arg2, unsigned char * triggersAlreadyRun)
{
rpmds trigger = rpmdsInit(rpmdsNew(trigH, RPMTAG_TRIGGERNAME, 0));
struct rpmtd_s pfx;
const char * sourceName = headerGetString(sourceH, RPMTAG_NAME);
const char * triggerName = headerGetString(trigH, RPMTAG_NAME);
rpmRC rc = RPMRC_OK;
int i;
if (trigger == NULL)
return rc;
headerGet(trigH, RPMTAG_INSTPREFIXES, &pfx, HEADERGET_ALLOC|HEADERGET_ARGV);
(void) rpmdsSetNoPromote(trigger, 1);
while ((i = rpmdsNext(trigger)) >= 0) {
uint32_t tix;
if (!(rpmdsFlags(trigger) & sense))
continue;
if (!rstreq(rpmdsN(trigger), sourceName))
continue;
/* XXX Trigger on any provided dependency, not just the package NEVR */
if (!rpmdsAnyMatchesDep(sourceH, trigger, 1))
continue;
tix = rpmdsTi(trigger);
if (triggersAlreadyRun == NULL || triggersAlreadyRun[tix] == 0) {
int arg1 = rpmdbCountPackages(rpmtsGetRdb(ts), triggerName);
if (arg1 < 0) {
/* XXX W2DO? fails as "execution of script failed" */
rc = RPMRC_FAIL;
} else {
rpmScript script = rpmScriptFromTriggerTag(trigH,
triggertag(sense), tix);
arg1 += countCorrection;
rc = runScript(ts, te, pfx.data, script, arg1, arg2);
if (triggersAlreadyRun != NULL)
triggersAlreadyRun[tix] = 1;
rpmScriptFree(script);
}
}
/*
* Each target/source header pair can only result in a single
* script being run.
*/
break;
}
rpmtdFreeData(&pfx);
rpmdsFree(trigger);
return rc;
}
/*
* Run all file triggers in header h
* @param searchMode 0 match trigger prefixes against files in te
* 1 match trigger prefixes against files in whole ts
* 2 match trigger prefixes against files in whole
* rpmdb
*/
static int runHandleTriggersInPkg(rpmts ts, rpmte te, Header h,
rpmsenseFlags sense, rpmscriptTriggerModes tm,
int searchMode, int ti)
{
int nerrors = 0;
rpmds rpmdsTriggers, rpmdsTrigger;
rpmfiles files = NULL;
matchFilesIter mfi = NULL;
rpmScript script;
struct rpmtd_s installPrefixes;
char *(*inputFunc)(void *);
rpmdsTriggers = rpmdsNew(h, triggerDsTag(tm), 0);
rpmdsTrigger = rpmdsFilterTi(rpmdsTriggers, ti);
/*
* Now rpmdsTrigger contains all dependencies belonging to one trigger
* with trigger index tix. Have a look at the first one to check flags.
*/
if ((rpmdsNext(rpmdsTrigger) >= 0) &&
(rpmdsFlags(rpmdsTrigger) & sense)) {
switch (searchMode) {
case 0:
/* Create iterator over files in te that this trigger matches */
files = rpmteFiles(te);
mfi = matchFilesIterator(rpmdsTrigger, files);
break;
case 1:
/* Create iterator over files in ts that this trigger matches */
mfi = matchDBFilesIterator(rpmdsTrigger, ts, 1);
break;
case 2:
/* Create iterator over files in whole rpmd that this trigger matches */
mfi = matchDBFilesIterator(rpmdsTrigger, ts, 0);
break;
}
/* If this trigger matches any file then run trigger script */
if (!matchFilesEmpty(mfi)) {
script = rpmScriptFromTriggerTag(h, triggertag(sense), tm, ti);
headerGet(h, RPMTAG_INSTPREFIXES, &installPrefixes,
HEADERGET_ALLOC|HEADERGET_ARGV);
/*
* As input function set function to get next file from
* matching file iterator. As parameter for this function
* set matching file iterator. Input function will be called
* during execution of trigger script in order to get data
* that will be passed as stdin to trigger script. To get
* these data from lua script function rpm.input() can be used.
*/
inputFunc = (char *(*)(void *)) matchFilesNext;
rpmScriptSetNextFileFunc(script, inputFunc, mfi);
nerrors += runScript(ts, te, installPrefixes.data,
script, 0, 0);
rpmtdFreeData(&installPrefixes);
rpmScriptFree(script);
}
rpmfilesFree(files);
matchFilesIteratorFree(mfi);
}
rpmdsFree(rpmdsTrigger);
rpmdsFree(rpmdsTriggers);
return nerrors;
}
/**
* Check dep for an unsatisfied dependency.
* @param ts transaction set
* @param dcache dependency cache
* @param dep dependency
* @return 0 if satisfied, 1 if not satisfied
*/
static int unsatisfiedDepend(rpmts ts, depCache dcache, rpmds dep)
{
tsMembers tsmem = rpmtsMembers(ts);
int rc;
int retrying = 0;
int adding = (rpmdsInstance(dep) == 0);
rpmsenseFlags dsflags = rpmdsFlags(dep);
retry:
rc = 0; /* assume dependency is satisfied */
/*
* New features in rpm packaging implicitly add versioned dependencies
* on rpmlib provides. The dependencies look like "rpmlib(YaddaYadda)".
* Check those dependencies now.
*/
if (dsflags & RPMSENSE_RPMLIB) {
if (tsmem->rpmlib == NULL)
rpmdsRpmlibPool(rpmtsPool(ts), &(tsmem->rpmlib), NULL);
if (tsmem->rpmlib != NULL && rpmdsSearch(tsmem->rpmlib, dep) >= 0) {
rpmdsNotify(dep, "(rpmlib provides)", rc);
goto exit;
}
goto unsatisfied;
}
/* Dont look at pre-requisites of already installed packages */
if (!adding && isInstallPreReq(dsflags) && !isErasePreReq(dsflags))
goto exit;
/* Handle rich dependencies */
if (rpmdsIsRich(dep)) {
rpmds ds1, ds2;
rpmrichOp op;
char *emsg = 0;
if (rpmdsParseRichDep(dep, &ds1, &ds2, &op, &emsg) != RPMRC_OK) {
rc = rpmdsTagN(dep) == RPMTAG_CONFLICTNAME ? 0 : 1;
if (rpmdsInstance(dep) != 0)
rc = !rc; /* ignore errors for installed packages */
rpmdsNotify(dep, emsg ? emsg : "(parse error)", rc);
_free(emsg);
goto exit;
}
if (op == RPMRICHOP_IF) {
if (rpmdsIsRich(ds2)) {
/* check if this is a IF...ELSE combination */
rpmds ds21 = NULL, ds22 = NULL;
rpmrichOp op2;
if (rpmdsParseRichDep(ds2, &ds21, &ds22, &op2, NULL) == RPMRC_OK && op2 == RPMRICHOP_ELSE) {
rc = unsatisfiedDepend(ts, dcache, ds21);
if (rc) {
rpmdsFree(ds1);
ds1 = ds22;
ds22 = NULL;
}
rc = 1;
}
rpmdsFree(ds21);
rpmdsFree(ds22);
}
if (!rc)
rc = !unsatisfiedDepend(ts, dcache, ds2);
}
if (op != RPMRICHOP_IF || rc)
rc = unsatisfiedDepend(ts, dcache, ds1);
if ((rc && op == RPMRICHOP_OR) || (!rc && op == RPMRICHOP_AND))
rc = unsatisfiedDepend(ts, dcache, ds2);
ds1 = rpmdsFree(ds1);
ds2 = rpmdsFree(ds2);
rpmdsNotify(dep, "(rich)", rc);
goto exit;
}
/* Pretrans dependencies can't be satisfied by added packages. */
if (!(dsflags & RPMSENSE_PRETRANS)) {
rpmte *matches = rpmalAllSatisfiesDepend(tsmem->addedPackages, dep);
int match = matches && *matches;
_free(matches);
if (match)
goto exit;
}
/* See if the rpmdb provides it */
if (rpmdbProvides(ts, dcache, dep) == 0)
goto exit;
/* Search for an unsatisfied dependency. */
if (adding && !retrying && !(dsflags & RPMSENSE_PRETRANS)) {
int xx = rpmtsSolve(ts, dep);
if (xx == 0)
goto exit;
if (xx == -1) {
retrying = 1;
goto retry;
}
}
unsatisfied:
if (dsflags & RPMSENSE_MISSINGOK) {
/* note the result, but missingok deps are never unsatisfied */
rpmdsNotify(dep, "(missingok)", 1);
} else {
/* dependency is unsatisfied */
rc = 1;
rpmdsNotify(dep, NULL, rc);
}
exit:
return rc;
}
/* Cached rpmdb provide lookup, returns 0 if satisfied, 1 otherwise */
static int rpmdbProvides(rpmts ts, depCache dcache, rpmds dep)
{
const char * Name = rpmdsN(dep);
const char * DNEVR = rpmdsDNEVR(dep);
rpmTagVal deptag = rpmdsTagN(dep);
int *cachedrc = NULL;
rpmdbMatchIterator mi = NULL;
Header h = NULL;
int rc = 0;
/* pretrans deps are provided by current packages, don't prune erasures */
int prune = (rpmdsFlags(dep) & RPMSENSE_PRETRANS) ? 0 : 1;
unsigned int keyhash = 0;
/* See if we already looked this up */
if (prune) {
keyhash = depCacheKeyHash(dcache, DNEVR);
if (depCacheGetHEntry(dcache, DNEVR, keyhash, &cachedrc, NULL, NULL)) {
rc = *cachedrc;
rpmdsNotify(dep, "(cached)", rc);
return rc;
}
}
/*
* See if a filename dependency is a real file in some package,
* taking file state into account: replaced, wrong colored and
* not installed files can not satisfy a dependency.
*/
if (deptag != RPMTAG_OBSOLETENAME && Name[0] == '/') {
mi = rpmtsPrunedIterator(ts, RPMDBI_INSTFILENAMES, Name, prune);
while ((h = rpmdbNextIterator(mi)) != NULL) {
/* Ignore self-conflicts */
if (deptag == RPMTAG_CONFLICTNAME) {
unsigned int instance = headerGetInstance(h);
if (instance && instance == rpmdsInstance(dep))
continue;
}
rpmdsNotify(dep, "(db files)", rc);
break;
}
rpmdbFreeIterator(mi);
}
/* Otherwise look in provides no matter what the dependency looks like */
if (h == NULL) {
rpmstrPool tspool = rpmtsPool(ts);
/* Obsoletes use just name alone, everything else uses provides */
rpmTagVal dbtag = RPMDBI_PROVIDENAME;
int selfevr = 0;
if (deptag == RPMTAG_OBSOLETENAME) {
dbtag = RPMDBI_NAME;
selfevr = 1;
}
mi = rpmtsPrunedIterator(ts, dbtag, Name, prune);
while ((h = rpmdbNextIterator(mi)) != NULL) {
/* Provide-indexes can't be used with nevr-only matching */
int prix = (selfevr) ? -1 : rpmdbGetIteratorFileNum(mi);
int match = rpmdsMatches(tspool, h, prix, dep, selfevr,
_rpmds_nopromote);
/* Ignore self-obsoletes and self-conflicts */
if (match && (deptag == RPMTAG_OBSOLETENAME || deptag == RPMTAG_CONFLICTNAME)) {
unsigned int instance = headerGetInstance(h);
if (instance && instance == rpmdsInstance(dep))
match = 0;
}
if (match) {
rpmdsNotify(dep, "(db provides)", rc);
break;
}
}
rpmdbFreeIterator(mi);
}
rc = (h != NULL) ? 0 : 1;
/* Cache the relatively expensive rpmdb lookup results */
/* Caching the oddball non-pruned case would mess up other results */
if (prune)
depCacheAddHEntry(dcache, xstrdup(DNEVR), keyhash, rc);
return rc;
}
static PyObject *
rpmdsDep_Flags(rpmdsDepObject * s)
{
return Py_BuildValue("i", rpmdsFlags(s->ds));
}
rpmRC parseRCPOT(rpmSpec spec, Package pkg, const char *field, rpmTagVal tagN,
int index, rpmsenseFlags tagflags)
{
const char *r, *re, *v, *ve;
char *emsg = NULL;
char * N = NULL, * EVR = NULL;
rpmTagVal nametag = RPMTAG_NOT_FOUND;
rpmsenseFlags Flags;
rpmds *pdsp = NULL;
rpmRC rc = RPMRC_FAIL; /* assume failure */
switch (tagN) {
default:
case RPMTAG_REQUIREFLAGS:
nametag = RPMTAG_REQUIRENAME;
tagflags |= RPMSENSE_ANY;
break;
case RPMTAG_RECOMMENDFLAGS:
nametag = RPMTAG_RECOMMENDNAME;
break;
case RPMTAG_SUGGESTFLAGS:
nametag = RPMTAG_SUGGESTNAME;
break;
case RPMTAG_SUPPLEMENTFLAGS:
nametag = RPMTAG_SUPPLEMENTNAME;
break;
case RPMTAG_ENHANCEFLAGS:
nametag = RPMTAG_ENHANCENAME;
break;
case RPMTAG_PROVIDEFLAGS:
nametag = RPMTAG_PROVIDENAME;
break;
case RPMTAG_OBSOLETEFLAGS:
nametag = RPMTAG_OBSOLETENAME;
break;
case RPMTAG_CONFLICTFLAGS:
nametag = RPMTAG_CONFLICTNAME;
break;
case RPMTAG_ORDERFLAGS:
nametag = RPMTAG_ORDERNAME;
break;
case RPMTAG_PREREQ:
/* XXX map legacy PreReq into Requires(pre,preun) */
nametag = RPMTAG_REQUIRENAME;
tagflags |= (RPMSENSE_SCRIPT_PRE|RPMSENSE_SCRIPT_PREUN);
break;
case RPMTAG_TRIGGERPREIN:
nametag = RPMTAG_TRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERPREIN;
break;
case RPMTAG_TRIGGERIN:
nametag = RPMTAG_TRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERIN;
break;
case RPMTAG_TRIGGERPOSTUN:
nametag = RPMTAG_TRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERPOSTUN;
break;
case RPMTAG_TRIGGERUN:
nametag = RPMTAG_TRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERUN;
break;
case RPMTAG_BUILDPREREQ:
case RPMTAG_BUILDREQUIRES:
nametag = RPMTAG_REQUIRENAME;
tagflags |= RPMSENSE_ANY;
break;
case RPMTAG_BUILDCONFLICTS:
nametag = RPMTAG_CONFLICTNAME;
break;
case RPMTAG_FILETRIGGERIN:
nametag = RPMTAG_FILETRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERIN;
break;
case RPMTAG_FILETRIGGERUN:
nametag = RPMTAG_FILETRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERUN;
break;
case RPMTAG_FILETRIGGERPOSTUN:
nametag = RPMTAG_FILETRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERPOSTUN;
break;
case RPMTAG_TRANSFILETRIGGERIN:
nametag = RPMTAG_TRANSFILETRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERIN;
break;
case RPMTAG_TRANSFILETRIGGERUN:
nametag = RPMTAG_TRANSFILETRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERUN;
break;
case RPMTAG_TRANSFILETRIGGERPOSTUN:
nametag = RPMTAG_TRANSFILETRIGGERNAME;
tagflags |= RPMSENSE_TRIGGERPOSTUN;
break;
}
for (r = field; *r != '\0'; r = re) {
SKIPWHITE(r);
if (*r == '\0')
break;
Flags = (tagflags & ~RPMSENSE_SENSEMASK);
if (r[0] == '(') {
struct parseRCPOTRichData data;
if (nametag != RPMTAG_REQUIRENAME && nametag != RPMTAG_CONFLICTNAME &&
nametag != RPMTAG_RECOMMENDNAME && nametag != RPMTAG_SUPPLEMENTNAME &&
nametag != RPMTAG_SUGGESTNAME && nametag != RPMTAG_ENHANCENAME) {
rasprintf(&emsg, _("No rich dependencies allowed for this type"));
goto exit;
}
data.spec = spec;
data.sb = newStringBuf();
if (rpmrichParse(&r, &emsg, parseRCPOTRichCB, &data) != RPMRC_OK) {
freeStringBuf(data.sb);
goto exit;
}
if (addReqProv(pkg, nametag, getStringBuf(data.sb), NULL, Flags | RPMSENSE_RICH, index)) {
rasprintf(&emsg, _("invalid dependency"));
freeStringBuf(data.sb);
goto exit;
}
freeStringBuf(data.sb);
re = r;
continue;
}
re = r;
SKIPNONWHITE(re);
N = xmalloc((re-r) + 1);
rstrlcpy(N, r, (re-r) + 1);
/* Parse EVR */
EVR = NULL;
v = re;
SKIPWHITE(v);
ve = v;
SKIPNONWHITE(ve);
re = v; /* ==> next token (if no EVR found) starts here */
/* Check for possible logical operator */
if (ve > v) {
rpmsenseFlags sense = rpmParseDSFlags(v, ve - v);
if (sense) {
Flags |= sense;
/* now parse EVR */
v = ve;
SKIPWHITE(v);
ve = v;
SKIPNONWHITE(ve);
if (*v == '\0' || ve == v) {
rasprintf(&emsg, _("Version required"));
goto exit;
}
EVR = xmalloc((ve-v) + 1);
rstrlcpy(EVR, v, (ve-v) + 1);
re = ve; /* ==> next token after EVR string starts here */
}
}
/* check that dependency is well-formed */
if (checkDep(spec, N, EVR, &emsg))
goto exit;
if (nametag == RPMTAG_FILETRIGGERNAME ||
nametag == RPMTAG_TRANSFILETRIGGERNAME) {
if (N[0] != '/') {
rasprintf(&emsg, _("Only absolute paths are allowed in "
"file triggers"));
}
}
/* Deny more "normal" triggers fired by the same pakage. File triggers are ok */
pdsp = packageDependencies(pkg, nametag);
rpmdsInit(*pdsp);
if (nametag == RPMTAG_TRIGGERNAME) {
while (rpmdsNext(*pdsp) >= 0) {
if (rstreq(rpmdsN(*pdsp), N) && ((rpmdsFlags(*pdsp) & tagflags))) {
rasprintf(&emsg, _("Trigger fired by the same package "
"is already defined in spec file"));
goto exit;
}
}
}
if (addReqProv(pkg, nametag, N, EVR, Flags, index)) {
rasprintf(&emsg, _("invalid dependency"));
goto exit;
}
N = _free(N);
EVR = _free(EVR);
}
rc = RPMRC_OK;
exit:
if (emsg) {
int lvl = (rc == RPMRC_OK) ? RPMLOG_WARNING : RPMLOG_ERR;
/* Automatic dependencies don't relate to spec lines */
if (tagflags & (RPMSENSE_FIND_REQUIRES|RPMSENSE_FIND_PROVIDES)) {
rpmlog(lvl, "%s: %s\n", emsg, r);
} else {
rpmlog(lvl, _("line %d: %s: %s\n"),
spec->lineNum, emsg, spec->line);
}
free(emsg);
}
_free(N);
_free(EVR);
return rc;
}