rpmts.h

Go to the documentation of this file.

#ifndef H_RPMTS
#define H_RPMTS

#include <sys/types.h>

#include <rpm/rpmtypes.h>
#include <rpm/rpmte.h>
#include <rpm/rpmps.h>
#include <rpm/rpmsw.h>
#include <rpm/rpmpgp.h>
#include <rpm/rpmfi.h>
#include <rpm/rpmcallback.h>

#ifdef __cplusplus
extern "C" {
#endif

extern int _rpmts_stats;

enum rpmtransFlags_e {
    RPMTRANS_FLAG_NONE          = 0,
    RPMTRANS_FLAG_TEST          = (1 <<  0),    
    RPMTRANS_FLAG_BUILD_PROBS   = (1 <<  1),    
    RPMTRANS_FLAG_NOSCRIPTS     = (1 <<  2),    
    RPMTRANS_FLAG_JUSTDB        = (1 <<  3),    
    RPMTRANS_FLAG_NOTRIGGERS    = (1 <<  4),    
    RPMTRANS_FLAG_NODOCS        = (1 <<  5),    
    RPMTRANS_FLAG_ALLFILES      = (1 <<  6),    
    RPMTRANS_FLAG_NOPLUGINS     = (1 <<  7),    
    RPMTRANS_FLAG_NOCONTEXTS    = (1 <<  8),    
    RPMTRANS_FLAG_NOCAPS        = (1 <<  9),    
    /* bits 10-15 unused */
    RPMTRANS_FLAG_NOTRIGGERPREIN= (1 << 16),    
    RPMTRANS_FLAG_NOPRE         = (1 << 17),    
    RPMTRANS_FLAG_NOPOST        = (1 << 18),    
    RPMTRANS_FLAG_NOTRIGGERIN   = (1 << 19),    
    RPMTRANS_FLAG_NOTRIGGERUN   = (1 << 20),    
    RPMTRANS_FLAG_NOPREUN       = (1 << 21),    
    RPMTRANS_FLAG_NOPOSTUN      = (1 << 22),    
    RPMTRANS_FLAG_NOTRIGGERPOSTUN = (1 << 23),  
    RPMTRANS_FLAG_NOPRETRANS    = (1 << 24),    
    RPMTRANS_FLAG_NOPOSTTRANS   = (1 << 25),    
    /* bit 26 unused */
    RPMTRANS_FLAG_NOMD5         = (1 << 27),    
    RPMTRANS_FLAG_NOFILEDIGEST  = (1 << 27),    
    /* bits 28-29 unused */
    RPMTRANS_FLAG_NOCONFIGS     = (1 << 30),    
    RPMTRANS_FLAG_DEPLOOPS      = (1 << 31)     
};

typedef rpmFlags rpmtransFlags;

#define _noTransScripts         \
  ( RPMTRANS_FLAG_NOPRE |       \
    RPMTRANS_FLAG_NOPOST |      \
    RPMTRANS_FLAG_NOPREUN |     \
    RPMTRANS_FLAG_NOPOSTUN |    \
    RPMTRANS_FLAG_NOPRETRANS |  \
    RPMTRANS_FLAG_NOPOSTTRANS \
  )

#define _noTransTriggers        \
  ( RPMTRANS_FLAG_NOTRIGGERPREIN | \
    RPMTRANS_FLAG_NOTRIGGERIN | \
    RPMTRANS_FLAG_NOTRIGGERUN | \
    RPMTRANS_FLAG_NOTRIGGERPOSTUN \
  )

/* Avoid unnecessary breakage for stuff referring to these unused flags */
#define RPMTRANS_FLAG_NOPAYLOAD 0
#define RPMTRANS_FLAG_APPLYONLY 0
#define RPMTRANS_FLAG_KEEPOBSOLETE 0
#define RPMTRANS_FLAG_DIRSTASH 0
#define RPMTRANS_FLAG_REPACKAGE 0
#define RPMTRANS_FLAG_PKGCOMMIT 0
#define RPMTRANS_FLAG_PKGUNDO 0
#define RPMTRANS_FLAG_COMMIT 0
#define RPMTRANS_FLAG_UNDO 0
#define RPMTRANS_FLAG_REVERSE 0
#define RPMTRANS_FLAG_NOSUGGEST 0
#define RPMTRANS_FLAG_ADDINDEPS 0

enum rpmVSFlags_e {
    RPMVSF_DEFAULT      = 0,
    RPMVSF_NOHDRCHK     = (1 <<  0),
    RPMVSF_NEEDPAYLOAD  = (1 <<  1),
    /* bit(s) 2-7 unused */
    RPMVSF_NOSHA1HEADER = (1 <<  8),
    RPMVSF_NOSHA256HEADER = (1 <<  9),
    RPMVSF_NODSAHEADER  = (1 << 10),
    RPMVSF_NORSAHEADER  = (1 << 11),
    /* bit(s) 12-15 unused */
    RPMVSF_NOPAYLOAD    = (1 << 16),
    RPMVSF_NOMD5        = (1 << 17),
    RPMVSF_NODSA        = (1 << 18),
    RPMVSF_NORSA        = (1 << 19)
    /* bit(s) 16-31 unused */
};

typedef rpmFlags rpmVSFlags;

#define RPMVSF_MASK_NODIGESTS   \
  ( RPMVSF_NOSHA1HEADER |       \
    RPMVSF_NOSHA256HEADER |     \
    RPMVSF_NOPAYLOAD |  \
    RPMVSF_NOMD5 )
#define _RPMVSF_NODIGESTS       RPMVSF_MASK_NODIGESTS

#define RPMVSF_MASK_NOSIGNATURES        \
  ( RPMVSF_NODSAHEADER |        \
    RPMVSF_NORSAHEADER |        \
    RPMVSF_NODSA |              \
    RPMVSF_NORSA )
#define _RPMVSF_NOSIGNATURES    RPMVSF_MASK_NOSIGNATURES

#define RPMVSF_MASK_NOHEADER    \
  ( RPMVSF_NOSHA1HEADER |       \
    RPMVSF_NOSHA256HEADER |     \
    RPMVSF_NODSAHEADER |        \
    RPMVSF_NORSAHEADER )
#define _RPMVSF_NOHEADER        RPMVSF_MASK_NOHEADER

#define RPMVSF_MASK_NOPAYLOAD   \
  ( RPMVSF_NOMD5 |              \
    RPMVSF_NOPAYLOAD |          \
    RPMVSF_NODSA |              \
    RPMVSF_NORSA )
#define _RPMVSF_NOPAYLOAD       RPMVSF_MASK_NOPAYLOAD

enum {
    RPMSIG_NONE_TYPE            = 0,
    RPMSIG_DIGEST_TYPE          = (1 << 0),
    RPMSIG_SIGNATURE_TYPE       = (1 << 1),
    RPMSIG_OTHER_TYPE           = (1 << 2),
};

#define RPMSIG_VERIFIABLE_TYPE (RPMSIG_DIGEST_TYPE|RPMSIG_SIGNATURE_TYPE)

typedef enum rpmtsOpX_e {
    RPMTS_OP_TOTAL              =  0,
    RPMTS_OP_CHECK              =  1,
    RPMTS_OP_ORDER              =  2,
    RPMTS_OP_FINGERPRINT        =  3,
    RPMTS_OP_INSTALL            =  5,
    RPMTS_OP_ERASE              =  6,
    RPMTS_OP_SCRIPTLETS         =  7,
    RPMTS_OP_COMPRESS           =  8,
    RPMTS_OP_UNCOMPRESS         =  9,
    RPMTS_OP_DIGEST             = 10,
    RPMTS_OP_SIGNATURE          = 11,
    RPMTS_OP_DBADD              = 12,
    RPMTS_OP_DBREMOVE           = 13,
    RPMTS_OP_DBGET              = 14,
    RPMTS_OP_DBPUT              = 15,
    RPMTS_OP_DBDEL              = 16,
    RPMTS_OP_VERIFY             = 17,
    RPMTS_OP_MAX                = 18
} rpmtsOpX;

enum rpmtxnFlags_e {
    RPMTXN_READ         = (1 << 0),
    RPMTXN_WRITE        = (1 << 1),
};
typedef rpmFlags rpmtxnFlags;

int rpmtsCheck(rpmts ts);

int rpmtsOrder(rpmts ts);

int rpmtsRun(rpmts ts, rpmps okProbs, rpmprobFilterFlags ignoreSet);

rpmts rpmtsLink (rpmts ts);

int rpmtsCloseDB(rpmts ts);

int rpmtsOpenDB(rpmts ts, int dbmode);

int rpmtsInitDB(rpmts ts, int dbmode);

int rpmtsGetDBMode(rpmts ts);

int rpmtsSetDBMode(rpmts ts, int dbmode);

int rpmtsRebuildDB(rpmts ts);

int rpmtsVerifyDB(rpmts ts);

rpmdbMatchIterator rpmtsInitIterator(const rpmts ts, rpmDbiTagVal rpmtag,
                        const void * keyp, size_t keylen);

rpmRC rpmtsImportHeader(rpmtxn txn, Header h, rpmFlags flags);

rpmRC rpmtsImportPubkey(rpmts ts, const unsigned char * pkt, size_t pktlen);

rpmKeyring rpmtsGetKeyring(rpmts ts, int autoload);

int rpmtsSetKeyring(rpmts ts, rpmKeyring keyring);

int rpmtsSetSolveCallback(rpmts ts,
                int (*solve) (rpmts ts, rpmds ds, const void * data),
                const void * solveData);

rpmps rpmtsProblems(rpmts ts);

void rpmtsCleanProblems(rpmts ts);

void rpmtsClean(rpmts ts);

void rpmtsEmpty(rpmts ts);

rpmts rpmtsFree(rpmts ts);

rpmVSFlags rpmtsVSFlags(rpmts ts);

rpmVSFlags rpmtsSetVSFlags(rpmts ts, rpmVSFlags vsflags);

rpmVSFlags rpmtsVfyFlags(rpmts ts);

rpmVSFlags rpmtsSetVfyFlags(rpmts ts, rpmVSFlags vfyflags);

int rpmtsVfyLevel(rpmts ts);

int rpmtsSetVfyLevel(rpmts ts, int vfylevel);

const char * rpmtsRootDir(rpmts ts);

int rpmtsSetRootDir(rpmts ts, const char * rootDir);

FD_t rpmtsScriptFd(rpmts ts);

void rpmtsSetScriptFd(rpmts ts, FD_t scriptFd);

rpm_tid_t rpmtsGetTid(rpmts ts);

rpm_tid_t rpmtsSetTid(rpmts ts, rpm_tid_t tid);

rpmdb rpmtsGetRdb(rpmts ts);

void * rpmtsNotify(rpmts ts, rpmte te,
                rpmCallbackType what, rpm_loff_t amount, rpm_loff_t total);

int rpmtsNElements(rpmts ts);

rpmte rpmtsElement(rpmts ts, int ix);

rpmprobFilterFlags rpmtsFilterFlags(rpmts ts);

rpmtransFlags rpmtsFlags(rpmts ts);

rpmtransFlags rpmtsSetFlags(rpmts ts, rpmtransFlags transFlags);

rpm_color_t rpmtsColor(rpmts ts);

rpm_color_t rpmtsPrefColor(rpmts ts);

rpm_color_t rpmtsSetColor(rpmts ts, rpm_color_t color);

rpm_color_t rpmtsSetPrefColor(rpmts ts, rpm_color_t color);

rpmop rpmtsOp(rpmts ts, rpmtsOpX opx);

rpmPlugins rpmtsPlugins(rpmts ts);

int rpmtsSetNotifyCallback(rpmts ts,
                rpmCallbackFunction notify,
                rpmCallbackData notifyData);

rpmts rpmtsCreate(void);

int rpmtsAddInstallElement(rpmts ts, Header h,
                const fnpyKey key, int upgrade,
                rpmRelocation * relocs);

int rpmtsAddReinstallElement(rpmts ts, Header h, const fnpyKey key);

int rpmtsAddEraseElement(rpmts ts, Header h, int dboffset);

rpmtxn rpmtxnBegin(rpmts ts, rpmtxnFlags flags);

rpmtxn rpmtxnEnd(rpmtxn txn);

rpmtsi rpmtsiFree(rpmtsi tsi);

rpmtsi rpmtsiInit(rpmts ts);

rpmte rpmtsiNext(rpmtsi tsi, rpmElementTypes types);

#ifdef __cplusplus
}
#endif


#endif  /* H_RPMTS */