lib/rpmdb_internal.h

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