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