lib/depends.c

Go to the documentation of this file.

#include "system.h"

#include "rpmio_internal.h"     /* XXX PGPHASHALGO_MD5 */
#include <rpmcli.h>             /* XXX rpmcliPackagesTotal */

#include <rpmmacro.h>           /* XXX rpmExpand("%{_dependency_whiteout}" */
#include <envvar.h>
#include <ugid.h>               /* XXX user()/group() probes */

#define _RPMDB_INTERNAL         /* XXX response cache needs dbiOpen et al. */
#include "rpmdb.h"

#define _RPMEVR_INTERNAL
#include "rpmds.h"
#include "rpmfi.h"

#define _RPMTE_INTERNAL
#include "rpmte.h"

#define _RPMTS_INTERNAL
#include "rpmts.h"

#include "debug.h"

/*@access tsortInfo @*/
/*@access rpmte @*/             /* XXX for install <-> erase associate. */
/*@access rpmts @*/
/*@access rpmDiskSpaceInfo @*/

/*@access alKey @*/     /* XXX for reordering and RPMAL_NOMATCH assign */

typedef /*@abstract@*/ struct orderListIndex_s *        orderListIndex;
/*@access orderListIndex@*/

struct orderListIndex_s {
/*@dependent@*/
    alKey pkgKey;
    int orIndex;
};

/*@unchecked@*/
int _cacheDependsRC = 1;

/*@observer@*/ /*@unchecked@*/
const char *rpmNAME = PACKAGE;

/*@observer@*/ /*@unchecked@*/
const char *rpmEVR = VERSION;

/*@unchecked@*/
int rpmFLAGS = RPMSENSE_EQUAL;

static int intcmp(const void * a, const void * b)
        /*@requires maxRead(a) == 0 /\ maxRead(b) == 0 @*/
{
    const int * aptr = a;
    const int * bptr = b;
    int rc = (*aptr - *bptr);
    return rc;
}

static int removePackage(rpmts ts, Header h, int dboffset,
                /*@null@*/ int * indexp,
                /*@exposed@*/ /*@dependent@*/ /*@null@*/ alKey depends)
        /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/
        /*@modifies ts, h, *indexp, rpmGlobalMacroContext, fileSystem, internalState @*/
{
    rpmte p;

    /* Filter out duplicate erasures. */
    if (ts->numRemovedPackages > 0 && ts->removedPackages != NULL) {
        int * needle = NULL;
/*@-boundswrite@*/
        needle = bsearch(&dboffset, ts->removedPackages, ts->numRemovedPackages,
                        sizeof(*ts->removedPackages), intcmp);
        if (needle != NULL) {
            /* XXX lastx should be per-call, not per-ts. */
            if (indexp != NULL)
                *indexp = needle - ts->removedPackages;
            return 0;
        }
/*@=boundswrite@*/
    }

    if (ts->numRemovedPackages == ts->allocedRemovedPackages) {
        ts->allocedRemovedPackages += ts->delta;
        ts->removedPackages = xrealloc(ts->removedPackages,
                sizeof(ts->removedPackages) * ts->allocedRemovedPackages);
    }

    if (ts->removedPackages != NULL) {  /* XXX can't happen. */
/*@-boundswrite@*/
        ts->removedPackages[ts->numRemovedPackages] = dboffset;
        ts->numRemovedPackages++;
/*@=boundswrite@*/
        if (ts->numRemovedPackages > 1)
            qsort(ts->removedPackages, ts->numRemovedPackages,
                        sizeof(*ts->removedPackages), intcmp);
    }

    if (ts->orderCount >= ts->orderAlloced) {
        ts->orderAlloced += (ts->orderCount - ts->orderAlloced) + ts->delta;
/*@-type +voidabstract @*/
        ts->order = xrealloc(ts->order, sizeof(*ts->order) * ts->orderAlloced);
/*@=type =voidabstract @*/
    }

    p = rpmteNew(ts, h, TR_REMOVED, NULL, NULL, dboffset, depends);
/*@-boundswrite@*/
    ts->order[ts->orderCount] = p;
    if (indexp != NULL)
        *indexp = ts->orderCount;
    ts->orderCount++;
/*@=boundswrite@*/

/*@-nullstate@*/        /* XXX FIX: ts->order[] can be NULL. */
   return 0;
/*@=nullstate@*/
}

static int rpmHeadersIdentical(Header first, Header second)
        /*@*/
{
    const char * one, * two;
    rpmds A, B;
    int rc;

    if (!headerGetEntry(first, RPMTAG_HDRID, NULL, (void **) &one, NULL))
        one = NULL;
    if (!headerGetEntry(second, RPMTAG_HDRID, NULL, (void **) &two, NULL))
        two = NULL;

    if (one && two)
        return ((strcmp(one, two) == 0) ? 1 : 0);
    if (one && !two)
        return 0;
    if (!one && two)
        return 0;
    /* XXX Headers w/o digests case devolves to NEVR comparison. */
    A = rpmdsThis(first, RPMTAG_REQUIRENAME, RPMSENSE_EQUAL);
    B = rpmdsThis(second, RPMTAG_REQUIRENAME, RPMSENSE_EQUAL);
    rc = rpmdsCompare(A, B);
    A = rpmdsFree(A);
    B = rpmdsFree(B);
    return rc;
}

int rpmtsAddInstallElement(rpmts ts, Header h,
                        fnpyKey key, int upgrade, rpmRelocation relocs)
{
    rpmdepFlags depFlags = rpmtsDFlags(ts);
    uint_32 tscolor = rpmtsColor(ts);
    uint_32 dscolor;
    uint_32 hcolor;
    rpmdbMatchIterator mi;
    Header oh;
    uint_32 ohcolor;
    int isSource;
    int duplicate = 0;
    rpmtsi pi = NULL; rpmte p;
    HGE_t hge = (HGE_t)headerGetEntryMinMemory;
    const char * arch;
    const char * os;
    rpmds oldChk, newChk;
    rpmds obsoletes;
    alKey pkgKey;       /* addedPackages key */
    int xx;
    int ec = 0;
    int rc;
    int oc;

    hcolor = hGetColor(h);
    pkgKey = RPMAL_NOMATCH;

    /*
     * Always add source headers.
     */
    isSource = (headerIsEntry(h, RPMTAG_SOURCERPM) == 0) ;
    if (isSource) {
        oc = ts->orderCount;
        goto addheader;
    }

    /*
     * Check platform affinity of binary packages.
     */
    arch = NULL;
    xx = hge(h, RPMTAG_ARCH, NULL, (void **)&arch, NULL);
    os = NULL;
    xx = hge(h, RPMTAG_OS, NULL, (void **)&os, NULL);
    if (nplatpat > 1) {
        const char * platform = NULL;

        if (hge(h, RPMTAG_PLATFORM, NULL, (void **)&platform, NULL))
            platform = xstrdup(platform);
        else
            platform = rpmExpand(arch, "-unknown-", os, NULL);

        rc = rpmPlatformScore(platform, platpat, nplatpat);
        if (rc <= 0) {
            const char * pkgNEVR = hGetNEVRA(h, NULL);
            rpmps ps = rpmtsProblems(ts);
            rpmpsAppend(ps, RPMPROB_BADPLATFORM, pkgNEVR, key,
                        platform, NULL, NULL, 0);
            ps = rpmpsFree(ps);
            pkgNEVR = _free(pkgNEVR);
            ec = 1;
        }
        platform = _free(platform);
        if (ec)
            goto exit;
    }

    /*
     * Always install compatible binary packages.
     */
    if (!upgrade) {
        oc = ts->orderCount;
        goto addheader;
    }

    /*
     * Check that upgrade package is uniquely newer, replace older if necessary.
     */
    oldChk = rpmdsThis(h, RPMTAG_REQUIRENAME, (RPMSENSE_LESS));
    newChk = rpmdsThis(h, RPMTAG_REQUIRENAME, (RPMSENSE_EQUAL|RPMSENSE_GREATER));
    /* XXX can't use rpmtsiNext() filter or oc will have wrong value. */
    for (pi = rpmtsiInit(ts), oc = 0; (p = rpmtsiNext(pi, 0)) != NULL; oc++) {
        rpmds this;

        /* XXX Only added packages need be checked for dupes here. */
        if (rpmteType(p) == TR_REMOVED)
            continue;

        /* XXX Never check source header NEVRAO. */
        if (rpmteIsSource(p))
            continue;

        if (tscolor) {
            const char * parch;
            const char * pos;

            if (arch == NULL || (parch = rpmteA(p)) == NULL)
                continue;
            /* XXX hackery for i[3456]86 alias matching. */
            if (arch[0] == 'i' && arch[2] == '8' && arch[3] == '6') {
                if (arch[0] != parch[0]) continue;
                if (arch[2] != parch[2]) continue;
                if (arch[3] != parch[3]) continue;
            } else if (strcmp(arch, parch))
                continue;
            if (os == NULL || (pos = rpmteO(p)) == NULL)
                continue;

            if (strcmp(os, pos))
                continue;
        }

        /* OK, binary rpm's with same arch and os.  Check NEVR. */
        if ((this = rpmteDS(p, RPMTAG_NAME)) == NULL)
            continue;   /* XXX can't happen */

        /* If newer NEVRAO already added, then skip adding older. */
        rc = rpmdsCompare(newChk, this);
        if (rc != 0) {
            const char * pkgNEVR = rpmdsDNEVR(this);
            const char * addNEVR = rpmdsDNEVR(oldChk);
            if (rpmIsVerbose())
                rpmMessage(RPMMESS_WARNING,
                    _("package %s was already added, skipping %s\n"),
                    (pkgNEVR ? pkgNEVR + 2 : "?pkgNEVR?"),
                    (addNEVR ? addNEVR + 2 : "?addNEVR?"));
            ec = 1;
            break;
        }

        /* If older NEVRAO already added, then replace old with new. */
        rc = rpmdsCompare(oldChk, this);
        if (rc != 0) {
            const char * pkgNEVR = rpmdsDNEVR(this);
            const char * addNEVR = rpmdsDNEVR(newChk);
            if (rpmIsVerbose())
                rpmMessage(RPMMESS_WARNING,
                    _("package %s was already added, replacing with %s\n"),
                    (pkgNEVR ? pkgNEVR + 2 : "?pkgNEVR?"),
                    (addNEVR ? addNEVR + 2 : "?addNEVR?"));
            duplicate = 1;
            pkgKey = rpmteAddedKey(p);
            break;
        }
    }
    pi = rpmtsiFree(pi);
    oldChk = rpmdsFree(oldChk);
    newChk = rpmdsFree(newChk);

    /* If newer (or same) NEVRAO was already added, exit now. */
    if (ec)
        goto exit;

addheader:
    if (oc >= ts->orderAlloced) {
        ts->orderAlloced += (oc - ts->orderAlloced) + ts->delta;
/*@-type +voidabstract @*/
        ts->order = xrealloc(ts->order, ts->orderAlloced * sizeof(*ts->order));
/*@=type =voidabstract @*/
    }

    p = rpmteNew(ts, h, TR_ADDED, key, relocs, -1, pkgKey);
assert(p != NULL);

    if (duplicate && oc < ts->orderCount) {
/*@-type -unqualifiedtrans@*/
/*@-boundswrite@*/
        ts->order[oc] = rpmteFree(ts->order[oc]);
/*@=boundswrite@*/
/*@=type =unqualifiedtrans@*/
    }

/*@-boundswrite@*/
    ts->order[oc] = p;
/*@=boundswrite@*/
    if (!duplicate) {
        ts->orderCount++;
        rpmcliPackagesTotal++;
    }
    
    pkgKey = rpmalAdd(&ts->addedPackages, pkgKey, rpmteKey(p),
                        rpmteDS(p, RPMTAG_PROVIDENAME),
                        rpmteFI(p, RPMTAG_BASENAMES), tscolor);
    if (pkgKey == RPMAL_NOMATCH) {
/*@-boundswrite@*/
        ts->order[oc] = rpmteFree(ts->order[oc]);
/*@=boundswrite@*/
        ts->teInstall = NULL;
        ec = 1;
        goto exit;
    }
    (void) rpmteSetAddedKey(p, pkgKey);

    if (!duplicate) {
        ts->numAddedPackages++;
    }

    ts->teInstall = ts->order[oc];

    /* XXX rpmgi hack: Save header in transaction element if requested. */
    if (upgrade & 0x2)
        (void) rpmteSetHeader(p, h);

    /* If not upgrading, then we're done. */
    if (!(upgrade & 0x1))
        goto exit;

    /* XXX binary rpms always have RPMTAG_SOURCERPM, source rpms do not */
    if (isSource)
        goto exit;

    /* Do lazy (readonly?) open of rpm database. */
    if (rpmtsGetRdb(ts) == NULL && ts->dbmode != -1) {
        if ((ec = rpmtsOpenDB(ts, ts->dbmode)) != 0)
            goto exit;
    }

    /* On upgrade, erase older packages of same color (if any). */

  if (!(depFlags & RPMDEPS_FLAG_NOUPGRADE)) {
    mi = rpmtsInitIterator(ts, RPMTAG_PROVIDENAME, rpmteN(p), 0);
    while((oh = rpmdbNextIterator(mi)) != NULL) {
        int lastx;
        rpmte q;

        /* Ignore colored packages not in our rainbow. */
        ohcolor = hGetColor(oh);
        if (tscolor && hcolor && ohcolor && !(hcolor & ohcolor))
            continue;

        /* Skip identical packages. */
        if (rpmHeadersIdentical(h, oh))
            continue;

        /* Create an erasure element. */
        lastx = -1;
        xx = removePackage(ts, oh, rpmdbGetIteratorOffset(mi), &lastx, pkgKey);
assert(lastx >= 0 && lastx < ts->orderCount);
        q = ts->order[lastx];

        /* Chain through upgrade flink. */
        xx = rpmteChain(p, q, oh, "Upgrades");

/*@-nullptrarith@*/
        rpmMessage(RPMMESS_DEBUG, _("   upgrade erases %s\n"), rpmteNEVRA(q));
/*@=nullptrarith@*/

    }
    mi = rpmdbFreeIterator(mi);
  }

  if (!(depFlags & RPMDEPS_FLAG_NOOBSOLETES)) {
    obsoletes = rpmdsLink(rpmteDS(p, RPMTAG_OBSOLETENAME), "Obsoletes");
    obsoletes = rpmdsInit(obsoletes);
    if (obsoletes != NULL)
    while (rpmdsNext(obsoletes) >= 0) {
        const char * Name;

        if ((Name = rpmdsN(obsoletes)) == NULL)
            continue;   /* XXX can't happen */

        /* Ignore colored obsoletes not in our rainbow. */
#if 0
        dscolor = rpmdsColor(obsoletes);
#else
        dscolor = hcolor;
#endif
        /* XXX obsoletes are never colored, so this is for future devel. */
        if (tscolor && dscolor && !(tscolor & dscolor))
            continue;

        /* XXX avoid self-obsoleting packages. */
        if (!strcmp(rpmteN(p), Name))
            continue;

        /* Obsolete containing package if given a file, otherwise provide. */
        if (Name[0] == '/')
            mi = rpmtsInitIterator(ts, RPMTAG_BASENAMES, Name, 0);
        else
            mi = rpmtsInitIterator(ts, RPMTAG_PROVIDENAME, Name, 0);

        xx = rpmdbPruneIterator(mi,
            ts->removedPackages, ts->numRemovedPackages, 1);

        while((oh = rpmdbNextIterator(mi)) != NULL) {
            int lastx;
            rpmte q;

            /* Ignore colored packages not in our rainbow. */
            ohcolor = hGetColor(oh);

            /* XXX provides *are* colored, effectively limiting Obsoletes:
                to matching only colored Provides: based on pkg coloring. */
            if (tscolor && hcolor && ohcolor && !(hcolor & ohcolor))
                /*@innercontinue@*/ continue;

            /*
             * Rpm prior to 3.0.3 does not have versioned obsoletes.
             * If no obsoletes version info is available, match all names.
             */
            if (!(rpmdsEVR(obsoletes) == NULL
             || rpmdsAnyMatchesDep(oh, obsoletes, _rpmds_nopromote)))
                /*@innercontinue@*/ continue;

            /* Create an erasure element. */
            lastx = -1;
            xx = removePackage(ts, oh, rpmdbGetIteratorOffset(mi), &lastx, pkgKey);
assert(lastx >= 0 && lastx < ts->orderCount);
            q = ts->order[lastx];

            /* Chain through obsoletes flink. */
            xx = rpmteChain(p, q, oh, "Obsoletes");

/*@-nullptrarith@*/
            rpmMessage(RPMMESS_DEBUG, _("  Obsoletes: %s\t\terases %s\n"),
                        rpmdsDNEVR(obsoletes)+2, rpmteNEVRA(q));
/*@=nullptrarith@*/
        }
        mi = rpmdbFreeIterator(mi);
    }
    obsoletes = rpmdsFree(obsoletes);
  }

    ec = 0;

exit:
    pi = rpmtsiFree(pi);
    return ec;
}

int rpmtsAddEraseElement(rpmts ts, Header h, int dboffset)
{
    int oc = -1;
    int rc = removePackage(ts, h, dboffset, &oc, RPMAL_NOMATCH);
    if (rc == 0 && oc >= 0 && oc < ts->orderCount)
        ts->teErase = ts->order[oc];
    else
        ts->teErase = NULL;
    return rc;
}

static int unsatisfiedDepend(rpmts ts, rpmds dep, int adding)
        /*@globals _cacheDependsRC, rpmGlobalMacroContext, h_errno,
                fileSystem, internalState @*/
        /*@modifies ts, dep, _cacheDependsRC, rpmGlobalMacroContext,
                fileSystem, internalState @*/
{
    DBT * key = alloca(sizeof(*key));
    DBT * data = alloca(sizeof(*data));
    rpmdbMatchIterator mi;
    nsType NSType;
    const char * Name;
    int_32 Flags;
    Header h;
    int _cacheThisRC = 1;
    int rc;
    int xx;
    int retries = 10;

    if ((Name = rpmdsN(dep)) == NULL)
        return 0;       /* XXX can't happen */
    Flags = rpmdsFlags(dep);
    NSType = rpmdsNSType(dep);

    /*
     * Check if dbiOpen/dbiPut failed (e.g. permissions), we can't cache.
     */
    if (_cacheDependsRC) {
        dbiIndex dbi;
        dbi = dbiOpen(rpmtsGetRdb(ts), RPMDBI_DEPENDS, 0);
        if (dbi == NULL)
            _cacheDependsRC = 0;
        else {
            const char * DNEVR;

            rc = -1;
/*@-branchstate@*/
            if ((DNEVR = rpmdsDNEVR(dep)) != NULL) {
                DBC * dbcursor = NULL;
                void * datap = NULL;
                size_t datalen = 0;
                size_t DNEVRlen = strlen(DNEVR);

                xx = dbiCopen(dbi, dbiTxnid(dbi), &dbcursor, 0);

                memset(key, 0, sizeof(*key));
/*@i@*/         key->data = (void *) DNEVR;
                key->size = DNEVRlen;
                memset(data, 0, sizeof(*data));
                data->data = datap;
                data->size = datalen;
/*@-nullstate@*/ /* FIX: data->data may be NULL */
                xx = dbiGet(dbi, dbcursor, key, data, DB_SET);
/*@=nullstate@*/
                DNEVR = key->data;
                DNEVRlen = key->size;
                datap = data->data;
                datalen = data->size;

/*@-boundswrite@*/
                if (xx == 0 && datap && datalen == 4)
                    memcpy(&rc, datap, datalen);
/*@=boundswrite@*/
                xx = dbiCclose(dbi, dbcursor, 0);
            }
/*@=branchstate@*/

            if (rc >= 0) {
                rpmdsNotify(dep, _("(cached)"), rc);
                return rpmdsNegateRC(dep, rc);
            }
        }
    }

retry:
    rc = 0;     /* assume dependency is satisfied */

    /* Expand macro probe dependencies. */
    if (NSType == RPMNS_TYPE_FUNCTION) {
        xx = rpmExpandNumeric(Name);
        rc = (xx ? 0 : 1);
        if (Flags & RPMSENSE_MISSINGOK)
            goto unsatisfied;
        rpmdsNotify(dep, _("(function probe)"), rc);
        goto exit;
    }

    /* Evaluate user/group lookup probes. */
    if (NSType == RPMNS_TYPE_USER) {
        const char *s;
        uid_t uid = 0;
        s = Name; while (*s && xisdigit(*s)) s++;

        if (*s)
            xx = unameToUid(Name, &uid);
        else {
            uid = strtol(Name, NULL, 10);
            xx = (uidToUname(uid) ? 0 : -1);
        }
        rc = (xx >= 0 ? 0 : 1);
        if (Flags & RPMSENSE_MISSINGOK)
            goto unsatisfied;
        rpmdsNotify(dep, _("(user lookup)"), rc);
        goto exit;
    }
    if (NSType == RPMNS_TYPE_GROUP) {
        const char *s;
        gid_t gid = 0;
        s = Name; while (*s && xisdigit(*s)) s++;

        if (*s)
            xx = gnameToGid(Name, &gid);
        else {
            gid = strtol(Name, NULL, 10);
            xx = (gidToGname(gid) ? 0 : -1);
        }
        rc = (xx >= 0 ? 0 : 1);
        if (Flags & RPMSENSE_MISSINGOK)
            goto unsatisfied;
        rpmdsNotify(dep, _("(group lookup)"), rc);
        goto exit;
    }

    /* Evaluate access(2) probe dependencies. */
    if (NSType == RPMNS_TYPE_ACCESS) {
        rc = rpmioAccess(Name, NULL, X_OK);
        if (Flags & RPMSENSE_MISSINGOK)
            goto unsatisfied;
        rpmdsNotify(dep, _("(access probe)"), rc);
        goto exit;
    }

    /* Evaluate mtab lookup and diskspace probe dependencies. */
    if (NSType == RPMNS_TYPE_MOUNTED) {
        const char ** fs = NULL;
        int nfs = 0;
        int i = 0;

        xx = rpmtsInitDSI(ts);
        fs = ts->filesystems;
        nfs = ts->filesystemCount;

        if (fs != NULL)
        for (i = 0; i < nfs; i++) {
            if (!strcmp(fs[i], Name))
                break;
        }
        rc = (i < nfs ? 0 : 1);
        if (Flags & RPMSENSE_MISSINGOK)
            goto unsatisfied;
        rpmdsNotify(dep, _("(mtab probe)"), rc);
        goto exit;
    }

    if (NSType == RPMNS_TYPE_DISKSPACE) {
        size_t nb = strlen(Name);
        rpmDiskSpaceInfo dsi = NULL;
        const char ** fs = NULL;
        size_t fslen = 0, longest = 0;
        int nfs = 0;
        int i = 0;

        xx = rpmtsInitDSI(ts);
        fs = ts->filesystems;
        nfs = ts->filesystemCount;

        if (fs != NULL)
        for (i = 0; i < nfs; i++) {
            fslen = strlen(fs[i]);
            if (fslen > nb)
                continue;
            if (strncmp(fs[i], Name, fslen))
                continue;
            if (fslen > 1 && Name[fslen] != '/' && Name[fslen] != '\0')
                continue;
            if (fslen < longest)
                continue;
            longest = fslen;
            dsi = ts->dsi + i;
        }
        if (dsi == NULL)
            rc = 1;     /* no mounted paths !?! */
        else {
            char * end = NULL;
            long long needed = strtoll(rpmdsEVR(dep), &end, 0);

            if (end && *end) {
                if (strchr("Gg", end[0]) && strchr("Bb", end[1]) && !end[2])
                    needed *= 1024 * 1024 * 1024;
                if (strchr("Mm", end[0]) && strchr("Bb", end[1]) && !end[2])
                    needed *= 1024 * 1024;
                if (strchr("Kk", end[0]) && strchr("Bb", end[1]) && !end[2])
                    needed *= 1024;
            } else
                needed *= 1024 * 1024;  /* XXX assume Mb if no units given */

            needed = BLOCK_ROUND(needed, dsi->f_bsize);
            xx = (dsi->f_bavail - needed);
            if ((Flags & RPMSENSE_LESS) && xx < 0) rc = 0;
            else if ((Flags & RPMSENSE_GREATER) && xx > 0) rc = 0;
            else if ((Flags & RPMSENSE_EQUAL) && xx == 0) rc = 0;
            else rc = 1;
        }
        if (Flags & RPMSENSE_MISSINGOK)
            goto unsatisfied;
        rpmdsNotify(dep, _("(diskspace probe)"), rc);
        goto exit;
    }

    if (NSType == RPMNS_TYPE_DIGEST) {
        const char * EVR = rpmdsEVR(dep);
        FD_t fd = Fopen(Name, "r");

        rc = 1;         /* XXX assume failure */
        if (fd && !Ferror(fd)) {
            pgpHashAlgo digestHashAlgo = PGPHASHALGO_MD5;
            DIGEST_CTX ctx = rpmDigestInit(digestHashAlgo, RPMDIGEST_NONE);
            const char * digest = NULL;
            size_t digestlen = 0;
            int asAscii = 1;
            size_t nbuf = 8 * BUFSIZ;
            char * buf = alloca(nbuf);
            size_t nb;

            while ((nb = Fread(buf, sizeof(buf[0]), nbuf, fd)) > 0)
                xx = rpmDigestUpdate(ctx, buf, nb);
            xx = Fclose(fd);    fd = NULL;
            xx = rpmDigestFinal(ctx, (void **)&digest, &digestlen, asAscii);

            xx = (EVR && *EVR && digest && *digest) ? strcmp(EVR, digest) : -1;
            /* XXX only equality makes sense for digest compares */
            if ((Flags & RPMSENSE_EQUAL) && xx == 0) rc = 0;
        }
        if (Flags & RPMSENSE_MISSINGOK)
            goto unsatisfied;
        rpmdsNotify(dep, _("(digest probe)"), rc);
        goto exit;
    }

    if (NSType == RPMNS_TYPE_GNUPG) {
        static const char gnupg_pre[] = "%(%{__gpg} -qv ";
        static const char gnupg_post[] = " 2>/dev/null; echo $?)";
        const char * t = rpmExpand(gnupg_pre, Name, gnupg_post, NULL);

        rc = (t && t[0] == '0') ? 0 : 1;
        t = _free(t);
        if (Flags & RPMSENSE_MISSINGOK)
            goto unsatisfied;
        rpmdsNotify(dep, _("(gnupg probe)"), rc);
        goto exit;
    }

    if (NSType == RPMNS_TYPE_MACRO) {
        static const char macro_pre[] = "%{?";
        static const char macro_post[] = ":0}";
        const char * a = rpmExpand(macro_pre, Name, macro_post, NULL);

        rc = (a && a[0] == '0') ? 0 : 1;
        a = _free(a);
        if (Flags & RPMSENSE_MISSINGOK)
            goto unsatisfied;
        rpmdsNotify(dep, _("(macro probe)"), rc);
        goto exit;
    }

    if (NSType == RPMNS_TYPE_ENVVAR) {
        const char * a = envGet(Name);
        const char * b = rpmdsEVR(dep);

        /* Existence test if EVR is missing/empty. */
        if (!(b && *b))
            rc = (!(a && *a));
        else {
            int sense = (a && *a) ? strcmp(a, b) : -1;

            if ((Flags & RPMSENSE_SENSEMASK) == RPMSENSE_NOTEQUAL)
                rc = (sense == 0);
            else if (sense < 0 && (Flags & RPMSENSE_LESS))
                rc = 0;
            else if (sense > 0 && (Flags & RPMSENSE_GREATER))
                rc = 0;
            else if (sense == 0 && (Flags & RPMSENSE_EQUAL))
                rc = 0;
            else
                rc = (sense != 0);
        }

        if (Flags & RPMSENSE_MISSINGOK)
            goto unsatisfied;
        rpmdsNotify(dep, _("(envvar probe)"), rc);
        goto exit;
    }

    if (NSType == RPMNS_TYPE_RUNNING) {
        char *t = NULL;
        pid_t pid = strtol(Name, &t, 10);

        if (t == NULL || *t != '\0') {
            const char * fn = rpmGetPath("%{_varrun}/", Name, ".pid", NULL);
            FD_t fd = NULL;

            if (fn && *fn != '%' && (fd = Fopen(fn, "r")) && !Ferror(fd)) {
                char buf[32];
                size_t nb = Fread(buf, sizeof(buf[0]), sizeof(buf), fd);

                if (nb > 0)
                    pid = strtol(buf, &t, 10);
            } else
                pid = 0;
            if (fd != NULL)
                (void) Fclose(fd);
            fn = _free(fn);
        }
        rc = (pid > 0 ? (kill(pid, 0) < 0 && errno == ESRCH) : 1);
        if (Flags & RPMSENSE_MISSINGOK)
            goto unsatisfied;
        rpmdsNotify(dep, _("(running probe)"), rc);
        goto exit;
    }

    /* Search system configured provides. */
    if (!rpmioAccess("/etc/rpm/sysinfo", NULL, R_OK)) {
#ifdef  NOTYET  /* XXX just sysinfo Provides: for now. */
        rpmTag tagN = (Name[0] == '/' ? RPMTAG_DIRNAMES : RPMTAG_PROVIDENAME);
#else
        rpmTag tagN = RPMTAG_PROVIDENAME;
#endif
        rpmds P = rpmdsFromPRCO(ts->PRCO, tagN);
        if (rpmdsSearch(P, dep) >= 0) {
            rpmdsNotify(dep, _("(sysinfo provides)"), rc);
            goto exit;
        }
    }

    /*
     * New features in rpm packaging implicitly add versioned dependencies
     * on rpmlib provides. The dependencies look like "rpmlib(YaddaYadda)".
     * Check those dependencies now.
     */
    if (NSType == RPMNS_TYPE_RPMLIB) {
        static rpmds rpmlibP = NULL;
        static int oneshot = -1;

        if (oneshot)
            oneshot = rpmdsRpmlib(&rpmlibP, NULL);
        if (rpmlibP == NULL)
            goto unsatisfied;

        if (rpmdsSearch(rpmlibP, dep) >= 0) {
            rpmdsNotify(dep, _("(rpmlib provides)"), rc);
            goto exit;
        }
        goto unsatisfied;
    }

    if (NSType == RPMNS_TYPE_CPUINFO) {
        static rpmds cpuinfoP = NULL;
        static int oneshot = -1;

        if (oneshot)
            oneshot = rpmdsCpuinfo(&cpuinfoP, NULL);
        if (cpuinfoP == NULL)
            goto unsatisfied;

        if (rpmdsSearch(cpuinfoP, dep) >= 0) {
            rpmdsNotify(dep, _("(cpuinfo provides)"), rc);
            goto exit;
        }
        goto unsatisfied;
    }

    if (NSType == RPMNS_TYPE_GETCONF) {
        static rpmds getconfP = NULL;
        static int oneshot = -1;

        if (oneshot)
            oneshot = rpmdsGetconf(&getconfP, NULL);
        if (getconfP == NULL)
            goto unsatisfied;

        if (rpmdsSearch(getconfP, dep) >= 0) {
            rpmdsNotify(dep, _("(getconf provides)"), rc);
            goto exit;
        }
        goto unsatisfied;
    }

    if (NSType == RPMNS_TYPE_UNAME) {
        static rpmds unameP = NULL;
        static int oneshot = -1;

        if (oneshot)
            oneshot = rpmdsUname(&unameP, NULL);
        if (unameP == NULL)
            goto unsatisfied;

        if (rpmdsSearch(unameP, dep) >= 0) {
            rpmdsNotify(dep, _("(uname provides)"), rc);
            goto exit;
        }
        goto unsatisfied;
    }

    if (NSType == RPMNS_TYPE_SONAME) {
        rpmds sonameP = NULL;
        rpmPRCO PRCO = rpmdsNewPRCO(NULL);
        char * fn = strcpy(alloca(strlen(Name)+1), Name);
        int flags = 0;  /* XXX RPMELF_FLAG_SKIPREQUIRES? */
        rpmds ds;

        /* XXX Only absolute paths for now. */
        if (*fn != '/')
            goto unsatisfied;
        fn[strlen(fn)-1] = '\0';

        /* Extract ELF Provides: from /path/to/DSO. */
        xx = rpmdsELF(fn, flags, rpmdsMergePRCO, PRCO);
        sonameP = rpmdsFromPRCO(PRCO, RPMTAG_PROVIDENAME);
        if (!(xx == 0 && sonameP != NULL))
            goto unsatisfied;

        /* Search using the original {EVR,"",Flags} from the dep set. */
        ds = rpmdsSingle(rpmdsTagN(dep), rpmdsEVR(dep), "", Flags);
        xx = rpmdsSearch(sonameP, ds);
        ds = rpmdsFree(ds);
        PRCO = rpmdsFreePRCO(PRCO);

        /* Was the dependency satisfied? */
        if (xx >= 0) {
            rpmdsNotify(dep, _("(soname provides)"), rc);
            goto exit;
        }
        goto unsatisfied;
    }

    /* Search added packages for the dependency. */
    if (rpmalSatisfiesDepend(ts->addedPackages, dep, NULL) != NULL) {
        /*
         * XXX Ick, context sensitive answers from dependency cache.
         * XXX Always resolve added dependencies within context to disambiguate.
         */
        if (_rpmds_nopromote)
            _cacheThisRC = 0;
        goto exit;
    }

    /* XXX only the installer does not have the database open here. */
    if (rpmtsGetRdb(ts) != NULL) {
/*@-boundsread@*/
        if (Name[0] == '/') {
            /* depFlags better be 0! */

            mi = rpmtsInitIterator(ts, RPMTAG_BASENAMES, Name, 0);
            (void) rpmdbPruneIterator(mi,
                        ts->removedPackages, ts->numRemovedPackages, 1);
            while ((h = rpmdbNextIterator(mi)) != NULL) {
                rpmdsNotify(dep, _("(db files)"), rc);
                mi = rpmdbFreeIterator(mi);
                goto exit;
            }
            mi = rpmdbFreeIterator(mi);
        }
/*@=boundsread@*/

        mi = rpmtsInitIterator(ts, RPMTAG_PROVIDENAME, Name, 0);
        (void) rpmdbPruneIterator(mi,
                        ts->removedPackages, ts->numRemovedPackages, 1);
        while ((h = rpmdbNextIterator(mi)) != NULL) {
            if (rpmdsAnyMatchesDep(h, dep, _rpmds_nopromote)) {
                rpmdsNotify(dep, _("(db provides)"), rc);
                mi = rpmdbFreeIterator(mi);
                goto exit;
            }
        }
        mi = rpmdbFreeIterator(mi);

    }

    /*
     * Search for an unsatisfied dependency.
     */
/*@-boundsread@*/
    if (adding == 1 && retries > 0 && !(rpmtsDFlags(ts) & RPMDEPS_FLAG_NOSUGGEST)) {
        if (ts->solve != NULL) {
            xx = (*ts->solve) (ts, dep, ts->solveData);
            if (xx == 0)
                goto exit;
            if (xx == -1) {
                retries--;
                rpmalMakeIndex(ts->addedPackages);
                goto retry;
            }
        }
    }
/*@=boundsread@*/

unsatisfied:
    if (Flags & RPMSENSE_MISSINGOK) {
        rc = 0; /* dependency is unsatisfied, but just a hint. */
        rpmdsNotify(dep, _("(hint skipped)"), rc);
    } else {
        rc = 1; /* dependency is unsatisfied */
        rpmdsNotify(dep, NULL, rc);
    }

exit:
    /*
     * If dbiOpen/dbiPut fails (e.g. permissions), we can't cache.
     */
    if (_cacheDependsRC && _cacheThisRC) {
        dbiIndex dbi;
        dbi = dbiOpen(rpmtsGetRdb(ts), RPMDBI_DEPENDS, 0);
        if (dbi == NULL) {
            _cacheDependsRC = 0;
        } else {
            const char * DNEVR;
            xx = 0;
            /*@-branchstate@*/
            if ((DNEVR = rpmdsDNEVR(dep)) != NULL) {
                DBC * dbcursor = NULL;
                size_t DNEVRlen = strlen(DNEVR);

                xx = dbiCopen(dbi, dbiTxnid(dbi), &dbcursor, DB_WRITECURSOR);

                memset(key, 0, sizeof(*key));
/*@i@*/         key->data = (void *) DNEVR;
                key->size = DNEVRlen;
                memset(data, 0, sizeof(*data));
                data->data = &rc;
                data->size = sizeof(rc);

                /*@-compmempass@*/
                xx = dbiPut(dbi, dbcursor, key, data, 0);
                /*@=compmempass@*/
                xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);
            }
            /*@=branchstate@*/
            if (xx)
                _cacheDependsRC = 0;
        }
    }

    return rpmdsNegateRC(dep, rc);
}

static int checkPackageDeps(rpmts ts, const char * pkgNEVRA,
                /*@null@*/ rpmds requires,
                /*@null@*/ rpmds conflicts,
                /*@null@*/ rpmds dirnames,
                /*@null@*/ rpmds linktos,
                /*@null@*/ const char * depName, uint_32 tscolor, int adding)
        /*@globals rpmGlobalMacroContext, h_errno,
                fileSystem, internalState @*/
        /*@modifies ts, requires, conflicts, dirnames, linktos,
                rpmGlobalMacroContext, fileSystem, internalState */