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
  50     int dbi_ecflags;            /*!< db_env_create flags */
  51     int dbi_cflags;             /*!< db_create flags */
  52     int dbi_oeflags;            /*!< common (db,dbenv}->open flags */
  53     int dbi_eflags;             /*!< dbenv->open flags */
  54     int dbi_oflags;             /*!< db->open flags */
  55     int dbi_tflags;             /*!< dbenv->txn_begin flags */
  56
  57     int dbi_type;               /*!< db index type */
  58     unsigned dbi_mode;          /*!< mode to use on open */
  59     int dbi_perms;              /*!< file permission to use on open */
  60
  61     int dbi_verify_on_close;
  62     int dbi_use_dbenv;          /*!< use db environment? */
  63     int dbi_permit_dups;        /*!< permit duplicate entries? */
  64     int dbi_no_fsync;           /*!< no-op fsync for db */
  65     int dbi_no_dbsync;          /*!< don't call dbiSync */
  66     int dbi_lockdbfd;           /*!< do fcntl lock on db fd */
  67     int dbi_byteswapped;
  68
  69         /* dbenv parameters */
  70     int dbi_lorder;
  71     /* XXX db-4.3.14 adds dbenv as 1st arg. */
  72     int dbi_verbose;
  73         /* mpool sub-system parameters */
  74     int dbi_mmapsize;   /*!< (10Mb) */
  75     int dbi_cachesize;  /*!< (128Kb) */
  76         /* dbinfo parameters */
  77     int dbi_pagesize;           /*!< (fs blksize) */
  78
  79     rpmdb dbi_rpmdb;            /*!< the parent rpm database */
  80     rpmTag dbi_rpmtag;  /*!< rpm tag used for index */
  81     int dbi_jlen;               /*!< size of join key */
  82
  83     DB * dbi_db;                /*!< Berkeley DB * handle */
  84     DB_TXN * dbi_txnid;         /*!< Bekerley DB_TXN * transaction id */
  85     void * dbi_stats;           /*!< Berkeley db statistics */
  86 };
  87
  88 /** \ingroup rpmdb
  89  * Describes the collection of index databases used by rpm.
  90  */
  91 struct rpmdb_s {
  92     char        * db_root;/*!< path prefix */
  93     char        * db_home;/*!< directory path */
  94     char        * db_fullpath;  /*!< full db path including prefix */
  95     int         db_flags;
  96     int         db_mode;        /*!< open mode */
  97     int         db_perms;       /*!< open permissions */
  98     int         db_api;         /*!< Berkeley API type */
  99     int         db_remove_env;
 100     int         db_chrootDone;  /*!< If chroot(2) done, ignore db_root. */
 101     int         db_mkdirDone;   /*!< Has db_home been created? */
 102     unsigned char * db_bits;    /*!< package instance bit mask. */
 103     int         db_nbits;       /*!< no. of bits in mask. */
 104     rpmdb       db_next;
 105     int         db_opens;
 106     void *      db_dbenv;       /*!< Berkeley DB_ENV handle. */
 107     int         db_ndbi;        /*!< No. of tag indices. */
 108     dbiIndex * _dbi;            /*!< Tag indices. */
 109
 110     struct rpmop_s db_getops;
 111     struct rpmop_s db_putops;
 112     struct rpmop_s db_delops;
 113
 114     int nrefs;                  /*!< Reference count. */
 115 };
 116
 117 /* for RPM's internal use only */
 118
 119 /** \ingroup rpmdb
 120  */
 121 enum rpmdbFlags {
 122         RPMDB_FLAG_JUSTCHECK    = (1 << 0),
 123         RPMDB_FLAG_MINIMAL      = (1 << 1),
 124         RPMDB_FLAG_CHROOT       = (1 << 2)
 125 };
 126
 127 #ifdef __cplusplus
 128 extern "C" {
 129 #endif
 130
 131 /** \ingroup dbi
 132  * Return new configured index database handle instance.
 133  * @param rpmdb         rpm database
 134  * @param rpmtag        rpm tag
 135  * @return              index database handle
 136  */
 137 RPM_GNUC_INTERNAL
 138 dbiIndex dbiNew(rpmdb rpmdb, rpmTag rpmtag);
 139
 140 /** \ingroup dbi
 141  * Destroy index database handle instance.
 142  * @param dbi           index database handle
 143  * @return              NULL always
 144  */
 145 RPM_GNUC_INTERNAL
 146 dbiIndex dbiFree( dbiIndex dbi);
 147
 148 /** \ingroup dbi
 149  * Format dbi open flags for debugging print.
 150  * @param dbflags               db open flags
 151  * @param print_dbenv_flags     format db env flags instead?
 152  * @return                      formatted flags (malloced)
 153  */
 154 RPM_GNUC_INTERNAL
 155 char * prDbiOpenFlags(int dbflags, int print_dbenv_flags);
 156
 157 /** \ingroup dbi
 158  * Return handle for an index database.
 159  * @param db            rpm database
 160  * @param rpmtag        rpm tag
 161  * @param flags         (unused)
 162  * @return              index database handle
 163  */
 164 RPM_GNUC_INTERNAL
 165 dbiIndex dbiOpen(rpmdb db, rpmTag rpmtag,
 166                 unsigned int flags);
 167
 168
 169 /** \ingroup dbi
 170  * Actually open the database of the index.
 171  * @param db            rpm database
 172  * @param rpmtag        rpm tag
 173  * @param dbiIndex      address of index database handle
 174  * @return              0 on success
 175  */
 176 RPM_GNUC_INTERNAL
 177 int dbiOpenDB(rpmdb rpmdb, rpmTag rpmtag, dbiIndex * dbip);
 178
 179
 180 /* FIX: vector annotations */
 181 /** \ingroup dbi
 182  * Open a database cursor.
 183  * @param dbi           index database handle
 184  * @param txnid         database transaction handle
 185  * @retval dbcp         returned database cursor
 186  * @param flags         DB_WRITECURSOR if writing, or 0
 187  * @return              0 on success
 188  */
 189 RPM_GNUC_INTERNAL
 190 int dbiCopen(dbiIndex dbi, DB_TXN * txnid,
 191              DBC ** dbcp, unsigned int flags);
 192
 193 /** \ingroup dbi
 194  * Close a database cursor.
 195  * @param dbi           index database handle
 196  * @param dbcursor      database cursor
 197  * @param flags         (unused)
 198  * @return              0 on success
 199  */
 200 RPM_GNUC_INTERNAL
 201 int dbiCclose(dbiIndex dbi, DBC * dbcursor, unsigned int flags);
 202
 203 /** \ingroup dbi
 204  * Delete (key,data) pair(s) from index database.
 205  * @param dbi           index database handle
 206  * @param dbcursor      database cursor (NULL will use db->del)
 207  * @param key           delete key value/length/flags
 208  * @param data          delete data value/length/flags
 209  * @param flags         (unused)
 210  * @return              0 on success
 211  */
 212 RPM_GNUC_INTERNAL
 213 int dbiDel(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
 214            unsigned int flags);
 215
 216 /** \ingroup dbi
 217  * Retrieve (key,data) pair from index database.
 218  * @param dbi           index database handle
 219  * @param dbcursor      database cursor (NULL will use db->get)
 220  * @param key           retrieve key value/length/flags
 221  * @param data          retrieve data value/length/flags
 222  * @param flags         (unused)
 223  * @return              0 on success
 224  */
 225 RPM_GNUC_INTERNAL
 226 int dbiGet(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
 227            unsigned int flags);
 228
 229 /** \ingroup dbi
 230  * Store (key,data) pair in index database.
 231  * @param dbi           index database handle
 232  * @param dbcursor      database cursor (NULL will use db->put)
 233  * @param key           store key value/length/flags
 234  * @param data          store data value/length/flags
 235  * @param flags         (unused)
 236  * @return              0 on success
 237  */
 238 RPM_GNUC_INTERNAL
 239 int dbiPut(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
 240            unsigned int flags);
 241
 242 /** \ingroup dbi
 243  * Retrieve count of (possible) duplicate items.
 244  * @param dbi           index database handle
 245  * @param dbcursor      database cursor
 246  * @param countp        address of count
 247  * @param flags         (unused)
 248  * @return              0 on success
 249  */
 250 int dbiCount(dbiIndex dbi, DBC * dbcursor, unsigned int * countp,
 251              unsigned int flags);
 252
 253 /** \ingroup dbi
 254  * Close index database.
 255  * @param dbi           index database handle
 256  * @param flags         (unused)
 257  * @return              0 on success
 258  */
 259 int dbiClose(dbiIndex dbi, unsigned int flags);
 260
 261 /** \ingroup dbi
 262  * Flush pending operations to disk.
 263  * @param dbi           index database handle
 264  * @param flags         (unused)
 265  * @return              0 on success
 266  */
 267 int dbiSync (dbiIndex dbi, unsigned int flags);
 268
 269 /** \ingroup dbi
 270  * Verify (and close) index database.
 271  * @param dbi           index database handle
 272  * @param flags         (unused)
 273  * @return              0 on success
 274  */
 275 static inline
 276 int dbiVerify(dbiIndex dbi, unsigned int flags)
 277 {
 278     dbi->dbi_verify_on_close = 1;
 279     return dbiClose(dbi, flags);
 280 }
 281
 282
 283 /** \ingroup dbi
 284  * Is database byte swapped?
 285  * @param dbi           index database handle
 286  * @return              0 same order, 1 swapped order
 287  */
 288 int dbiByteSwapped(dbiIndex dbi);
 289
 290 /** \ingroup dbi
 291  * Is database byte swapped?
 292  * @param dbi           index database handle
 293  * @param flags         DB_FAST_STAT or 0
 294  * @return              0 on success
 295  */
 296 int dbiStat(dbiIndex dbi, unsigned int flags);
 297
 298 /** \ingroup rpmdb
 299  * Return rpmdb home directory (depending on chroot state)
 300  * param db             rpmdb handle
 301  * return               db home directory (or NULL on error)
 302  */
 303 RPM_GNUC_INTERNAL
 304 const char *rpmdbHome(rpmdb db);
 305
 306 /** \ingroup rpmdb
 307  * Return database iterator.
 308  * @param mi            rpm database iterator
 309  * @param keyp          key data (NULL for sequential access)
 310  * @param keylen        key data length (0 will use strlen(keyp))
 311  * @return              0 on success
 312  */
 313 int rpmdbExtendIterator(rpmdbMatchIterator mi,
 314                         const void * keyp, size_t keylen);
 315
 316 /** \ingroup rpmdb
 317  * sort the iterator by (recnum, filenum)
 318  * Return database iterator.
 319  * @param mi            rpm database iterator
 320  */
 321 void rpmdbSortIterator(rpmdbMatchIterator mi);
 322
 323 #ifndef __APPLE__
 324 /**
 325  *  * Mergesort, same arguments as qsort(2).
 326  *   */
 327 RPM_GNUC_INTERNAL
 328 int mergesort(void *base, size_t nmemb, size_t size,
 329                 int (*cmp) (const void *, const void *));
 330 #else
 331 /* mergesort is defined in stdlib.h on Mac OS X */
 332 #endif /* __APPLE__ */
 333
 334 #endif