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, /*@out@*/ 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) (/*@only@*/ 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  * Open database cursor.
  87  * @param dbi           index database handle
  88  * @param dbcp          address of database cursor
  89  * @param flags         (unused)
  90  */
  91     int (*copen) (dbiIndex dbi, /*@out@*/ DBC ** dbcp, unsigned int flags);
  92
  93 /**
  94  * Close database cursor.
  95  * @param dbi           index database handle
  96  * @param dbcursor      database cursor
  97  * @param flags         (unused)
  98  */
  99     int (*cclose) (dbiIndex dbi, /*@only@*/ DBC * dbcursor, unsigned int flags);
 100
 101 /**
 102  * Delete (key,data) pair(s) using db->del or dbcursor->c_del.
 103  * @param dbi           index database handle
 104  * @param dbcursor      database cursor
 105  * @param keyp          key data
 106  * @param keylen        key data length
 107  * @param flags         (unused)
 108  * @return              0 on success
 109  */
 110     int (*cdel) (dbiIndex dbi, DBC * dbcursor, const void * keyp, size_t keylen, unsigned int flags);
 111
 112 /**
 113  * Retrieve (key,data) pair using db->get or dbcursor->c_get.
 114  * @param dbi           index database handle
 115  * @param dbcursor      database cursor
 116  * @param keypp         address of key data
 117  * @param keylenp       address of key data length
 118  * @param datapp        address of data pointer
 119  * @param datalenp      address of data length
 120  * @param flags         (unused)
 121  * @return              0 on success
 122  */
 123     int (*cget) (dbiIndex dbi, DBC * dbcursor,
 124                         /*@out@*/ void ** keypp, /*@out@*/ size_t * keylenp,
 125                         /*@out@*/ void ** datapp, /*@out@*/ size_t * datalenp,
 126                         unsigned int flags);
 127
 128 /**
 129  * Store (key,data) pair using db->put or dbcursor->c_put.
 130  * @param dbi           index database handle
 131  * @param dbcursor      database cursor
 132  * @param keyp          key data
 133  * @param keylen        key data length
 134  * @param datap         data pointer
 135  * @param datalen       data length
 136  * @param flags         (unused)
 137  * @return              0 on success
 138  */
 139     int (*cput) (dbiIndex dbi, DBC * dbcursor,
 140                         const void * keyp, size_t keylen,
 141                         const void * datap, size_t datalen,
 142                         unsigned int flags);
 143
 144 /**
 145  * Is database byte swapped?
 146  * @param dbi           index database handle
 147  * @return              0 no
 148  */
 149     int (*byteswapped) (dbiIndex dbi);
 150
 151 };
 152
 153 /**
 154  * Describes an index database (implemented on Berkeley db[123] API).
 155  */
 156 struct _dbiIndex {
 157     const char *        dbi_root;
 158     const char *        dbi_home;
 159     const char *        dbi_file;
 160     const char *        dbi_subfile;
 161
 162     int                 dbi_cflags;     /*!< db_create/db_env_create flags */
 163     int                 dbi_oeflags;    /*!< common (db,dbenv}->open flags */
 164     int                 dbi_eflags;     /*!< dbenv->open flags */
 165     int                 dbi_oflags;     /*!< db->open flags */
 166     int                 dbi_tflags;     /*!< dbenv->txn_begin flags */
 167
 168     int                 dbi_type;       /*!< db index type */
 169     int                 dbi_mode;       /*!< mode to use on open */
 170     int                 dbi_perms;      /*!< file permission to use on open */
 171     int                 dbi_api;        /*!< Berkeley API type */
 172
 173     int                 dbi_tear_down;
 174     int                 dbi_use_cursors;
 175     int                 dbi_use_dbenv;
 176     int                 dbi_get_rmw_cursor;
 177     int                 dbi_no_fsync;   /*!< no-op fsync for db */
 178     int                 dbi_no_dbsync;  /*!< don't call dbiSync */
 179     int                 dbi_lockdbfd;   /*!< do fcntl lock on db fd */
 180     int                 dbi_temporary;  /*!< non-persistent */
 181     int                 dbi_debug;
 182
 183         /* dbenv parameters */
 184     int                 dbi_lorder;
 185     void                (*db_errcall) (const char *db_errpfx, char *buffer);
 186     FILE *              dbi_errfile;
 187     const char *        dbi_errpfx;
 188     int                 dbi_verbose;
 189     int                 dbi_region_init;
 190     int                 dbi_tas_spins;
 191         /* mpool sub-system parameters */
 192     int                 dbi_mp_mmapsize;        /*!< (10Mb) */
 193     int                 dbi_mp_size;    /*!< (128Kb) */
 194         /* lock sub-system parameters */
 195     unsigned int        dbi_lk_max;
 196     unsigned int        dbi_lk_detect;
 197     int                 dbi_lk_nmodes;
 198     unsigned char       *dbi_lk_conflicts;
 199         /* log sub-system parameters */
 200     unsigned int        dbi_lg_max;
 201     unsigned int        dbi_lg_bsize;
 202         /* transaction sub-system parameters */
 203     unsigned int        dbi_tx_max;
 204 #if 0
 205     int                 (*dbi_tx_recover) (DB_ENV *dbenv, DBT *log_rec, DB_LSN *lsnp, int redo, void *info);
 206 #endif
 207         /* dbinfo parameters */
 208     int                 dbi_cachesize;  /*!< */
 209     int                 dbi_pagesize;   /*!< (fs blksize) */
 210     void *              (*dbi_malloc) (size_t nbytes);
 211         /* hash access parameters */
 212     unsigned int        dbi_h_ffactor;  /*!< */
 213     unsigned int        (*dbi_h_hash_fcn) (const void *bytes, unsigned int length);
 214     unsigned int        dbi_h_nelem;    /*!< */
 215     unsigned int        dbi_h_flags;    /*!< DB_DUP, DB_DUPSORT */
 216     int                 (*dbi_h_dup_compare_fcn) (const DBT *, const DBT *);
 217         /* btree access parameters */
 218     int                 dbi_bt_flags;
 219     int                 dbi_bt_minkey;
 220     int                 (*dbi_bt_compare_fcn)(const DBT *, const DBT *);
 221     int                 (*dbi_bt_dup_compare_fcn) (const DBT *, const DBT *);
 222     size_t              (*dbi_bt_prefix_fcn) (const DBT *, const DBT *);
 223         /* recno access parameters */
 224     int                 dbi_re_flags;
 225     int                 dbi_re_delim;
 226     unsigned int        dbi_re_len;
 227     int                 dbi_re_pad;
 228     const char *        dbi_re_source;
 229
 230     rpmdb       dbi_rpmdb;
 231     int         dbi_rpmtag;             /*!< rpm tag used for index */
 232     int         dbi_jlen;               /*!< size of join key */
 233
 234     unsigned int dbi_lastoffset;        /*!< db1 with falloc.c needs this */
 235
 236     void *      dbi_db;                 /*!< dbi handle */
 237     void *      dbi_dbenv;
 238     void *      dbi_dbinfo;
 239     void *      dbi_rmw;                /*!< db cursor (with DB_WRITECURSOR) */
 240
 241 /*@observer@*/ const struct _dbiVec * dbi_vec;  /*!< private methods */
 242
 243 };
 244
 245 /**
 246  * Describes the collection of index databases used by rpm.
 247  */
 248 struct rpmdb_s {
 249     const char *        db_root;        /*!< path prefix */
 250     const char *        db_home;        /*!< directory path */
 251     int                 db_flags;
 252
 253     int                 db_mode;        /*!< open mode */
 254     int                 db_perms;       /*!< open permissions */
 255
 256     int                 db_api;         /*!< Berkeley API type */
 257
 258     int                 db_remove_env;
 259     int                 db_filter_dups;
 260
 261     const char *        db_errpfx;
 262
 263     void                (*db_errcall) (const char *db_errpfx, char *buffer);
 264     FILE *              db_errfile;
 265     void *              (*db_malloc) (size_t nbytes);
 266
 267     int                 db_ndbi;
 268     dbiIndex            *_dbi;
 269 };
 270
 271 /* for RPM's internal use only */
 272
 273 #define RPMDB_FLAG_JUSTCHECK    (1 << 0)
 274 #define RPMDB_FLAG_MINIMAL      (1 << 1)
 275 #define RPMDB_FLAG_CHROOT       (1 << 2)
 276
 277 #ifdef __cplusplus
 278 extern "C" {
 279 #endif
 280
 281 /**
 282  * Return new configured index database handle instance.
 283  * @param rpmdb         rpm database
 284  */
 285 /*@only@*/ /*@null@*/ dbiIndex db3New(/*@keep@*/ rpmdb rpmdb, int rpmtag);
 286
 287 /**
 288  * Destroy index database handle instance.
 289  * @param dbi           index database handle
 290  */
 291 void db3Free( /*@only@*/ /*@null@*/ dbiIndex dbi);
 292
 293 /**
 294  * Return handle for an index database.
 295  * @param rpmdb         rpm database
 296  * @param rpmtag        rpm tag
 297  * @param flags         (unused)
 298  * @return              index database handle
 299  */
 300 /*@only@*/ /*@null@*/ dbiIndex dbiOpen(rpmdb rpmdb, int rpmtag,
 301                 unsigned int flags);
 302
 303 /**
 304  * @param dbi           index database handle
 305  * @param flags         (unused)
 306  */
 307 int dbiCopen(dbiIndex dbi, /*@out@*/ DBC ** dbcp, unsigned int flags);
 308 int XdbiCopen(dbiIndex dbi, /*@out@*/ DBC ** dbcp, unsigned int flags, const char *f, unsigned int l);
 309 #define dbiCopen(_a,_b,_c) \
 310         XdbiCopen(_a, _b, _c, __FILE__, __LINE__)
 311
 312 /**
 313  * @param dbi           index database handle
 314  * @param flags         (unused)
 315  */
 316 int dbiCclose(dbiIndex dbi, /*@only@*/ DBC * dbcursor, unsigned int flags);
 317 int XdbiCclose(dbiIndex dbi, /*@only@*/ DBC * dbcursor, unsigned int flags, const char *f, unsigned int l);
 318 #define dbiCclose(_a,_b,_c) \
 319         XdbiCclose(_a, _b, _c, __FILE__, __LINE__)
 320
 321 /**
 322  * Delete (key,data) pair(s) from index database.
 323  * @param dbi           index database handle
 324  * @param keyp          key data
 325  * @param keylen        key data length
 326  * @param flags         (unused)
 327  * @return              0 on success
 328  */
 329 int dbiDel(dbiIndex dbi, DBC * dbcursor, const void * keyp, size_t keylen,
 330         unsigned int flags);
 331
 332 /**
 333  * Retrieve (key,data) pair from index database.
 334  * @param dbi           index database handle
 335  * @param keypp         address of key data
 336  * @param keylenp       address of key data length
 337  * @param datapp        address of data pointer
 338  * @param datalenp      address of data length
 339  * @param flags         (unused)
 340  * @return              0 on success
 341  */
 342 int dbiGet(dbiIndex dbi, DBC * dbcursor, void ** keypp, size_t * keylenp,
 343         void ** datapp, size_t * datalenp, unsigned int flags);
 344
 345 /**
 346  * Store (key,data) pair in index database.
 347  * @param dbi           index database handle
 348  * @param keyp          key data
 349  * @param keylen        key data length
 350  * @param datap         data pointer
 351  * @param datalen       data length
 352  * @param flags         (unused)
 353  * @return              0 on success
 354  */
 355 int dbiPut(dbiIndex dbi, DBC * dbcursor, const void * keyp, size_t keylen,
 356         const void * datap, size_t datalen, unsigned int flags);
 357
 358 /**
 359  * Close index database.
 360  * @param dbi           index database handle
 361  * @param flags         (unused)
 362  * @return              0 on success
 363  */
 364 int dbiClose(/*@only@*/ dbiIndex dbi, unsigned int flags);
 365
 366 /**
 367  * Flush pending operations to disk.
 368  * @param dbi           index database handle
 369  * @param flags         (unused)
 370  * @return              0 on success
 371  */
 372 int dbiSync (dbiIndex dbi, unsigned int flags);
 373
 374 /**
 375  * Is database byte swapped?
 376  * @param dbi           index database handle
 377  * @return              0 no
 378  */
 379 int dbiByteSwapped(dbiIndex dbi);
 380
 381 /**
 382  * Return base file name for index database (legacy).
 383  * @param rpmtag        rpm tag
 384  * @return              base file name
 385  */
 386 char * db1basename(int rpmtag);
 387
 388 /**
 389  */
 390 unsigned int rpmdbGetIteratorFileNum(rpmdbMatchIterator mi);
 391
 392 /**
 393  * @param rpmdb         rpm database
 394  */
 395 int rpmdbFindFpList(rpmdb rpmdb, fingerPrint * fpList, /*@out@*/dbiIndexSet * matchList,
 396                     int numItems);
 397
 398 /**
 399  * Destroy set of index database items.
 400  * @param set   set of index database items
 401  */
 402 void dbiFreeIndexSet(/*@only@*/ /*@null@*/ dbiIndexSet set);
 403
 404 /**
 405  * Count items in index database set.
 406  * @param set   set of index database items
 407  * @return      number of items
 408  */
 409 unsigned int dbiIndexSetCount(dbiIndexSet set);
 410
 411 /**
 412  * Return record offset of header from element in index database set.
 413  * @param set   set of index database items
 414  * @param recno index of item in set
 415  * @return      record offset of header
 416  */
 417 unsigned int dbiIndexRecordOffset(dbiIndexSet set, int recno);
 418
 419 /**
 420  * Return file index from element in index database set.
 421  * @param set   set of index database items
 422  * @param recno index of item in set
 423  * @return      file index
 424  */
 425 unsigned int dbiIndexRecordFileNumber(dbiIndexSet set, int recno);
 426
 427 #ifdef __cplusplus
 428 }
 429 #endif
 430
 431 #endif  /* H_RPMDB */