cscvs to tla changeset 68

[onak.git] / keydb_db3.c

diff --git a/keydb_db3.c b/keydb_db3.c
index 5224b52129f4e2828c01bff82d6998679514dd90..0f4239bd212b37cb8621ce46ed799d807a9d166e 100644 (file)
--- a/keydb_db3.c
+++ b/keydb_db3.c
@@ -6,6 +6,7 @@
  * Copyright 2002 Project Purple
  */
 
  * Copyright 2002 Project Purple
  */
 

+#include <assert.h>

 #include <sys/types.h>
 #include <sys/uio.h>
 #include <ctype.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <ctype.h>


@@ -21,12 +22,18 @@
 #include "charfuncs.h"
 #include "keydb.h"
 #include "keyid.h"
 #include "charfuncs.h"
 #include "keydb.h"
 #include "keyid.h"

-#include "keyindex.h"
+#include "decodekey.h"

 #include "keystructs.h"
 #include "mem.h"
 #include "keystructs.h"
 #include "mem.h"

+#include "log.h"

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

+/**
+ *     dbenv - our database environment.
+ */
+static DB_ENV *dbenv = NULL;
+

 /**
  *     dbconn - our connection to the key database.
  */
 /**
  *     dbconn - our connection to the key database.
  */


@@ -37,6 +44,11 @@ static DB *dbconn = NULL;
  */
 static DB *worddb = NULL;
 
  */
 static DB *worddb = NULL;
 

+/**
+ *     txn - our current transaction id.
+ */
+static DB_TXN *txn = NULL;
+

 /**
  *     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.


@@ -96,41 +108,75 @@ struct ll *makewordlist(struct ll *wordlist, char *word)
  */
 void initdb(void)
 {
  */
 void initdb(void)
 {

-       char buf[1024];

        int ret = 0;
 
        int ret = 0;
 

-       strcpy(buf, config.db2_dbpath);
-       strcat(buf, "/keydb.db");
-       
-       ret = db_create(&dbconn, NULL, 0);
+       ret = db_env_create(&dbenv, 0);
+       if (ret != 0) {
+               logthing(LOGTHING_CRITICAL,
+                       "db_env_create: %s", db_strerror(ret));
+               exit(1);
+       }
+
+       /*
+        * 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 = 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 |
+                       DB_INIT_TXN |
+                       DB_CREATE,
+                       0);
+       if (ret != 0) {
+               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) {
        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);
        }
 

-       ret = dbconn->open(dbconn, buf, NULL, DB_HASH,
+       ret = dbconn->open(dbconn, "keydb.db", 
+                       NULL,
+                       DB_HASH,

                        DB_CREATE,
                        0664);
        if (ret != 0) {
                        DB_CREATE,
                        0664);
        if (ret != 0) {

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

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

-       strcpy(buf, config.db2_dbpath);
-       strcat(buf, "/worddb");
-       
-       ret = db_create(&worddb, NULL, 0);
+       ret = db_create(&worddb, dbenv, 0);

        if (ret != 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);
 

-       ret = worddb->open(worddb, buf, NULL, DB_BTREE,
+       ret = worddb->open(worddb, "worddb", NULL, DB_BTREE,

                        DB_CREATE,
                        0664);
        if (ret != 0) {
                        DB_CREATE,
                        0664);
        if (ret != 0) {

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

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


@@ -145,10 +191,13 @@ 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);
        dbconn = NULL;
        worddb->close(worddb, 0);
        worddb = NULL;
        dbconn->close(dbconn, 0);
        dbconn = NULL;

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

 }
 
 /**
 }
 
 /**


@@ -160,6 +209,22 @@ void cleanupdb(void)
  */
 bool starttrans(void)
 {
  */
 bool starttrans(void)
 {

+       int ret;
+
+       assert(dbenv != NULL);
+       assert(txn == NULL);
+
+       ret = txn_begin(dbenv,
+               NULL, /* No parent transaction */
+               &txn,
+               0);
+       if (ret != 0) {
+               logthing(LOGTHING_CRITICAL,
+                               "Error starting transaction: %s",
+                               db_strerror(ret));
+               exit(1);
+       }
+

        return true;
 }
 
        return true;
 }
 


@@ -170,6 +235,21 @@ bool starttrans(void)
  */
 void endtrans(void)
 {
  */
 void endtrans(void)
 {

+       int ret;
+
+       assert(dbenv != NULL);
+       assert(txn != NULL);
+
+       ret = txn_commit(txn,
+               0);
+       if (ret != 0) {
+               logthing(LOGTHING_CRITICAL,
+                               "Error ending transaction: %s",
+                               db_strerror(ret));
+               exit(1);
+       }
+       txn = NULL;
+

        return;
 }
 
        return;
 }
 


@@ -204,8 +284,12 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
        key.data = &keyid;
        keyid &= 0xFFFFFFFF;
 
        key.data = &keyid;
        keyid &= 0xFFFFFFFF;
 

+       if (!intrans) {
+               starttrans();
+       }
+

        ret = dbconn->get(dbconn,
        ret = dbconn->get(dbconn,

-                       NULL, /* txn id */
+                       txn,

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


@@ -217,14 +301,27 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
                read_openpgp_stream(buffer_fetchchar, &fetchbuf,
                                &packets);
                parse_keys(packets, publickey);
                read_openpgp_stream(buffer_fetchchar, &fetchbuf,
                                &packets);
                parse_keys(packets, publickey);

+               free_packet_list(packets);
+               packets = NULL;

                numkeys++;
        } else if (ret != DB_NOTFOUND) {
                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) {
+               endtrans();

        }
 
        return (numkeys);
 }
 
        }
 
        return (numkeys);
 }
 

+int worddb_cmp(const char *d1, const char *d2)
+{
+       return memcmp(d1, d2, 12);
+}
+

 /**
  *     fetch_key_text - Trys to find the keys that contain the supplied text.
  *     @search: The text to search for.
 /**
  *     fetch_key_text - Trys to find the keys that contain the supplied text.
  *     @search: The text to search for.


@@ -241,39 +338,92 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey)
        uint64_t keyid;
        int i;
        int numkeys;
        uint64_t keyid;
        int i;
        int numkeys;

+       char *searchtext = NULL;
+       struct ll *wordlist = NULL;
+       struct ll *curword = NULL;
+       struct ll *keylist = NULL;
+       struct ll *newkeylist = NULL;

 
        numkeys = 0;
 
        numkeys = 0;

+       searchtext = strdup(search);
+       wordlist = makewordlist(wordlist, searchtext);
+
+       starttrans();

 
        ret = worddb->cursor(worddb,
 
        ret = worddb->cursor(worddb,

-                       NULL, /* txn */
+                       txn,

                        &cursor,
                        0);   /* flags */
                        &cursor,
                        0);   /* flags */

-       if (ret == 0) {
+
+       for (curword = wordlist; curword != NULL; curword = curword->next) {

                memset(&key, 0, sizeof(key));
                memset(&data, 0, sizeof(data));
                memset(&key, 0, sizeof(key));
                memset(&data, 0, sizeof(data));

-               key.data = (void *) search;
-               key.size = strlen(search);
+               key.data = curword->object;
+               key.size = strlen(curword->object);
+               data.flags = DB_DBT_MALLOC;

                ret = cursor->c_get(cursor,
                                &key,
                                &data,
                                DB_SET);
                ret = cursor->c_get(cursor,
                                &key,
                                &data,
                                DB_SET);

-               while (ret == 0 && strcmp(key.data, search) == 0) {
+               while (ret == 0 && strncmp(key.data, curword->object,
+                                       key.size) == 0 &&
+                               ((char *) curword->object)[key.size] == 0) {

                        keyid = 0;
                        for (i = 4; i < 12; i++) {
                                keyid <<= 8;
                        keyid = 0;
                        for (i = 4; i < 12; i++) {
                                keyid <<= 8;

-                               keyid += ((unsigned char *) data.data)[i];
+                               keyid += ((unsigned char *)
+                                               data.data)[i];
+                       }
+
+                       if (keylist == NULL ||
+                                       llfind(keylist, data.data,
+                                               worddb_cmp) != NULL) {
+                               newkeylist = lladd(newkeylist, data.data);
+                               data.data = NULL;
+                       } else {
+                               free(data.data);
+                               data.data = NULL;

                        }
                        }

-                       numkeys += fetch_key(keyid,
-                                       publickey,
-                                       false);

                        ret = cursor->c_get(cursor,
                                        &key,
                                        &data,
                                        DB_NEXT);
                }
                        ret = cursor->c_get(cursor,
                                        &key,
                                        &data,
                                        DB_NEXT);
                }

-               ret = cursor->c_close(cursor);
-               cursor = NULL;
+               llfree(keylist, free);
+               keylist = newkeylist;
+               newkeylist = NULL;
+               if (data.data != NULL) {
+                       free(data.data);
+                       data.data = NULL;
+               }
+       }
+       llfree(wordlist, NULL);
+       wordlist = NULL;
+       
+       for (newkeylist = keylist;
+                       newkeylist != NULL && numkeys < config.maxkeys;
+                       newkeylist = newkeylist->next) {
+
+                       keyid = 0;
+                       for (i = 4; i < 12; i++) {
+                               keyid <<= 8;
+                               keyid += ((unsigned char *)
+                                               newkeylist->object)[i];
+                       }
+
+                       numkeys += fetch_key(keyid,
+                                       publickey,
+                                       true);

        }
        }

+       llfree(keylist, free);
+       keylist = NULL;
+       free(searchtext);
+       searchtext = NULL;
+
+       ret = cursor->c_close(cursor);
+       cursor = NULL;
+
+       endtrans();

        
        return (numkeys);
 }
        
        return (numkeys);
 }


@@ -306,9 +456,14 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
        unsigned char worddb_data[12];
        struct ll *wordlist = NULL;
        struct ll *curword  = NULL;
        unsigned char worddb_data[12];
        struct ll *wordlist = NULL;
        struct ll *curword  = NULL;

+       bool       deadlock = false;

 
        keyid = get_keyid(publickey);
 
 
        keyid = get_keyid(publickey);
 

+       if (!intrans) {
+               starttrans();
+       }
+

        /*
         * Delete the key if we already have it.
         *
        /*
         * Delete the key if we already have it.
         *


@@ -318,53 +473,71 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
         * it definitely needs updated.
         */
        if (update) {
         * it definitely needs updated.
         */
        if (update) {

-               delete_key(keyid, true);
+               deadlock = (delete_key(keyid, true) == -1);

        }
 
        /*
         * Convert the key to a flat set of binary data.
         */
        }
 
        /*
         * Convert the key to a flat set of binary data.
         */

-       next = publickey->next;
-       publickey->next = NULL;
-       flatten_publickey(publickey, &packets, &list_end);
-       publickey->next = next;
-
-       storebuf.offset = 0; 
-       storebuf.size = 8192;
-       storebuf.buffer = malloc(8192);
+       if (!deadlock) {
+               next = publickey->next;
+               publickey->next = NULL;
+               flatten_publickey(publickey, &packets, &list_end);
+               publickey->next = next;
+
+               storebuf.offset = 0; 
+               storebuf.size = 8192;
+               storebuf.buffer = malloc(8192);

        
        

-       write_openpgp_stream(buffer_putchar, &storebuf, packets);
+               write_openpgp_stream(buffer_putchar, &storebuf, packets);

 
 

-       /*
-        * Now we have the key data store it in the DB; the keyid is the key.
-        */
-       memset(&key, 0, sizeof(key));
-       memset(&data, 0, sizeof(data));
-       key.data = &keyid;
-       key.size = sizeof(keyid);
-       keyid &= 0xFFFFFFFF;
-       data.size = storebuf.offset;
-       data.data = storebuf.buffer;
+               /*
+                * Now we have the key data store it in the DB; the keyid is
+                * the key.
+                */
+               memset(&key, 0, sizeof(key));
+               memset(&data, 0, sizeof(data));
+               key.data = &keyid;
+               key.size = sizeof(keyid);
+               keyid &= 0xFFFFFFFF;
+               data.size = storebuf.offset;
+               data.data = storebuf.buffer;
+
+               ret = dbconn->put(dbconn,
+                               txn,
+                               &key,
+                               &data,
+                               0); /* flags*/
+               if (ret != 0) {
+                       logthing(LOGTHING_ERROR,
+                                       "Problem storing key: %s",
+                                       db_strerror(ret));
+                       if (ret == DB_LOCK_DEADLOCK) {
+                               deadlock = true;
+                       }
+               }

 
 

-       ret = dbconn->put(dbconn,
-                       NULL, /* txn id */
-                       &key,
-                       &data,
-                       0); /* flags*/
-       if (ret != 0) {
-               dbconn->err(dbconn, ret, "Problem storing key");
+               free(storebuf.buffer);
+               storebuf.buffer = NULL;
+               storebuf.size = 0;
+               storebuf.offset = 0; 
+       
+               free_packet_list(packets);
+               packets = NULL;

        }
 
        /*
         * Walk through our uids storing the words into the db with the keyid.
         */
        }
 
        /*
         * Walk through our uids storing the words into the db with the keyid.
         */

-       uids = keyuids(publickey, &primary);
+       if (!deadlock) {
+               uids = keyuids(publickey, &primary);
+       }

        if (uids != NULL) {
                for (i = 0; ret == 0 && uids[i] != NULL; i++) {
                        wordlist = makewordlist(wordlist, uids[i]);
                }
 
        if (uids != NULL) {
                for (i = 0; ret == 0 && uids[i] != NULL; i++) {
                        wordlist = makewordlist(wordlist, uids[i]);
                }
 

-               for (curword = wordlist; curword != NULL;
+               for (curword = wordlist; curword != NULL && !deadlock;

                                curword = curword->next) {
                        memset(&key, 0, sizeof(key));
                        memset(&data, 0, sizeof(data));
                                curword = curword->next) {
                        memset(&key, 0, sizeof(key));
                        memset(&data, 0, sizeof(data));


@@ -390,13 +563,17 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
                        worddb_data[10] = (keyid >>  8) & 0xFF;
                        worddb_data[11] = keyid & 0xFF; 
                        ret = worddb->put(worddb,
                        worddb_data[10] = (keyid >>  8) & 0xFF;
                        worddb_data[11] = keyid & 0xFF; 
                        ret = worddb->put(worddb,

-                               0,
+                               txn,

                                &key,
                                &data,
                                0);
                        if (ret != 0) {
                                &key,
                                &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;
+                               }

                        }
                }
 
                        }
                }
 


@@ -412,7 +589,11 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
                uids = NULL;
        }
 
                uids = NULL;
        }
 

-       return 0;
+       if (!intrans) {
+               endtrans();
+       }
+
+       return deadlock ? -1 : 0 ;

 }
 
 /**
 }
 
 /**


@@ -435,10 +616,15 @@ int delete_key(uint64_t keyid, bool intrans)
        unsigned char worddb_data[12];
        struct ll *wordlist = NULL;
        struct ll *curword  = NULL;
        unsigned char worddb_data[12];
        struct ll *wordlist = NULL;
        struct ll *curword  = NULL;

+       bool deadlock = false;

 
        keyid &= 0xFFFFFFFF;
 
 
        keyid &= 0xFFFFFFFF;
 

-       fetch_key(keyid, &publickey, intrans);
+       if (!intrans) {
+               starttrans();
+       }
+
+       fetch_key(keyid, &publickey, true);

 
        /*
         * Walk through the uids removing the words from the worddb.
 
        /*
         * Walk through the uids removing the words from the worddb.


@@ -452,11 +638,11 @@ int delete_key(uint64_t keyid, bool intrans)
                }
                                
                ret = worddb->cursor(worddb,
                }
                                
                ret = worddb->cursor(worddb,

-                       NULL, /* txn */
+                       txn,

                        &cursor,
                        0);   /* flags */
 
                        &cursor,
                        0);   /* flags */
 

-               for (curword = wordlist; curword != NULL;
+               for (curword = wordlist; curword != NULL && !deadlock;

                                curword = curword->next) {
                        memset(&key, 0, sizeof(key));
                        memset(&data, 0, sizeof(data));
                                curword = curword->next) {
                        memset(&key, 0, sizeof(key));
                        memset(&data, 0, sizeof(data));


@@ -486,13 +672,23 @@ int delete_key(uint64_t keyid, bool intrans)
                                &key,
                                &data,
                                DB_GET_BOTH);
                                &key,
                                &data,
                                DB_GET_BOTH);

+

                        if (ret == 0) {
                                ret = cursor->c_del(cursor, 0);
                        if (ret == 0) {
                                ret = cursor->c_del(cursor, 0);

+                               if (ret != 0) {
+                                       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;
+                               }

                        }
                }
                ret = cursor->c_close(cursor);
                        }
                }
                ret = cursor->c_close(cursor);


@@ -512,15 +708,67 @@ int delete_key(uint64_t keyid, bool intrans)
                publickey = NULL;
        }
 
                publickey = NULL;
        }
 

-       key.data = &keyid;
-       key.size = sizeof(keyid);
+       if (!deadlock) {
+               key.data = &keyid;
+               key.size = sizeof(keyid);

 
 

-       dbconn->del(dbconn,
-                       NULL, /* txn id */
-                       &key,
-                       0); /* flags */
+               dbconn->del(dbconn,
+                               txn,
+                               &key,
+                               0); /* flags */
+       }
+
+       if (!intrans) {
+               endtrans();
+       }
+
+       return deadlock ? (-1) : (ret == DB_NOTFOUND);
+}

 
 

-       return (ret == DB_NOTFOUND);
+/**
+ *     dumpdb - dump the key database
+ *     @filenamebase: The base filename to use for the dump.
+ *
+ *     Dumps the database into one or more files, which contain pure OpenPGP
+ *     that can be reimported into onak or gpg. filenamebase provides a base
+ *     file name for the dump; several files may be created, all of which will
+ *     begin with this string and then have a unique number and a .pgp
+ *     extension.
+ */
+int dumpdb(char *filenamebase)
+{
+       DBT key, data;
+       DBC *cursor = NULL;
+       int ret = 0;
+       int fd = -1;
+
+       starttrans();
+       
+       ret = dbconn->cursor(dbconn,
+               txn,
+               &cursor,
+               0);   /* flags */
+
+       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);
+       }
+       logthing(LOGTHING_ERROR, "Problem reading key: %s", db_strerror(ret));
+
+       close(fd);
+
+       ret = cursor->c_close(cursor);
+       cursor = NULL;
+       
+       endtrans();
+       
+       return 0;

 }
 
 /*
 }
 
 /*