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