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),    
    /* bit 28 unused */
    RPMTRANS_FLAG_NOARTIFACTS   = (1 << 29),    
    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)
#define RPMSIG_UNVERIFIED_TYPE  (1 << 30)
 
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;
 
typedef enum rpmtsEvent_e {
    RPMTS_EVENT_ADD             = 1,
    RPMTS_EVENT_DEL             = 2,
} rpmtsEvent;
 
typedef int (*rpmtsChangeFunction)
                (int event, rpmte te, rpmte other, void *data);
 
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 perms);
 
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);
 
int rpmtsSetNotifyStyle(rpmts ts, int style);
 
int rpmtsGetNotifyStyle(rpmts ts);
 
int rpmtsSetChangeCallback(rpmts ts, rpmtsChangeFunction notify, void *data);
 
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 */