lib/rpmdb.h

   1 #ifndef H_RPMDB
   2 #define H_RPMDB
   3
   4 /** \file lib/rpmdb.h
   5  * Access RPM indices using Berkeley db[123] interface.
   6  */
   7
   8 #include <rpmlib.h>
   9
  10 #include "fprint.h"
  11
  12 typedef /*@abstract@*/ struct _dbiIndexItem * dbiIndexItem;
  13 typedef /*@abstract@*/ struct _dbiIndex * dbiIndex;
  14
  15 /* this will break if sizeof(int) != 4 */
  16 /**
  17  * A single item from an index database (i.e. the "data returned").
  18  * Note: In rpm-3.0.4 and earlier, this structure was passed by value,
  19  * and was identical to the "data saved" structure below.
  20  */
  21 struct _dbiIndexItem {
  22     unsigned int hdrNum;                /*!< header instance in db */
  23     unsigned int tagNum;                /*!< tag index in header */
  24     unsigned int fpNum;                 /*!< finger print index */
  25     unsigned int dbNum;                 /*!< database index */
  26 };
  27
  28 /**
  29  * A single item in an index database (i.e. the "data saved").
  30  */
  31 struct _dbiIR {
  32     unsigned int recOffset;             /*!< byte offset of header in db */
  33     unsigned int fileNumber;            /*!< file array index */
  34 };
  35 typedef struct _dbiIR * DBIR_t;
  36
  37 /**
  38  * Items retrieved from the index database.
  39  */
  40 struct _dbiIndexSet {
  41 /*@owned@*/ struct _dbiIndexItem * recs; /*!< array of records */
  42     int count;                          /*!< number of records */
  43 };
  44
  45 /* XXX hack to get prototypes correct */
  46 #if !defined(DB_VERSION_MAJOR)
  47 #define DB_ENV  void
  48 #define DBC     void
  49 #define DBT     void
  50 #define DB_LSN  void
  51 #endif
  52
  53 /**
  54  * Private methods for accessing an index database.
  55  */
  56 struct _dbiVec {
  57     int dbv_major;                      /*<! Berkeley db version major */
  58     int dbv_minor;                      /*<! Berkeley db version minor */
  59     int dbv_patch;                      /*<! Berkeley db version patch */
  60
  61 /**
  62  * Return handle for an index database.
  63  * @param rpmdb         rpm database
  64  * @param rpmtag        rpm tag
  65  * @return              0 on success
  66  */
  67     int (*open) (rpmdb rpmdb, int rpmtag, dbiIndex * dbip);
  68
  69 /**
  70  * Close index database.
  71  * @param dbi           index database handle
  72  * @param flags         (unused)
  73  * @return              0 on success
  74  */
  75     int (*close) (dbiIndex dbi, unsigned int flags);
  76
  77 /**
  78  * Flush pending operations to disk.
  79  * @param dbi           index database handle
  80  * @param flags         (unused)
  81  * @return              0 on success
  82  */
  83     int (*sync) (dbiIndex dbi, unsigned int flags);
  84
  85 /**
  86  */
  87     int (*copen) (dbiIndex dbi, DBC ** dbcp, unsigned int flags);
  88
  89 /**
  90  */
  91     int (*cclose) (dbiIndex dbi, /*@only@*/ DBC * dbcursor, unsigned int flags);
  92
  93 /**
  94  * Delete (key,data) pair(s) using db->del or dbcursor->c_del.
  95  * @param dbi           index database handle
  96  * @param keyp          key data
  97  * @param keylen        key data length
  98  * @param flags         (unused)
  99  * @return              0 on success
 100  */
 101     int (*cdel) (dbiIndex dbi, DBC * dbcursor, const void * keyp, size_t keylen, unsigned int flags);
 102
 103 /**
 104  * Retrieve (key,data) pair using db->get or dbcursor->c_get.
 105  * @param dbi           index database handle
 106  * @param keypp         address of key data
 107  * @param keylenp       address of key data length
 108  * @param datapp        address of data pointer
 109  * @param datalenp      address of data length
 110  * @param flags         (unused)
 111  * @return              0 on success
 112  */
 113     int (*cget) (dbiIndex dbi, DBC * dbcursor, void ** keypp, size_t * keylenp,
 114                         void ** datapp, size_t * datalenp, unsigned int flags);
 115
 116 /**
 117  * Store (key,data) pair using db->put or dbcursor->c_put.
 118  * @param dbi           index database handle
 119  * @param keyp          key data
 120  * @param keylen        key data length
 121  * @param datap         data pointer
 122  * @param datalen       data length
 123  * @param flags         (unused)
 124  * @return              0 on success
 125  */
 126     int (*cput) (dbiIndex dbi, DBC * dbcursor, const void * keyp, size_t keylen,
 127                         const void * datap, size_t datalen, unsigned int flags);
 128
 129 /**
 130  * Is database byte swapped?
 131  * @param dbi           index database handle
 132  * @return              0 no
 133  */
 134     int (*byteswapped) (dbiIndex dbi);
 135
 136 };
 137
 138 /**
 139  * Describes an index database (implemented on Berkeley db[123] API).
 140  */
 141 struct _dbiIndex {
 142     const char *        dbi_root;
 143     const char *        dbi_home;
 144     const char *        dbi_file;
 145     const char *        dbi_subfile;
 146
 147     int                 dbi_cflags;     /*<! db_create/db_env_create flags */
 148     int                 dbi_oeflags;    /*<! common (db,dbenv}->open flags */
 149     int                 dbi_eflags;     /*<! dbenv->open flags */
 150     int                 dbi_oflags;     /*<! db->open flags */
 151     int                 dbi_tflags;     /*<! dbenv->txn_begin flags */
 152
 153     int                 dbi_type;       /*<! db index type */
 154     int                 dbi_mode;       /*<! mode to use on open */
 155     int                 dbi_perms;      /*<! file permission to use on open */
 156     int                 dbi_api;        /*<! Berkeley API type */
 157
 158     int                 dbi_tear_down;
 159     int                 dbi_use_cursors;
 160     int                 dbi_use_dbenv;
 161     int                 dbi_get_rmw_cursor;
 162     int                 dbi_no_fsync;   /*<! no-op fsync for db */
 163     int                 dbi_no_dbsync;  /*<! don't call dbiSync */
 164     int                 dbi_lockdbfd;   /*<! do fcntl lock on db fd */
 165     int                 dbi_temporary;  /*<! non-persistent */
 166     int                 dbi_debug;
 167
 168         /* dbenv parameters */
 169     int                 dbi_lorder;
 170     void                (*db_errcall) (const char *db_errpfx, char *buffer);
 171     FILE *              dbi_errfile;
 172     const char *        dbi_errpfx;
 173     int                 dbi_verbose;
 174     int                 dbi_region_init;
 175     int                 dbi_tas_spins;
 176         /* mpool sub-system parameters */
 177     int                 dbi_mp_mmapsize;        /*<! (10Mb) */
 178     int                 dbi_mp_size;    /*<! (128Kb) */
 179         /* lock sub-system parameters */
 180     unsigned int        dbi_lk_max;
 181     unsigned int        dbi_lk_detect;
 182     int                 dbi_lk_nmodes;
 183     unsigned char       *dbi_lk_conflicts;
 184         /* log sub-system parameters */
 185     unsigned int        dbi_lg_max;
 186     unsigned int        dbi_lg_bsize;
 187         /* transaction sub-system parameters */
 188     unsigned int        dbi_tx_max;
 189 #if 0
 190     int                 (*dbi_tx_recover) (DB_ENV *dbenv, DBT *log_rec, DB_LSN *lsnp, int redo, void *info);
 191 #endif
 192         /* dbinfo parameters */
 193     int                 dbi_cachesize;  /*<! */
 194     int                 dbi_pagesize;   /*<! (fs blksize) */
 195     void *              (*dbi_malloc) (size_t nbytes);
 196         /* hash access parameters */
 197     unsigned int        dbi_h_ffactor;  /*<! */
 198     unsigned int        (*dbi_h_hash_fcn) (const void *bytes, unsigned int length);
 199     unsigned int        dbi_h_nelem;    /*<! */
 200     unsigned int        dbi_h_flags;    /*<! DB_DUP, DB_DUPSORT */
 201     int                 (*dbi_h_dup_compare_fcn) (const DBT *, const DBT *);
 202         /* btree access parameters */
 203     int                 dbi_bt_flags;
 204     int                 dbi_bt_minkey;
 205     int                 (*dbi_bt_compare_fcn)(const DBT *, const DBT *);
 206     int                 (*dbi_bt_dup_compare_fcn) (const DBT *, const DBT *);
 207     size_t              (*dbi_bt_prefix_fcn) (const DBT *, const DBT *);
 208         /* recno access parameters */
 209     int                 dbi_re_flags;
 210     int                 dbi_re_delim;
 211     unsigned int        dbi_re_len;
 212     int                 dbi_re_pad;
 213     const char *        dbi_re_source;
 214
 215     rpmdb       dbi_rpmdb;
 216     int         dbi_rpmtag;             /*<! rpm tag used for index */
 217     int         dbi_jlen;               /*<! size of join key */
 218
 219     unsigned int dbi_lastoffset;        /*<! db1 with falloc.c needs this */
 220
 221     void *      dbi_db;                 /*<! dbi handle */
 222     void *      dbi_dbenv;
 223     void *      dbi_dbinfo;
 224     void *      dbi_rmw;                /*<! db cursor (with DB_WRITECURSOR) */
 225
 226 /*@observer@*/ const struct _dbiVec * dbi_vec;  /*<! private methods */
 227
 228 };
 229
 230 /**
 231  * Describes the collection of index databases used by rpm.
 232  */
 233 struct rpmdb_s {
 234     const char *        db_root;        /*<! path prefix */
 235     const char *        db_home;        /*<! directory path */
 236     int                 db_flags;
 237
 238     int                 db_mode;        /*<! open mode */
 239     int                 db_perms;       /*<! open permissions */
 240
 241     int                 db_api;         /*<! Berkeley API type */
 242
 243     int                 db_remove_env;
 244     int                 db_filter_dups;
 245
 246     const char *        db_errpfx;
 247
 248     void                (*db_errcall) (const char *db_errpfx, char *buffer);
 249     FILE *              db_errfile;
 250     void *              (*db_malloc) (size_t nbytes);
 251
 252     int                 db_ndbi;
 253     dbiIndex            *_dbi;
 254 };
 255
 256 /* for RPM's internal use only */
 257
 258 #define RPMDB_FLAG_JUSTCHECK    (1 << 0)
 259 #define RPMDB_FLAG_MINIMAL      (1 << 1)
 260 #define RPMDB_FLAG_CHROOT       (1 << 2)
 261
 262 #ifdef __cplusplus
 263 extern "C" {
 264 #endif
 265
 266 /**
 267  * Return new configured index database handle instance.
 268  * @param rpmdb         rpm database
 269  */
 270 /*@only@*/ /*@null@*/ dbiIndex db3New(rpmdb rpmdb, int rpmtag);
 271
 272 /**
 273  * Destroy index database handle instance.
 274  * @param dbi           index database handle
 275  */
 276 void db3Free( /*@only@*/ /*@null@*/ dbiIndex dbi);
 277
 278 /**
 279  * Return handle for an index database.
 280  * @param rpmdb         rpm database
 281  * @param rpmtag        rpm tag
 282  * @param flags         (unused)
 283  * @return              index database handle
 284  */
 285 dbiIndex dbiOpen(rpmdb rpmdb, int rpmtag, unsigned int flags);
 286
 287 /**
 288  * @param flags         (unused)
 289  */
 290 int dbiCopen(dbiIndex dbi, DBC ** dbcp, unsigned int flags);
 291 int XdbiCopen(dbiIndex dbi, DBC ** dbcp, unsigned int flags, const char *f, unsigned int l);
 292 #define dbiCopen(_a,_b,_c) \
 293         XdbiCopen(_a, _b, _c, __FILE__, __LINE__)
 294
 295 /**
 296  * @param flags         (unused)
 297  */
 298 int dbiCclose(dbiIndex dbi, DBC * dbcursor, unsigned int flags);
 299 int XdbiCclose(dbiIndex dbi, DBC * dbcursor, unsigned int flags, const char *f, unsigned int l);
 300 #define dbiCclose(_a,_b,_c) \
 301         XdbiCclose(_a, _b, _c, __FILE__, __LINE__)
 302
 303 /**
 304  * Delete (key,data) pair(s) from index database.
 305  * @param dbi           index database handle
 306  * @param keyp          key data
 307  * @param keylen        key data length
 308  * @param flags         (unused)
 309  * @return              0 on success
 310  */
 311 int dbiDel(dbiIndex dbi, DBC * dbcursor, const void * keyp, size_t keylen,
 312         unsigned int flags);
 313
 314 /**
 315  * Retrieve (key,data) pair from index database.
 316  * @param dbi           index database handle
 317  * @param keypp         address of key data
 318  * @param keylenp       address of key data length
 319  * @param datapp        address of data pointer
 320  * @param datalenp      address of data length
 321  * @param flags         (unused)
 322  * @return              0 on success
 323  */
 324 int dbiGet(dbiIndex dbi, DBC * dbcursor, void ** keypp, size_t * keylenp,
 325         void ** datapp, size_t * datalenp, unsigned int flags);
 326
 327 /**
 328  * Store (key,data) pair in index database.
 329  * @param dbi           index database handle
 330  * @param keyp          key data
 331  * @param keylen        key data length
 332  * @param datap         data pointer
 333  * @param datalen       data length
 334  * @param flags         (unused)
 335  * @return              0 on success
 336  */
 337 int dbiPut(dbiIndex dbi, DBC * dbcursor, const void * keyp, size_t keylen,
 338         const void * datap, size_t datalen, unsigned int flags);
 339
 340 /**
 341  * Close index database.
 342  * @param dbi           index database handle
 343  * @param flags         (unused)
 344  * @return              0 on success
 345  */
 346 int dbiClose(dbiIndex dbi, unsigned int flags);
 347
 348 /**
 349  * Flush pending operations to disk.
 350  * @param dbi           index database handle
 351  * @param flags         (unused)
 352  * @return              0 on success
 353  */
 354 int dbiSync (dbiIndex dbi, unsigned int flags);
 355
 356 /**
 357  * Is database byte swapped?
 358  * @param dbi           index database handle
 359  * @return              0 no
 360  */
 361 int dbiByteSwapped(dbiIndex dbi);
 362
 363 /**
 364  * Return base file name for index database (legacy).
 365  * @param rpmtag        rpm tag
 366  * @return              base file name
 367  */
 368 char * db1basename(int rpmtag);
 369
 370 /**
 371  */
 372 unsigned int rpmdbGetIteratorFileNum(rpmdbMatchIterator mi);
 373
 374 /**
 375  * @param rpmdb         rpm database
 376  */
 377 int rpmdbFindFpList(rpmdb rpmdb, fingerPrint * fpList, /*@out@*/dbiIndexSet * matchList,
 378                     int numItems);
 379
 380 /**
 381  * Destroy set of index database items.
 382  * @param set   set of index database items
 383  */
 384 void dbiFreeIndexSet(/*@only@*/ /*@null@*/ dbiIndexSet set);
 385
 386 /**
 387  * Count items in index database set.
 388  * @param set   set of index database items
 389  * @return      number of items
 390  */
 391 unsigned int dbiIndexSetCount(dbiIndexSet set);
 392
 393 /**
 394  * Return record offset of header from element in index database set.
 395  * @param set   set of index database items
 396  * @param recno index of item in set
 397  * @return      record offset of header
 398  */
 399 unsigned int dbiIndexRecordOffset(dbiIndexSet set, int recno);
 400
 401 /**
 402  * Return file index from element in index database set.
 403  * @param set   set of index database items
 404  * @param recno index of item in set
 405  * @return      file index
 406  */
 407 unsigned int dbiIndexRecordFileNumber(dbiIndexSet set, int recno);
 408
 409 #ifdef __cplusplus
 410 }
 411 #endif
 412
 413 #endif  /* H_RPMDB */