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