Start (re-)joining librpmdb and librpm

- the split is largely arbitrary and mostly just causes, well, arbitrary
  issues and limitations
- just move content from rpmdb/ to lib/ for now

3 files changed, 3043 insertions, 0 deletions

diff --git a/lib/backend/db3.c b/lib/backend/db3.c
new file mode 100644
index 000000000..e1983de41
--- /dev/null
+++ b/lib/backend/db3.c
@@ -0,0 +1,1184 @@
+/** \ingroup db3
+ * \file rpmdb/db3.c
+ */
+
+static int _debug = 1;	/* XXX if < 0 debugging, > 0 unusual error returns */
+
+#include "system.h"
+
+#if defined(HAVE_FTOK) && defined(HAVE_SYS_IPC_H)
+#include <sys/ipc.h>
+#endif
+
+#include <rpm/rpmtag.h>
+#include <rpm/rpmmacro.h>
+#include <rpm/rpmfileutil.h>	/* rpmioMkPath */
+#include <rpm/rpmlog.h>
+
+#include "rpmdb/rpmdb_internal.h"
+
+#include "debug.h"
+
+#if !defined(DB_CLIENT)	/* XXX db-4.2.42 retrofit */
+#define	DB_CLIENT	DB_RPCCLIENT
+#endif
+
+
+/** \ingroup dbi
+ * Hash database statistics.
+ */
+struct dbiHStats_s {
+    unsigned int hash_magic;	/*!< hash database magic number. */
+    unsigned int hash_version;	/*!< version of the hash database. */
+    unsigned int hash_nkeys;	/*!< no. of unique keys in the database. */
+    unsigned int hash_ndata;	/*!< no. of key/data pairs in the database. */
+    unsigned int hash_pagesize;	/*!< db page (and bucket) size, in bytes. */
+    unsigned int hash_nelem;	/*!< estimated size of the hash table. */
+    unsigned int hash_ffactor;	/*!< no. of items per bucket. */
+    unsigned int hash_buckets;	/*!< no. of hash buckets. */
+    unsigned int hash_free;	/*!< no. of pages on the free list. */
+    unsigned int hash_bfree;	/*!< no. of bytes free on bucket pages. */
+    unsigned int hash_bigpages;	/*!< no. of big key/data pages. */
+    unsigned int hash_big_bfree;/*!< no. of bytes free on big item pages. */
+    unsigned int hash_overflows;/*!< no. of overflow pages. */
+    unsigned int hash_ovfl_free;/*!< no. of bytes free on overflow pages. */
+    unsigned int hash_dup;	/*!< no. of duplicate pages. */
+    unsigned int hash_dup_free;	/*!< no. bytes free on duplicate pages. */
+};
+
+/** \ingroup dbi
+ * B-tree database statistics.
+ */
+struct dbiBStats_s {
+    unsigned int bt_magic;	/*!< btree database magic. */
+    unsigned int bt_version;	/*!< version of the btree database. */
+    unsigned int bt_nkeys;	/*!< no. of unique keys in the database. */
+    unsigned int bt_ndata;	/*!< no. of key/data pairs in the database. */
+    unsigned int bt_pagesize;	/*!< database page size, in bytes. */
+    unsigned int bt_minkey;	/*!< minimum keys per page. */
+    unsigned int bt_re_len;	/*!< length of fixed-length records. */
+    unsigned int bt_re_pad;	/*!< padding byte for fixed-length records. */
+    unsigned int bt_levels;	/*!< no. of levels in the database. */
+    unsigned int bt_int_pg;	/*!< no. of database internal pages. */
+    unsigned int bt_leaf_pg;	/*!< no. of database leaf pages. */
+    unsigned int bt_dup_pg;	/*!< no. of database duplicate pages. */
+    unsigned int bt_over_pg;	/*!< no. of database overflow pages. */
+    unsigned int bt_free;	/*!< no. of pages on the free list. */
+    unsigned int bt_int_pgfree;	/*!< no. of bytes free in internal pages. */
+    unsigned int bt_leaf_pgfree;/*!< no. of bytes free in leaf pages. */
+    unsigned int bt_dup_pgfree;	/*!< no. of bytes free in duplicate pages. */
+    unsigned int bt_over_pgfree;/*!< no. of bytes free in overflow pages. */
+};
+
+#ifdef	NOTNOW
+static const char * bfstring(unsigned int x, const char * xbf)
+{
+    const char * s = xbf;
+    static char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
+    static char buf[256];
+    char * t, * te;
+    unsigned radix;
+    unsigned c, i, k;
+
+    radix = (s != NULL ? *s++ : 16);
+
+    if (radix <= 1 || radix >= 32)
+	radix = 16;
+
+    t = buf;
+    switch (radix) {
+    case 8:	*t++ = '0';	break;
+    case 16:	*t++ = '0';	*t++ = 'x';	break;
+    }
+
+    i = 0;
+    k = x;
+    do { i++; k /= radix; } while (k);
+
+    te = t + i;
+
+    k = x;
+    do { --i; t[i] = digits[k % radix]; k /= radix; } while (k);
+
+    t = te;
+    i = '<';
+    if (s != NULL)
+    while ((c = *s++) != '\0') {
+	if (c > ' ') continue;
+
+	k = (1 << (c - 1));
+	if (!(x & k)) continue;
+
+	if (t == te) *t++ = '=';
+
+	*t++ = i;
+	i = ',';
+	while (*s > ' ')
+	    *t++ = *s++;
+    }
+    if (t > te)	*t++ = '>';
+    *t = '\0';
+    return buf;
+}
+
+static const char * dbtFlags =
+	"\20\1APPMALLOC\2ISSET\3MALLOC\4PARTIAL\5REALLOC\6USERMEM\7DUPOK";
+
+static const char * dbenvOpenFlags =
+	"\20\1CREATE\2NO_EXCEPTIONS\3FORCE\4NOMMAP\5RDONLY\6RECOVER\7THREAD\10TXN_NOSYNC\11USE_ENVIRON\12USE_ENVIRON_ROOT\13CDB\14LOCK\15LOG\16MPOOL\17TXN\20JOINENV\21LOCKDOWN\22PRIVATE\23RECOVER_FATAL\24SYSTEM_MEM";
+
+static const char * dbOpenFlags =
+	"\20\1CREATE\2NO_EXCEPTIONS\3FORCE\4NOMMAP\5RDONLY\6RECOVER\7THREAD\10TXN_NOSYNC\11USE_ENVIRON\12USE_ENVIRON_ROOT\13EXCL\14FCNTL_LOCKING\15RDWRMASTER\16TRUNCATE\17EXTENT\20APPLY_LOGREG";
+
+static const char * dbenvSetFlags =
+	"\20\1CREATE\2NO_EXCEPTIONS\3FORCE\4NOMMAP\5RDONLY\6RECOVER\7THREAD\10TXN_NOSYNC\11USE_ENVIRON\12USE_ENVIRON_ROOT\13CDB_ALLDB\14NOLOCKING\15NOPANIC\16PANIC_ENV\17REGION_INIT\20YIELDCPU";
+
+static const char * dbSetFlags =
+	"\20\1DUP\2DUPSORT\3RECNUM\4RENUMBER\5REVSPLITOFF\6SNAPSHOT";
+
+static const char * dbiModeFlags =
+	"\20\1WRONLY\2RDWR\7CREAT\10EXCL\11NOCTTY\12TRUNC\13APPEND\14NONBLOCK\15SYNC\16ASYNC\17DIRECT\20LARGEFILE\21DIRECTORY\22NOFOLLOW";
+#endif	/* NOTNOW */
+
+
+static int cvtdberr(dbiIndex dbi, const char * msg, int error, int printit)
+{
+    int rc = error;
+
+    if (printit && rc) {
+	if (msg)
+	    rpmlog(RPMLOG_ERR, _("db%d error(%d) from %s: %s\n"),
+		dbi->dbi_api, rc, msg, db_strerror(error));
+	else
+	    rpmlog(RPMLOG_ERR, _("db%d error(%d): %s\n"),
+		dbi->dbi_api, rc, db_strerror(error));
+    }
+
+    return rc;
+}
+
+static int db_fini(dbiIndex dbi, const char * dbhome,
+		const char * dbfile,
+		const char * dbsubfile)
+{
+    rpmdb rpmdb = dbi->dbi_rpmdb;
+    DB_ENV * dbenv = rpmdb->db_dbenv;
+    int rc;
+
+    if (dbenv == NULL)
+	return 0;
+
+    rc = dbenv->close(dbenv, 0);
+    rc = cvtdberr(dbi, "dbenv->close", rc, _debug);
+
+    if (dbfile)
+	rpmlog(RPMLOG_DEBUG, "closed   db environment %s/%s\n",
+			dbhome, dbfile);
+
+    if (rpmdb->db_remove_env) {
+	int xx;
+
+	xx = db_env_create(&dbenv, 0);
+	xx = cvtdberr(dbi, "db_env_create", xx, _debug);
+	xx = dbenv->remove(dbenv, dbhome, 0);
+	xx = cvtdberr(dbi, "dbenv->remove", xx, _debug);
+
+	if (dbfile)
+	    rpmlog(RPMLOG_DEBUG, "removed  db environment %s/%s\n",
+			dbhome, dbfile);
+
+    }
+    return rc;
+}
+
+static int db3_fsync_disable(int fd)
+{
+    return 0;
+}
+
+#if (DB_VERSION_MAJOR >= 4 && DB_VERSION_MINOR >= 5)
+/*
+ * dbenv->failchk() callback method for determining is the given pid/tid 
+ * is alive. We only care about pid's though. 
+ */ 
+static int db3isalive(DB_ENV *dbenv, pid_t pid, db_threadid_t tid, uint32_t flags)
+{
+    int alive = 0;
+
+    if (pid == getpid()) {
+	alive = 1;
+    } else if (kill(pid, 0) == 0) {
+	alive = 1;
+    /* only existing processes can fail with EPERM */
+    } else if (errno == EPERM) {
+    	alive = 1;
+    }
+    
+    return alive;
+}
+#endif
+
+static int db_init(dbiIndex dbi, const char * dbhome,
+		const char * dbfile,
+		const char * dbsubfile,
+		DB_ENV ** dbenvp)
+{
+    rpmdb rpmdb = dbi->dbi_rpmdb;
+    DB_ENV *dbenv = NULL;
+    int eflags;
+    int rc;
+
+    if (dbenvp == NULL)
+	return 1;
+
+    /* XXX HACK */
+    if (rpmdb->db_errfile == NULL)
+	rpmdb->db_errfile = stderr;
+
+    eflags = (dbi->dbi_oeflags | dbi->dbi_eflags);
+    if (eflags & DB_JOINENV) eflags &= DB_JOINENV;
+
+    if (dbfile) {
+	char *dbiflags = prDbiOpenFlags(eflags, 1);
+	rpmlog(RPMLOG_DEBUG, "opening  db environment %s/%s %s\n",
+		dbhome, dbfile, dbiflags);
+	free(dbiflags);
+    }
+
+    /* XXX Can't do RPC w/o host. */
+    if (dbi->dbi_host == NULL)
+	dbi->dbi_ecflags &= ~DB_CLIENT;
+
+    /* XXX Set a default shm_key. */
+    if ((dbi->dbi_eflags & DB_SYSTEM_MEM) && dbi->dbi_shmkey == 0) {
+#if defined(HAVE_FTOK)
+	dbi->dbi_shmkey = ftok(dbhome, 0);
+#else
+	dbi->dbi_shmkey = 0x44631380;
+#endif
+    }
+
+    rc = db_env_create(&dbenv, dbi->dbi_ecflags);
+    rc = cvtdberr(dbi, "db_env_create", rc, _debug);
+    if (dbenv == NULL || rc)
+	goto errxit;
+
+  { int xx;
+
+ /* 4.1: dbenv->set_app_dispatch(???) */
+ /* 4.1: dbenv->set_alloc(???) */
+ /* 4.1: dbenv->set_data_dir(???) */
+ /* 4.1: dbenv->set_encrypt(???) */
+
+    dbenv->set_errcall(dbenv, (void *) rpmdb->db_errcall);
+    dbenv->set_errfile(dbenv, rpmdb->db_errfile);
+    dbenv->set_errpfx(dbenv, rpmdb->db_errpfx);
+
+ /* 4.1: dbenv->set_feedback(???) */
+ /* 4.1: dbenv->set_flags(???) */
+
+ /* dbenv->set_paniccall(???) */
+
+#if (DB_VERSION_MAJOR >= 4 && DB_VERSION_MINOR >= 5)
+    /* 
+     * These enable automatic stale lock removal. 
+     * thread_count 8 is some kind of "magic minimum" value...
+     */
+    dbenv->set_thread_count(dbenv, 8);
+    dbenv->set_isalive(dbenv, db3isalive);
+#endif
+
+    if ((dbi->dbi_ecflags & DB_CLIENT) && dbi->dbi_host) {
+	const char * home;
+	int retry = 0;
+
+	if ((home = strrchr(dbhome, '/')) != NULL)
+	    dbhome = ++home;
+
+	while (retry++ < 5) {
+	    xx = dbenv->set_rpc_server(dbenv, NULL, dbi->dbi_host,
+		dbi->dbi_cl_timeout, dbi->dbi_sv_timeout, 0);
+	    xx = cvtdberr(dbi, "dbenv->set_server", xx, _debug);
+	    if (!xx)
+		break;
+	    (void) sleep(15);
+	}
+    } else {
+#if !(DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
+	xx = dbenv->set_verbose(dbenv, DB_VERB_CHKPOINT,
+		(dbi->dbi_verbose & DB_VERB_CHKPOINT));
+#endif
+	xx = dbenv->set_verbose(dbenv, DB_VERB_DEADLOCK,
+		(dbi->dbi_verbose & DB_VERB_DEADLOCK));
+	xx = dbenv->set_verbose(dbenv, DB_VERB_RECOVERY,
+		(dbi->dbi_verbose & DB_VERB_RECOVERY));
+	xx = dbenv->set_verbose(dbenv, DB_VERB_WAITSFOR,
+		(dbi->dbi_verbose & DB_VERB_WAITSFOR));
+
+	if (dbi->dbi_mmapsize) {
+	    xx = dbenv->set_mp_mmapsize(dbenv, dbi->dbi_mmapsize);
+	    xx = cvtdberr(dbi, "dbenv->set_mp_mmapsize", xx, _debug);
+	}
+	if (dbi->dbi_tmpdir) {
+	    const char * root;
+	    char * tmpdir;
+
+	    root = (dbi->dbi_root ? dbi->dbi_root : rpmdb->db_root);
+	    if ((root[0] == '/' && root[1] == '\0') || rpmdb->db_chrootDone)
+		root = NULL;
+	    tmpdir = rpmGenPath(root, dbi->dbi_tmpdir, NULL);
+	    xx = dbenv->set_tmp_dir(dbenv, tmpdir);
+	    xx = cvtdberr(dbi, "dbenv->set_tmp_dir", xx, _debug);
+	    tmpdir = _free(tmpdir);
+	}
+    }
+
+ /* dbenv->set_lk_conflicts(???) */
+ /* dbenv->set_lk_detect(???) */
+ /* 4.1: dbenv->set_lk_max_lockers(???) */
+ /* 4.1: dbenv->set_lk_max_locks(???) */
+ /* 4.1: dbenv->set_lk_max_objects(???) */
+
+ /* 4.1: dbenv->set_lg_bsize(???) */
+ /* 4.1: dbenv->set_lg_dir(???) */
+ /* 4.1: dbenv->set_lg_max(???) */
+ /* 4.1: dbenv->set_lg_regionmax(???) */
+
+    if (dbi->dbi_cachesize) {
+	xx = dbenv->set_cachesize(dbenv, 0, dbi->dbi_cachesize, 0);
+	xx = cvtdberr(dbi, "dbenv->set_cachesize", xx, _debug);
+    }
+
+ /* 4.1 dbenv->set_timeout(???) */
+ /* dbenv->set_tx_max(???) */
+ /* 4.1: dbenv->set_tx_timestamp(???) */
+ /* dbenv->set_tx_recover(???) */
+
+ /* dbenv->set_rep_transport(???) */
+ /* dbenv->set_rep_limit(???) */
+
+    if (dbi->dbi_no_fsync) {
+	xx = db_env_set_func_fsync(db3_fsync_disable);
+	xx = cvtdberr(dbi, "db_env_set_func_fsync", xx, _debug);
+    }
+
+    if (dbi->dbi_shmkey) {
+	xx = dbenv->set_shm_key(dbenv, dbi->dbi_shmkey);
+	xx = cvtdberr(dbi, "dbenv->set_shm_key", xx, _debug);
+    }
+  }
+
+    rc = (dbenv->open)(dbenv, dbhome, eflags, dbi->dbi_perms);
+    rc = cvtdberr(dbi, "dbenv->open", rc, _debug);
+    if (rc)
+	goto errxit;
+
+#if (DB_VERSION_MAJOR >= 4 && DB_VERSION_MINOR >= 5)
+    /* stale lock removal */
+    rc = dbenv->failchk(dbenv, 0);
+#endif
+
+    *dbenvp = dbenv;
+
+    return 0;
+
+errxit:
+    if (dbenv) {
+	int xx;
+	xx = dbenv->close(dbenv, 0);
+	xx = cvtdberr(dbi, "dbenv->close", xx, _debug);
+    }
+    return rc;
+}
+
+static int db3sync(dbiIndex dbi, unsigned int flags)
+{
+    DB * db = dbi->dbi_db;
+    int rc = 0;
+    int _printit;
+
+    if (db != NULL)
+	rc = db->sync(db, flags);
+    /* XXX DB_INCOMPLETE is returned occaisionally with multiple access. */
+    _printit = _debug;
+    rc = cvtdberr(dbi, "db->sync", rc, _printit);
+    return rc;
+}
+
+static int db3cdup(dbiIndex dbi, DBC * dbcursor, DBC ** dbcp,
+		unsigned int flags)
+{
+    int rc;
+
+    if (dbcp) *dbcp = NULL;
+    rc = dbcursor->c_dup(dbcursor, dbcp, flags);
+    rc = cvtdberr(dbi, "dbcursor->c_dup", rc, _debug);
+    /* FIX: *dbcp can be NULL */
+    return rc;
+}
+
+static int db3cclose(dbiIndex dbi, DBC * dbcursor,
+		unsigned int flags)
+{
+    int rc = -2;
+
+    /* XXX db3copen error pathways come through here. */
+    if (dbcursor != NULL) {
+	rc = dbcursor->c_close(dbcursor);
+	rc = cvtdberr(dbi, "dbcursor->c_close", rc, _debug);
+    }
+    return rc;
+}
+
+static int db3copen(dbiIndex dbi, DB_TXN * txnid,
+		DBC ** dbcp, unsigned int dbiflags)
+{
+    DB * db = dbi->dbi_db;
+    DBC * dbcursor = NULL;
+    int flags;
+    int rc;
+
+   /* XXX DB_WRITECURSOR cannot be used with sunrpc dbenv. */
+    assert(db != NULL);
+    if ((dbiflags & DB_WRITECURSOR) &&
+	(dbi->dbi_eflags & DB_INIT_CDB) && !(dbi->dbi_oflags & DB_RDONLY))
+    {
+	flags = DB_WRITECURSOR;
+    } else
+	flags = 0;
+
+    rc = db->cursor(db, txnid, &dbcursor, flags);
+    rc = cvtdberr(dbi, "db->cursor", rc, _debug);
+
+    if (dbcp)
+	*dbcp = dbcursor;
+    else
+	(void) db3cclose(dbi, dbcursor, 0);
+
+    return rc;
+}
+
+static int db3cput(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
+		unsigned int flags)
+{
+    DB * db = dbi->dbi_db;
+    int rc;
+
+    assert(db != NULL);
+    if (dbcursor == NULL) {
+	rc = db->put(db, dbi->dbi_txnid, key, data, 0);
+	rc = cvtdberr(dbi, "db->put", rc, _debug);
+    } else {
+	rc = dbcursor->c_put(dbcursor, key, data, DB_KEYLAST);
+	rc = cvtdberr(dbi, "dbcursor->c_put", rc, _debug);
+    }
+
+    return rc;
+}
+
+static int db3cdel(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
+		unsigned int flags)
+{
+    DB * db = dbi->dbi_db;
+    int rc;
+
+    assert(db != NULL);
+    if (dbcursor == NULL) {
+	rc = db->del(db, dbi->dbi_txnid, key, flags);
+	rc = cvtdberr(dbi, "db->del", rc, _debug);
+    } else {
+	int _printit;
+
+	/* XXX TODO: insure that cursor is positioned with duplicates */
+	rc = dbcursor->c_get(dbcursor, key, data, DB_SET);
+	/* XXX DB_NOTFOUND can be returned */
+	_printit = (rc == DB_NOTFOUND ? 0 : _debug);
+	rc = cvtdberr(dbi, "dbcursor->c_get", rc, _printit);
+
+	if (rc == 0) {
+	    rc = dbcursor->c_del(dbcursor, flags);
+	    rc = cvtdberr(dbi, "dbcursor->c_del", rc, _debug);
+	}
+    }
+
+    return rc;
+}
+
+static int db3cget(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
+		unsigned int flags)
+{
+    DB * db = dbi->dbi_db;
+    int _printit;
+    int rc;
+
+    assert(db != NULL);
+    if (dbcursor == NULL) {
+	/* XXX duplicates require cursors. */
+	rc = db->get(db, dbi->dbi_txnid, key, data, 0);
+	/* XXX DB_NOTFOUND can be returned */
+	_printit = (rc == DB_NOTFOUND ? 0 : _debug);
+	rc = cvtdberr(dbi, "db->get", rc, _printit);
+    } else {
+	/* XXX db3 does DB_FIRST on uninitialized cursor */
+	rc = dbcursor->c_get(dbcursor, key, data, flags);
+	/* XXX DB_NOTFOUND can be returned */
+	_printit = (rc == DB_NOTFOUND ? 0 : _debug);
+	rc = cvtdberr(dbi, "dbcursor->c_get", rc, _printit);
+    }
+
+    return rc;
+}
+
+static int db3cpget(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * pkey,
+		DBT * data, unsigned int flags)
+{
+    DB * db = dbi->dbi_db;
+    int _printit;
+    int rc;
+
+    assert(db != NULL);
+    assert(dbcursor != NULL);
+
+    /* XXX db3 does DB_FIRST on uninitialized cursor */
+    rc = dbcursor->c_pget(dbcursor, key, pkey, data, flags);
+    /* XXX DB_NOTFOUND can be returned */
+    _printit = (rc == DB_NOTFOUND ? 0 : _debug);
+    rc = cvtdberr(dbi, "dbcursor->c_pget", rc, _printit);
+
+    return rc;
+}
+
+static int db3ccount(dbiIndex dbi, DBC * dbcursor,
+		unsigned int * countp,
+		unsigned int flags)
+{
+    db_recno_t count = 0;
+    int rc = 0;
+
+    flags = 0;
+    rc = dbcursor->c_count(dbcursor, &count, flags);
+    rc = cvtdberr(dbi, "dbcursor->c_count", rc, _debug);
+    if (rc) return rc;
+    if (countp) *countp = count;
+
+    return rc;
+}
+
+static int db3byteswapped(dbiIndex dbi)	
+{
+    DB * db = dbi->dbi_db;
+    int rc = 0;
+
+    if (db != NULL) {
+	int isswapped = 0;
+	rc = db->get_byteswapped(db, &isswapped);
+	if (rc == 0)
+	    rc = isswapped;
+    }
+
+    return rc;
+}
+
+static int db3stat(dbiIndex dbi, unsigned int flags)
+{
+    DB * db = dbi->dbi_db;
+#if (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
+    DB_TXN * txnid = NULL;
+#endif
+    int rc = 0;
+
+    assert(db != NULL);
+#if defined(DB_FAST_STAT)
+    if (flags)
+	flags = DB_FAST_STAT;
+    else
+#endif
+	flags = 0;
+    dbi->dbi_stats = _free(dbi->dbi_stats);
+#if (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
+    rc = db->stat(db, txnid, &dbi->dbi_stats, flags);
+#else
+    rc = db->stat(db, &dbi->dbi_stats, flags);
+#endif
+    rc = cvtdberr(dbi, "db->stat", rc, _debug);
+    return rc;
+}
+
+static int db3associate(dbiIndex dbi, dbiIndex dbisecondary,
+		int (*callback)(DB *, const DBT *, const DBT *, DBT *),
+		unsigned int flags)
+{
+    DB * db = dbi->dbi_db;
+    DB * secondary = dbisecondary->dbi_db;
+    int rc;
+
+    DB_TXN * txnid = NULL;
+
+assert(db != NULL);
+    rc = db->associate(db, txnid, secondary, callback, flags);
+    rc = cvtdberr(dbi, "db->associate", rc, _debug);
+    return rc;
+}
+
+static int db3join(dbiIndex dbi, DBC ** curslist, DBC ** dbcp,
+		unsigned int flags)
+{
+    DB * db = dbi->dbi_db;
+    int rc;
+
+assert(db != NULL);
+    rc = db->join(db, curslist, dbcp, flags);
+    rc = cvtdberr(dbi, "db->join", rc, _debug);
+    return rc;
+}
+
+static int db3close(dbiIndex dbi, unsigned int flags)
+{
+    rpmdb rpmdb = dbi->dbi_rpmdb;
+    const char * root;
+    const char * home;
+    char * dbhome;
+    const char * dbfile;
+    const char * dbsubfile;
+    DB * db = dbi->dbi_db;
+    int _printit;
+    int rc = 0, xx;
+
+    flags = 0;	/* XXX unused */
+
+    /*
+     * Get the prefix/root component and directory path.
+     */
+    root = (dbi->dbi_root ? dbi->dbi_root : rpmdb->db_root);
+    if ((root[0] == '/' && root[1] == '\0') || rpmdb->db_chrootDone)
+	root = NULL;
+    home = (dbi->dbi_home ? dbi->dbi_home : rpmdb->db_home);
+
+    dbhome = rpmGenPath(root, home, NULL);
+    if (dbi->dbi_temporary) {
+	dbfile = NULL;
+	dbsubfile = NULL;
+    } else {
+#ifdef	HACK	/* XXX necessary to support dbsubfile */
+	dbfile = (dbi->dbi_file ? dbi->dbi_file : db3basename);
+	dbsubfile = (dbi->dbi_subfile ? dbi->dbi_subfile : rpmTagGetName(dbi->dbi_rpmtag));
+#else
+	dbfile = (dbi->dbi_file ? dbi->dbi_file : rpmTagGetName(dbi->dbi_rpmtag));
+	dbsubfile = NULL;
+#endif
+    }
+
+    if (db) {
+	rc = db->close(db, 0);
+	/* XXX ignore not found error messages. */
+	_printit = (rc == ENOENT ? 0 : _debug);
+	rc = cvtdberr(dbi, "db->close", rc, _printit);
+	db = dbi->dbi_db = NULL;
+
+	rpmlog(RPMLOG_DEBUG, "closed   db index       %s/%s\n",
+		dbhome, (dbfile ? dbfile : rpmTagGetName(dbi->dbi_rpmtag)));
+
+    }
+
+    if (rpmdb->db_dbenv != NULL && dbi->dbi_use_dbenv) {
+	if (rpmdb->db_opens == 1) {
+	    xx = db_fini(dbi, (dbhome ? dbhome : ""), dbfile, dbsubfile);
+	    rpmdb->db_dbenv = NULL;
+	}
+	rpmdb->db_opens--;
+    }
+
+    if (dbi->dbi_verify_on_close && !dbi->dbi_temporary) {
+	DB_ENV * dbenv = NULL;
+
+	rc = db_env_create(&dbenv, 0);
+	rc = cvtdberr(dbi, "db_env_create", rc, _debug);
+	if (rc || dbenv == NULL) goto exit;
+
+	dbenv->set_errcall(dbenv, (void *) rpmdb->db_errcall);
+	dbenv->set_errfile(dbenv, rpmdb->db_errfile);
+	dbenv->set_errpfx(dbenv, rpmdb->db_errpfx);
+ /*	dbenv->set_paniccall(???) */
+#if !(DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
+	xx = dbenv->set_verbose(dbenv, DB_VERB_CHKPOINT,
+		(dbi->dbi_verbose & DB_VERB_CHKPOINT));
+#endif
+	xx = dbenv->set_verbose(dbenv, DB_VERB_DEADLOCK,
+		(dbi->dbi_verbose & DB_VERB_DEADLOCK));
+	xx = dbenv->set_verbose(dbenv, DB_VERB_RECOVERY,
+		(dbi->dbi_verbose & DB_VERB_RECOVERY));
+	xx = dbenv->set_verbose(dbenv, DB_VERB_WAITSFOR,
+		(dbi->dbi_verbose & DB_VERB_WAITSFOR));
+
+	if (dbi->dbi_tmpdir) {
+	    char * tmpdir = rpmGenPath(root, dbi->dbi_tmpdir, NULL);
+	    rc = dbenv->set_tmp_dir(dbenv, tmpdir);
+	    rc = cvtdberr(dbi, "dbenv->set_tmp_dir", rc, _debug);
+	    tmpdir = _free(tmpdir);
+	    if (rc) goto exit;
+	}
+	    
+	rc = (dbenv->open)(dbenv, dbhome,
+            DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE | DB_USE_ENVIRON, 0);
+	rc = cvtdberr(dbi, "dbenv->open", rc, _debug);
+	if (rc) goto exit;
+
+	rc = db_create(&db, dbenv, 0);
+	rc = cvtdberr(dbi, "db_create", rc, _debug);
+
+	if (db != NULL) {
+		char * dbf = rpmGetPath(dbhome, "/", dbfile, NULL);
+
+		rc = db->verify(db, dbf, NULL, NULL, flags);
+		rc = cvtdberr(dbi, "db->verify", rc, _debug);
+
+		rpmlog(RPMLOG_DEBUG, "verified db index       %s/%s\n",
+			(dbhome ? dbhome : ""),
+			(dbfile ? dbfile : rpmTagGetName(dbi->dbi_rpmtag)));
+
+	        /*
+		 * The DB handle may not be accessed again after
+		 * DB->verify is called, regardless of its return.
+		 */
+		db = NULL;
+		dbf = _free(dbf);
+	}
+	xx = dbenv->close(dbenv, 0);
+	xx = cvtdberr(dbi, "dbenv->close", xx, _debug);
+	if (rc == 0 && xx) rc = xx;
+    }
+
+exit:
+    dbi->dbi_db = NULL;
+
+    free(dbhome);
+
+    dbi = db3Free(dbi);
+
+    return rc;
+}
+
+static int db3open(rpmdb rpmdb, rpmTag rpmtag, dbiIndex * dbip)
+{
+    extern const struct _dbiVec db3vec;
+    const char * root;
+    const char * home;
+    char * dbhome;
+    const char * dbfile;
+    const char * dbsubfile;
+    dbiIndex dbi = NULL;
+    int rc = 0;
+    int xx;
+
+    DB * db = NULL;
+    DB_ENV * dbenv = NULL;
+    DB_TXN * txnid = NULL;
+    uint32_t oflags;
+    int _printit;
+
+    if (dbip)
+	*dbip = NULL;
+
+    /*
+     * Parse db configuration parameters.
+     */
+    if ((dbi = db3New(rpmdb, rpmtag)) == NULL)
+	return 1;
+    dbi->dbi_api = DB_VERSION_MAJOR;
+
+    /*
+     * Get the prefix/root component and directory path.
+     */
+    root = (dbi->dbi_root ? dbi->dbi_root : rpmdb->db_root);
+    if ((root[0] == '/' && root[1] == '\0') || rpmdb->db_chrootDone)
+	root = NULL;
+    home = (dbi->dbi_home ? dbi->dbi_home : rpmdb->db_home);
+
+    dbhome = rpmGenPath(root, home, NULL);
+    if (dbi->dbi_temporary) {
+	dbfile = NULL;
+	dbsubfile = NULL;
+    } else {
+#ifdef	HACK	/* XXX necessary to support dbsubfile */
+	dbfile = (dbi->dbi_file ? dbi->dbi_file : db3basename);
+	dbsubfile = (dbi->dbi_subfile ? dbi->dbi_subfile : rpmTagGetName(dbi->dbi_rpmtag));
+#else
+	dbfile = (dbi->dbi_file ? dbi->dbi_file : rpmTagGetName(dbi->dbi_rpmtag));
+	dbsubfile = NULL;
+#endif
+    }
+
+    oflags = (dbi->dbi_oeflags | dbi->dbi_oflags);
+    oflags &= ~DB_TRUNCATE;	/* XXX this is dangerous */
+
+#if 0	/* XXX rpmdb: illegal flag combination specified to DB->open */
+    if ( dbi->dbi_mode & O_EXCL) oflags |= DB_EXCL;
+#endif
+
+    /*
+     * Map open mode flags onto configured database/environment flags.
+     */
+    if (dbi->dbi_temporary) {
+	oflags |= DB_CREATE;
+	dbi->dbi_oeflags |= DB_CREATE;
+	oflags &= ~DB_RDONLY;
+	dbi->dbi_oflags &= ~DB_RDONLY;
+    } else {
+	if (!(dbi->dbi_mode & (O_RDWR|O_WRONLY))) oflags |= DB_RDONLY;
+	if (dbi->dbi_mode & O_CREAT) {
+	    oflags |= DB_CREATE;
+	    dbi->dbi_oeflags |= DB_CREATE;
+	}
+#ifdef	DANGEROUS
+	if ( dbi->dbi_mode & O_TRUNC) oflags |= DB_TRUNCATE;
+#endif
+    }
+
+    /*
+     * Create the /var/lib/rpm directory if it doesn't exist (root only).
+     */
+    (void) rpmioMkpath(dbhome, 0755, getuid(), getgid());
+
+    /*
+     * Avoid incompatible DB_CREATE/DB_RDONLY flags on DBENV->open.
+     */
+    if (dbi->dbi_use_dbenv) {
+
+	if (access(dbhome, W_OK) == -1) {
+
+	    /* dbhome is unwritable, don't attempt DB_CREATE on DB->open ... */
+	    oflags &= ~DB_CREATE;
+
+	    /* ... but DBENV->open might still need DB_CREATE ... */
+	    if (dbi->dbi_eflags & DB_PRIVATE) {
+		dbi->dbi_eflags &= ~DB_JOINENV;
+	    } else {
+		dbi->dbi_eflags |= DB_JOINENV;
+		dbi->dbi_oeflags &= ~DB_CREATE;
+		dbi->dbi_oeflags &= ~DB_THREAD;
+		/* ... but, unless DB_PRIVATE is used, skip DBENV. */
+		dbi->dbi_use_dbenv = 0;
+	    }
+
+	    /* ... DB_RDONLY maps dbhome perms across files ...  */
+	    if (dbi->dbi_temporary) {
+		oflags |= DB_CREATE;
+		dbi->dbi_oeflags |= DB_CREATE;
+		oflags &= ~DB_RDONLY;
+		dbi->dbi_oflags &= ~DB_RDONLY;
+	    } else {
+		oflags |= DB_RDONLY;
+		/* ... and DB_WRITECURSOR won't be needed ...  */
+		dbi->dbi_oflags |= DB_RDONLY;
+	    }
+
+	} else {	/* dbhome is writable, check for persistent dbenv. */
+	    char * dbf = rpmGetPath(dbhome, "/__db.001", NULL);
+
+	    if (access(dbf, F_OK) == -1) {
+		/* ... non-existent (or unwritable) DBENV, will create ... */
+		dbi->dbi_oeflags |= DB_CREATE;
+		dbi->dbi_eflags &= ~DB_JOINENV;
+	    } else {
+		/* ... pre-existent (or bogus) DBENV, will join ... */
+		if (dbi->dbi_eflags & DB_PRIVATE) {
+		    dbi->dbi_eflags &= ~DB_JOINENV;
+		} else {
+		    dbi->dbi_eflags |= DB_JOINENV;
+		    dbi->dbi_oeflags &= ~DB_CREATE;
+		    dbi->dbi_oeflags &= ~DB_THREAD;
+		}
+	    }
+	    dbf = _free(dbf);
+	}
+    }
+
+    /*
+     * Avoid incompatible DB_CREATE/DB_RDONLY flags on DB->open.
+     */
+    if ((oflags & DB_CREATE) && (oflags & DB_RDONLY)) {
+	/* dbhome is writable, and DB->open flags may conflict. */
+	const char * dbfn = (dbfile ? dbfile : rpmTagGetName(dbi->dbi_rpmtag));
+	char * dbf = rpmGetPath(dbhome, "/", dbfn, NULL);
+
+	if (access(dbf, F_OK) == -1) {
+	    /* File does not exist, DB->open might create ... */
+	    oflags &= ~DB_RDONLY;
+	} else {
+	    /* File exists, DB->open need not create ... */
+	    oflags &= ~DB_CREATE;
+	}
+
+	/* Only writers need DB_WRITECURSOR ... */
+	if (!(oflags & DB_RDONLY) && access(dbf, W_OK) == 0) {
+	    dbi->dbi_oflags &= ~DB_RDONLY;
+	} else {
+	    dbi->dbi_oflags |= DB_RDONLY;
+	}
+	dbf = _free(dbf);
+    }
+
+    /*
+     * Turn off verify-on-close if opening read-only.
+     */
+    if (oflags & DB_RDONLY)
+	dbi->dbi_verify_on_close = 0;
+
+    if (dbi->dbi_use_dbenv) {
+	if (rpmdb->db_dbenv == NULL) {
+	    rc = db_init(dbi, dbhome, dbfile, dbsubfile, &dbenv);
+	    if (rc == 0) {
+		rpmdb->db_dbenv = dbenv;
+		rpmdb->db_opens = 1;
+	    }
+	} else {
+	    dbenv = rpmdb->db_dbenv;
+	    rpmdb->db_opens++;
+	}
+    }
+
+    {	char *dbiflags = prDbiOpenFlags(oflags, 0);
+    	rpmlog(RPMLOG_DEBUG, "opening  db index       %s/%s %s mode=0x%x\n",
+		dbhome, (dbfile ? dbfile : rpmTagGetName(dbi->dbi_rpmtag)),
+		dbiflags, dbi->dbi_mode);
+	free(dbiflags);
+    }
+
+    if (rc == 0) {
+	static int _lockdbfd = 0;
+
+	rc = db_create(&db, dbenv, dbi->dbi_cflags);
+	rc = cvtdberr(dbi, "db_create", rc, _debug);
+	if (rc == 0 && db != NULL) {
+
+	    if (rc == 0 &&
+			rpmdb->db_malloc && rpmdb->db_realloc && rpmdb->db_free)
+	    {
+		rc = db->set_alloc(db,
+			rpmdb->db_malloc, rpmdb->db_realloc, rpmdb->db_free);
+		rc = cvtdberr(dbi, "db->set_alloc", rc, _debug);
+	    }
+
+/* 4.1: db->set_cache_priority(???) */
+	    if (rc == 0 && !dbi->dbi_use_dbenv && dbi->dbi_cachesize) {
+		rc = db->set_cachesize(db, 0, dbi->dbi_cachesize, 0);
+		rc = cvtdberr(dbi, "db->set_cachesize", rc, _debug);
+	    }
+/* 4.1: db->set_encrypt(???) */
+/* 4.1: db->set_errcall(dbenv, rpmdb->db_errcall); */
+/* 4.1: db->set_errfile(dbenv, rpmdb->db_errfile); */
+/* 4.1: db->set_errpfx(dbenv, rpmdb->db_errpfx); */
+ /* 4.1: db->set_feedback(???) */
+
+	    if (rc == 0 && dbi->dbi_lorder) {
+		rc = db->set_lorder(db, dbi->dbi_lorder);
+		rc = cvtdberr(dbi, "db->set_lorder", rc, _debug);
+	    }
+	    if (rc == 0 && dbi->dbi_pagesize) {
+		rc = db->set_pagesize(db, dbi->dbi_pagesize);
+		rc = cvtdberr(dbi, "db->set_pagesize", rc, _debug);
+	    }
+ /* 4.1: db->set_paniccall(???) */
+	    if (rc == 0 && oflags & DB_CREATE) {
+		switch(dbi->dbi_type) {
+		default:
+		case DB_HASH:
+		    if (dbi->dbi_h_ffactor) {
+			rc = db->set_h_ffactor(db, dbi->dbi_h_ffactor);
+			rc = cvtdberr(dbi, "db->set_h_ffactor", rc, _debug);
+			if (rc) break;
+		    }
+		    if (dbi->dbi_h_nelem) {
+			rc = db->set_h_nelem(db, dbi->dbi_h_nelem);
+			rc = cvtdberr(dbi, "db->set_h_nelem", rc, _debug);
+			if (rc) break;
+		    }
+		    if (dbi->dbi_h_flags) {
+			rc = db->set_flags(db, dbi->dbi_h_flags);
+			rc = cvtdberr(dbi, "db->set_h_flags", rc, _debug);
+			if (rc) break;
+		    }
+		    if (dbi->dbi_h_hash_fcn) {
+			rc = db->set_h_hash(db, dbi->dbi_h_hash_fcn);
+			rc = cvtdberr(dbi, "db->set_h_hash", rc, _debug);
+			if (rc) break;
+		    }
+		    if (dbi->dbi_h_dup_compare_fcn) {
+			rc = db->set_dup_compare(db, dbi->dbi_h_dup_compare_fcn);
+			rc = cvtdberr(dbi, "db->set_dup_compare", rc, _debug);
+			if (rc) break;
+		    }
+		    break;
+		case DB_BTREE:
+/* 4.1: db->set_append_recno(???) */
+		    if (dbi->dbi_bt_flags) {
+			rc = db->set_flags(db, dbi->dbi_bt_flags);
+			rc = cvtdberr(dbi, "db->set_bt_flags", rc, _debug);
+			if (rc) break;
+		    }
+		    if (dbi->dbi_bt_minkey) {
+			rc = db->set_bt_minkey(db, dbi->dbi_bt_minkey);
+			rc = cvtdberr(dbi, "db->set_bt_minkey", rc, _debug);
+			if (rc) break;
+		    }
+		    if (dbi->dbi_bt_compare_fcn) {
+			rc = db->set_bt_compare(db, dbi->dbi_bt_compare_fcn);
+			rc = cvtdberr(dbi, "db->set_bt_compare", rc, _debug);
+			if (rc) break;
+		    }
+		    if (dbi->dbi_bt_dup_compare_fcn) {
+			rc = db->set_dup_compare(db, dbi->dbi_bt_dup_compare_fcn);
+			rc = cvtdberr(dbi, "db->set_dup_compare", rc, _debug);
+			if (rc) break;
+		    }
+		    if (dbi->dbi_bt_prefix_fcn) {
+			rc = db->set_bt_prefix(db, dbi->dbi_bt_prefix_fcn);
+			rc = cvtdberr(dbi, "db->set_bt_prefix", rc, _debug);
+			if (rc) break;
+		    }
+		    break;
+		case DB_RECNO:
+		    if (dbi->dbi_re_delim) {
+/* 4.1: db->set_append_recno(???) */
+			rc = db->set_re_delim(db, dbi->dbi_re_delim);
+			rc = cvtdberr(dbi, "db->set_re_selim", rc, _debug);
+			if (rc) break;
+		    }
+		    if (dbi->dbi_re_len) {
+			rc = db->set_re_len(db, dbi->dbi_re_len);
+			rc = cvtdberr(dbi, "db->set_re_len", rc, _debug);
+			if (rc) break;
+		    }
+		    if (dbi->dbi_re_pad) {
+			rc = db->set_re_pad(db, dbi->dbi_re_pad);
+			rc = cvtdberr(dbi, "db->set_re_pad", rc, _debug);
+			if (rc) break;
+		    }
+		    if (dbi->dbi_re_source) {
+			rc = db->set_re_source(db, dbi->dbi_re_source);
+			rc = cvtdberr(dbi, "db->set_re_source", rc, _debug);
+			if (rc) break;
+		    }
+		    break;
+		case DB_QUEUE:
+		    if (dbi->dbi_q_extentsize) {
+			rc = db->set_q_extentsize(db, dbi->dbi_q_extentsize);
+			rc = cvtdberr(dbi, "db->set_q_extentsize", rc, _debug);
+			if (rc) break;
+		    }
+		    break;
+		}
+	    }
+
+	    if (rc == 0) {
+		char * fullpath;
+		const char * dbpath;
+		fullpath = rpmGetPath(dbhome, "/", dbfile ? dbfile : "", NULL);
+
+#ifdef	HACK	/* XXX necessary to support dbsubfile */
+		dbpath = (!dbi->dbi_use_dbenv && !dbi->dbi_temporary)
+			? fullpath : dbfile;
+#else
+		dbpath = (!dbi->dbi_temporary)
+			? fullpath : dbfile;
+#endif
+
+		rc = (db->open)(db, txnid, dbpath, dbsubfile,
+		    dbi->dbi_type, oflags, dbi->dbi_perms);
+
+		if (rc == 0 && dbi->dbi_type == DB_UNKNOWN) {
+		    DBTYPE dbi_type = DB_UNKNOWN;
+		    xx = db->get_type(db, &dbi_type);
+		    if (xx == 0)
+			dbi->dbi_type = dbi_type;
+		}
+		free(fullpath);
+	    }
+
+	    /* XXX return rc == errno without printing */
+	    _printit = (rc > 0 ? 0 : _debug);
+	    xx = cvtdberr(dbi, "db->open", rc, _printit);
+
+	    dbi->dbi_txnid = NULL;
+
+	    /*
+	     * Lock a file using fcntl(2). Traditionally this is Packages,
+	     * the file used to store metadata of installed header(s),
+	     * as Packages is always opened, and should be opened first,
+	     * for any rpmdb access.
+	     *
+	     * If no DBENV is used, then access is protected with a
+	     * shared/exclusive locking scheme, as always.
+	     *
+	     * With a DBENV, the fcntl(2) lock is necessary only to keep
+	     * the riff-raff from playing where they don't belong, as
+	     * the DBENV should provide it's own locking scheme. So try to
+	     * acquire a lock, but permit failures, as some other
+	     * DBENV player may already have acquired the lock.
+	     *
+	     * With NPTL posix mutexes, revert to fcntl lock on non-functioning
+	     * glibc/kernel combinations.
+	     */
+	    if (rc == 0 && dbi->dbi_lockdbfd &&
+		!((dbi->dbi_ecflags & DB_CLIENT) && dbi->dbi_host) &&
+		(!dbi->dbi_use_dbenv || _lockdbfd++ == 0))
+	    {
+		int fdno = -1;
+
+		if (!(db->fd(db, &fdno) == 0 && fdno >= 0)) {
+		    rc = 1;
+		} else {
+		    struct flock l;
+		    memset(&l, 0, sizeof(l));
+		    l.l_whence = 0;
+		    l.l_start = 0;
+		    l.l_len = 0;
+		    l.l_type = (dbi->dbi_mode & (O_RDWR|O_WRONLY))
+				? F_WRLCK : F_RDLCK;
+		    l.l_pid = 0;
+
+		    rc = fcntl(fdno, F_SETLK, (void *) &l);
+		    if (rc) {
+			/* Warning iff using non-private CDB locking. */
+			rc = ((dbi->dbi_use_dbenv &&
+				(dbi->dbi_eflags & DB_INIT_CDB) &&
+				!(dbi->dbi_eflags & DB_PRIVATE))
+			    ? 0 : 1);
+			rpmlog( (rc ? RPMLOG_ERR : RPMLOG_WARNING),
+				_("cannot get %s lock on %s/%s\n"),
+				((dbi->dbi_mode & (O_RDWR|O_WRONLY))
+					? _("exclusive") : _("shared")),
+				dbhome, (dbfile ? dbfile : ""));
+		    } else if (dbfile) {
+			rpmlog(RPMLOG_DEBUG,
+				"locked   db index       %s/%s\n",
+				dbhome, dbfile);
+		    }
+		}
+	    }
+	}
+    }
+
+    dbi->dbi_db = db;
+
+    if (rc == 0 && dbi->dbi_db != NULL && dbip != NULL) {
+	dbi->dbi_vec = &db3vec;
+	*dbip = dbi;
+    } else {
+	dbi->dbi_verify_on_close = 0;
+	(void) db3close(dbi, 0);
+    }
+
+    free(dbhome);
+
+    return rc;
+}
+
+/** \ingroup db3
+ */
+const struct _dbiVec db3vec = {
+    DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH,
+    db3open, db3close, db3sync, db3associate, db3join,
+    db3copen, db3cclose, db3cdup, db3cdel, db3cget, db3cpget, db3cput, db3ccount,
+    db3byteswapped, db3stat
+};
diff --git a/lib/backend/dbconfig.c b/lib/backend/dbconfig.c
new file mode 100644
index 000000000..fc75af3bf
--- /dev/null
+++ b/lib/backend/dbconfig.c
@@ -0,0 +1,473 @@
+/** \ingroup rpmdb
+ * \file rpmdb/dbconfig.c
+ */
+
+#include "system.h"
+
+#include <popt.h>
+
+#include <rpm/rpmtag.h>
+#include <rpm/rpmmacro.h>
+#include <rpm/rpmstring.h>
+#include <rpm/rpmlog.h>
+#include <rpm/argv.h>
+#include "rpmdb/rpmdb_internal.h"
+#include "debug.h"
+
+
+#if (DB_VERSION_MAJOR == 3) || (DB_VERSION_MAJOR == 4)
+#define	__USE_DB3	1
+
+struct _dbiIndex db3dbi;
+
+static int dbi_use_cursors;
+
+static int dbi_tear_down;
+
+/** \ingroup db3
+ */
+struct poptOption rdbOptions[] = {
+ /* XXX DB_CXX_NO_EXCEPTIONS */
+#if defined(DB_CLIENT)
+ { "client",	0,POPT_BIT_SET,	&db3dbi.dbi_ecflags, DB_CLIENT,
+	NULL, NULL },
+#endif
+#if defined(DB_RPCCLIENT)
+ { "client",	0,POPT_BIT_SET,	&db3dbi.dbi_ecflags, DB_RPCCLIENT,
+	NULL, NULL },
+ { "rpcclient",	0,POPT_BIT_SET,	&db3dbi.dbi_ecflags, DB_RPCCLIENT,
+	NULL, NULL },
+#endif
+
+ { "xa_create",	0,POPT_BIT_SET,	&db3dbi.dbi_cflags, DB_XA_CREATE,
+	NULL, NULL },
+
+ { "create",	0,POPT_BIT_SET,	&db3dbi.dbi_oeflags, DB_CREATE,
+	NULL, NULL },
+ { "thread",	0,POPT_BIT_SET,	&db3dbi.dbi_oeflags, DB_THREAD,
+	NULL, NULL },
+
+ { "force",	0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_FORCE,
+	NULL, NULL },
+ { "cdb",	0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_INIT_CDB,
+	NULL, NULL },
+ { "lock",	0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_INIT_LOCK,
+	NULL, NULL },
+ { "log",	0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_INIT_LOG,
+	NULL, NULL },
+ { "mpool",	0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_INIT_MPOOL,
+	NULL, NULL },
+ { "txn",	0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_INIT_TXN,
+	NULL, NULL },
+ { "joinenv",	0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_JOINENV,
+	NULL, NULL },
+ { "recover",	0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_RECOVER,
+	NULL, NULL },
+ { "recover_fatal", 0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_RECOVER_FATAL,
+	NULL, NULL },
+ { "shared",	0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_SYSTEM_MEM,
+	NULL, NULL },
+ { "txn_nosync", 0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_TXN_NOSYNC,
+	NULL, NULL },
+ { "use_environ_root", 0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_USE_ENVIRON_ROOT,
+	NULL, NULL },
+ { "use_environ", 0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_USE_ENVIRON,
+	NULL, NULL },
+ { "lockdown",	0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_LOCKDOWN,
+	NULL, NULL },
+ { "private",	0,POPT_BIT_SET,	&db3dbi.dbi_eflags, DB_PRIVATE,
+	NULL, NULL },
+
+ { "txn_sync",	0,POPT_BIT_SET,	&db3dbi.dbi_tflags, DB_TXN_SYNC,
+	NULL, NULL },
+ { "txn_nowait",0,POPT_BIT_SET,	&db3dbi.dbi_tflags, DB_TXN_NOWAIT,
+	NULL, NULL },
+
+ { "excl",	0,POPT_BIT_SET,	&db3dbi.dbi_oflags, DB_EXCL,
+	NULL, NULL },
+ { "nommap",	0,POPT_BIT_SET,	&db3dbi.dbi_oflags, DB_NOMMAP,
+	NULL, NULL },
+ { "rdonly",	0,POPT_BIT_SET,	&db3dbi.dbi_oflags, DB_RDONLY,
+	NULL, NULL },
+ { "truncate",	0,POPT_BIT_SET,	&db3dbi.dbi_oflags, DB_TRUNCATE,
+	NULL, NULL },
+ { "fcntl_locking",0,POPT_BIT_SET,	&db3dbi.dbi_oflags, DB_FCNTL_LOCKING,
+	NULL, NULL },
+
+ { "btree",	0,POPT_ARG_VAL,		&db3dbi.dbi_type, DB_BTREE,
+	NULL, NULL },
+ { "hash", 	0,POPT_ARG_VAL,		&db3dbi.dbi_type, DB_HASH,
+	NULL, NULL },
+ { "recno",	0,POPT_ARG_VAL,		&db3dbi.dbi_type, DB_RECNO,
+	NULL, NULL },
+ { "queue",	0,POPT_ARG_VAL,		&db3dbi.dbi_type, DB_QUEUE,
+	NULL, NULL },
+ { "unknown",	0,POPT_ARG_VAL,		&db3dbi.dbi_type, DB_UNKNOWN,
+	NULL, NULL },
+
+ { "root",	0,POPT_ARG_STRING,	&db3dbi.dbi_root, 0,
+	NULL, NULL },
+ { "home",	0,POPT_ARG_STRING,	&db3dbi.dbi_home, 0,
+	NULL, NULL },
+ { "file",	0,POPT_ARG_STRING,	&db3dbi.dbi_file, 0,
+	NULL, NULL },
+ { "subfile",	0,POPT_ARG_STRING,	&db3dbi.dbi_subfile, 0,
+	NULL, NULL },
+ { "mode",	0,POPT_ARG_INT,		&db3dbi.dbi_mode, 0,
+	NULL, NULL },
+ { "perms",	0,POPT_ARG_INT,		&db3dbi.dbi_perms, 0,
+	NULL, NULL },
+ { "shmkey",	0,POPT_ARG_LONG,	&db3dbi.dbi_shmkey, 0,
+	NULL, NULL },
+ { "tmpdir",	0,POPT_ARG_STRING,	&db3dbi.dbi_tmpdir, 0,
+	NULL, NULL },
+
+ { "host",	0,POPT_ARG_STRING,	&db3dbi.dbi_host, 0,
+	NULL, NULL },
+ { "server",	0,POPT_ARG_STRING,	&db3dbi.dbi_host, 0,
+	NULL, NULL },
+ { "cl_timeout", 0,POPT_ARG_LONG,	&db3dbi.dbi_cl_timeout, 0,
+	NULL, NULL },
+ { "sv_timeout", 0,POPT_ARG_LONG,	&db3dbi.dbi_sv_timeout, 0,
+	NULL, NULL },
+
+ { "verify",	0,POPT_ARG_NONE,	&db3dbi.dbi_verify_on_close, 0,
+	NULL, NULL },
+ { "teardown",	0,POPT_ARG_NONE,	&dbi_tear_down, 0,
+	NULL, NULL },
+ { "usecursors",0,POPT_ARG_NONE,	&dbi_use_cursors, 0,
+	NULL, NULL },
+ { "usedbenv",	0,POPT_ARG_NONE,	&db3dbi.dbi_use_dbenv, 0,
+	NULL, NULL },
+ { "nofsync",	0,POPT_ARG_NONE,	&db3dbi.dbi_no_fsync, 0,
+	NULL, NULL },
+ { "nodbsync",	0,POPT_ARG_NONE,	&db3dbi.dbi_no_dbsync, 0,
+	NULL, NULL },
+ { "lockdbfd",	0,POPT_ARG_NONE,	&db3dbi.dbi_lockdbfd, 0,
+	NULL, NULL },
+ { "temporary",	0,POPT_ARG_NONE,	&db3dbi.dbi_temporary, 0,
+	NULL, NULL },
+ { "debug",	0,POPT_ARG_NONE,	&db3dbi.dbi_debug, 0,
+	NULL, NULL },
+
+ { "cachesize",	0,POPT_ARG_INT,		&db3dbi.dbi_cachesize, 0,
+	NULL, NULL },
+ { "errpfx",	0,POPT_ARG_STRING,	&db3dbi.dbi_errpfx, 0,
+	NULL, NULL },
+ { "region_init", 0,POPT_ARG_VAL,	&db3dbi.dbi_region_init, 1,
+	NULL, NULL },
+ { "tas_spins",	0,POPT_ARG_INT,		&db3dbi.dbi_tas_spins, 0,
+	NULL, NULL },
+
+#if defined(DB_VERB_CHKPOINT)
+ { "chkpoint",	0,POPT_BIT_SET,	&db3dbi.dbi_verbose, DB_VERB_CHKPOINT,
+	NULL, NULL },
+#endif
+ { "deadlock",	0,POPT_BIT_SET,	&db3dbi.dbi_verbose, DB_VERB_DEADLOCK,
+	NULL, NULL },
+ { "recovery",	0,POPT_BIT_SET,	&db3dbi.dbi_verbose, DB_VERB_RECOVERY,
+	NULL, NULL },
+ { "waitsfor",	0,POPT_BIT_SET,	&db3dbi.dbi_verbose, DB_VERB_WAITSFOR,
+	NULL, NULL },
+ { "verbose",	0,POPT_ARG_VAL,		&db3dbi.dbi_verbose, -1,
+	NULL, NULL },
+
+ { "lk_oldest",	0,POPT_ARG_VAL,		&db3dbi.dbi_lk_detect, DB_LOCK_OLDEST,
+	NULL, NULL },
+ { "lk_random",	0,POPT_ARG_VAL,		&db3dbi.dbi_lk_detect, DB_LOCK_RANDOM,
+	NULL, NULL },
+ { "lk_youngest",0, POPT_ARG_VAL,	&db3dbi.dbi_lk_detect, DB_LOCK_YOUNGEST,
+	NULL, NULL },
+/* XXX lk_conflicts matrix */
+ { "lk_max",	0,POPT_ARG_INT,		&db3dbi.dbi_lk_max, 0,
+	NULL, NULL },
+
+ { "lg_bsize",	0,POPT_ARG_INT,		&db3dbi.dbi_lg_bsize, 0,
+	NULL, NULL },
+ { "lg_max",	0,POPT_ARG_INT,		&db3dbi.dbi_lg_max, 0,
+	NULL, NULL },
+
+/* XXX tx_recover */
+ { "tx_max",	0,POPT_ARG_INT,		&db3dbi.dbi_tx_max, 0,
+	NULL, NULL },
+
+ { "lorder",	0,POPT_ARG_INT,		&db3dbi.dbi_lorder, 0,
+	NULL, NULL },
+
+ { "mmapsize", 0,POPT_ARG_INT,		&db3dbi.dbi_mmapsize, 0,
+	NULL, NULL },
+ { "mp_mmapsize", 0,POPT_ARG_INT,	&db3dbi.dbi_mmapsize, 0,
+	NULL, NULL },
+ { "mp_size",	0,POPT_ARG_INT,		&db3dbi.dbi_cachesize, 0,
+	NULL, NULL },
+ { "pagesize",	0,POPT_ARG_INT,		&db3dbi.dbi_pagesize, 0,
+	NULL, NULL },
+
+/* XXX bt_minkey */
+/* XXX bt_compare */
+/* XXX bt_dup_compare */
+/* XXX bt_prefix */
+ { "bt_dup",	0,POPT_BIT_SET,	&db3dbi.dbi_bt_flags, DB_DUP,
+	NULL, NULL },
+ { "bt_dupsort",0,POPT_BIT_SET,	&db3dbi.dbi_bt_flags, DB_DUPSORT,
+	NULL, NULL },
+ { "bt_recnum",	0,POPT_BIT_SET,	&db3dbi.dbi_bt_flags, DB_RECNUM,
+	NULL, NULL },
+ { "bt_revsplitoff", 0,POPT_BIT_SET,	&db3dbi.dbi_bt_flags, DB_REVSPLITOFF,
+	NULL, NULL },
+
+ { "h_dup",	0,POPT_BIT_SET,	&db3dbi.dbi_h_flags, DB_DUP,
+	NULL, NULL },
+ { "h_dupsort",	0,POPT_BIT_SET,	&db3dbi.dbi_h_flags, DB_DUPSORT,
+	NULL, NULL },
+ { "h_ffactor",	0,POPT_ARG_INT,		&db3dbi.dbi_h_ffactor, 0,
+	NULL, NULL },
+ { "h_nelem",	0,POPT_ARG_INT,		&db3dbi.dbi_h_nelem, 0,
+	NULL, NULL },
+
+ { "re_renumber", 0,POPT_BIT_SET,	&db3dbi.dbi_re_flags, DB_RENUMBER,
+	NULL, NULL },
+ { "re_snapshot",0,POPT_BIT_SET,	&db3dbi.dbi_re_flags, DB_SNAPSHOT,
+	NULL, NULL },
+ { "re_delim",	0,POPT_ARG_INT,		&db3dbi.dbi_re_delim, 0,
+	NULL, NULL },
+ { "re_len",	0,POPT_ARG_INT,		&db3dbi.dbi_re_len, 0,
+	NULL, NULL },
+ { "re_pad",	0,POPT_ARG_INT,		&db3dbi.dbi_re_pad, 0,
+	NULL, NULL },
+ { "re_source",	0,POPT_ARG_STRING,	&db3dbi.dbi_re_source, 0,
+	NULL, NULL },
+
+ { "q_extentsize", 0,POPT_ARG_INT,	&db3dbi.dbi_q_extentsize, 0,
+	NULL, NULL },
+
+    POPT_TABLEEND
+};
+
+dbiIndex db3Free(dbiIndex dbi)
+{
+    if (dbi) {
+	dbi->dbi_root = _free(dbi->dbi_root);
+	dbi->dbi_home = _free(dbi->dbi_home);
+	dbi->dbi_file = _free(dbi->dbi_file);
+	dbi->dbi_subfile = _free(dbi->dbi_subfile);
+	dbi->dbi_tmpdir = _free(dbi->dbi_tmpdir);
+	dbi->dbi_host = _free(dbi->dbi_host);
+	dbi->dbi_errpfx = _free(dbi->dbi_errpfx);
+	dbi->dbi_re_source = _free(dbi->dbi_re_source);
+	dbi->dbi_stats = _free(dbi->dbi_stats);
+	dbi = _free(dbi);
+    }
+    return dbi;
+}
+
+/** @todo Set a reasonable "last gasp" default db config. */
+static const char * const db3_config_default =
+    "db3:hash:mpool:cdb:usecursors:verbose:mp_mmapsize=8Mb:cachesize=512Kb:pagesize=512:perms=0644";
+
+dbiIndex db3New(rpmdb rpmdb, rpmTag rpmtag)
+{
+    dbiIndex dbi = xcalloc(1, sizeof(*dbi));
+    char *dbOpts;
+
+    dbOpts = rpmExpand("%{_dbi_config_", rpmTagGetName(rpmtag), "}", NULL);
+    
+    if (!(dbOpts && *dbOpts && *dbOpts != '%')) {
+	dbOpts = _free(dbOpts);
+	dbOpts = rpmExpand("%{_dbi_config}", NULL);
+	if (!(dbOpts && *dbOpts && *dbOpts != '%')) {
+	    dbOpts = rpmExpand(db3_config_default, NULL);
+	}
+    }
+
+    /* Parse the options for the database element(s). */
+    if (dbOpts && *dbOpts && *dbOpts != '%') {
+	char *o, *oe;
+	char *p, *pe;
+
+	memset(&db3dbi, 0, sizeof(db3dbi));
+/*=========*/
+	for (o = dbOpts; o && *o; o = oe) {
+	    struct poptOption *opt;
+	    const char * tok;
+	    unsigned int argInfo;
+
+	    /* Skip leading white space. */
+	    while (*o && risspace(*o))
+		o++;
+
+	    /* Find and terminate next key=value pair. Save next start point. */
+	    for (oe = o; oe && *oe; oe++) {
+		if (risspace(*oe))
+		    break;
+		if (oe[0] == ':' && !(oe[1] == '/' && oe[2] == '/'))
+		    break;
+	    }
+	    if (oe && *oe)
+		*oe++ = '\0';
+	    if (*o == '\0')
+		continue;
+
+	    /* Separate key from value, save value start (if any). */
+	    for (pe = o; pe && *pe && *pe != '='; pe++)
+		{};
+	    p = (pe ? *pe++ = '\0', pe : NULL);
+
+	    /* Skip over negation at start of token. */
+	    for (tok = o; *tok == '!'; tok++)
+		{};
+
+	    /* Find key in option table. */
+	    for (opt = rdbOptions; opt->longName != NULL; opt++) {
+		if (strcmp(tok, opt->longName))
+		    continue;
+		break;
+	    }
+	    if (opt->longName == NULL) {
+		rpmlog(RPMLOG_ERR,
+			_("unrecognized db option: \"%s\" ignored.\n"), o);
+		continue;
+	    }
+
+	    /* Toggle the flags for negated tokens, if necessary. */
+	    argInfo = opt->argInfo;
+	    if (argInfo == POPT_BIT_SET && *o == '!' && ((tok - o) % 2))
+		argInfo = POPT_BIT_CLR;
+
+	    /* Save value in template as appropriate. */
+	    switch (argInfo & POPT_ARG_MASK) {
+
+	    case POPT_ARG_NONE:
+		(void) poptSaveInt((int *)opt->arg, argInfo, 1L);
+		break;
+	    case POPT_ARG_VAL:
+		(void) poptSaveInt((int *)opt->arg, argInfo, (long)opt->val);
+	    	break;
+	    case POPT_ARG_STRING:
+	    {	char ** t = opt->arg;
+		if (t) {
+/* FIX: opt->arg annotation in popt.h */
+		    *t = _free(*t);
+		    *t = xstrdup( (p ? p : "") );
+		}
+	    }	break;
+
+	    case POPT_ARG_INT:
+	    case POPT_ARG_LONG:
+	      {	long aLong = strtol(p, &pe, 0);
+		if (pe) {
+		    if (!rstrncasecmp(pe, "Mb", 2))
+			aLong *= 1024 * 1024;
+		    else if (!rstrncasecmp(pe, "Kb", 2))
+			aLong *= 1024;
+		    else if (*pe != '\0') {
+			rpmlog(RPMLOG_ERR,
+				_("%s has invalid numeric value, skipped\n"),
+				opt->longName);
+			continue;
+		    }
+		}
+
+		if ((argInfo & POPT_ARG_MASK) == POPT_ARG_LONG) {
+		    if (aLong == LONG_MIN || aLong == LONG_MAX) {
+			rpmlog(RPMLOG_ERR,
+				_("%s has too large or too small long value, skipped\n"),
+				opt->longName);
+			continue;
+		    }
+		    (void) poptSaveLong((long *)opt->arg, argInfo, aLong);
+		    break;
+		} else {
+		    if (aLong > INT_MAX || aLong < INT_MIN) {
+			rpmlog(RPMLOG_ERR,
+				_("%s has too large or too small integer value, skipped\n"),
+				opt->longName);
+			continue;
+		    }
+		    (void) poptSaveInt((int *)opt->arg, argInfo, aLong);
+		}
+	      }	break;
+	    default:
+		break;
+	    }
+	}
+/*=========*/
+    }
+
+    dbOpts = _free(dbOpts);
+
+    *dbi = db3dbi;	/* structure assignment */
+    memset(&db3dbi, 0, sizeof(db3dbi));
+
+    if (!(dbi->dbi_perms & 0600))
+	dbi->dbi_perms = 0644;
+    dbi->dbi_mode = rpmdb->db_mode;
+    /* FIX: figger rpmdb/dbi refcounts */
+    dbi->dbi_rpmdb = rpmdb;
+    dbi->dbi_rpmtag = rpmtag;
+    
+    /*
+     * Inverted lists have join length of 2, primary data has join length of 1.
+     */
+    switch (rpmtag) {
+    case RPMDBI_PACKAGES:
+    case RPMDBI_DEPENDS:
+	dbi->dbi_jlen = 1 * sizeof(int32_t);
+	break;
+    default:
+	dbi->dbi_jlen = 2 * sizeof(int32_t);
+	break;
+    }
+
+    dbi->dbi_byteswapped = -1;	/* -1 unknown, 0 native order, 1 alien order */
+
+    if (!dbi->dbi_use_dbenv) {		/* db3 dbenv is always used now. */
+	dbi->dbi_use_dbenv = 1;
+	dbi->dbi_eflags |= (DB_INIT_MPOOL|DB_JOINENV);
+	dbi->dbi_mmapsize = 16 * 1024 * 1024;
+	dbi->dbi_cachesize = 1 * 1024 * 1024;
+    }
+
+    if ((dbi->dbi_bt_flags | dbi->dbi_h_flags) & DB_DUP)
+	dbi->dbi_permit_dups = 1;
+
+    /* FIX: *(rdbOptions->arg) reachable */
+    return dbi;
+}
+
+char * prDbiOpenFlags(int dbflags, int print_dbenv_flags)
+{
+    ARGV_t flags = NULL;
+    struct poptOption *opt;
+    char *buf;
+
+    for (opt = rdbOptions; opt->longName != NULL; opt++) {
+	if (opt->argInfo != POPT_BIT_SET)
+	    continue;
+	if (print_dbenv_flags) {
+	    if (!(opt->arg == &db3dbi.dbi_oeflags ||
+		  opt->arg == &db3dbi.dbi_eflags))
+		continue;
+	} else {
+	    if (!(opt->arg == &db3dbi.dbi_oeflags ||
+		  opt->arg == &db3dbi.dbi_oflags))
+		continue;
+	}
+	if ((dbflags & opt->val) != opt->val)
+	    continue;
+	argvAdd(&flags, opt->longName);
+	dbflags &= ~opt->val;
+    }
+    if (dbflags) {
+	char *df = NULL;
+	rasprintf(&df, "0x%x", (unsigned)dbflags);
+	argvAdd(&flags, df);
+	free(df);
+    }
+    buf = argvJoin(flags, ":");
+    argvFree(flags);
+	
+    return buf;
+}
+
+#endif
diff --git a/lib/backend/sqlite.c b/lib/backend/sqlite.c
new file mode 100644
index 000000000..e290a5b25
--- /dev/null
+++ b/lib/backend/sqlite.c
@@ -0,0 +1,1386 @@
+
+/*
+ * sqlite.c
+ * sqlite interface for rpmdb
+ *
+ * Author: Mark Hatle <mhatle@mvista.com> or <fray@kernel.crashing.org>
+ * Copyright (c) 2004 MontaVista Software, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * or GNU Library General Public License, at your option,
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and GNU Library Public License along with this program;
+ * if not, write to the Free Software Foundation, Inc., 
+ * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ */
+
+#include "system.h"
+
+#include <sqlite3.h>
+
+#include <rpm/rpmtag.h>
+#include <rpm/rpmlog.h>
+#include <rpm/rpmmacro.h>
+#include <rpm/rpmfileutil.h>	/* rpmioMkpath */
+#include <rpm/rpmstring.h>
+#include <rpm/rpmdb.h>
+
+#include "rpmdb/rpmdb_internal.h"
+
+#include "debug.h"
+
+
+static int _debug = 0;
+
+/* Define the things normally in a header... */
+struct _sql_db_s;	typedef struct _sql_db_s	SQL_DB;
+struct _sql_dbcursor_s;	typedef struct _sql_dbcursor_s *SCP_t; 
+
+struct _sql_db_s {
+    sqlite3 * db;		/* Database pointer */
+    int transaction;		/* Do we have a transaction open? */
+};
+
+struct _sql_dbcursor_s {
+    DB *dbp;
+
+    char * cmd;			/* SQL command string */
+    sqlite3_stmt *pStmt;	/* SQL byte code */
+    const char * pzErrmsg;	/* SQL error msg */
+
+  /* Table -- result of query */
+    char ** av;			/* item ptrs */
+    int * avlen;		/* item sizes */
+    int nalloc;
+    int ac;			/* no. of items */
+    int rx;			/* Which row are we on? 1, 2, 3 ... */
+    int nr;			/* no. of rows */
+    int nc;			/* no. of columns */
+
+    int all;			/* sequential iteration cursor */
+    DBT ** keys;		/* array of package keys */
+    int nkeys;
+
+    int count;
+
+    void * lkey;		/* Last key returned */
+    void * ldata;		/* Last data returned */
+
+    int used;
+};
+
+union _dbswap {
+    unsigned int ui;
+    unsigned char uc[4];
+};
+
+#define _DBSWAP(_a) \
+  { unsigned char _b, *_c = (_a).uc; \
+    _b = _c[3]; _c[3] = _c[0]; _c[0] = _b; \
+    _b = _c[2]; _c[2] = _c[1]; _c[1] = _b; \
+  }
+
+static const unsigned int endian = 0x11223344;
+
+static char * sqlCwd = NULL;
+static int sqlInRoot = 0;
+
+static void enterChroot(dbiIndex dbi)
+{
+    int xx;
+
+    if ((dbi->dbi_root[0] == '/' && dbi->dbi_root[1] == '\0') || dbi->dbi_rpmdb->db_chrootDone || sqlInRoot)
+       /* Nothing to do, was not already in chroot */
+       return;
+
+if (_debug)
+fprintf(stderr, "sql:chroot(%s)\n", dbi->dbi_root);
+
+    sqlCwd = rpmGetCwd();
+    xx = chdir("/");
+    xx = chroot(dbi->dbi_root);
+assert(xx == 0);
+    sqlInRoot=1;
+}
+
+static void leaveChroot(dbiIndex dbi)
+{
+    int xx;
+
+    if ((dbi->dbi_root[0] == '/' && dbi->dbi_root[1] == '\0') || dbi->dbi_rpmdb->db_chrootDone || !sqlInRoot)
+       /* Nothing to do, not in chroot */
+       return;
+
+if (_debug)
+fprintf(stderr, "sql:chroot(.)\n");
+
+    xx = chroot(".");
+assert(xx == 0);
+    xx = chdir(sqlCwd);
+    sqlCwd = _free(sqlCwd);
+
+    sqlInRoot=0;
+}
+
+static void dbg_scp(void *ptr)
+{
+    SCP_t scp = ptr;
+
+if (_debug)
+fprintf(stderr, "\tscp %p [%d:%d] av %p avlen %p nr [%d:%d] nc %d all %d\n", scp, scp->ac, scp->nalloc, scp->av, scp->avlen, scp->rx, scp->nr, scp->nc, scp->all);
+
+}
+
+static void dbg_keyval(const char * msg, dbiIndex dbi, DBC * dbcursor,
+		DBT * key, DBT * data, unsigned int flags)
+{
+
+if (!_debug) return;
+
+    fprintf(stderr, "%s on %s (%p,%p,%p,0x%x)", msg, dbi->dbi_subfile, dbcursor, key, data, flags);
+
+    /* XXX FIXME: ptr alignment is fubar here. */
+    if (key != NULL && key->data != NULL) {
+	fprintf(stderr, "  key 0x%x[%d]", *(unsigned int *)key->data, key->size);
+	if (dbi->dbi_rpmtag == RPMTAG_NAME)
+	    fprintf(stderr, " \"%s\"", (const char *)key->data);
+    }
+    if (data != NULL && data->data != NULL)
+	fprintf(stderr, " data 0x%x[%d]", *(unsigned int *)data->data, data->size);
+
+    fprintf(stderr, "\n");
+    dbg_scp(dbcursor);
+}
+
+
+static SCP_t scpResetKeys(SCP_t scp)
+{
+    int ix;
+
+if (_debug)
+fprintf(stderr, "*** %s(%p)\n", __FUNCTION__, scp);
+dbg_scp(scp);
+
+    for ( ix =0 ; ix < scp->nkeys ; ix++ ) {
+      scp->keys[ix]->data = _free(scp->keys[ix]->data);
+      scp->keys[ix] = _free(scp->keys[ix]);
+    }
+    scp->keys = _free(scp->keys);
+    scp->nkeys = 0;
+
+    return scp;
+}
+
+
+static SCP_t scpResetAv(SCP_t scp)
+{
+    int xx;
+
+if (_debug)
+fprintf(stderr, "*** %s(%p)\n", __FUNCTION__, scp);
+dbg_scp(scp);
+
+    if (scp->av) {
+	if (scp->nalloc <= 0) {
+	    /* Clean up SCP_t used by sqlite3_get_table(). */
+	    sqlite3_free_table(scp->av);
+	    scp->av = NULL;
+	    scp->nalloc = 0;
+	} else {
+	    /* Clean up SCP_t used by sql_step(). */
+	    for (xx = 0; xx < scp->ac; xx++)
+		scp->av[xx] = _free(scp->av[xx]);
+	    if (scp->av != NULL)
+		memset(scp->av, 0, scp->nalloc * sizeof(*scp->av));
+	    if (scp->avlen != NULL)
+		memset(scp->avlen, 0, scp->nalloc * sizeof(*scp->avlen));
+	    scp->av = _free(scp->av);
+	    scp->avlen = _free(scp->avlen);
+	    scp->nalloc = 0;
+	}
+    } else
+	scp->nalloc = 0;
+    scp->ac = 0;
+    scp->nr = 0;
+    scp->nc = 0;
+
+    return scp;
+}
+
+
+static SCP_t scpReset(SCP_t scp)
+{
+    int xx;
+
+if (_debug)
+fprintf(stderr, "*** %s(%p)\n", __FUNCTION__, scp);
+dbg_scp(scp);
+
+    if (scp->cmd) {
+	sqlite3_free(scp->cmd);
+	scp->cmd = NULL;
+    }
+    if (scp->pStmt) {
+	xx = sqlite3_reset(scp->pStmt);
+	if (xx) rpmlog(RPMLOG_DEBUG, "reset %d\n", xx);
+	xx = sqlite3_finalize(scp->pStmt);
+	if (xx) rpmlog(RPMLOG_DEBUG, "finalize %d\n", xx);
+	scp->pStmt = NULL;
+    }
+
+    scp = scpResetAv(scp);
+
+    scp->rx = 0;
+    return scp;
+}
+
+static SCP_t scpFree(SCP_t scp)
+{
+    scp = scpReset(scp);
+    scp = scpResetKeys(scp);
+    scp->av = _free(scp->av);
+    scp->avlen = _free(scp->avlen);
+
+if (_debug)
+fprintf(stderr, "*** %s(%p)\n", __FUNCTION__, scp);
+    scp = _free(scp);
+    return NULL;
+}
+
+static SCP_t scpNew(DB * dbp)
+{
+    SCP_t scp = xcalloc(1, sizeof(*scp));
+    scp->dbp = dbp;
+
+    scp->used = 0;
+
+    scp->lkey = NULL;
+    scp->ldata = NULL;
+
+if (_debug)
+fprintf(stderr, "*** %s(%p)\n", __FUNCTION__, scp);
+    return scp;
+}
+
+static int sql_step(dbiIndex dbi, SCP_t scp)
+{
+    const char * cname;
+    const char * vtype;
+    size_t nb;
+    int loop;
+    int need;
+    int rc;
+    int i;
+
+    scp->nc = sqlite3_column_count(scp->pStmt);
+
+    if (scp->nr == 0 && scp->av != NULL)
+	need = 2 * scp->nc;
+    else
+	need = scp->nc;
+
+    /* XXX scp->nc = need = scp->nalloc = 0 case forces + 1 here */
+    if (!scp->ac && !need && !scp->nalloc)
+	need++;
+   
+    if (scp->ac + need >= scp->nalloc) {
+	/* XXX +4 is bogus, was +1 */
+	scp->nalloc = 2 * scp->nalloc + need + 4;
+	scp->av = xrealloc(scp->av, scp->nalloc * sizeof(*scp->av));
+	scp->avlen = xrealloc(scp->avlen, scp->nalloc * sizeof(*scp->avlen));
+    }
+
+    if (scp->nr == 0) {
+	for (i = 0; i < scp->nc; i++) {
+	    scp->av[scp->ac] = xstrdup(sqlite3_column_name(scp->pStmt, i));
+	    if (scp->avlen) scp->avlen[scp->ac] = strlen(scp->av[scp->ac]) + 1;
+	    scp->ac++;
+assert(scp->ac <= scp->nalloc);
+	}
+    }
+
+    loop = 1;
+    while (loop) {
+	rc = sqlite3_step(scp->pStmt);
+	switch (rc) {
+	case SQLITE_DONE:
+if (_debug)
+fprintf(stderr, "sqlite3_step: DONE scp %p [%d:%d] av %p avlen %p\n", scp, scp->ac, scp->nalloc, scp->av, scp->avlen);
+	    loop = 0;
+	    break;
+	case SQLITE_ROW:
+	    if (scp->av != NULL)
+	    for (i = 0; i < scp->nc; i++) {
+		/* Expand the row array for new elements */
+    		if (scp->ac + need >= scp->nalloc) {
+		    /* XXX +4 is bogus, was +1 */
+		    scp->nalloc = 2 * scp->nalloc + need + 4;
+		    scp->av = xrealloc(scp->av, scp->nalloc * sizeof(*scp->av));
+		    scp->avlen = xrealloc(scp->avlen, scp->nalloc * sizeof(*scp->avlen));
+	        }
+
+		cname = sqlite3_column_name(scp->pStmt, i);
+		vtype = sqlite3_column_decltype(scp->pStmt, i);
+		nb = 0;
+
+		if (!strcmp(vtype, "blob")) {
+		    const void * v = sqlite3_column_blob(scp->pStmt, i);
+		    nb = sqlite3_column_bytes(scp->pStmt, i);
+if (_debug)
+fprintf(stderr, "\t%d %s %s %p[%zd]\n", i, cname, vtype, v, nb);
+		    if (nb > 0) {
+			void * t = xmalloc(nb);
+			scp->av[scp->ac] = memcpy(t, v, nb);
+			scp->avlen[scp->ac] = nb;
+			scp->ac++;
+		    }
+		} else
+		if (!strcmp(vtype, "double")) {
+		    double v = sqlite3_column_double(scp->pStmt, i);
+		    nb = sizeof(v);
+if (_debug)
+fprintf(stderr, "\t%d %s %s %g\n", i, cname, vtype, v);
+		    if (nb > 0) {
+			scp->av[scp->ac] = memcpy(xmalloc(nb), &v, nb);
+			scp->avlen[scp->ac] = nb;
+assert(dbiByteSwapped(dbi) == 0); /* Byte swap?! */
+			scp->ac++;
+		    }
+		} else
+		if (!strcmp(vtype, "int")) {
+		    int32_t v = sqlite3_column_int(scp->pStmt, i);
+		    nb = sizeof(v);
+if (_debug)
+fprintf(stderr, "\t%d %s %s %d\n", i, cname, vtype, v);
+		    if (nb > 0) {
+			scp->av[scp->ac] = memcpy(xmalloc(nb), &v, nb);
+			scp->avlen[scp->ac] = nb;
+if (dbiByteSwapped(dbi) == 1)
+{
+  union _dbswap dbswap;
+  memcpy(&dbswap.ui, scp->av[scp->ac], sizeof(dbswap.ui));
+  _DBSWAP(dbswap);
+  memcpy(scp->av[scp->ac], &dbswap.ui, sizeof(dbswap.ui));
+}
+			scp->ac++;
+		    }
+		} else
+		if (!strcmp(vtype, "int64")) {
+		    int64_t v = sqlite3_column_int64(scp->pStmt, i);
+		    nb = sizeof(v);
+if (_debug)
+fprintf(stderr, "\t%d %s %s %ld\n", i, cname, vtype, (long)v);
+		    if (nb > 0) {
+			scp->av[scp->ac] = memcpy(xmalloc(nb), &v, nb);
+			scp->avlen[scp->ac] = nb;
+assert(dbiByteSwapped(dbi) == 0); /* Byte swap?! */
+			scp->ac++;
+		    }
+		} else
+		if (!strcmp(vtype, "text")) {
+		    const char * v = (const char *) sqlite3_column_text(scp->pStmt, i);
+		    nb = strlen(v) + 1;
+if (_debug)
+fprintf(stderr, "\t%d %s %s \"%s\"\n", i, cname, vtype, v);
+		    if (nb > 0) {
+			scp->av[scp->ac] = memcpy(xmalloc(nb), v, nb);
+			scp->avlen[scp->ac] = nb;
+			scp->ac++;
+		    }
+		}
+assert(scp->ac <= scp->nalloc);
+	    }
+	    scp->nr++;
+	    break;
+	case SQLITE_BUSY:
+	    fprintf(stderr, "sqlite3_step: BUSY %d\n", rc);
+	    break;
+	case SQLITE_ERROR: {
+	    char *cwd = rpmGetCwd();
+	    fprintf(stderr, "sqlite3_step: ERROR %d -- %s\n", rc, scp->cmd);
+	    fprintf(stderr, "              %s (%d)\n", 
+			sqlite3_errmsg(((SQL_DB*)dbi->dbi_db)->db), sqlite3_errcode(((SQL_DB*)dbi->dbi_db)->db));
+	    
+	    fprintf(stderr, "              cwd '%s'\n", cwd);
+	    free(cwd);
+	    loop = 0;
+	}
+	    break;
+	case SQLITE_MISUSE:
+	    fprintf(stderr, "sqlite3_step: MISUSE %d\n", rc);
+	    loop = 0;
+	    break;
+	default:
+	    fprintf(stderr, "sqlite3_step: rc %d\n", rc);
+	    loop = 0;
+	    break;
+	}
+    }
+
+    if (rc == SQLITE_DONE)
+	rc = SQLITE_OK;
+
+    return rc;
+}
+
+static int sql_bind_key(dbiIndex dbi, SCP_t scp, int pos, DBT * key)
+{
+    int rc = 0;
+
+    union _dbswap dbswap;
+
+assert(key->data != NULL);
+    switch (dbi->dbi_rpmtag) {
+	case RPMDBI_PACKAGES:
+	{   unsigned int hnum;
+assert(key->size == sizeof(int32_t));
+	    memcpy(&hnum, key->data, sizeof(hnum));
+
+if (dbiByteSwapped(dbi) == 1)
+{
+  memcpy(&dbswap.ui, &hnum, sizeof(dbswap.ui));
+  _DBSWAP(dbswap);
+  memcpy(&hnum, &dbswap.ui, sizeof(dbswap.ui));
+}
+	    rc = sqlite3_bind_int(scp->pStmt, pos, hnum);
+	}   break;
+	default:
+	    switch (rpmTagGetType(dbi->dbi_rpmtag)) {
+	    case RPM_NULL_TYPE:   
+	    case RPM_BIN_TYPE:
+	        rc = sqlite3_bind_blob(scp->pStmt, pos, key->data, key->size, SQLITE_STATIC);
+		break;
+	    case RPM_CHAR_TYPE:
+	    case RPM_INT8_TYPE:
+	    {	unsigned char i;
+assert(key->size == sizeof(unsigned char));
+assert(dbiByteSwapped(dbi) == 0); /* Byte swap?! */
+		memcpy(&i, key->data, sizeof(i));
+	        rc = sqlite3_bind_int(scp->pStmt, pos, i);
+	    }   break;
+	    case RPM_INT16_TYPE:
+	    {	unsigned short i;
+assert(key->size == sizeof(int16_t));
+assert(dbiByteSwapped(dbi) == 0); /* Byte swap?! */
+		memcpy(&i, key->data, sizeof(i));
+	        rc = sqlite3_bind_int(scp->pStmt, pos, i);
+	    }   break;
+            case RPM_INT32_TYPE:
+/*          case RPM_INT64_TYPE: */   
+	    default:
+	    {	unsigned int i;
+assert(key->size == sizeof(int32_t));
+		memcpy(&i, key->data, sizeof(i));
+
+if (dbiByteSwapped(dbi) == 1)
+{
+  memcpy(&dbswap.ui, &i, sizeof(dbswap.ui));
+  _DBSWAP(dbswap);
+  memcpy(&i, &dbswap.ui, sizeof(dbswap.ui));
+}
+	        rc = sqlite3_bind_int(scp->pStmt, pos, i);
+	    }   break;
+            case RPM_STRING_TYPE:
+            case RPM_STRING_ARRAY_TYPE:
+            case RPM_I18NSTRING_TYPE:
+		rc = sqlite3_bind_text(scp->pStmt, pos, key->data, key->size, SQLITE_STATIC);
+                break;
+            }
+    }
+
+    return rc;
+}
+
+static int sql_bind_data(dbiIndex dbi, SCP_t scp, int pos, DBT * data)
+{
+    int rc;
+
+assert(data->data != NULL);
+    rc = sqlite3_bind_blob(scp->pStmt, pos, data->data, data->size, SQLITE_STATIC);
+
+    return rc;
+}
+
+/*===================================================================*/
+/*
+ * Transaction support
+ */
+
+static int sql_startTransaction(dbiIndex dbi)
+{
+    SQL_DB * sqldb = (SQL_DB *) dbi->dbi_db;
+    int rc = 0;
+
+    /* XXX:  Transaction Support */
+    if (!sqldb->transaction) {
+      char * pzErrmsg;
+      rc = sqlite3_exec(sqldb->db, "BEGIN TRANSACTION;", NULL, NULL, &pzErrmsg);
+
+if (_debug)
+fprintf(stderr, "Begin %s SQL transaction %s (%d)\n",
+		dbi->dbi_subfile, pzErrmsg, rc);
+
+      if (rc == 0)
+	sqldb->transaction = 1;
+    }
+
+    return rc;
+}
+
+static int sql_endTransaction(dbiIndex dbi)
+{
+    SQL_DB * sqldb = (SQL_DB *) dbi->dbi_db;
+    int rc=0;
+
+    /* XXX:  Transaction Support */
+    if (sqldb->transaction) {
+      char * pzErrmsg;
+      rc = sqlite3_exec(sqldb->db, "END TRANSACTION;", NULL, NULL, &pzErrmsg);
+
+if (_debug)
+fprintf(stderr, "End %s SQL transaction %s (%d)\n",
+		dbi->dbi_subfile, pzErrmsg, rc);
+
+      if (rc == 0)
+	sqldb->transaction = 0;
+    }
+
+    return rc;
+}
+
+static int sql_commitTransaction(dbiIndex dbi, int flag)
+{
+    SQL_DB * sqldb = (SQL_DB *) dbi->dbi_db;
+    int rc = 0;
+
+    /* XXX:  Transactions */
+    if ( sqldb->transaction ) {
+      char * pzErrmsg;
+      rc = sqlite3_exec(sqldb->db, "COMMIT;", NULL, NULL, &pzErrmsg);
+
+if (_debug)
+fprintf(stderr, "Commit %s SQL transaction(s) %s (%d)\n",
+		dbi->dbi_subfile, pzErrmsg, rc);
+
+      sqldb->transaction=0;
+
+      /* Start a new transaction if we were in the middle of one */
+      if ( flag == 0 )
+	rc = sql_startTransaction(dbi);
+    }
+
+    return rc;
+}
+
+static int sql_busy_handler(void * dbi_void, int time)
+{
+    dbiIndex dbi = (dbiIndex) dbi_void;
+
+    rpmlog(RPMLOG_WARNING, _("Unable to get lock on db %s, retrying... (%d)\n"),
+		dbi->dbi_file, time);
+
+    (void) sleep(1);
+
+    return 1;
+}
+
+/*===================================================================*/
+
+/**
+ * Verify the DB is setup.. if not initialize it
+ *
+ * Create the table.. create the db_info
+ */
+static int sql_initDB(dbiIndex dbi)
+{
+    SQL_DB * sqldb = (SQL_DB *) dbi->dbi_db;
+    SCP_t scp = scpNew(dbi->dbi_db);
+    char *cmd = NULL;
+    int rc = 0;
+
+    /* Check if the table exists... */
+    rasprintf(&cmd,
+	"SELECT name FROM 'sqlite_master' WHERE type='table' and name='%s';",
+		dbi->dbi_subfile);
+    rc = sqlite3_get_table(sqldb->db, cmd,
+	&scp->av, &scp->nr, &scp->nc, (char **)&scp->pzErrmsg);
+    cmd = _free(cmd);
+    if (rc)
+	goto exit;
+
+    if (scp->nr < 1) {
+	const char * valtype = "blob";
+	const char * keytype;
+
+	switch (dbi->dbi_rpmtag) {
+	case RPMDBI_PACKAGES:
+	    keytype = "int UNIQUE PRIMARY KEY";
+	    valtype = "blob";
+	    break;
+	default:
+	    switch (rpmTagGetType(dbi->dbi_rpmtag)) {
+	    case RPM_NULL_TYPE:
+	    case RPM_BIN_TYPE:
+	    default:
+		keytype = "blob UNIQUE";
+		break;
+	    case RPM_CHAR_TYPE:
+	    case RPM_INT8_TYPE:
+	    case RPM_INT16_TYPE:
+	    case RPM_INT32_TYPE:
+/*	    case RPM_INT64_TYPE: */
+		keytype = "int UNIQUE";
+		break;
+	    case RPM_STRING_TYPE:
+	    case RPM_STRING_ARRAY_TYPE:
+	    case RPM_I18NSTRING_TYPE:
+		keytype = "text UNIQUE";
+		break;
+	    }
+	}
+if (_debug)
+fprintf(stderr, "\t%s(%d) type(%d) keytype %s\n", rpmTagGetName(dbi->dbi_rpmtag), dbi->dbi_rpmtag, rpmTagGetType(dbi->dbi_rpmtag), keytype);
+	rasprintf(&cmd, "CREATE TABLE '%s' (key %s, value %s)",
+			dbi->dbi_subfile, keytype, valtype);
+	rc = sqlite3_exec(sqldb->db, cmd, NULL, NULL, (char **)&scp->pzErrmsg);
+	cmd = _free(cmd);
+	if (rc)
+	    goto exit;
+
+	rasprintf(&cmd, "CREATE TABLE 'db_info' (endian TEXT)");
+	rc = sqlite3_exec(sqldb->db, cmd, NULL, NULL, (char **)&scp->pzErrmsg);
+	cmd = _free(cmd);
+	if (rc)
+	    goto exit;
+
+	rasprintf(&cmd, "INSERT INTO 'db_info' values('%d')", ((union _dbswap *)&endian)->uc[0]);
+	rc = sqlite3_exec(sqldb->db, cmd, NULL, NULL, (char **)&scp->pzErrmsg);
+	_free(cmd);
+	if (rc)
+	    goto exit;
+    }
+
+    if (dbi->dbi_no_fsync) {
+	int xx;
+        rasprintf(&cmd, "PRAGMA synchronous = OFF;");
+        xx = sqlite3_exec(sqldb->db, cmd, NULL, NULL, (char **)&scp->pzErrmsg);
+	cmd = _free(cmd);
+    }
+
+exit:
+    if (rc)
+	rpmlog(RPMLOG_WARNING, _("Unable to initDB %s (%d)\n"),
+		scp->pzErrmsg, rc);
+
+    scp = scpFree(scp);
+
+    return rc;
+}
+
+/**   
+ * Close database cursor.
+ * @param dbi           index database handle
+ * @param dbcursor      database cursor
+ * @param flags         (unused)
+ * @return              0 on success
+ */   
+static int sql_cclose (dbiIndex dbi, DBC * dbcursor,
+		unsigned int flags)
+{
+    SCP_t scp = (SCP_t)dbcursor;
+    int rc;
+
+if (_debug)
+fprintf(stderr, "==> %s(%p)\n", __FUNCTION__, scp);
+
+    if (scp->lkey)
+	scp->lkey = _free(scp->lkey);
+
+    if (scp->ldata)
+	scp->ldata = _free(scp->ldata);
+
+enterChroot(dbi);
+
+    if (flags == DB_WRITECURSOR)
+	rc = sql_commitTransaction(dbi, 1);
+    else
+	rc = sql_endTransaction(dbi);
+
+    scp = scpFree(scp);
+
+leaveChroot(dbi);
+
+    return rc;
+}
+
+/**
+ * Close index database, and destroy database handle.
+ * @param dbi           index database handle
+ * @param flags         (unused)
+ * @return              0 on success
+ */
+static int sql_close(dbiIndex dbi, unsigned int flags)
+{
+    SQL_DB * sqldb = (SQL_DB *) dbi->dbi_db;
+    int rc = 0;
+
+    if (sqldb) {
+enterChroot(dbi);
+
+	/* Commit, don't open a new one */
+	rc = sql_commitTransaction(dbi, 1);
+
+	(void) sqlite3_close(sqldb->db);
+
+	rpmlog(RPMLOG_DEBUG, "closed   sql db         %s\n",
+		dbi->dbi_subfile);
+
+	dbi->dbi_stats = _free(dbi->dbi_stats);
+	dbi->dbi_file = _free(dbi->dbi_file);
+	dbi->dbi_db = _free(dbi->dbi_db);
+
+leaveChroot(dbi);
+    }
+
+    dbi = _free(dbi);
+
+    return rc;
+}
+
+/**
+ * Return handle for an index database.
+ * @param rpmdb         rpm database
+ * @param rpmtag        rpm tag
+ * @param dbip
+ * @return              0 on success
+ */
+static int sql_open(rpmdb rpmdb, rpmTag rpmtag, dbiIndex * dbip)
+{
+    extern const struct _dbiVec sqlitevec;
+   
+    char * root;
+    char * home;
+    char * dbhome;
+    const char * dbfile;  
+    char * dbfname;
+    const char * sql_errcode;
+    dbiIndex dbi;
+    SQL_DB * sqldb;
+    size_t len;
+    int rc = 0;
+    int xx;
+    
+    if (dbip)
+	*dbip = NULL;
+
+    /*
+     * Parse db configuration parameters.
+     */
+    if ((dbi = db3New(rpmdb, rpmtag)) == NULL)
+	return 1;
+
+   /*
+     * Get the prefix/root component and directory path
+     */
+    root = rpmdb->db_root;
+    home = rpmdb->db_home;
+    
+    dbi->dbi_root = root;
+    dbi->dbi_home = home;
+      
+    dbfile = rpmTagGetName(dbi->dbi_rpmtag);
+
+enterChroot(dbi);
+
+    /*
+     * Make a copy of the tagName result..
+     * use this for the filename and table name
+     */
+    {	
+      char * t;
+      len = strlen(dbfile);
+      t = xcalloc(len + 1, sizeof(*t));
+      (void) stpcpy( t, dbfile );
+      dbi->dbi_file = t;
+/* WRONG */
+      dbi->dbi_subfile = t;
+    }
+
+    dbi->dbi_mode=O_RDWR;
+       
+    dbhome = rpmGenPath(NULL, home, NULL);
+
+    /* 
+     * Create the /var/lib/rpm directory if it doesn't exist (root only).
+     */
+    (void) rpmioMkpath(dbhome, 0755, getuid(), getgid());
+       
+    dbfname = rpmGenPath(dbhome, dbi->dbi_file, NULL);
+
+    rpmlog(RPMLOG_DEBUG, "opening  sql db         %s (%s) mode=0x%x\n",
+		dbfname, dbi->dbi_subfile, dbi->dbi_mode);
+
+    /* Open the Database */
+    sqldb = xcalloc(1,sizeof(*sqldb));
+       
+    sql_errcode = NULL;
+    xx = sqlite3_open(dbfname, &sqldb->db);
+    if (xx != SQLITE_OK)
+	sql_errcode = sqlite3_errmsg(sqldb->db);
+
+    if (sqldb->db)
+	(void) sqlite3_busy_handler(sqldb->db, &sql_busy_handler, dbi);
+
+    sqldb->transaction = 0;	/* Initialize no current transactions */
+
+    dbi->dbi_db = (DB *)sqldb;
+
+    if (sql_errcode != NULL) {
+      rpmlog(RPMLOG_ERR, _("Unable to open database: %s\n"), sql_errcode);
+      rc = EINVAL;
+    }
+
+    /* initialize table */
+    if (rc == 0)
+	rc = sql_initDB(dbi);
+
+    if (rc == 0 && dbi->dbi_db != NULL && dbip != NULL) {
+	dbi->dbi_vec = &sqlitevec;
+	*dbip = dbi;
+    } else {
+	(void) sql_close(dbi, 0);
+    }
+ 
+    free(dbhome);
+    dbfname = _free(dbfname);
+
+leaveChroot(dbi);
+   
+    return rc;
+}
+
+/**
+ * Flush pending operations to disk.
+ * @param dbi           index database handle
+ * @param flags         (unused)
+ * @return              0 on success
+ */
+static int sql_sync (dbiIndex dbi, unsigned int flags)
+{
+    int rc = 0;
+
+enterChroot(dbi);
+    rc = sql_commitTransaction(dbi, 0);
+leaveChroot(dbi);
+
+    return rc;
+}
+
+/**
+ * Open database cursor.
+ * @param dbi           index database handle
+ * @param txnid         database transaction handle
+ * @retval dbcp         address of new database cursor
+ * @param flags         DB_WRITECURSOR or 0
+ * @return              0 on success
+ */
+static int sql_copen (dbiIndex dbi, DB_TXN * txnid,
+		DBC ** dbcp, unsigned int flags)
+{
+    SCP_t scp = scpNew(dbi->dbi_db);
+    DBC * dbcursor = (DBC *)scp;
+    int rc = 0;
+
+if (_debug)
+fprintf(stderr, "==> %s(%s) tag %d type %d scp %p\n", __FUNCTION__, rpmTagGetName(dbi->dbi_rpmtag), dbi->dbi_rpmtag, rpmTagGetType(dbi->dbi_rpmtag), scp);
+
+enterChroot(dbi);
+
+    /* If we're going to write, start a transaction (lock the DB) */
+    if (flags == DB_WRITECURSOR)
+	rc = sql_startTransaction(dbi);
+
+    if (dbcp)
+	*dbcp = dbcursor;
+    else
+	(void) sql_cclose(dbi, dbcursor, 0);
+
+leaveChroot(dbi);
+     
+    return rc;
+}
+
+/**
+ * Delete (key,data) pair(s) using db->del or dbcursor->c_del.
+ * @param dbi           index database handle
+ * @param dbcursor      database cursor (NULL will use db->del)   
+ * @param key           delete key value/length/flags
+ * @param data          delete data value/length/flags
+ * @param flags         (unused)
+ * @return              0 on success
+ */
+static int sql_cdel (dbiIndex dbi, DBC * dbcursor, DBT * key,
+		DBT * data, unsigned int flags)
+{
+   SQL_DB * sqldb = (SQL_DB *) dbi->dbi_db;
+    SCP_t scp = scpNew(dbi->dbi_db);
+    int rc = 0;
+
+dbg_keyval(__FUNCTION__, dbi, dbcursor, key, data, flags);
+enterChroot(dbi);
+
+    scp->cmd = sqlite3_mprintf("DELETE FROM '%q' WHERE key=? AND value=?;",
+	dbi->dbi_subfile);
+
+    rc = sqlite3_prepare(sqldb->db, scp->cmd, strlen(scp->cmd), &scp->pStmt, &scp->pzErrmsg);
+    if (rc) rpmlog(RPMLOG_DEBUG, "cdel(%s) prepare %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqldb->db), rc);
+    rc = sql_bind_key(dbi, scp, 1, key);
+    if (rc) rpmlog(RPMLOG_DEBUG, "cdel(%s) bind key %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqldb->db), rc);
+    rc = sql_bind_data(dbi, scp, 2, data);
+    if (rc) rpmlog(RPMLOG_DEBUG, "cdel(%s) bind data %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqldb->db), rc);
+
+    rc = sql_step(dbi, scp);
+    if (rc) rpmlog(RPMLOG_DEBUG, "cdel(%s) sql_step rc %d\n", dbi->dbi_subfile, rc);
+
+    scp = scpFree(scp);
+
+leaveChroot(dbi);
+
+    return rc;
+}
+
+/**
+ * Retrieve (key,data) pair using db->get or dbcursor->c_get.
+ * @param dbi           index database handle
+ * @param dbcursor      database cursor (NULL will use db->get)
+ * @param key           retrieve key value/length/flags
+ * @param data          retrieve data value/length/flags
+ * @param flags         (unused)
+ * @return              0 on success
+ */
+static int sql_cget (dbiIndex dbi, DBC * dbcursor, DBT * key,
+		DBT * data, unsigned int flags)
+{
+   SQL_DB * sqldb = (SQL_DB *) dbi->dbi_db;
+    SCP_t scp = (SCP_t)dbcursor;
+    int rc = 0;
+    int ix;
+
+dbg_keyval(__FUNCTION__, dbi, dbcursor, key, data, flags);
+
+enterChroot(dbi);
+
+    /*
+     * First determine if this is a new scan or existing scan
+     */
+
+if (_debug)
+fprintf(stderr, "\tcget(%s) scp %p rc %d flags %d av %p\n",
+		dbi->dbi_subfile, scp, rc, flags, scp->av);
+    if ( flags == DB_SET || scp->used == 0 ) {
+        scp->used = 1; /* Signal this scp as now in use... */
+        scp = scpReset(scp);	/* Free av and avlen, reset counters.*/
+
+/* XXX: Should we also reset the key table here?  Can you re-use a cursor? */
+
+        /*
+         * If we're scanning everything, load the iterator key table
+         */
+        if ( key->size == 0) {
+	    scp->all = 1;
+
+/* 
+ * The only condition not dealt with is if there are multiple identical keys.  This can lead
+ * to later iteration confusion.  (It may return the same value for the multiple keys.)
+ */
+
+/* Only RPMDBI_PACKAGES is supposed to be iterating, and this is guarenteed to be unique */
+assert(dbi->dbi_rpmtag == RPMDBI_PACKAGES);
+
+	    switch (dbi->dbi_rpmtag) {
+	    case RPMDBI_PACKAGES:
+	        scp->cmd = sqlite3_mprintf("SELECT key FROM '%q' ORDER BY key;",
+		    dbi->dbi_subfile);
+	        break;
+	    default:
+	        scp->cmd = sqlite3_mprintf("SELECT key FROM '%q';",
+		    dbi->dbi_subfile);
+	        break;
+	    }
+	    rc = sqlite3_prepare(sqldb->db, scp->cmd, strlen(scp->cmd), &scp->pStmt, &scp->pzErrmsg);
+	    if (rc) rpmlog(RPMLOG_DEBUG, "cget(%s) sequential prepare %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqldb->db), rc);
+
+	    rc = sql_step(dbi, scp);
+	    if (rc) rpmlog(RPMLOG_DEBUG, "cget(%s) sequential sql_step rc %d\n", dbi->dbi_subfile, rc);
+
+	    scp = scpResetKeys(scp);
+	    scp->nkeys = scp->nr;
+	    scp->keys = xcalloc(scp->nkeys, sizeof(*scp->keys));
+	    for (ix = 0; ix < scp->nkeys; ix++) {
+		scp->keys[ix] = xmalloc(sizeof(DBT));
+		scp->keys[ix]->size = scp->avlen[ix+1];
+		scp->keys[ix]->data = xmalloc(scp->keys[ix]->size);
+		memcpy(scp->keys[ix]->data, scp->av[ix+1], scp->avlen[ix+1]);
+	    }
+        } else {
+	    /*
+	     * We're only scanning ONE element
+	     */
+	    scp = scpResetKeys(scp);
+	    scp->nkeys = 1;
+	    scp->keys = xcalloc(scp->nkeys, sizeof(*scp->keys));
+	    scp->keys[0] = xmalloc(sizeof(DBT));
+	    scp->keys[0]->size = key->size;
+	    scp->keys[0]->data = xmalloc(scp->keys[0]->size);
+	    memcpy(scp->keys[0]->data, key->data, key->size);
+	}
+
+	scp = scpReset(scp);	/* reset */
+
+        /* Prepare SQL statement to retrieve the value for the current key */
+        scp->cmd = sqlite3_mprintf("SELECT value FROM '%q' WHERE key=?;", dbi->dbi_subfile);
+        rc = sqlite3_prepare(sqldb->db, scp->cmd, strlen(scp->cmd), &scp->pStmt, &scp->pzErrmsg);
+
+        if (rc) rpmlog(RPMLOG_DEBUG, "cget(%s) prepare %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqldb->db), rc);
+    }
+
+    scp = scpResetAv(scp);	/* Free av and avlen, reset counters.*/
+
+    /* Now continue with a normal retrive based on key */
+    if ((scp->rx + 1) > scp->nkeys )
+	rc = DB_NOTFOUND; /* At the end of the list */
+
+    if (rc != 0)
+	goto exit;
+
+    /* Bind key to prepared statement */
+    rc = sql_bind_key(dbi, scp, 1, scp->keys[scp->rx]);
+    if (rc) rpmlog(RPMLOG_DEBUG, "cget(%s)  key bind %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqldb->db), rc);
+
+    rc = sql_step(dbi, scp);
+    if (rc) rpmlog(RPMLOG_DEBUG, "cget(%s) sql_step rc %d\n", dbi->dbi_subfile, rc);
+
+    rc = sqlite3_reset(scp->pStmt);
+    if (rc) rpmlog(RPMLOG_DEBUG, "reset %d\n", rc);
+
+/* 1 key should return 0 or 1 row/value */
+assert(scp->nr < 2);
+
+    if (scp->nr == 0 && scp->all == 0)
+        rc = DB_NOTFOUND; /* No data for that key found! */
+
+    if (rc != 0)
+	goto exit;
+
+    /* If we're looking at the whole db, return the key */
+    if (scp->all) {
+
+/* To get this far there has to be _1_ key returned! (protect against dup keys) */
+assert(scp->nr == 1);
+
+	if ( scp->lkey ) {
+	    scp->lkey = _free(scp->lkey);
+	}
+
+	key->size = scp->keys[scp->rx]->size;
+	key->data = xmalloc(key->size);
+	if (! (key->flags & DB_DBT_MALLOC))
+	    scp->lkey = key->data;
+
+	(void) memcpy(key->data, scp->keys[scp->rx]->data, key->size);
+    }
+
+    /* Construct and return the data element (element 0 is "value", 1 is _THE_ value)*/
+    switch (dbi->dbi_rpmtag) {
+    default:
+	if ( scp->ldata ) {
+	    scp->ldata = _free(scp->ldata);
+	}
+
+	data->size = scp->avlen[1];
+        data->data = xmalloc(data->size);
+	if (! (data->flags & DB_DBT_MALLOC) )
+	    scp->ldata = data->data;
+
+	(void) memcpy(data->data, scp->av[1], data->size);
+    }
+
+    scp->rx++;
+
+    /* XXX FIXME: ptr alignment is fubar here. */
+if (_debug)
+fprintf(stderr, "\tcget(%s) found  key 0x%x (%d)\n", dbi->dbi_subfile,
+		key->data == NULL ? 0 : *(unsigned int *)key->data, key->size);
+if (_debug)
+fprintf(stderr, "\tcget(%s) found data 0x%x (%d)\n", dbi->dbi_subfile,
+		key->data == NULL ? 0 : *(unsigned int *)data->data, data->size);
+
+exit:
+    if (rc == DB_NOTFOUND) {
+if (_debug)
+fprintf(stderr, "\tcget(%s) not found\n", dbi->dbi_subfile);
+    }
+
+leaveChroot(dbi);
+
+    return rc;
+}
+
+/**
+ * Store (key,data) pair using db->put or dbcursor->c_put.
+ * @param dbi           index database handle
+ * @param dbcursor      database cursor (NULL will use db->put)
+ * @param key           store key value/length/flags
+ * @param data          store data value/length/flags
+ * @param flags         (unused)
+ * @return              0 on success
+ */
+static int sql_cput (dbiIndex dbi, DBC * dbcursor, DBT * key,
+			DBT * data, unsigned int flags)
+{
+   SQL_DB * sqldb = (SQL_DB *) dbi->dbi_db;
+    SCP_t scp = scpNew(dbi->dbi_db);
+    int rc = 0;
+
+dbg_keyval(__FUNCTION__, dbi, dbcursor, key, data, flags);
+
+enterChroot(dbi);
+
+    switch (dbi->dbi_rpmtag) {
+    default:
+	scp->cmd = sqlite3_mprintf("INSERT OR REPLACE INTO '%q' VALUES(?, ?);",
+		dbi->dbi_subfile);
+	rc = sqlite3_prepare(sqldb->db, scp->cmd, strlen(scp->cmd), &scp->pStmt, &scp->pzErrmsg);
+	if (rc) rpmlog(RPMLOG_DEBUG, "cput(%s) prepare %s (%d)\n",dbi->dbi_subfile,  sqlite3_errmsg(sqldb->db), rc);
+	rc = sql_bind_key(dbi, scp, 1, key);
+	if (rc) rpmlog(RPMLOG_DEBUG, "cput(%s)  key bind %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqldb->db), rc);
+	rc = sql_bind_data(dbi, scp, 2, data);
+	if (rc) rpmlog(RPMLOG_DEBUG, "cput(%s) data bind %s (%d)\n", dbi->dbi_subfile, sqlite3_errmsg(sqldb->db), rc);
+
+	rc = sql_step(dbi, scp);
+	if (rc) rpmlog(RPMLOG_DEBUG, "cput(%s) sql_step rc %d\n", dbi->dbi_subfile, rc);
+
+	break;
+    }
+
+    scp = scpFree(scp);
+
+leaveChroot(dbi);
+
+    return rc;
+}
+
+/**
+ * Is database byte swapped?
+ * @param dbi           index database handle   
+ * @return              0 no
+ */
+static int sql_byteswapped (dbiIndex dbi)
+{
+    SQL_DB * sqldb = (SQL_DB *) dbi->dbi_db;
+    SCP_t scp = scpNew(dbi->dbi_db);
+    int sql_rc, rc = 0;
+    union _dbswap db_endian;
+
+enterChroot(dbi);
+
+    sql_rc = sqlite3_get_table(sqldb->db, "SELECT endian FROM 'db_info';",
+	&scp->av, &scp->nr, &scp->nc, (char **)&scp->pzErrmsg);
+
+    if (sql_rc == 0 && scp->nr > 0) {
+assert(scp->av != NULL);
+	db_endian.uc[0] = strtol(scp->av[1], NULL, 10);
+
+	if ( db_endian.uc[0] == ((union _dbswap *)&endian)->uc[0] )
+	    rc = 0; /* Native endian */
+	else
+	    rc = 1; /* swapped */
+
+    } else {
+	if ( sql_rc ) {
+	    rpmlog(RPMLOG_DEBUG, "db_info failed %s (%d)\n",
+		scp->pzErrmsg, sql_rc);
+	}
+	rpmlog(RPMLOG_WARNING, _("Unable to determine DB endianess.\n"));
+    }
+
+    scp = scpFree(scp);
+
+leaveChroot(dbi);
+
+    return rc;
+}
+
+/**************************************************
+ *
+ *  All of the following are not implemented!
+ *  they are not used by the rest of the system
+ *
+ **************************************************/
+
+/**
+ * Associate secondary database with primary.
+ * @param dbi           index database handle
+ * @param dbisecondary  secondary index database handle
+ * @param callback      create secondary key from primary (NULL if DB_RDONLY)
+ * @param flags         DB_CREATE or 0
+ * @return              0 on success
+ */
+static int sql_associate (dbiIndex dbi, dbiIndex dbisecondary,
+		int (*callback) (DB *, const DBT *, const DBT *, DBT *),
+		unsigned int flags)
+{
+if (_debug)
+fprintf(stderr, "*** %s:\n", __FUNCTION__);
+    return EINVAL;
+}
+
+/**
+ * Return join cursor for list of cursors.
+ * @param dbi           index database handle
+ * @param curslist      NULL terminated list of database cursors
+ * @retval dbcp         address of join database cursor
+ * @param flags         DB_JOIN_NOSORT or 0
+ * @return              0 on success
+ */
+static int sql_join (dbiIndex dbi, DBC ** curslist, DBC ** dbcp,
+		unsigned int flags)
+{
+if (_debug)
+fprintf(stderr, "*** %s:\n", __FUNCTION__);
+    return EINVAL;
+}
+
+/**
+ * Duplicate a database cursor.   
+ * @param dbi           index database handle
+ * @param dbcursor      database cursor
+ * @retval dbcp         address of new database cursor
+ * @param flags         DB_POSITION for same position, 0 for uninitialized
+ * @return              0 on success
+ */
+static int sql_cdup (dbiIndex dbi, DBC * dbcursor, DBC ** dbcp,
+		unsigned int flags)
+{
+if (_debug)
+fprintf(stderr, "*** %s:\n", __FUNCTION__);
+    return EINVAL;
+}
+
+/**
+ * Retrieve (key,data) pair using dbcursor->c_pget.
+ * @param dbi           index database handle
+ * @param dbcursor      database cursor
+ * @param key           secondary retrieve key value/length/flags
+ * @param pkey          primary retrieve key value/length/flags
+ * @param data          primary retrieve data value/length/flags 
+ * @param flags         DB_NEXT, DB_SET, or 0
+ * @return              0 on success
+ */
+static int sql_cpget (dbiIndex dbi, DBC * dbcursor,
+		DBT * key, DBT * pkey, DBT * data, unsigned int flags)
+{
+if (_debug)
+fprintf(stderr, "*** %s:\n", __FUNCTION__);
+    return EINVAL;
+}
+
+/**
+ * Retrieve count of (possible) duplicate items using dbcursor->c_count.
+ * @param dbi           index database handle
+ * @param dbcursor      database cursor
+ * @param countp        address of count
+ * @param flags         (unused)
+ * @return              0 on success
+ */
+static int sql_ccount (dbiIndex dbi, DBC * dbcursor,   
+		unsigned int * countp,
+		unsigned int flags)
+{
+if (_debug)
+fprintf(stderr, "*** %s:\n", __FUNCTION__);
+    return EINVAL;
+}
+
+/** \ingroup dbi
+ * Save statistics in database handle.
+ * @param dbi           index database handle
+ * @param flags         retrieve statistics that don't require traversal?
+ * @return              0 on success
+ */
+static int sql_stat (dbiIndex dbi, unsigned int flags)
+{
+   SQL_DB * sqldb = (SQL_DB *) dbi->dbi_db;
+    SCP_t scp = scpNew(dbi->dbi_db);
+    int rc = 0;
+    long nkeys = -1;
+
+enterChroot(dbi);
+
+    dbi->dbi_stats = _free(dbi->dbi_stats);
+
+    dbi->dbi_stats = xcalloc(1, sizeof(DB_HASH_STAT));
+
+    scp->cmd = sqlite3_mprintf("SELECT COUNT('key') FROM '%q';", dbi->dbi_subfile);
+    rc = sqlite3_get_table(sqldb->db, scp->cmd,
+		&scp->av, &scp->nr, &scp->nc, (char **)&scp->pzErrmsg);
+
+    if ( rc == 0 && scp->nr > 0) {
+assert(scp->av != NULL);
+	nkeys = strtol(scp->av[1], NULL, 10);
+
+	rpmlog(RPMLOG_DEBUG, "  stat on %s nkeys %ld\n",
+		dbi->dbi_subfile, nkeys);
+    } else {
+	if ( rc ) {
+	    rpmlog(RPMLOG_DEBUG, "stat failed %s (%d)\n",
+		scp->pzErrmsg, rc);
+	}
+    }
+
+    if (nkeys < 0)
+	nkeys = 4096;  /* Good high value */
+
+    ((DB_HASH_STAT *)(dbi->dbi_stats))->hash_nkeys = nkeys;
+
+    scp = scpFree(scp);
+
+leaveChroot(dbi);
+
+    return rc;
+}
+
+/* Major, minor, patch version of DB.. we're not using db.. so set to 0 */
+/* open, close, sync, associate, join */
+/* cursor_open, cursor_close, cursor_dup, cursor_delete, cursor_get, */
+/* cursor_pget?, cursor_put, cursor_count */
+/* db_bytewapped, stat */
+const struct _dbiVec sqlitevec = {
+    0, 0, 0, 
+    sql_open, 
+    sql_close,
+    sql_sync,  
+    sql_associate,  
+    sql_join,
+    sql_copen,
+    sql_cclose,
+    sql_cdup, 
+    sql_cdel,
+    sql_cget,
+    sql_cpget,
+    sql_cput,
+    sql_ccount,
+    sql_byteswapped,
+    sql_stat
+};
+