Begin turning cdb_ functions into pointers assigned to bdb_ functions

diff --git a/citadel/server/citserver.c b/citadel/server/citserver.c
index ebb7a469f1a455f037e653c4af02e2d1df8b471f..b16235cb3b9ae0de7c933973e73e79c1eaa9ee08 100644 (file)
--- a/citadel/server/citserver.c
+++ b/citadel/server/citserver.c
@@ -78,6 +78,7 @@ void master_startup(void) {
        syslog(LOG_DEBUG, "citserver: ctdl_run_dir is %s", ctdl_run_dir);
 
        syslog(LOG_INFO, "Opening databases");
+       cdb_init_backends();
        cdb_open_databases();
 
        // Load site-specific configuration

diff --git a/citadel/server/database.h b/citadel/server/database.h
index baad0a46f22a7c408e105601b73c7b9dec5eeeb1..ff65918d776eb37358169d93db2aac8ae0aa92ca 100644 (file)
--- a/citadel/server/database.h
+++ b/citadel/server/database.h
@@ -8,22 +8,25 @@
 #ifndef DATABASE_H
 #define DATABASE_H
 
+void                   cdb_init_backends(void);
+
 void                   cdb_open_databases(void);
 void                   cdb_close_databases(void);
-int                    cdb_store(int cdb, const void *key, int keylen, void *data, int datalen);
-int                    cdb_delete(int cdb, void *key, int keylen);
-struct cdbdata *       cdb_fetch(int cdb, const void *key, int keylen);
-void                   cdb_free(struct cdbdata *cdb);
-void                   cdb_rewind(int cdb);
-struct cdbdata *       cdb_next_item(int cdb);
-void                   cdb_close_cursor(int cdb);
+int                    cdb_store(int, const void *, int, void *, int);
+int                    cdb_delete(int, void *, int);
+struct cdbdata *       cdb_fetch(int, const void *, int);
+void                   cdb_free(struct cdbdata *);
+void                   cdb_rewind(int);
+struct cdbdata *       cdb_next_item(int);
+void                   cdb_close_cursor(int);
 void                   cdb_begin_transaction(void);
 void                   cdb_end_transaction(void);
 void                   cdb_check_handles(void);
-void                   cdb_trunc(int cdb);
+void                   cdb_trunc(int);
 void                   cdb_chmod_data(void);
-void                   cdb_checkpoint(void);
-void                   check_handles(void *arg);
-void                   cdb_compact(void);
+void                   check_handles(void *);
+
+extern void            (*cdb_checkpoint)(void);
+extern void            (*cdb_compact)(void);
 
 #endif

diff --git a/citadel/server/database_bdb.c b/citadel/server/database_bdb.c
index e570615f74fede897aba26b59eaa228ab62ca2ba..25d97ef98b8667ab98540473e32a3ead62248f70 100644 (file)
--- a/citadel/server/database_bdb.c
+++ b/citadel/server/database_bdb.c
@@ -30,12 +30,15 @@
 #include "citserver.h"
 #include "config.h"
 
+void (*cdb_compact)(void)      = NULL;
+void (*cdb_checkpoint)(void)   = NULL;
+
 static DB *dbp[MAXCDB];                // One DB handle for each Citadel database
 static DB_ENV *dbenv;          // The DB environment (global)
 
 
 void cdb_abort(void) {
-       syslog(LOG_DEBUG, "db: citserver is stopping in order to prevent data loss. uid=%d gid=%d euid=%d egid=%d",
+       syslog(LOG_DEBUG, "bdb: citserver is stopping in order to prevent data loss. uid=%d gid=%d euid=%d egid=%d",
                getuid(), getgid(), geteuid(), getegid()
        );
        raise(SIGABRT);         // This will exit in a way that can produce a core dump if needed.
@@ -46,14 +49,14 @@ void cdb_abort(void) {
 // Verbose logging callback
 void cdb_verbose_log(const DB_ENV *dbenv, const char *msg, const char *foo) {
        if (!IsEmptyStr(msg)) {
-               syslog(LOG_DEBUG, "db: %s %s", msg, foo);
+               syslog(LOG_DEBUG, "bdb: %s %s", msg, foo);
        }
 }
 
 
 // Verbose logging callback
 void cdb_verbose_err(const DB_ENV *dbenv, const char *errpfx, const char *msg) {
-       syslog(LOG_ERR, "db: %s", msg);
+       syslog(LOG_ERR, "bdb: %s", msg);
 }
 
 
@@ -64,7 +67,7 @@ static void txabort(DB_TXN *tid) {
        ret = tid->abort(tid);
 
        if (ret) {
-               syslog(LOG_ERR, "db: txn_abort: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: txn_abort: %s", db_strerror(ret));
                cdb_abort();
        }
 }
@@ -77,7 +80,7 @@ static void txcommit(DB_TXN *tid) {
        ret = tid->commit(tid, 0);
 
        if (ret) {
-               syslog(LOG_ERR, "db: txn_commit: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: txn_commit: %s", db_strerror(ret));
                cdb_abort();
        }
 }
@@ -90,7 +93,7 @@ static void txbegin(DB_TXN **tid) {
        ret = dbenv->txn_begin(dbenv, NULL, tid, 0);
 
        if (ret) {
-               syslog(LOG_ERR, "db: txn_begin: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: txn_begin: %s", db_strerror(ret));
                cdb_abort();
        }
 }
@@ -98,7 +101,7 @@ static void txbegin(DB_TXN **tid) {
 
 // panic callback
 static void dbpanic(DB_ENV *env, int errval) {
-       syslog(LOG_ERR, "db: PANIC: %s", db_strerror(errval));
+       syslog(LOG_ERR, "bdb: PANIC: %s", db_strerror(errval));
        cdb_abort();
 }
 
@@ -107,7 +110,7 @@ static void cclose(DBC *cursor) {
        int ret;
 
        if ((ret = cursor->c_close(cursor))) {
-               syslog(LOG_ERR, "db: c_close: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: c_close: %s", db_strerror(ret));
                cdb_abort();
        }
 }
@@ -118,7 +121,7 @@ static void bailIfCursor(DBC **cursors, const char *msg) {
 
        for (i = 0; i < MAXCDB; i++)
                if (cursors[i] != NULL) {
-                       syslog(LOG_ERR, "db: cursor still in progress on cdb %02x: %s", i, msg);
+                       syslog(LOG_ERR, "bdb: cursor still in progress on cdb %02x: %s", i, msg);
                        cdb_abort();
                }
 }
@@ -128,21 +131,21 @@ void cdb_check_handles(void) {
        bailIfCursor(TSD->cursors, "in check_handles");
 
        if (TSD->tid != NULL) {
-               syslog(LOG_ERR, "db: transaction still in progress!");
+               syslog(LOG_ERR, "bdb: transaction still in progress!");
                cdb_abort();
        }
 }
 
 
 // Request a checkpoint of the database.  Called once per minute by the thread manager.
-void cdb_checkpoint(void) {
+void bdb_checkpoint(void) {
        int ret;
 
-       syslog(LOG_DEBUG, "db: -- checkpoint --");
+       syslog(LOG_DEBUG, "bdb: -- checkpoint --");
        ret = dbenv->txn_checkpoint(dbenv, MAX_CHECKPOINT_KBYTES, MAX_CHECKPOINT_MINUTES, 0);
 
        if (ret != 0) {
-               syslog(LOG_ERR, "db: cdb_checkpoint() txn_checkpoint: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: cdb_checkpoint() txn_checkpoint: %s", db_strerror(ret));
                cdb_abort();
        }
 
@@ -167,39 +170,39 @@ void cdb_open_databases(void) {
        u_int32_t flags = 0;
        int dbversion_major, dbversion_minor, dbversion_patch;
 
-       syslog(LOG_DEBUG, "db: cdb_open_databases() starting");
-       syslog(LOG_DEBUG, "db:    Linked zlib: %s", zlibVersion());
-       syslog(LOG_DEBUG, "db: Compiled libdb: %s", DB_VERSION_STRING);
-       syslog(LOG_DEBUG, "db:   Linked libdb: %s", db_version(&dbversion_major, &dbversion_minor, &dbversion_patch));
+       syslog(LOG_DEBUG, "bdb: cdb_open_databases() starting");
+       syslog(LOG_DEBUG, "bdb:    Linked zlib: %s", zlibVersion());
+       syslog(LOG_DEBUG, "bdb: Compiled libdb: %s", DB_VERSION_STRING);
+       syslog(LOG_DEBUG, "bdb:   Linked libdb: %s", db_version(&dbversion_major, &dbversion_minor, &dbversion_patch));
 
        // Create synthetic integer version numbers and compare them.
        // Never allow citserver to run with a libdb older then the one with which it was compiled.
        int compiled_db_version = ( (DB_VERSION_MAJOR * 1000000) + (DB_VERSION_MINOR * 1000) + (DB_VERSION_PATCH) );
        int linked_db_version = ( (dbversion_major * 1000000) + (dbversion_minor * 1000) + (dbversion_patch) );
        if (compiled_db_version > linked_db_version) {
-               syslog(LOG_ERR, "db: citserver is running with a version of libdb older than the one with which it was compiled.");
-               syslog(LOG_ERR, "db: This is an invalid configuration.  citserver will now exit to prevent data loss.");
+               syslog(LOG_ERR, "bdb: citserver is running with a version of libdb older than the one with which it was compiled.");
+               syslog(LOG_ERR, "bdb: This is an invalid configuration.  citserver will now exit to prevent data loss.");
                exit(CTDLEXIT_DB);
        }
 
        // Silently try to create the database subdirectory.  If it's already there, no problem.
        if ((mkdir(ctdl_db_dir, 0700) != 0) && (errno != EEXIST)) {
-               syslog(LOG_ERR, "db: database directory [%s] does not exist and could not be created: %m", ctdl_db_dir);
+               syslog(LOG_ERR, "bdb: database directory [%s] does not exist and could not be created: %m", ctdl_db_dir);
                exit(CTDLEXIT_DB);
        }
        if (chmod(ctdl_db_dir, 0700) != 0) {
-               syslog(LOG_ERR, "db: unable to set database directory permissions [%s]: %m", ctdl_db_dir);
+               syslog(LOG_ERR, "bdb: unable to set database directory permissions [%s]: %m", ctdl_db_dir);
                exit(CTDLEXIT_DB);
        }
        if (chown(ctdl_db_dir, CTDLUID, (-1)) != 0) {
-               syslog(LOG_ERR, "db: unable to set the owner for [%s]: %m", ctdl_db_dir);
+               syslog(LOG_ERR, "bdb: unable to set the owner for [%s]: %m", ctdl_db_dir);
                exit(CTDLEXIT_DB);
        }
-       syslog(LOG_DEBUG, "db: Setting up DB environment");
+       syslog(LOG_DEBUG, "bdb: Setting up DB environment");
        ret = db_env_create(&dbenv, 0);
        if (ret) {
-               syslog(LOG_ERR, "db: db_env_create: %s", db_strerror(ret));
-               syslog(LOG_ERR, "db: exit code %d", ret);
+               syslog(LOG_ERR, "bdb: db_env_create: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: exit code %d", ret);
                exit(CTDLEXIT_DB);
        }
        dbenv->set_errpfx(dbenv, "citserver");
@@ -212,59 +215,59 @@ void cdb_open_databases(void) {
        // We want to specify the shared memory buffer pool cachesize, but everything else is the default.
        ret = dbenv->set_cachesize(dbenv, 0, 64 * 1024, 0);
        if (ret) {
-               syslog(LOG_ERR, "db: set_cachesize: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: set_cachesize: %s", db_strerror(ret));
                dbenv->close(dbenv, 0);
-               syslog(LOG_ERR, "db: exit code %d", ret);
+               syslog(LOG_ERR, "bdb: exit code %d", ret);
                exit(CTDLEXIT_DB);
        }
 
        if ((ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT))) {
-               syslog(LOG_ERR, "db: set_lk_detect: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: set_lk_detect: %s", db_strerror(ret));
                dbenv->close(dbenv, 0);
-               syslog(LOG_ERR, "db: exit code %d", ret);
+               syslog(LOG_ERR, "bdb: exit code %d", ret);
                exit(CTDLEXIT_DB);
        }
 
        flags = DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE | DB_INIT_TXN | DB_INIT_LOCK | DB_THREAD | DB_INIT_LOG;
-       syslog(LOG_DEBUG, "db: dbenv->open(dbenv, %s, %d, 0)", ctdl_db_dir, flags);
+       syslog(LOG_DEBUG, "bdb: dbenv->open(dbenv, %s, %d, 0)", ctdl_db_dir, flags);
        ret = dbenv->open(dbenv, ctdl_db_dir, flags, 0);                                // try opening the database cleanly
        if (ret == DB_RUNRECOVERY) {
-               syslog(LOG_ERR, "db: dbenv->open: %s", db_strerror(ret));
-               syslog(LOG_ERR, "db: attempting recovery...");
+               syslog(LOG_ERR, "bdb: dbenv->open: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: attempting recovery...");
                flags |= DB_RECOVER;
                ret = dbenv->open(dbenv, ctdl_db_dir, flags, 0);                        // try recovery
        }
        if (ret == DB_RUNRECOVERY) {
-               syslog(LOG_ERR, "db: dbenv->open: %s", db_strerror(ret));
-               syslog(LOG_ERR, "db: attempting catastrophic recovery...");
+               syslog(LOG_ERR, "bdb: dbenv->open: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: attempting catastrophic recovery...");
                flags &= ~DB_RECOVER;
                flags |= DB_RECOVER_FATAL;
                ret = dbenv->open(dbenv, ctdl_db_dir, flags, 0);                        // try catastrophic recovery
        }
        if (ret) {
-               syslog(LOG_ERR, "db: dbenv->open: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: dbenv->open: %s", db_strerror(ret));
                dbenv->close(dbenv, 0);
-               syslog(LOG_ERR, "db: exit code %d", ret);
+               syslog(LOG_ERR, "bdb: exit code %d", ret);
                exit(CTDLEXIT_DB);
        }
 
-       syslog(LOG_INFO, "db: mounting databases");
+       syslog(LOG_INFO, "bdb: mounting databases");
        for (i = 0; i < MAXCDB; ++i) {
                ret = db_create(&dbp[i], dbenv, 0);                                     // Create a database handle
                if (ret) {
-                       syslog(LOG_ERR, "db: db_create: %s", db_strerror(ret));
-                       syslog(LOG_ERR, "db: exit code %d", ret);
+                       syslog(LOG_ERR, "bdb: db_create: %s", db_strerror(ret));
+                       syslog(LOG_ERR, "bdb: exit code %d", ret);
                        exit(CTDLEXIT_DB);
                }
 
                snprintf(dbfilename, sizeof dbfilename, "cdb.%02x", i);                 // table names by number
                ret = dbp[i]->open(dbp[i], NULL, dbfilename, NULL, DB_BTREE, DB_CREATE | DB_AUTO_COMMIT | DB_THREAD, 0600);
                if (ret) {
-                       syslog(LOG_ERR, "db: db_open[%02x]: %s", i, db_strerror(ret));
+                       syslog(LOG_ERR, "bdb: db_open[%02x]: %s", i, db_strerror(ret));
                        if (ret == ENOMEM) {
-                               syslog(LOG_ERR, "db: You may need to tune your database; please check http://www.citadel.org for more information.");
+                               syslog(LOG_ERR, "bdb: You may need to tune your database; please check http://www.citadel.org for more information.");
                        }
-                       syslog(LOG_ERR, "db: exit code %d", ret);
+                       syslog(LOG_ERR, "bdb: exit code %d", ret);
                        exit(CTDLEXIT_DB);
                }
        }
@@ -282,8 +285,8 @@ void cdb_chmod_data(void) {
                while (d = readdir(dp), d != NULL) {
                        if (d->d_name[0] != '.') {
                                snprintf(filename, sizeof filename, "%s/%s", ctdl_db_dir, d->d_name);
-                               syslog(LOG_DEBUG, "db: chmod(%s, 0600) returned %d", filename, chmod(filename, 0600));
-                               syslog(LOG_DEBUG, "db: chown(%s, CTDLUID, -1) returned %d", filename, chown(filename, CTDLUID, (-1)));
+                               syslog(LOG_DEBUG, "bdb: chmod(%s, 0600) returned %d", filename, chmod(filename, 0600));
+                               syslog(LOG_DEBUG, "bdb: chown(%s, CTDLUID, -1) returned %d", filename, chown(filename, CTDLUID, (-1)));
                        }
                }
                closedir(dp);
@@ -298,34 +301,34 @@ void cdb_close_databases(void) {
 
        static int closing = 0;
        while (closing == 1) {
-               syslog(LOG_INFO, "db: already closing");
+               syslog(LOG_INFO, "bdb: already closing");
        }
        closing = 1;
 
-       syslog(LOG_INFO, "db: performing final checkpoint");
+       syslog(LOG_INFO, "bdb: performing final checkpoint");
        if ((ret = dbenv->txn_checkpoint(dbenv, 0, 0, 0))) {
-               syslog(LOG_ERR, "db: txn_checkpoint: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: txn_checkpoint: %s", db_strerror(ret));
        }
 
-       syslog(LOG_INFO, "db: flushing the database logs");
+       syslog(LOG_INFO, "bdb: flushing the database logs");
        if ((ret = dbenv->log_flush(dbenv, NULL))) {
-               syslog(LOG_ERR, "db: log_flush: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: log_flush: %s", db_strerror(ret));
        }
 
        // close the tables
-       syslog(LOG_INFO, "db: closing databases");
+       syslog(LOG_INFO, "bdb: closing databases");
        for (i = 0; i < MAXCDB; ++i) {
-               syslog(LOG_INFO, "db: closing database %02x", i);
+               syslog(LOG_INFO, "bdb: closing database %02x", i);
                ret = dbp[i]->close(dbp[i], 0);
                if (ret) {
-                       syslog(LOG_ERR, "db: db_close: %s", db_strerror(ret));
+                       syslog(LOG_ERR, "bdb: db_close: %s", db_strerror(ret));
                }
        }
 
        // Close the handle.
        ret = dbenv->close(dbenv, DB_FORCESYNC);
        if (ret) {
-               syslog(LOG_ERR, "db: DBENV->close: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: DBENV->close: %s", db_strerror(ret));
        }
 }
 
@@ -362,7 +365,7 @@ void cdb_decompress_if_necessary(struct cdbdata *cdb) {
 
        if (uncompress((Bytef *) uncompressed_data,
                       (uLongf *) &destLen, (const Bytef *) compressed_data, (uLong) sourceLen) != Z_OK) {
-               syslog(LOG_ERR, "db: uncompress() error");
+               syslog(LOG_ERR, "bdb: uncompress() error");
                cdb_abort();
        }
 
@@ -402,7 +405,7 @@ int cdb_store(int cdb, const void *ckey, int ckeylen, void *cdata, int cdatalen)
                destLen = (uLongf) buffer_len;
                compressed_data = malloc(buffer_len);
                if (compress2((Bytef *) (compressed_data + sizeof(struct CtdlCompressHeader)), &destLen, (Bytef *) cdata, (uLongf) cdatalen, 1) != Z_OK) {
-                       syslog(LOG_ERR, "db: compress2() error");
+                       syslog(LOG_ERR, "bdb: compress2() error");
                        cdb_abort();
                }
                zheader.compressed_len = (size_t) destLen;
@@ -419,7 +422,7 @@ int cdb_store(int cdb, const void *ckey, int ckeylen, void *cdata, int cdatalen)
                                    0           // flags
                );
                if (ret) {
-                       syslog(LOG_ERR, "db: cdb_store(%d): %s", cdb, db_strerror(ret));
+                       syslog(LOG_ERR, "bdb: cdb_store(%d): %s", cdb, db_strerror(ret));
                        cdb_abort();
                }
                if (compressing) {
@@ -443,7 +446,7 @@ int cdb_store(int cdb, const void *ckey, int ckeylen, void *cdata, int cdatalen)
                                goto retry;
                        }
                        else {
-                               syslog(LOG_ERR, "db: cdb_store(%d): %s", cdb, db_strerror(ret));
+                               syslog(LOG_ERR, "bdb: cdb_store(%d): %s", cdb, db_strerror(ret));
                                cdb_abort();
                        }
                }
@@ -472,7 +475,7 @@ int cdb_delete(int cdb, void *key, int keylen) {
        if (TSD->tid != NULL) {
                ret = dbp[cdb]->del(dbp[cdb], TSD->tid, &dkey, 0);
                if (ret) {
-                       syslog(LOG_ERR, "db: cdb_delete(%d): %s", cdb, db_strerror(ret));
+                       syslog(LOG_ERR, "bdb: cdb_delete(%d): %s", cdb, db_strerror(ret));
                        if (ret != DB_NOTFOUND) {
                                cdb_abort();
                        }
@@ -490,7 +493,7 @@ int cdb_delete(int cdb, void *key, int keylen) {
                                goto retry;
                        }
                        else {
-                               syslog(LOG_ERR, "db: cdb_delete(%d): %s", cdb, db_strerror(ret));
+                               syslog(LOG_ERR, "bdb: cdb_delete(%d): %s", cdb, db_strerror(ret));
                                cdb_abort();
                        }
                }
@@ -514,7 +517,7 @@ static DBC *localcursor(int cdb) {
        }
 
        if (ret) {
-               syslog(LOG_ERR, "db: localcursor: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: localcursor: %s", db_strerror(ret));
                cdb_abort();
        }
 
@@ -557,7 +560,7 @@ struct cdbdata *cdb_fetch(int cdb, const void *key, int keylen) {
        }
 
        if ((ret != 0) && (ret != DB_NOTFOUND)) {
-               syslog(LOG_ERR, "db: cdb_fetch(%d): %s", cdb, db_strerror(ret));
+               syslog(LOG_ERR, "bdb: cdb_fetch(%d): %s", cdb, db_strerror(ret));
                cdb_abort();
        }
 
@@ -567,7 +570,7 @@ struct cdbdata *cdb_fetch(int cdb, const void *key, int keylen) {
 
        tempcdb = (struct cdbdata *) malloc(sizeof(struct cdbdata));
        if (tempcdb == NULL) {
-               syslog(LOG_ERR, "db: cdb_fetch() cannot allocate memory for tempcdb: %m");
+               syslog(LOG_ERR, "bdb: cdb_fetch() cannot allocate memory for tempcdb: %m");
                cdb_abort();
        }
        else {
@@ -609,7 +612,7 @@ void cdb_rewind(int cdb) {
        int ret = 0;
 
        if (TSD->cursors[cdb] != NULL) {
-               syslog(LOG_ERR, "db: cdb_rewind: must close cursor on database %d before reopening", cdb);
+               syslog(LOG_ERR, "bdb: cdb_rewind: must close cursor on database %d before reopening", cdb);
                cdb_abort();
                // cclose(TSD->cursors[cdb]);
        }
@@ -617,7 +620,7 @@ void cdb_rewind(int cdb) {
        // Now initialize the cursor
        ret = dbp[cdb]->cursor(dbp[cdb], TSD->tid, &TSD->cursors[cdb], 0);
        if (ret) {
-               syslog(LOG_ERR, "db: cdb_rewind: db_cursor: %s", db_strerror(ret));
+               syslog(LOG_ERR, "bdb: cdb_rewind: db_cursor: %s", db_strerror(ret));
                cdb_abort();
        }
 }
@@ -639,7 +642,7 @@ struct cdbdata *cdb_next_item(int cdb) {
 
        if (ret) {
                if (ret != DB_NOTFOUND) {
-                       syslog(LOG_ERR, "db: cdb_next_item(%d): %s", cdb, db_strerror(ret));
+                       syslog(LOG_ERR, "bdb: cdb_next_item(%d): %s", cdb, db_strerror(ret));
                        cdb_abort();
                }
                cdb_close_cursor(cdb);
@@ -660,7 +663,7 @@ void cdb_begin_transaction(void) {
        bailIfCursor(TSD->cursors, "can't begin transaction during r/o cursor");
 
        if (TSD->tid != NULL) {
-               syslog(LOG_ERR, "db: cdb_begin_transaction: ERROR: nested transaction");
+               syslog(LOG_ERR, "bdb: cdb_begin_transaction: ERROR: nested transaction");
                cdb_abort();
        }
 
@@ -673,14 +676,14 @@ void cdb_end_transaction(void) {
 
        for (i = 0; i < MAXCDB; i++) {
                if (TSD->cursors[i] != NULL) {
-                       syslog(LOG_WARNING, "db: cdb_end_transaction: WARNING: cursor %d still open at transaction end", i);
+                       syslog(LOG_WARNING, "bdb: cdb_end_transaction: WARNING: cursor %d still open at transaction end", i);
                        cclose(TSD->cursors[i]);
                        TSD->cursors[i] = NULL;
                }
        }
 
        if (TSD->tid == NULL) {
-               syslog(LOG_ERR, "db: cdb_end_transaction: ERROR: txcommit(NULL) !!");
+               syslog(LOG_ERR, "bdb: cdb_end_transaction: ERROR: txcommit(NULL) !!");
                cdb_abort();
        }
        else {
@@ -697,7 +700,7 @@ void cdb_trunc(int cdb) {
        u_int32_t count;
 
        if (TSD->tid != NULL) {
-               syslog(LOG_ERR, "db: cdb_trunc must not be called in a transaction.");
+               syslog(LOG_ERR, "bdb: cdb_trunc must not be called in a transaction.");
                cdb_abort();
        }
        else {
@@ -713,9 +716,9 @@ void cdb_trunc(int cdb) {
                                goto retry;
                        }
                        else {
-                               syslog(LOG_ERR, "db: cdb_truncate(%d): %s", cdb, db_strerror(ret));
+                               syslog(LOG_ERR, "bdb: cdb_truncate(%d): %s", cdb, db_strerror(ret));
                                if (ret == ENOMEM) {
-                                       syslog(LOG_ERR, "db: You may need to tune your database; please read http://www.citadel.org for more information.");
+                                       syslog(LOG_ERR, "bdb: You may need to tune your database; please read http://www.citadel.org for more information.");
                                }
                                exit(CTDLEXIT_DB);
                        }
@@ -725,27 +728,24 @@ void cdb_trunc(int cdb) {
 
 
 // compact (defragment) the database, possibly returning space back to the underlying filesystem
-void cdb_compact(void) {
+void bdb_compact(void) {
        int ret;
        int i;
 
-       syslog(LOG_DEBUG, "db: cdb_compact() started");
+       syslog(LOG_DEBUG, "bdb: cdb_compact() started");
        for (i = 0; i < MAXCDB; i++) {
-               syslog(LOG_DEBUG, "db: compacting database %d", i);
+               syslog(LOG_DEBUG, "bdb: compacting database %d", i);
                ret = dbp[i]->compact(dbp[i], NULL, NULL, NULL, NULL, DB_FREE_SPACE, NULL);
                if (ret) {
-                       syslog(LOG_ERR, "db: compact: %s", db_strerror(ret));
+                       syslog(LOG_ERR, "bdb: compact: %s", db_strerror(ret));
                }
        }
-       syslog(LOG_DEBUG, "db: cdb_compact() finished");
+       syslog(LOG_DEBUG, "bdb: cdb_compact() finished");
 }
 
 
-char *ctdl_module_init_database_bdb() {
-       if (!threading) {
-               // nothing here
-       }
-
-       // return our module id for the log
-       return "database";
+void cdb_init_backends(void) {
+       cdb_compact = bdb_compact;
+       cdb_checkpoint = bdb_checkpoint;
+       syslog(LOG_INFO, "db: initialized Berkeley DB backend");
 }

diff --git a/citadel/server/modules_init.c b/citadel/server/modules_init.c
index a1f86a6131b9e97de6c90e33b86744ec0a290029..d0d240177a9ec368cbf07b895a0bb1fda3a4129b 100644 (file)
--- a/citadel/server/modules_init.c
+++ b/citadel/server/modules_init.c
@@ -29,7 +29,6 @@ void initialize_modules(int is_threading) {
        syslog(LOG_DEBUG, "extensions: init %s", ctdl_module_init_control());
        syslog(LOG_DEBUG, "extensions: init %s", ctdl_module_init_euidindex());
        syslog(LOG_DEBUG, "extensions: init %s", ctdl_module_init_msgbase());
-       syslog(LOG_DEBUG, "extensions: init %s", ctdl_module_init_database_bdb());
        syslog(LOG_DEBUG, "extensions: init %s", ctdl_module_init_autocompletion());
        syslog(LOG_DEBUG, "extensions: init %s", ctdl_module_init_bio());
        syslog(LOG_DEBUG, "extensions: init %s", ctdl_module_init_blog());