cscvs to tla changeset 107

[onak.git] / keydb_db3.c

diff --git a/keydb_db3.c b/keydb_db3.c
index de24f750d2656ad04c6c53fc7367fdbbbb601eb2..309a29747d81082e4bb834fd9c61707fc1007724 100644 (file)
--- a/keydb_db3.c
+++ b/keydb_db3.c
@@ -4,6 +4,8 @@
  * Jonathan McDowell <noodles@earth.li>
  *
  * Copyright 2002 Project Purple
  * Jonathan McDowell <noodles@earth.li>
  *
  * Copyright 2002 Project Purple

+ *
+ * $Id: keydb_db3.c,v 1.21 2003/10/03 23:02:04 noodles Exp $

  */
 
 #include <assert.h>
  */
 
 #include <assert.h>


@@ -25,6 +27,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"
 


@@ -34,9 +37,14 @@
 static DB_ENV *dbenv = NULL;
 
 /**
 static DB_ENV *dbenv = NULL;
 
 /**

- *     dbconn - our connection to the key database.
+ *     numdb - The number of database files we have.
+ */
+static int numdbs = 16;
+
+/**
+ *     dbconn - our connections to the key database files.

  */
  */

-static DB *dbconn = NULL;
+static DB **dbconns = NULL;

 
 /**
  *     worddb - our connection to the word database.
 
 /**
  *     worddb - our connection to the word database.


@@ -48,6 +56,15 @@ static DB *worddb = NULL;
  */
 static DB_TXN *txn = NULL;
 
  */
 static DB_TXN *txn = NULL;
 

+DB *keydb(uint64_t keyid)
+{
+       uint64_t keytrun;
+
+       keytrun = keyid >> 8;
+
+       return(dbconns[keytrun % numdbs]);
+}
+

 /**
  *     makewordlist - Takes a string and splits it into a set of unique words.
  *     @wordlist: The current word list.
 /**
  *     makewordlist - Takes a string and splits it into a set of unique words.
  *     @wordlist: The current word list.


@@ -107,24 +124,48 @@ struct ll *makewordlist(struct ll *wordlist, char *word)
  */
 void initdb(void)
 {
  */
 void initdb(void)
 {

-       int ret = 0;
+       char  buf[1024];
+       FILE *numdb = NULL;
+       int   ret = 0;
+       int   i = 0;
+
+       snprintf(buf, sizeof(buf) - 1, "%s/num_keydb", config.db_dir);
+       numdb = fopen(buf, "r");
+       if (numdb != NULL) {
+               if (fgets(buf, sizeof(buf), numdb) != NULL) {
+                       numdbs = atoi(buf);
+               }
+               fclose(numdb);
+       } else {
+               logthing(LOGTHING_ERROR, "Couldn't open num_keydb: %s",
+                               strerror(errno));
+       }
+
+       dbconns = malloc(sizeof (DB *) * numdbs);
+       if (dbconns == NULL) {
+               logthing(LOGTHING_CRITICAL,
+                               "Couldn't allocate memory for dbconns");
+               exit(1);
+       }

 
        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,29 +173,39 @@ 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,
+                               "Error opening db environment: %s (%s)",
+                               config.db_dir,
+                               db_strerror(ret));

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

-       ret = db_create(&dbconn, dbenv, 0);
-       if (ret != 0) {
-               fprintf(stderr, "db_create: %s\n", db_strerror(ret));
-               exit(1);
-       }
+       for (i = 0; i < numdbs; i++) {
+               ret = db_create(&dbconns[i], dbenv, 0);
+               if (ret != 0) {
+                       logthing(LOGTHING_CRITICAL,
+                               "db_create: %s", db_strerror(ret));
+                       exit(1);
+               }

 
 

-       ret = dbconn->open(dbconn, "keydb.db", 
+               snprintf(buf, 1023, "keydb.%d.db", i);
+               ret = dbconns[i]->open(dbconns[i], buf,

                        NULL,
                        DB_HASH,
                        DB_CREATE,
                        0664);
                        NULL,
                        DB_HASH,
                        DB_CREATE,
                        0664);

-       if (ret != 0) {
-               dbconn->err(dbconn, ret, "keydb.db");
-               exit(1);
+               if (ret != 0) {
+                       logthing(LOGTHING_CRITICAL,
+                               "Error opening key database: %s (%s)",
+                               buf,
+                               db_strerror(ret));
+                       exit(1);
+               }

        }
 
        ret = db_create(&worddb, dbenv, 0);
        if (ret != 0) {
        }
 
        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 +214,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,10 +232,15 @@ void initdb(void)
  */
 void cleanupdb(void)
 {
  */
 void cleanupdb(void)
 {

+       int i = 0;
+
+       txn_checkpoint(dbenv, 0, 0, 0);

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

-       dbconn->close(dbconn, 0);
-       dbconn = NULL;
+       for (i = 0; i < numdbs; i++) {
+               dbconns[i]->close(dbconns[i], 0);
+               dbconns[i] = NULL;
+       }

        dbenv->close(dbenv, 0);
        dbenv = NULL;
 }
        dbenv->close(dbenv, 0);
        dbenv = NULL;
 }


@@ -205,7 +264,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 +288,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;


@@ -270,7 +333,7 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
                starttrans();
        }
 
                starttrans();
        }
 

-       ret = dbconn->get(dbconn,
+       ret = keydb(keyid)->get(keydb(keyid),

                        txn,
                        &key,
                        &data,
                        txn,
                        &key,
                        &data,


@@ -281,13 +344,15 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
                fetchbuf.offset = 0;
                fetchbuf.size = data.size;
                read_openpgp_stream(buffer_fetchchar, &fetchbuf,
                fetchbuf.offset = 0;
                fetchbuf.size = data.size;
                read_openpgp_stream(buffer_fetchchar, &fetchbuf,

-                               &packets);
+                               &packets, 0);

                parse_keys(packets, publickey);
                free_packet_list(packets);
                packets = NULL;
                numkeys++;
        } else if (ret != DB_NOTFOUND) {
                parse_keys(packets, publickey);
                free_packet_list(packets);
                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) {


@@ -483,13 +548,15 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
                data.size = storebuf.offset;
                data.data = storebuf.buffer;
 
                data.size = storebuf.offset;
                data.data = storebuf.buffer;
 

-               ret = dbconn->put(dbconn,
+               ret = keydb(keyid)->put(keydb(keyid),

                                txn,
                                &key,
                                &data,
                                0); /* flags*/
                if (ret != 0) {
                                txn,
                                &key,
                                &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 +613,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 +721,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;
                                }


@@ -687,7 +757,7 @@ int delete_key(uint64_t keyid, bool intrans)
                key.data = &keyid;
                key.size = sizeof(keyid);
 
                key.data = &keyid;
                key.size = sizeof(keyid);
 

-               dbconn->del(dbconn,
+               keydb(keyid)->del(keydb(keyid),

                                txn,
                                &key,
                                0); /* flags */
                                txn,
                                &key,
                                0); /* flags */


@@ -712,36 +782,49 @@ int delete_key(uint64_t keyid, bool intrans)
  */
 int dumpdb(char *filenamebase)
 {
  */
 int dumpdb(char *filenamebase)
 {

-       DBT key, data;
-       DBC *cursor = NULL;
-       int ret = 0;
-       int fd = -1;
+       DBT   key, data;
+       DBC  *cursor = NULL;
+       int   ret = 0;
+       int   fd = -1;
+       int   i = 0;
+       char  filename[1024];
+
+       filename[1023] = 0;
+       for (i = 0; i < numdbs; i++) {
+               ret = dbconns[i]->cursor(dbconns[i],
+                       NULL,
+                       &cursor,
+                       0);   /* flags */

 
 

-       starttrans();
-       
-       ret = dbconn->cursor(dbconn,
-               txn,
-               &cursor,
-               0);   /* flags */
+               snprintf(filename, 1023, "%s.%d.pgp", filenamebase, i);
+               fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0640);
+               if (fd == -1) {
+                       logthing(LOGTHING_ERROR,
+                               "Error opening keydump file (%s): %s",
+                               filename,
+                               strerror(errno));
+               } else {
+                       memset(&key, 0, sizeof(key));
+                       memset(&data, 0, sizeof(data));
+                       ret = cursor->c_get(cursor, &key, &data, DB_NEXT);
+                       while (ret == 0) {
+                               write(fd, data.data, data.size);
+                               memset(&key, 0, sizeof(key));
+                               memset(&data, 0, sizeof(data));
+                               ret = cursor->c_get(cursor, &key, &data,
+                                               DB_NEXT);
+                       }
+                       if (ret != DB_NOTFOUND) {
+                               logthing(LOGTHING_ERROR,
+                                       "Problem reading key: %s",
+                                       db_strerror(ret));
+                       }
+                       close(fd);
+               }

 
 

-       fd = open(filenamebase, O_CREAT | O_WRONLY | O_TRUNC, 0640);
-       memset(&key, 0, sizeof(key));
-       memset(&data, 0, sizeof(data));
-       ret = cursor->c_get(cursor, &key, &data, DB_NEXT);
-       while (ret == 0) {
-               write(fd, data.data, data.size);
-               memset(&key, 0, sizeof(key));
-               memset(&data, 0, sizeof(data));
-               ret = cursor->c_get(cursor, &key, &data, DB_NEXT);
+               ret = cursor->c_close(cursor);
+               cursor = NULL;

        }
        }

-       dbconn->err(dbconn, ret, "Problem reading key");
-
-       close(fd);
-
-       ret = cursor->c_close(cursor);
-       cursor = NULL;
-       
-       endtrans();

        
        return 0;
 }
        
        return 0;
 }