rpmds.h

Go to the documentation of this file.

#ifndef H_RPMDS
#define H_RPMDS

#include <time.h>

#include <rpm/rpmtypes.h>
#include <rpm/rpmutil.h>
#include <rpm/rpmps.h>

#ifdef __cplusplus
extern "C" {
#endif

enum rpmsenseFlags_e {
    RPMSENSE_ANY    = 0,
    RPMSENSE_LESS   = (1 << 1),
    RPMSENSE_GREATER    = (1 << 2),
    RPMSENSE_EQUAL  = (1 << 3),
    /* bit 4 unused */
    RPMSENSE_POSTTRANS  = (1 << 5), 
    RPMSENSE_PREREQ = (1 << 6),     /* legacy prereq dependency */
    RPMSENSE_PRETRANS   = (1 << 7), 
    RPMSENSE_INTERP = (1 << 8), 
    RPMSENSE_SCRIPT_PRE = (1 << 9), 
    RPMSENSE_SCRIPT_POST = (1 << 10),   
    RPMSENSE_SCRIPT_PREUN = (1 << 11),  
    RPMSENSE_SCRIPT_POSTUN = (1 << 12), 
    RPMSENSE_SCRIPT_VERIFY = (1 << 13), 
    RPMSENSE_FIND_REQUIRES = (1 << 14), 
    RPMSENSE_FIND_PROVIDES = (1 << 15), 
    RPMSENSE_TRIGGERIN  = (1 << 16),    
    RPMSENSE_TRIGGERUN  = (1 << 17),    
    RPMSENSE_TRIGGERPOSTUN = (1 << 18), 
    RPMSENSE_MISSINGOK  = (1 << 19),    
    RPMSENSE_PREUNTRANS = (1 << 20),    
    RPMSENSE_POSTUNTRANS = (1 << 21),   
    /* bits 22-23 unused */
    RPMSENSE_RPMLIB = (1 << 24),    
    RPMSENSE_TRIGGERPREIN = (1 << 25),  
    RPMSENSE_KEYRING    = (1 << 26),
    /* bit 27 unused */
    RPMSENSE_CONFIG = (1 << 28),
    RPMSENSE_META   = (1 << 29),    
};

typedef rpmFlags rpmsenseFlags;

#define RPMSENSE_SENSEMASK  15   /* Mask to get senses, ie serial, */
                                         /* less, greater, equal.          */

#define RPMSENSE_TRIGGER    \
    (RPMSENSE_TRIGGERPREIN | RPMSENSE_TRIGGERIN | RPMSENSE_TRIGGERUN | RPMSENSE_TRIGGERPOSTUN)

#define _ALL_REQUIRES_MASK  (\
    RPMSENSE_INTERP | \
    RPMSENSE_SCRIPT_PRE | \
    RPMSENSE_SCRIPT_POST | \
    RPMSENSE_SCRIPT_PREUN | \
    RPMSENSE_SCRIPT_POSTUN | \
    RPMSENSE_SCRIPT_VERIFY | \
    RPMSENSE_FIND_REQUIRES | \
    RPMSENSE_RPMLIB | \
    RPMSENSE_KEYRING | \
    RPMSENSE_PRETRANS | \
    RPMSENSE_POSTTRANS | \
    RPMSENSE_PREUNTRANS | \
    RPMSENSE_POSTUNTRANS | \
    RPMSENSE_PREREQ | \
    RPMSENSE_META | \
    RPMSENSE_MISSINGOK)

#define _notpre(_x)     ((_x) & ~RPMSENSE_PREREQ)
#define _INSTALL_ONLY_MASK \
    _notpre(RPMSENSE_SCRIPT_PRE|RPMSENSE_SCRIPT_POST|RPMSENSE_RPMLIB|RPMSENSE_KEYRING|RPMSENSE_PRETRANS|RPMSENSE_POSTTRANS)
#define _ERASE_ONLY_MASK  \
    _notpre(RPMSENSE_SCRIPT_PREUN|RPMSENSE_SCRIPT_POSTUN|RPMSENSE_PREUNTRANS|RPMSENSE_POSTUNTRANS)
#define _UNORDERED_ONLY_MASK \
    _notpre(RPMSENSE_RPMLIB|RPMSENSE_CONFIG|RPMSENSE_PRETRANS|RPMSENSE_POSTTRANS|RPMSENSE_PREUNTRANS|RPMSENSE_POSTUNTRANS|RPMSENSE_SCRIPT_VERIFY|RPMSENSE_META)
#define _FORCE_ORDER_ONLY_MASK \
    _notpre(RPMSENSE_SCRIPT_PRE|RPMSENSE_SCRIPT_POST|RPMSENSE_SCRIPT_PREUN|RPMSENSE_SCRIPT_POSTUN)

#define isLegacyPreReq(_x)  (((_x) & _ALL_REQUIRES_MASK) == RPMSENSE_PREREQ)
#define isInstallPreReq(_x) ((_x) & _INSTALL_ONLY_MASK)
#define isErasePreReq(_x)   ((_x) & _ERASE_ONLY_MASK)
#define isUnorderedReq(_x)  ((_x) & _UNORDERED_ONLY_MASK && \
                 !((_x) & _FORCE_ORDER_ONLY_MASK))
#define isTransientReq(_x)  (isInstallPreReq(_x) && \
                 !isErasePreReq(_x) &&  \
                 !((_x) & RPMSENSE_META))

rpmsenseFlags rpmSanitizeDSFlags(rpmTagVal tagN, rpmsenseFlags Flags);

rpmsenseFlags rpmParseDSFlags(const char *str, size_t len);

rpmds rpmdsLink(rpmds ds);

rpmds rpmdsFree(rpmds ds);

rpmds rpmdsNew(Header h, rpmTagVal tagN, int flags);

char * rpmdsNewDNEVR(const char * dspfx, const rpmds ds);

rpmds rpmdsThis(Header h, rpmTagVal tagN, rpmsenseFlags Flags);

rpmds rpmdsSingle(rpmTagVal tagN, const char * N, const char * EVR, rpmsenseFlags Flags);

rpmds rpmdsCurrent(rpmds ds);

int rpmdsPutToHeader(rpmds ds, Header h);

int rpmdsCount(const rpmds ds);

int rpmdsIx(const rpmds ds);

int rpmdsSetIx(rpmds ds, int ix);

const char * rpmdsDNEVR(const rpmds ds);

char rpmdsD(const rpmds ds);

rpmTagVal rpmdsDToTagN(char deptype);

const char * rpmdsN(const rpmds ds);

const char * rpmdsEVR(const rpmds ds);

int rpmdsTi(const rpmds ds);

rpmsenseFlags rpmdsFlags(const rpmds ds);

rpmTagVal rpmdsTagN(const rpmds ds);

rpmTagVal rpmdsTagEVR(const rpmds ds);

rpmTagVal rpmdsTagF(const rpmds ds);

rpmTagVal rpmdsTagTi(const rpmds ds);

unsigned int rpmdsInstance(rpmds ds);

int rpmdsIsWeak(rpmds ds);

int rpmdsIsReverse(rpmds ds);

int rpmdsIsSysuser(rpmds ds, char **sysuser);

rpm_color_t rpmdsColor(const rpmds ds);

rpm_color_t rpmdsSetColor(const rpmds ds, rpm_color_t color);

int rpmdsNext(rpmds ds);

rpmds rpmdsInit(rpmds ds);

int rpmdsFind(rpmds ds, const rpmds ods);

int rpmdsMerge(rpmds * dsp, rpmds ods);

int rpmdsSearch(rpmds ds, rpmds ods);

int rpmdsCompare(const rpmds A, const rpmds B);

int rpmdsAnyMatchesDep (const Header h, const rpmds req, int nopromote);

int rpmdsMatchesDep (const Header h, int ix, const rpmds req, int nopromote);

int rpmdsNVRMatchesDep(const Header h, const rpmds req, int nopromote);

int rpmdsRpmlib(rpmds * dsp, const void * tblp);

int rpmdsUname(rpmds * dsp);

int rpmdsCpuinfo(rpmds * dsp);

rpmds rpmdsNewPool(rpmstrPool pool, Header h, rpmTagVal tagN, int flags);

rpmds rpmdsThisPool(rpmstrPool pool,
            Header h, rpmTagVal tagN, rpmsenseFlags Flags);

rpmds rpmdsSinglePool(rpmstrPool pool, rpmTagVal tagN,
              const char * N, const char * EVR, rpmsenseFlags Flags);

rpmds rpmdsSinglePoolTix(rpmstrPool pool, rpmTagVal tagN,
                const char * N, const char * EVR, 
                rpmsenseFlags Flags, int triggerIndex);

int rpmdsRpmlibPool(rpmstrPool pool, rpmds * dsp, const void * tblp);

int rpmdsUnamePool(rpmstrPool pool, rpmds * dsp);

int rpmdsCpuinfoPool(rpmstrPool pool, rpmds * dsp);


typedef enum rpmrichOp_e {
    RPMRICHOP_NONE    = 0,
    RPMRICHOP_SINGLE  = 1,
    RPMRICHOP_AND     = 2,
    RPMRICHOP_OR      = 3,
    RPMRICHOP_IF      = 4,
    RPMRICHOP_ELSE    = 5,
    RPMRICHOP_WITH    = 6,
    RPMRICHOP_WITHOUT = 7,
    RPMRICHOP_UNLESS  = 8
} rpmrichOp;

typedef enum rpmrichParseType_e {
    RPMRICH_PARSE_SIMPLE = 1,   /* standard N <=> EVR dep */
    RPMRICH_PARSE_ENTER  = 2,   /* entering sub-dependency */
    RPMRICH_PARSE_LEAVE  = 3,   /* leaving sub-dependency */
    RPMRICH_PARSE_OP     = 4    /* parsed a rich dependency op */
} rpmrichParseType;

typedef rpmRC (*rpmrichParseFunction) (void *cbdata, rpmrichParseType type,
             const char *n, int nl, const char *e, int el, rpmsenseFlags sense,
             rpmrichOp op, char **emsg);

rpmRC rpmrichParse(const char **dstrp, char **emsg, rpmrichParseFunction cb, void *cbdata);

rpmRC rpmrichParseForTag(const char **dstrp, char **emsg, rpmrichParseFunction cb, void *cbdata, rpmTagVal tagN);


int rpmdsIsRich(rpmds dep);

const char *rpmrichOpStr(rpmrichOp op);

rpmRC rpmdsParseRichDep(rpmds dep, rpmds *leftds, rpmds *rightds, rpmrichOp *op, char **emsg);

#ifdef __cplusplus
}
#endif

#endif  /* H_RPMDS */