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 <assert.h>
  10 #include <rpmlib.h>
  11 #include <db.h>
  12
  13 /**
  14  */
  15 typedef /*@abstract@*/ struct _dbiIndexItem * dbiIndexItem;
  16
  17 /**
  18  */
  19 typedef /*@abstract@*/ struct _dbiIndex * dbiIndex;
  20
  21 /* this will break if sizeof(int) != 4 */
  22 /** \ingroup dbi
  23  * A single item from an index database (i.e. the "data returned").
  24  * Note: In rpm-3.0.4 and earlier, this structure was passed by value,
  25  * and was identical to the "data saved" structure below.
  26  */
  27 struct _dbiIndexItem {
  28     unsigned int hdrNum;                /*!< header instance in db */
  29     unsigned int tagNum;                /*!< tag index in header */
  30     unsigned int fpNum;                 /*!< finger print index */
  31     unsigned int dbNum;                 /*!< database index */
  32 };
  33
  34 /** \ingroup dbi
  35  * Items retrieved from the index database.
  36  */
  37 struct _dbiIndexSet {
  38 /*@owned@*/ struct _dbiIndexItem * recs; /*!< array of records */
  39     int count;                          /*!< number of records */
  40 };
  41
  42 /** \ingroup dbi
  43  * Private methods for accessing an index database.
  44  */
  45 struct _dbiVec {
  46     int dbv_major;                      /*!< Berkeley db version major */
  47     int dbv_minor;                      /*!< Berkeley db version minor */
  48     int dbv_patch;                      /*!< Berkeley db version patch */
  49
  50 /** \ingroup dbi
  51  * Return handle for an index database.
  52  * @param rpmdb         rpm database
  53  * @param rpmtag        rpm tag
  54  * @return              0 on success
  55  */
  56     int (*open) (rpmdb rpmdb, rpmTag rpmtag, /*@out@*/ dbiIndex * dbip)
  57         /*@globals fileSystem @*/
  58         /*@modifies *dbip, fileSystem @*/;
  59
  60 /** \ingroup dbi
  61  * Close index database, and destroy database handle.
  62  * @param dbi           index database handle
  63  * @param flags         (unused)
  64  * @return              0 on success
  65  */
  66     int (*close) (/*@only@*/ dbiIndex dbi, unsigned int flags)
  67         /*@globals fileSystem @*/
  68         /*@modifies dbi, fileSystem @*/;
  69
  70 /** \ingroup dbi
  71  * Flush pending operations to disk.
  72  * @param dbi           index database handle
  73  * @param flags         (unused)
  74  * @return              0 on success
  75  */
  76     int (*sync) (dbiIndex dbi, unsigned int flags)
  77         /*@globals fileSystem @*/
  78         /*@modifies fileSystem @*/;
  79
  80 /** \ingroup dbi
  81  * Associate secondary database with primary.
  82  * @param dbi           index database handle
  83  * @param dbisecondary  secondary index database handle
  84  * @param callback      create secondary key from primary (NULL if DB_RDONLY)
  85  * @param flags         DB_CREATE or 0
  86  * @return              0 on success
  87  */
  88     int (*associate) (dbiIndex dbi, dbiIndex dbisecondary,
  89                 int (*callback) (DB *, const DBT *, const DBT *, DBT *),
  90                 unsigned int flags)
  91         /*@globals fileSystem @*/
  92         /*@modifies dbi, fileSystem @*/;
  93
  94 /** \ingroup dbi
  95  * Return join cursor for list of cursors.
  96  * @param dbi           index database handle
  97  * @param curslist      NULL terminated list of database cursors
  98  * @retval dbcp         address of join database cursor
  99  * @param flags         DB_JOIN_NOSORT or 0
 100  * @return              0 on success
 101  */
 102     int (*join) (dbiIndex dbi, DBC ** curslist, /*@out@*/ DBC ** dbcp,
 103                 unsigned int flags)
 104         /*@globals fileSystem @*/
 105         /*@modifies dbi, *dbcp, fileSystem @*/;
 106
 107 /** \ingroup dbi
 108  * Open database cursor.
 109  * @param dbi           index database handle
 110  * @param txnid         database transaction handle
 111  * @retval dbcp         address of new database cursor
 112  * @param dbiflags      DB_WRITECURSOR or 0
 113  * @return              0 on success
 114  */
 115     int (*copen) (dbiIndex dbi, /*@null@*/ DB_TXN * txnid,
 116                         /*@out@*/ DBC ** dbcp, unsigned int dbiflags)
 117         /*@globals fileSystem @*/
 118         /*@modifies dbi, *txnid, *dbcp, fileSystem @*/;
 119
 120 /** \ingroup dbi
 121  * Close database cursor.
 122  * @param dbi           index database handle
 123  * @param dbcursor      database cursor
 124  * @param flags         (unused)
 125  * @return              0 on success
 126  */
 127     int (*cclose) (dbiIndex dbi, /*@only@*/ DBC * dbcursor, unsigned int flags)
 128         /*@globals fileSystem @*/
 129         /*@modifies dbi, *dbcursor, fileSystem @*/;
 130
 131 /** \ingroup dbi
 132  * Duplicate a database cursor.
 133  * @param dbi           index database handle
 134  * @param dbcursor      database cursor
 135  * @retval dbcp         address of new database cursor
 136  * @param flags         DB_POSITION for same position, 0 for uninitialized
 137  * @return              0 on success
 138  */
 139     int (*cdup) (dbiIndex dbi, DBC * dbcursor, /*@out@*/ DBC ** dbcp,
 140                 unsigned int flags)
 141         /*@globals fileSystem @*/
 142         /*@modifies dbi, *dbcp, fileSystem @*/;
 143
 144 /** \ingroup dbi
 145  * Delete (key,data) pair(s) using db->del or dbcursor->c_del.
 146  * @param dbi           index database handle
 147  * @param dbcursor      database cursor (NULL will use db->del)
 148  * @param key           delete key value/length/flags
 149  * @param data          delete data value/length/flags
 150  * @param flags         (unused)
 151  * @return              0 on success
 152  */
 153     int (*cdel) (dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
 154                         unsigned int flags)
 155         /*@globals fileSystem @*/
 156         /*@modifies *dbcursor, fileSystem @*/;
 157
 158 /** \ingroup dbi
 159  * Retrieve (key,data) pair using db->get or dbcursor->c_get.
 160  * @param dbi           index database handle
 161  * @param dbcursor      database cursor (NULL will use db->get)
 162  * @param key           retrieve key value/length/flags
 163  * @param data          retrieve data value/length/flags
 164  * @param flags         (unused)
 165  * @return              0 on success
 166  */
 167     int (*cget) (dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
 168                         unsigned int flags)
 169         /*@globals fileSystem @*/
 170         /*@modifies *dbcursor, *key, *data, fileSystem @*/;
 171
 172 /** \ingroup dbi
 173  * Retrieve (key,data) pair using dbcursor->c_pget.
 174  * @param dbi           index database handle
 175  * @param dbcursor      database cursor
 176  * @param key           secondary retrieve key value/length/flags
 177  * @param pkey          primary retrieve key value/length/flags
 178  * @param data          primary retrieve data value/length/flags
 179  * @param flags         DB_NEXT, DB_SET, or 0
 180  * @return              0 on success
 181  */
 182     int (*cpget) (dbiIndex dbi, /*@null@*/ DBC * dbcursor,
 183                 DBT * key, DBT * pkey, DBT * data, unsigned int flags)
 184         /*@globals fileSystem @*/
 185         /*@modifies *dbcursor, *key, *pkey, *data, fileSystem @*/;
 186
 187 /** \ingroup dbi
 188  * Store (key,data) pair using db->put or dbcursor->c_put.
 189  * @param dbi           index database handle
 190  * @param dbcursor      database cursor (NULL will use db->put)
 191  * @param key           store key value/length/flags
 192  * @param data          store data value/length/flags
 193  * @param flags         (unused)
 194  * @return              0 on success
 195  */
 196     int (*cput) (dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
 197                         unsigned int flags)
 198         /*@globals fileSystem @*/
 199         /*@modifies *dbcursor, fileSystem @*/;
 200
 201 /** \ingroup dbi
 202  * Retrieve count of (possible) duplicate items using dbcursor->c_count.
 203  * @param dbi           index database handle
 204  * @param dbcursor      database cursor
 205  * @param countp        address of count
 206  * @param flags         (unused)
 207  * @return              0 on success
 208  */
 209     int (*ccount) (dbiIndex dbi, DBC * dbcursor,
 210                         /*@out@*/ unsigned int * countp,
 211                         unsigned int flags)
 212         /*@globals fileSystem @*/
 213         /*@modifies *dbcursor, fileSystem @*/;
 214
 215 /** \ingroup dbi
 216  * Is database byte swapped?
 217  * @param dbi           index database handle
 218  * @return              0 no
 219  */
 220     int (*byteswapped) (dbiIndex dbi)
 221         /*@globals fileSystem @*/
 222         /*@modifies fileSystem @*/;
 223
 224 /** \ingroup dbi
 225  * Save statistics in database handle.
 226  * @param dbi           index database handle
 227  * @param flags         retrieve statistics that don't require traversal?
 228  * @return              0 on success
 229  */
 230     int (*stat) (dbiIndex dbi, unsigned int flags)
 231         /*@globals fileSystem @*/
 232         /*@modifies dbi, fileSystem @*/;
 233
 234 };
 235
 236 /** \ingroup dbi
 237  * Describes an index database (implemented on Berkeley db3 functionality).
 238  */
 239 struct _dbiIndex {
 240 /*@null@*/
 241     const char * dbi_root;      /*!< chroot(2) component of path */
 242 /*@null@*/
 243     const char * dbi_home;      /*!< directory component of path */
 244 /*@null@*/
 245     const char * dbi_file;      /*!< file component of path */
 246 /*@null@*/
 247     const char * dbi_subfile;
 248 /*@null@*/
 249     const char * dbi_tmpdir;    /*!< temporary directory */
 250
 251     int dbi_ecflags;            /*!< db_env_create flags */
 252     int dbi_cflags;             /*!< db_create flags */
 253     int dbi_oeflags;            /*!< common (db,dbenv}->open flags */
 254     int dbi_eflags;             /*!< dbenv->open flags */
 255     int dbi_oflags;             /*!< db->open flags */
 256     int dbi_tflags;             /*!< dbenv->txn_begin flags */
 257
 258     int dbi_type;               /*!< db index type */
 259     unsigned dbi_mode;          /*!< mode to use on open */
 260     int dbi_perms;              /*!< file permission to use on open */
 261     long dbi_shmkey;            /*!< shared memory base key */
 262     int dbi_api;                /*!< Berkeley API type */
 263
 264     int dbi_verify_on_close;
 265     int dbi_tear_down;          /*!< tear down dbenv on close */
 266     int dbi_use_cursors;        /*!< access with cursors? (always) */
 267     int dbi_use_dbenv;          /*!< use db environment? */
 268     int dbi_permit_dups;        /*!< permit duplicate entries? */
 269     int dbi_no_fsync;           /*!< no-op fsync for db */
 270     int dbi_no_dbsync;          /*!< don't call dbiSync */
 271     int dbi_lockdbfd;           /*!< do fcntl lock on db fd */
 272     int dbi_temporary;          /*!< non-persistent */
 273     int dbi_debug;
 274     int dbi_byteswapped;
 275
 276 /*@null@*/ char * dbi_host;
 277     long dbi_cl_timeout;
 278     long dbi_sv_timeout;
 279
 280         /* dbenv parameters */
 281     int dbi_lorder;
 282 /*@unused@*/
 283     void (*db_errcall) (const char *db_errpfx, char *buffer)
 284         /*@globals fileSystem @*/
 285         /*@modifies fileSystem @*/;
 286 /*@unused@*/ /*@shared@*/
 287     FILE *      dbi_errfile;
 288     const char * dbi_errpfx;
 289     int dbi_verbose;
 290     int dbi_region_init;
 291     int dbi_tas_spins;
 292         /* mpool sub-system parameters */
 293     int dbi_mp_mmapsize;        /*!< (10Mb) */
 294     int dbi_mp_size;    /*!< (128Kb) */
 295         /* lock sub-system parameters */
 296     unsigned int dbi_lk_max;
 297     unsigned int dbi_lk_detect;
 298 /*@unused@*/ int dbi_lk_nmodes;
 299 /*@unused@*/ unsigned char * dbi_lk_conflicts;
 300         /* log sub-system parameters */
 301     unsigned int dbi_lg_max;
 302     unsigned int dbi_lg_bsize;
 303         /* transaction sub-system parameters */
 304     unsigned int dbi_tx_max;
 305 #if 0
 306     int (*dbi_tx_recover) (DB_ENV *dbenv, DBT *log_rec,
 307                                 DB_LSN *lsnp, int redo, void *info)
 308         /*@globals fileSystem @*/
 309         /*@modifies fileSystem @*/;
 310 #endif
 311         /* dbinfo parameters */
 312     int dbi_cachesize;          /*!< */
 313     int dbi_pagesize;           /*!< (fs blksize) */
 314 /*@unused@*/ /*@null@*/
 315     void * (*dbi_malloc) (size_t nbytes)
 316         /*@*/;
 317         /* hash access parameters */
 318     unsigned int dbi_h_ffactor; /*!< */
 319     unsigned int (*dbi_h_hash_fcn) (DB *, const void *bytes,
 320                                 unsigned int length)
 321         /*@*/;
 322     unsigned int dbi_h_nelem;   /*!< */
 323     unsigned int dbi_h_flags;   /*!< DB_DUP, DB_DUPSORT */
 324     int (*dbi_h_dup_compare_fcn) (DB *, const DBT *, const DBT *)
 325         /*@*/;
 326         /* btree access parameters */
 327     int dbi_bt_flags;
 328     int dbi_bt_minkey;
 329     int (*dbi_bt_compare_fcn) (DB *, const DBT *, const DBT *)
 330         /*@*/;
 331     int (*dbi_bt_dup_compare_fcn) (DB *, const DBT *, const DBT *)
 332         /*@*/;
 333     size_t (*dbi_bt_prefix_fcn) (DB *, const DBT *, const DBT *)
 334         /*@*/;
 335         /* recno access parameters */
 336     int dbi_re_flags;
 337     int dbi_re_delim;
 338     unsigned int dbi_re_len;
 339     int dbi_re_pad;
 340     const char * dbi_re_source;
 341         /* queue access parameters */
 342     unsigned int dbi_q_extentsize;
 343
 344 /*@refcounted@*/
 345     rpmdb dbi_rpmdb;
 346     rpmTag dbi_rpmtag;          /*!< rpm tag used for index */
 347     int dbi_jlen;               /*!< size of join key */
 348
 349     unsigned int dbi_lastoffset;        /*!< db1 with falloc.c needs this */
 350
 351 /*@only@*//*@null@*/
 352     DB * dbi_db;                /*!< Berkeley DB * handle */
 353 /*@only@*//*@null@*/
 354     DB_TXN * dbi_txnid;         /*!< Bekerley DB_TXN * transaction id */
 355 /*@only@*//*@null@*/
 356     void * dbi_stats;           /*!< Berkeley db statistics */
 357
 358 /*@observer@*/
 359     const struct _dbiVec * dbi_vec;     /*!< private methods */
 360
 361 };
 362
 363 /** \ingroup rpmdb
 364  * Describes the collection of index databases used by rpm.
 365  */
 366 struct rpmdb_s {
 367 /*@owned@*/ const char * db_root;/*!< path prefix */
 368 /*@owned@*/ const char * db_home;/*!< directory path */
 369     int         db_flags;
 370     int         db_mode;        /*!< open mode */
 371     int         db_perms;       /*!< open permissions */
 372     int         db_api;         /*!< Berkeley API type */
 373 /*@owned@*/ const char * db_errpfx;
 374     int         db_remove_env;
 375     int         db_filter_dups;
 376     int         db_chrootDone;  /*!< If chroot(2) done, ignore db_root. */
 377     void (*db_errcall) (const char *db_errpfx, char *buffer)
 378         /*@*/;
 379 /*@shared@*/ FILE *     db_errfile;
 380 /*@only@*/ void * (*db_malloc) (size_t nbytes)
 381         /*@*/;
 382 /*@only@*/ void * (*db_realloc) (/*@only@*//*@null@*/ void * ptr,
 383                                                 size_t nbytes)
 384         /*@*/;
 385     void (*db_free) (/*@only@*/ void * ptr)
 386         /*@modifies *ptr @*/;
 387     int         db_opens;
 388 /*@only@*//*@null@*/ void * db_dbenv;   /*!< Berkeley DB_ENV handle */
 389     int         db_ndbi;        /*!< No. of tag indices. */
 390     dbiIndex *  _dbi;           /*!< Tag indices. */
 391
 392 /*@refs@*/ int nrefs;           /*!< Reference count. */
 393 };
 394
 395 /* for RPM's internal use only */
 396
 397 /** \ingroup rpmdb
 398  */
 399 enum rpmdbFlags {
 400         RPMDB_FLAG_JUSTCHECK    = (1 << 0),
 401         RPMDB_FLAG_MINIMAL      = (1 << 1),
 402 /*@-enummemuse@*/
 403         RPMDB_FLAG_CHROOT       = (1 << 2)
 404 /*@=enummemuse@*/
 405 };
 406
 407 #ifdef __cplusplus
 408 extern "C" {
 409 #endif
 410
 411 /*@-exportlocal@*/
 412 /** \ingroup db3
 413  * Return new configured index database handle instance.
 414  * @param rpmdb         rpm database
 415  * @param rpmtag        rpm tag
 416  * @return              index database handle
 417  */
 418 /*@unused@*/ /*@only@*/ /*@null@*/
 419 dbiIndex db3New(rpmdb rpmdb, rpmTag rpmtag)
 420         /*@globals rpmGlobalMacroContext @*/
 421         /*@modifies rpmGlobalMacroContext @*/;
 422
 423 /** \ingroup db3
 424  * Destroy index database handle instance.
 425  * @param dbi           index database handle
 426  * @return              NULL always
 427  */
 428 /*@null@*/
 429 dbiIndex db3Free( /*@only@*/ /*@null@*/ dbiIndex dbi)
 430         /*@*/;
 431
 432 /** \ingroup db3
 433  * Format db3 open flags for debugging print.
 434  * @param dbflags               db open flags
 435  * @param print_dbenv_flags     format db env flags instead?
 436  * @return                      formatted flags (static buffer)
 437  */
 438 /*@-redecl@*/
 439 /*@exposed@*/
 440 extern const char *const prDbiOpenFlags(int dbflags, int print_dbenv_flags)
 441         /*@*/;
 442 /*@=redecl@*/
 443
 444 /** \ingroup dbi
 445  * Return handle for an index database.
 446  * @param db            rpm database
 447  * @param rpmtag        rpm tag
 448  * @param flags         (unused)
 449  * @return              index database handle
 450  */
 451 /*@only@*/ /*@null@*/ dbiIndex dbiOpen(/*@null@*/ rpmdb db, rpmTag rpmtag,
 452                 unsigned int flags)
 453         /*@modifies db @*/;
 454
 455 /*@-globuse -mods -mustmod @*/
 456 /** \ingroup dbi
 457  * Open a database cursor.
 458  * @param dbi           index database handle
 459  * @param txnid         database transaction handle
 460  * @retval dbcp         returned database cursor
 461  * @param flags         DB_WRITECURSOR if writing, or 0
 462  * @return              0 on success
 463  */
 464 /*@unused@*/ static inline
 465 int dbiCopen(dbiIndex dbi, /*@null@*/ DB_TXN * txnid,
 466                 /*@out@*/ DBC ** dbcp, unsigned int flags)
 467         /*@globals fileSystem @*/
 468         /*@modifies dbi, *dbcp, fileSystem @*/
 469 {
 470     return (*dbi->dbi_vec->copen) (dbi, txnid, dbcp, flags);
 471 }
 472
 473 /** \ingroup dbi
 474  * Close a database cursor.
 475  * @param dbi           index database handle
 476  * @param dbcursor      database cursor
 477  * @param flags         (unused)
 478  * @return              0 on success
 479  */
 480 /*@unused@*/ static inline
 481 int dbiCclose(dbiIndex dbi, /*@only@*/ DBC * dbcursor, unsigned int flags)
 482         /*@globals fileSystem @*/
 483         /*@modifies dbi, *dbcursor, fileSystem @*/
 484 {
 485     return (*dbi->dbi_vec->cclose) (dbi, dbcursor, flags);
 486 }
 487
 488 /** \ingroup dbi
 489  * Duplicate a database cursor.
 490  * @param dbi           index database handle
 491  * @param dbcursor      database cursor
 492  * @retval dbcp         address of new database cursor
 493  * @param flags         DB_POSITION for same position, 0 for uninitialized
 494  * @return              0 on success
 495  */
 496 /*@unused@*/ static inline
 497 int dbiCdup(dbiIndex dbi, DBC * dbcursor, /*@out@*/ DBC ** dbcp,
 498                 unsigned int flags)
 499         /*@modifies dbi, *dbcp @*/
 500 {
 501     return (*dbi->dbi_vec->cdup) (dbi, dbcursor, dbcp, flags);
 502 }
 503
 504 /** \ingroup dbi
 505  * Delete (key,data) pair(s) from index database.
 506  * @param dbi           index database handle
 507  * @param dbcursor      database cursor (NULL will use db->del)
 508  * @param key           delete key value/length/flags
 509  * @param data          delete data value/length/flags
 510  * @param flags         (unused)
 511  * @return              0 on success
 512  */
 513 /*@unused@*/ static inline
 514 int dbiDel(dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
 515                 unsigned int flags)
 516         /*@globals fileSystem @*/
 517         /*@modifies *dbcursor, fileSystem @*/
 518 {
 519     assert(key->size > 0);
 520     return (dbi->dbi_vec->cdel) (dbi, dbcursor, key, data, flags);
 521 }
 522
 523 /** \ingroup dbi
 524  * Retrieve (key,data) pair from index database.
 525  * @param dbi           index database handle
 526  * @param dbcursor      database cursor (NULL will use db->get)
 527  * @param key           retrieve key value/length/flags
 528  * @param data          retrieve data value/length/flags
 529  * @param flags         (unused)
 530  * @return              0 on success
 531  */
 532 /*@unused@*/ static inline
 533 int dbiGet(dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
 534                 unsigned int flags)
 535         /*@globals fileSystem @*/
 536         /*@modifies *dbcursor, *key, *data, fileSystem @*/
 537 {
 538     assert((flags == DB_NEXT) || key->size > 0);
 539     return (dbi->dbi_vec->cget) (dbi, dbcursor, key, data, flags);
 540 }
 541
 542 /** \ingroup dbi
 543  * Retrieve (key,data) pair using dbcursor->c_pget.
 544  * @param dbi           index database handle
 545  * @param dbcursor      database cursor (NULL will use db->get)
 546  * @param key           secondary retrieve key value/length/flags
 547  * @param pkey          primary retrieve key value/length/flags
 548  * @param data          primary retrieve data value/length/flags
 549  * @param flags         DB_NEXT, DB_SET, or 0
 550  * @return              0 on success
 551  */
 552 /*@unused@*/ static inline
 553 int dbiPget(dbiIndex dbi, /*@null@*/ DBC * dbcursor,
 554                 DBT * key, DBT * pkey, DBT * data, unsigned int flags)
 555         /*@globals fileSystem @*/
 556         /*@modifies *dbcursor, *key, *pkey, *data, fileSystem @*/
 557 {
 558     assert((flags == DB_NEXT) || key->size > 0);
 559     return (dbi->dbi_vec->cpget) (dbi, dbcursor, key, pkey, data, flags);
 560 }
 561
 562 /** \ingroup dbi
 563  * Store (key,data) pair in index database.
 564  * @param dbi           index database handle
 565  * @param dbcursor      database cursor (NULL will use db->put)
 566  * @param key           store key value/length/flags
 567  * @param data          store data value/length/flags
 568  * @param flags         (unused)
 569  * @return              0 on success
 570  */
 571 /*@unused@*/ static inline
 572 int dbiPut(dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
 573                 unsigned int flags)
 574         /*@globals fileSystem @*/
 575         /*@modifies *dbcursor, *key, fileSystem @*/
 576 {
 577     assert(key->size > 0);
 578     return (dbi->dbi_vec->cput) (dbi, dbcursor, key, data, flags);
 579 }
 580
 581 /** \ingroup dbi
 582  * Retrieve count of (possible) duplicate items.
 583  * @param dbi           index database handle
 584  * @param dbcursor      database cursor
 585  * @param countp        address of count
 586  * @param flags         (unused)
 587  * @return              0 on success
 588  */
 589 /*@unused@*/ static inline
 590 int dbiCount(dbiIndex dbi, DBC * dbcursor, /*@out@*/ unsigned int * countp,
 591                 unsigned int flags)
 592         /*@globals fileSystem @*/
 593         /*@modifies *dbcursor, fileSystem @*/
 594 {
 595     return (*dbi->dbi_vec->ccount) (dbi, dbcursor, countp, flags);
 596 }
 597
 598 /** \ingroup dbi
 599  * Verify (and close) index database.
 600  * @param dbi           index database handle
 601  * @param flags         (unused)
 602  * @return              0 on success
 603  */
 604 /*@unused@*/ static inline
 605 int dbiVerify(/*@only@*/ dbiIndex dbi, unsigned int flags)
 606         /*@globals fileSystem @*/
 607         /*@modifies dbi, fileSystem @*/
 608 {
 609     dbi->dbi_verify_on_close = 1;
 610     return (*dbi->dbi_vec->close) (dbi, flags);
 611 }
 612
 613 /** \ingroup dbi
 614  * Close index database.
 615  * @param dbi           index database handle
 616  * @param flags         (unused)
 617  * @return              0 on success
 618  */
 619 /*@unused@*/ static inline
 620 int dbiClose(/*@only@*/ dbiIndex dbi, unsigned int flags)
 621         /*@globals fileSystem @*/
 622         /*@modifies dbi, fileSystem @*/
 623 {
 624     return (*dbi->dbi_vec->close) (dbi, flags);
 625 }
 626
 627 /** \ingroup dbi
 628  * Flush pending operations to disk.
 629  * @param dbi           index database handle
 630  * @param flags         (unused)
 631  * @return              0 on success
 632  */
 633 /*@unused@*/ static inline
 634 int dbiSync (dbiIndex dbi, unsigned int flags)
 635         /*@globals fileSystem @*/
 636         /*@modifies fileSystem @*/
 637 {
 638     return (*dbi->dbi_vec->sync) (dbi, flags);
 639 }
 640
 641 /** \ingroup dbi
 642  * Associate secondary database with primary.
 643  * @param dbi           index database handle
 644  * @param dbisecondary  secondary index database handle
 645  * @param callback      create secondary key from primary (NULL if DB_RDONLY)
 646  * @param flags         DB_CREATE or 0
 647  * @return              0 on success
 648  */
 649 /*@unused@*/ static inline
 650 int dbiAssociate(dbiIndex dbi, dbiIndex dbisecondary,
 651                 int (*callback) (DB *, const DBT *, const DBT *, DBT *),
 652                 unsigned int flags)
 653         /*@globals fileSystem @*/
 654         /*@modifies dbi, fileSystem @*/
 655 {
 656     return (*dbi->dbi_vec->associate) (dbi, dbisecondary, callback, flags);
 657 }
 658
 659 /** \ingroup dbi
 660  * Return join cursor for list of cursors.
 661  * @param dbi           index database handle
 662  * @param curslist      NULL terminated list of database cursors
 663  * @retval dbcp         address of join database cursor
 664  * @param flags         DB_JOIN_NOSORT or 0
 665  * @return              0 on success
 666  */
 667 /*@unused@*/ static inline
 668 int dbiJoin(dbiIndex dbi, DBC ** curslist, /*@out@*/ DBC ** dbcp,
 669                 unsigned int flags)
 670         /*@globals fileSystem @*/
 671         /*@modifies dbi, *dbcp, fileSystem @*/
 672 {
 673     return (*dbi->dbi_vec->join) (dbi, curslist, dbcp, flags);
 674 }
 675
 676 /** \ingroup dbi
 677  * Is database byte swapped?
 678  * @param dbi           index database handle
 679  * @return              0 no
 680  */
 681 /*@unused@*/ static inline
 682 int dbiByteSwapped(dbiIndex dbi)
 683         /*@*/
 684 {
 685 /*@-mods@*/ /* FIX: shrug */
 686     if (dbi->dbi_byteswapped == -1)
 687         dbi->dbi_byteswapped = (*dbi->dbi_vec->byteswapped) (dbi);
 688 /*@=mods@*/
 689     return dbi->dbi_byteswapped;
 690 }
 691 /*@=globuse =mods =mustmod @*/
 692
 693 /*@=exportlocal@*/
 694
 695 /** \ingroup rpmdb
 696  */
 697 unsigned int rpmdbGetIteratorFileNum(rpmdbMatchIterator mi)
 698         /*@*/;
 699
 700 /** \ingroup dbi
 701  * Destroy set of index database items.
 702  * @param set   set of index database items
 703  * @return      NULL always
 704  */
 705 /*@null@*/ dbiIndexSet dbiFreeIndexSet(/*@only@*/ /*@null@*/ dbiIndexSet set)
 706         /*@modifies set @*/;
 707
 708 /** \ingroup dbi
 709  * Count items in index database set.
 710  * @param set   set of index database items
 711  * @return      number of items
 712  */
 713 unsigned int dbiIndexSetCount(dbiIndexSet set)
 714         /*@*/;
 715
 716 /** \ingroup dbi
 717  * Return record offset of header from element in index database set.
 718  * @param set   set of index database items
 719  * @param recno index of item in set
 720  * @return      record offset of header
 721  */
 722 unsigned int dbiIndexRecordOffset(dbiIndexSet set, int recno)
 723         /*@*/;
 724
 725 /** \ingroup dbi
 726  * Return file index from element in index database set.
 727  * @param set   set of index database items
 728  * @param recno index of item in set
 729  * @return      file index
 730  */
 731 unsigned int dbiIndexRecordFileNumber(dbiIndexSet set, int recno)
 732         /*@*/;
 733
 734 /**
 735  * Mergesort, same arguments as qsort(2).
 736  */
 737 /*@unused@*/
 738 int mergesort(void *base, size_t nmemb, size_t size,
 739                 int (*cmp) (const void *, const void *))
 740         /*@globals errno @*/
 741         /*@modifies base, errno @*/;
 742
 743 #ifdef __cplusplus
 744 }
 745 #endif
 746
 747 #endif  /* H_RPMDB */