rpmdb/rpmdb.h

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