cscvs to tla changeset 76

[onak.git] / keydb_db3.c

diff --git a/keydb_db3.c b/keydb_db3.c
index de24f750d2656ad04c6c53fc7367fdbbbb601eb2..7ca5312612c5264aaba5fb38124f840cf6cc271b 100644 (file)
--- a/keydb_db3.c
+++ b/keydb_db3.c
@@ -25,6 +25,7 @@
 #include "decodekey.h"
 #include "keystructs.h"
 #include "mem.h"
 #include "decodekey.h"
 #include "keystructs.h"
 #include "mem.h"

+#include "log.h"

 #include "onak-conf.h"
 #include "parsekey.h"
 
 #include "onak-conf.h"
 #include "parsekey.h"
 


@@ -111,20 +112,22 @@ void initdb(void)
 
        ret = db_env_create(&dbenv, 0);
        if (ret != 0) {
 
        ret = db_env_create(&dbenv, 0);
        if (ret != 0) {

-               fprintf(stderr, "db_env_create: %s\n", db_strerror(ret));
+               logthing(LOGTHING_CRITICAL,
+                       "db_env_create: %s", db_strerror(ret));

                exit(1);
        }
 
        /*
                exit(1);
        }
 
        /*

-        * This is a bit of a kludge. Either we run a separate process for
-        * deadlock detection or we do this every time we run. What we really
-        * want to do is specify that our locks are exclusive locks when we
-        * start to do an update.
+        * Enable deadlock detection so that we don't block indefinitely on
+        * anything. What we really want is simple 2 state locks, but I'm not
+        * sure how to make the standard DB functions do that yet.

         */
         */

-       ret = lock_detect(dbenv,
-                       0, /* flags */
-                       DB_LOCK_RANDOM,
-                       NULL); /* If non null int* for number broken */
+       ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT);
+       if (ret != 0) {
+               logthing(LOGTHING_CRITICAL,
+                       "db_env_create: %s", db_strerror(ret));
+               exit(1);
+       }

 
        ret = dbenv->open(dbenv, config.db_dir,
                        DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_LOCK |
 
        ret = dbenv->open(dbenv, config.db_dir,
                        DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_LOCK |


@@ -132,13 +135,17 @@ void initdb(void)
                        DB_CREATE,
                        0);
        if (ret != 0) {
                        DB_CREATE,
                        0);
        if (ret != 0) {

-               dbenv->err(dbenv, ret, "%s", config.db_dir);
+               logthing(LOGTHING_CRITICAL,
+                               "Erroring opening db environment: %s (%s)",
+                               config.db_dir,
+                               db_strerror(ret));

                exit(1);
        }
 
        ret = db_create(&dbconn, dbenv, 0);
        if (ret != 0) {
                exit(1);
        }
 
        ret = db_create(&dbconn, dbenv, 0);
        if (ret != 0) {

-               fprintf(stderr, "db_create: %s\n", db_strerror(ret));
+               logthing(LOGTHING_CRITICAL,
+                               "db_create: %s", db_strerror(ret));

                exit(1);
        }
 
                exit(1);
        }
 


@@ -148,13 +155,16 @@ void initdb(void)
                        DB_CREATE,
                        0664);
        if (ret != 0) {
                        DB_CREATE,
                        0664);
        if (ret != 0) {

-               dbconn->err(dbconn, ret, "keydb.db");
+               logthing(LOGTHING_CRITICAL,
+                               "Error opening key database: %s (%s)",
+                               "keydb.db",
+                               db_strerror(ret));

                exit(1);
        }
 
        ret = db_create(&worddb, dbenv, 0);
        if (ret != 0) {
                exit(1);
        }
 
        ret = db_create(&worddb, dbenv, 0);
        if (ret != 0) {

-               fprintf(stderr, "db_create: %s\n", db_strerror(ret));
+               logthing(LOGTHING_CRITICAL, "db_create: %s", db_strerror(ret));

                exit(1);
        }
        ret = worddb->set_flags(worddb, DB_DUP);
                exit(1);
        }
        ret = worddb->set_flags(worddb, DB_DUP);


@@ -163,7 +173,10 @@ void initdb(void)
                        DB_CREATE,
                        0664);
        if (ret != 0) {
                        DB_CREATE,
                        0664);
        if (ret != 0) {

-               worddb->err(worddb, ret, "worddb");
+               logthing(LOGTHING_CRITICAL,
+                               "Error opening word database: %s (%s)",
+                               "worddb",
+                               db_strerror(ret));

                exit(1);
        }
        
                exit(1);
        }
        


@@ -178,6 +191,7 @@ void initdb(void)
  */
 void cleanupdb(void)
 {
  */
 void cleanupdb(void)
 {

+       txn_checkpoint(dbenv, 0, 0, 0);

        worddb->close(worddb, 0);
        worddb = NULL;
        dbconn->close(dbconn, 0);
        worddb->close(worddb, 0);
        worddb = NULL;
        dbconn->close(dbconn, 0);


@@ -205,7 +219,9 @@ bool starttrans(void)
                &txn,
                0);
        if (ret != 0) {
                &txn,
                0);
        if (ret != 0) {

-               dbenv->err(dbenv, ret, "starttrans():");
+               logthing(LOGTHING_CRITICAL,
+                               "Error starting transaction: %s",
+                               db_strerror(ret));

                exit(1);
        }
 
                exit(1);
        }
 


@@ -227,7 +243,9 @@ void endtrans(void)
        ret = txn_commit(txn,
                0);
        if (ret != 0) {
        ret = txn_commit(txn,
                0);
        if (ret != 0) {

-               dbenv->err(dbenv, ret, "endtrans():");
+               logthing(LOGTHING_CRITICAL,
+                               "Error ending transaction: %s",
+                               db_strerror(ret));

                exit(1);
        }
        txn = NULL;
                exit(1);
        }
        txn = NULL;


@@ -287,7 +305,9 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
                packets = NULL;
                numkeys++;
        } else if (ret != DB_NOTFOUND) {
                packets = NULL;
                numkeys++;
        } else if (ret != DB_NOTFOUND) {

-               dbconn->err(dbconn, ret, "Problem retrieving key");
+               logthing(LOGTHING_ERROR,
+                               "Problem retrieving key: %s",
+                               db_strerror(ret));

        }
 
        if (!intrans) {
        }
 
        if (!intrans) {


@@ -489,7 +509,9 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
                                &data,
                                0); /* flags*/
                if (ret != 0) {
                                &data,
                                0); /* flags*/
                if (ret != 0) {

-                       dbconn->err(dbconn, ret, "Problem storing key");
+                       logthing(LOGTHING_ERROR,
+                                       "Problem storing key: %s",
+                                       db_strerror(ret));

                        if (ret == DB_LOCK_DEADLOCK) {
                                deadlock = true;
                        }
                        if (ret == DB_LOCK_DEADLOCK) {
                                deadlock = true;
                        }


@@ -546,8 +568,9 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
                                &data,
                                0);
                        if (ret != 0) {
                                &data,
                                0);
                        if (ret != 0) {

-                               worddb->err(worddb, ret,
-                                       "Problem storing key");
+                               logthing(LOGTHING_ERROR,
+                                       "Problem storing word: %s",
+                                       db_strerror(ret));

                                if (ret == DB_LOCK_DEADLOCK) {
                                        deadlock = true;
                                }
                                if (ret == DB_LOCK_DEADLOCK) {
                                        deadlock = true;
                                }


@@ -653,14 +676,16 @@ int delete_key(uint64_t keyid, bool intrans)
                        if (ret == 0) {
                                ret = cursor->c_del(cursor, 0);
                                if (ret != 0) {
                        if (ret == 0) {
                                ret = cursor->c_del(cursor, 0);
                                if (ret != 0) {

-                                       worddb->err(worddb, ret,
-                                               "Problem deleting word.");
+                                       logthing(LOGTHING_ERROR,
+                                               "Problem deleting word: %s",
+                                               db_strerror(ret));

                                }
                        }
 
                        if (ret != 0) {
                                }
                        }
 
                        if (ret != 0) {

-                               worddb->err(worddb, ret,
-                                       "Problem deleting word.");
+                               logthing(LOGTHING_ERROR,
+                                       "Problem deleting word: %s",
+                                       db_strerror(ret));

                                if (ret == DB_LOCK_DEADLOCK) {
                                        deadlock = true;
                                }
                                if (ret == DB_LOCK_DEADLOCK) {
                                        deadlock = true;
                                }


@@ -734,7 +759,10 @@ int dumpdb(char *filenamebase)
                memset(&data, 0, sizeof(data));
                ret = cursor->c_get(cursor, &key, &data, DB_NEXT);
        }
                memset(&data, 0, sizeof(data));
                ret = cursor->c_get(cursor, &key, &data, DB_NEXT);
        }

-       dbconn->err(dbconn, ret, "Problem reading key");
+       if (ret != DB_NOTFOUND) {
+               logthing(LOGTHING_ERROR, "Problem reading key: %s",
+                               db_strerror(ret));
+       }

 
        close(fd);
 
 
        close(fd);