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/rpmfi.h>
#include <rpm/rpmcallback.h>
#include <rpm/rpmkeyring.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),    
    RPMTRANS_FLAG_NODB        = (1 << 10),    
    /* bits 11-13 unused */
    RPMTRANS_FLAG_NOPREUNTRANS    = (1 << 14),    
    RPMTRANS_FLAG_NOPOSTUNTRANS  = (1 << 15),    
    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),    
    RPMTRANS_FLAG_NOSYSUSERS    = (1 << 26),    
    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 | \
    RPMTRANS_FLAG_NOPREUNTRANS |\
    RPMTRANS_FLAG_NOPOSTUNTRANS \
  )
 
#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),
    RPMVSF_NOOPENPGP    = (1 << 12),
    /* 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_NOOPENPGP |  \
    RPMVSF_NODSA |      \
    RPMVSF_NORSA )
#define _RPMVSF_NOSIGNATURES    RPMVSF_MASK_NOSIGNATURES
 
#define RPMVSF_MASK_NOHEADER    \
  ( RPMVSF_NOSHA1HEADER |   \
    RPMVSF_NOSHA256HEADER | \
    RPMVSF_NOOPENPGP |      \
    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);

rpmRC rpmtxnImportPubkey(rpmtxn txn, const unsigned char * pkt, size_t pktlen);

rpmRC rpmtxnDeletePubkey(rpmtxn txn, rpmPubkey key);

rpmRC rpmtxnRebuildKeystore(rpmtxn txn, const char * from);

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 rpmtsAddRestoreElement(rpmts ts, Header h);

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 */