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  * Describes an index database (implemented on Berkeley db functionality).
  46  */
  47 struct _dbiIndex {
  48     char * dbi_file;            /*!< file component of path */
  49     char * dbi_subfile;
  50     char * dbi_tmpdir;          /*!< temporary directory */
  51
  52     int dbi_ecflags;            /*!< db_env_create flags */
  53     int dbi_cflags;             /*!< db_create flags */
  54     int dbi_oeflags;            /*!< common (db,dbenv}->open flags */
  55     int dbi_eflags;             /*!< dbenv->open flags */
  56     int dbi_oflags;             /*!< db->open flags */
  57     int dbi_tflags;             /*!< dbenv->txn_begin flags */
  58
  59     int dbi_type;               /*!< db index type */
  60     unsigned dbi_mode;          /*!< mode to use on open */
  61     int dbi_perms;              /*!< file permission to use on open */
  62     long dbi_shmkey;            /*!< shared memory base key */
  63
  64     int dbi_verify_on_close;
  65     int dbi_use_dbenv;          /*!< use db environment? */
  66     int dbi_permit_dups;        /*!< permit duplicate entries? */
  67     int dbi_no_fsync;           /*!< no-op fsync for db */
  68     int dbi_no_dbsync;          /*!< don't call dbiSync */
  69     int dbi_lockdbfd;           /*!< do fcntl lock on db fd */
  70     int dbi_temporary;          /*!< non-persistent */
  71     int dbi_debug;
  72     int dbi_byteswapped;
  73
  74         /* dbenv parameters */
  75     int dbi_lorder;
  76     /* XXX db-4.3.14 adds dbenv as 1st arg. */
  77     void (*db_errcall) (void * dbenv, const char *db_errpfx, char *buffer);
  78     FILE *      dbi_errfile;
  79     char * dbi_errpfx;
  80     int dbi_verbose;
  81     int dbi_region_init;
  82     int dbi_tas_spins;
  83         /* mpool sub-system parameters */
  84     int dbi_mmapsize;   /*!< (10Mb) */
  85     int dbi_cachesize;  /*!< (128Kb) */
  86         /* lock sub-system parameters */
  87     unsigned int dbi_lk_max;
  88     unsigned int dbi_lk_detect;
  89 int dbi_lk_nmodes;
  90 unsigned char * dbi_lk_conflicts;
  91         /* log sub-system parameters */
  92     unsigned int dbi_lg_max;
  93     unsigned int dbi_lg_bsize;
  94         /* transaction sub-system parameters */
  95     unsigned int dbi_tx_max;
  96 #if 0
  97     int (*dbi_tx_recover) (DB_ENV *dbenv, DBT *log_rec,
  98                                 DB_LSN *lsnp, int redo, void *info);
  99 #endif
 100         /* dbinfo parameters */
 101     int dbi_pagesize;           /*!< (fs blksize) */
 102     void * (*dbi_malloc) (size_t nbytes);
 103         /* hash access parameters */
 104     unsigned int dbi_h_ffactor; /*!< */
 105     unsigned int (*dbi_h_hash_fcn) (DB *, const void *bytes,
 106                                 unsigned int length);
 107     unsigned int dbi_h_nelem;   /*!< */
 108     unsigned int dbi_h_flags;   /*!< DB_DUP, DB_DUPSORT */
 109     int (*dbi_h_dup_compare_fcn) (DB *, const DBT *, const DBT *);
 110         /* btree access parameters */
 111     int dbi_bt_flags;
 112     int dbi_bt_minkey;
 113     int (*dbi_bt_compare_fcn) (DB *, const DBT *, const DBT *);
 114     int (*dbi_bt_dup_compare_fcn) (DB *, const DBT *, const DBT *);
 115     size_t (*dbi_bt_prefix_fcn) (DB *, const DBT *, const DBT *);
 116         /* recno access parameters */
 117     int dbi_re_flags;
 118     int dbi_re_delim;
 119     unsigned int dbi_re_len;
 120     int dbi_re_pad;
 121     char * dbi_re_source;
 122         /* queue access parameters */
 123     unsigned int dbi_q_extentsize;
 124
 125     rpmdb dbi_rpmdb;            /*!< the parent rpm database */
 126     rpmTag dbi_rpmtag;  /*!< rpm tag used for index */
 127     int dbi_jlen;               /*!< size of join key */
 128
 129     DB * dbi_db;                /*!< Berkeley DB * handle */
 130     DB_TXN * dbi_txnid;         /*!< Bekerley DB_TXN * transaction id */
 131     void * dbi_stats;           /*!< Berkeley db statistics */
 132 };
 133
 134 /** \ingroup rpmdb
 135  * Describes the collection of index databases used by rpm.
 136  */
 137 struct rpmdb_s {
 138     char        * db_root;/*!< path prefix */
 139     char        * db_home;/*!< directory path */
 140     char        * db_fullpath;  /*!< full db path including prefix */
 141     int         db_flags;
 142     int         db_mode;        /*!< open mode */
 143     int         db_perms;       /*!< open permissions */
 144     int         db_api;         /*!< Berkeley API type */
 145     char        * db_errpfx;
 146     int         db_remove_env;
 147     int         db_chrootDone;  /*!< If chroot(2) done, ignore db_root. */
 148     int         db_mkdirDone;   /*!< Has db_home been created? */
 149     void (*db_errcall) (const char *db_errpfx, char *buffer);
 150     FILE *      db_errfile;
 151     void * (*db_malloc) (size_t nbytes);
 152     void * (*db_realloc) (void * ptr,
 153                                                 size_t nbytes);
 154     void (*db_free) (void * ptr);
 155     unsigned char * db_bits;    /*!< package instance bit mask. */
 156     int         db_nbits;       /*!< no. of bits in mask. */
 157     rpmdb       db_next;
 158     int         db_opens;
 159     void *      db_dbenv;       /*!< Berkeley DB_ENV handle. */
 160     int         db_ndbi;        /*!< No. of tag indices. */
 161     dbiIndex * _dbi;            /*!< Tag indices. */
 162
 163     struct rpmop_s db_getops;
 164     struct rpmop_s db_putops;
 165     struct rpmop_s db_delops;
 166
 167     int nrefs;                  /*!< Reference count. */
 168 };
 169
 170 /* for RPM's internal use only */
 171
 172 /** \ingroup rpmdb
 173  */
 174 enum rpmdbFlags {
 175         RPMDB_FLAG_JUSTCHECK    = (1 << 0),
 176         RPMDB_FLAG_MINIMAL      = (1 << 1),
 177         RPMDB_FLAG_CHROOT       = (1 << 2)
 178 };
 179
 180 #ifdef __cplusplus
 181 extern "C" {
 182 #endif
 183
 184 /** \ingroup dbi
 185  * Return new configured index database handle instance.
 186  * @param rpmdb         rpm database
 187  * @param rpmtag        rpm tag
 188  * @return              index database handle
 189  */
 190 RPM_GNUC_INTERNAL
 191 dbiIndex dbiNew(rpmdb rpmdb, rpmTag rpmtag);
 192
 193 /** \ingroup dbi
 194  * Destroy index database handle instance.
 195  * @param dbi           index database handle
 196  * @return              NULL always
 197  */
 198 RPM_GNUC_INTERNAL
 199 dbiIndex dbiFree( dbiIndex dbi);
 200
 201 /** \ingroup dbi
 202  * Format dbi open flags for debugging print.
 203  * @param dbflags               db open flags
 204  * @param print_dbenv_flags     format db env flags instead?
 205  * @return                      formatted flags (malloced)
 206  */
 207 RPM_GNUC_INTERNAL
 208 char * prDbiOpenFlags(int dbflags, int print_dbenv_flags);
 209
 210 /** \ingroup dbi
 211  * Return handle for an index database.
 212  * @param db            rpm database
 213  * @param rpmtag        rpm tag
 214  * @param flags         (unused)
 215  * @return              index database handle
 216  */
 217 RPM_GNUC_INTERNAL
 218 dbiIndex dbiOpen(rpmdb db, rpmTag rpmtag,
 219                 unsigned int flags);
 220
 221
 222 /** \ingroup dbi
 223  * Actually open the database of the index.
 224  * @param db            rpm database
 225  * @param rpmtag        rpm tag
 226  * @param dbiIndex      address of index database handle
 227  * @return              0 on success
 228  */
 229 RPM_GNUC_INTERNAL
 230 int dbiOpenDB(rpmdb rpmdb, rpmTag rpmtag, dbiIndex * dbip);
 231
 232
 233 /* FIX: vector annotations */
 234 /** \ingroup dbi
 235  * Open a database cursor.
 236  * @param dbi           index database handle
 237  * @param txnid         database transaction handle
 238  * @retval dbcp         returned database cursor
 239  * @param flags         DB_WRITECURSOR if writing, or 0
 240  * @return              0 on success
 241  */
 242 RPM_GNUC_INTERNAL
 243 int dbiCopen(dbiIndex dbi, DB_TXN * txnid,
 244              DBC ** dbcp, unsigned int flags);
 245
 246 /** \ingroup dbi
 247  * Close a database cursor.
 248  * @param dbi           index database handle
 249  * @param dbcursor      database cursor
 250  * @param flags         (unused)
 251  * @return              0 on success
 252  */
 253 RPM_GNUC_INTERNAL
 254 int dbiCclose(dbiIndex dbi, DBC * dbcursor, unsigned int flags);
 255
 256 /** \ingroup dbi
 257  * Delete (key,data) pair(s) from index database.
 258  * @param dbi           index database handle
 259  * @param dbcursor      database cursor (NULL will use db->del)
 260  * @param key           delete key value/length/flags
 261  * @param data          delete data value/length/flags
 262  * @param flags         (unused)
 263  * @return              0 on success
 264  */
 265 RPM_GNUC_INTERNAL
 266 int dbiDel(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
 267            unsigned int flags);
 268
 269 /** \ingroup dbi
 270  * Retrieve (key,data) pair from index database.
 271  * @param dbi           index database handle
 272  * @param dbcursor      database cursor (NULL will use db->get)
 273  * @param key           retrieve key value/length/flags
 274  * @param data          retrieve data value/length/flags
 275  * @param flags         (unused)
 276  * @return              0 on success
 277  */
 278 RPM_GNUC_INTERNAL
 279 int dbiGet(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
 280            unsigned int flags);
 281
 282 /** \ingroup dbi
 283  * Store (key,data) pair in index database.
 284  * @param dbi           index database handle
 285  * @param dbcursor      database cursor (NULL will use db->put)
 286  * @param key           store key value/length/flags
 287  * @param data          store data value/length/flags
 288  * @param flags         (unused)
 289  * @return              0 on success
 290  */
 291 RPM_GNUC_INTERNAL
 292 int dbiPut(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
 293            unsigned int flags);
 294
 295 /** \ingroup dbi
 296  * Retrieve count of (possible) duplicate items.
 297  * @param dbi           index database handle
 298  * @param dbcursor      database cursor
 299  * @param countp        address of count
 300  * @param flags         (unused)
 301  * @return              0 on success
 302  */
 303 int dbiCount(dbiIndex dbi, DBC * dbcursor, unsigned int * countp,
 304              unsigned int flags);
 305
 306 /** \ingroup dbi
 307  * Close index database.
 308  * @param dbi           index database handle
 309  * @param flags         (unused)
 310  * @return              0 on success
 311  */
 312 int dbiClose(dbiIndex dbi, unsigned int flags);
 313
 314 /** \ingroup dbi
 315  * Flush pending operations to disk.
 316  * @param dbi           index database handle
 317  * @param flags         (unused)
 318  * @return              0 on success
 319  */
 320 int dbiSync (dbiIndex dbi, unsigned int flags);
 321
 322 /** \ingroup dbi
 323  * Verify (and close) index database.
 324  * @param dbi           index database handle
 325  * @param flags         (unused)
 326  * @return              0 on success
 327  */
 328 static inline
 329 int dbiVerify(dbiIndex dbi, unsigned int flags)
 330 {
 331     dbi->dbi_verify_on_close = 1;
 332     return dbiClose(dbi, flags);
 333 }
 334
 335
 336 /** \ingroup dbi
 337  * Is database byte swapped?
 338  * @param dbi           index database handle
 339  * @return              0 same order, 1 swapped order
 340  */
 341 int dbiByteSwapped(dbiIndex dbi);
 342
 343 /** \ingroup dbi
 344  * Is database byte swapped?
 345  * @param dbi           index database handle
 346  * @param flags         DB_FAST_STAT or 0
 347  * @return              0 on success
 348  */
 349 int dbiStat(dbiIndex dbi, unsigned int flags);
 350
 351 /** \ingroup dbi
 352  * Destroy set of index database items.
 353  * @param set   set of index database items
 354  * @return      NULL always
 355  */
 356 RPM_GNUC_INTERNAL
 357 dbiIndexSet dbiFreeIndexSet(dbiIndexSet set);
 358
 359 /** \ingroup dbi
 360  * Count items in index database set.
 361  * @param set   set of index database items
 362  * @return      number of items
 363  */
 364 RPM_GNUC_INTERNAL
 365 unsigned int dbiIndexSetCount(dbiIndexSet set);
 366
 367 /** \ingroup dbi
 368  * Return record offset of header from element in index database set.
 369  * @param set   set of index database items
 370  * @param recno index of item in set
 371  * @return      record offset of header
 372  */
 373 RPM_GNUC_INTERNAL
 374 unsigned int dbiIndexRecordOffset(dbiIndexSet set, int recno);
 375
 376 /** \ingroup dbi
 377  * Return file index from element in index database set.
 378  * @param set   set of index database items
 379  * @param recno index of item in set
 380  * @return      file index
 381  */
 382 RPM_GNUC_INTERNAL
 383 unsigned int dbiIndexRecordFileNumber(dbiIndexSet set, int recno);
 384
 385 /** \ingroup rpmdb
 386  * Return rpmdb home directory (depending on chroot state)
 387  * param db             rpmdb handle
 388  * return               db home directory (or NULL on error)
 389  */
 390 RPM_GNUC_INTERNAL
 391 const char *rpmdbHome(rpmdb db);
 392
 393 /** \ingroup rpmdb
 394  * Return database iterator.
 395  * @param mi            rpm database iterator
 396  * @param keyp          key data (NULL for sequential access)
 397  * @param keylen        key data length (0 will use strlen(keyp))
 398  * @return              0 on success
 399  */
 400 int rpmdbExtendIterator(rpmdbMatchIterator mi,
 401                         const void * keyp, size_t keylen);
 402
 403 /** \ingroup rpmdb
 404  * sort the iterator by (recnum, filenum)
 405  * Return database iterator.
 406  * @param mi            rpm database iterator
 407  */
 408 void rpmdbSortIterator(rpmdbMatchIterator mi);
 409
 410 #ifndef __APPLE__
 411 /**
 412  *  * Mergesort, same arguments as qsort(2).
 413  *   */
 414 RPM_GNUC_INTERNAL
 415 int mergesort(void *base, size_t nmemb, size_t size,
 416                 int (*cmp) (const void *, const void *));
 417 #else
 418 /* mergesort is defined in stdlib.h on Mac OS X */
 419 #endif /* __APPLE__ */
 420
 421 #endif