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