Add links to HTML index output. (Debian bug #275227)

[onak.git] / keydb_db4.c

diff --git a/keydb_db4.c b/keydb_db4.c
index 04949d000ce90dd48a37401f12cf15855434530f..1daf00bed8f91d016d55938848f2f92ce8101399 100644 (file)
--- a/keydb_db4.c
+++ b/keydb_db4.c
@@ -1,12 +1,11 @@
 /*
 /*

- * keydb_db4.c - Routines to store and fetch keys in a DB3 database.
+ * keydb_db4.c - Routines to store and fetch keys in a DB4 database.

  *
  * Jonathan McDowell <noodles@earth.li>
  *
  * Copyright 2002-2004 Project Purple
  */
 
  *
  * Jonathan McDowell <noodles@earth.li>
  *
  * Copyright 2002-2004 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>


@@ -20,6 +19,7 @@
 #include <db.h>
 
 #include "charfuncs.h"
 #include <db.h>
 
 #include "charfuncs.h"

+#include "keyarray.h"

 #include "keydb.h"
 #include "keyid.h"
 #include "decodekey.h"
 #include "keydb.h"
 #include "keyid.h"
 #include "decodekey.h"


@@ -109,14 +109,15 @@ void initdb(bool readonly)
        if (dbconns == NULL) {
                logthing(LOGTHING_CRITICAL,
                                "Couldn't allocate memory for dbconns");
        if (dbconns == NULL) {
                logthing(LOGTHING_CRITICAL,
                                "Couldn't allocate memory for dbconns");

-               exit(1);
+               ret = 1;

        }
 
        }
 

-       ret = db_env_create(&dbenv, 0);
-       if (ret != 0) {
-               logthing(LOGTHING_CRITICAL,
-                       "db_env_create: %s", db_strerror(ret));
-               exit(1);
+       if (ret == 0) {
+               ret = db_env_create(&dbenv, 0);
+               if (ret != 0) {
+                       logthing(LOGTHING_CRITICAL,
+                               "db_env_create: %s", db_strerror(ret));
+               }

        }
 
        /*
        }
 
        /*


@@ -124,93 +125,121 @@ void initdb(bool readonly)
         * 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.
         */
         * 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);
+       if (ret == 0) {
+               ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT);
+               if (ret != 0) {
+                       logthing(LOGTHING_CRITICAL,
+                               "db_env_create: %s", db_strerror(ret));
+               }

        }
 
        }
 

-       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,
-                               "Error opening db environment: %s (%s)",
-                               config.db_dir,
-                               db_strerror(ret));
-               exit(1);
+       if (ret == 0) {
+               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,
+                                       "Error opening db environment: %s (%s)",
+                                       config.db_dir,
+                                       db_strerror(ret));
+               }

        }
 
        }
 

-       starttrans();
+       if (ret == 0) {
+               starttrans();

 
 

-       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);
+               for (i = 0; !ret && i < numdbs; i++) {
+                       ret = db_create(&dbconns[i], dbenv, 0);
+                       if (ret != 0) {
+                               logthing(LOGTHING_CRITICAL,
+                                       "db_create: %s", db_strerror(ret));
+                       }
+
+                       if (ret == 0) {
+                               snprintf(buf, 1023, "keydb.%d.db", i);
+                               flags = DB_CREATE;
+                               if (readonly) {
+                                       flags = DB_RDONLY;
+                               }
+                               ret = dbconns[i]->open(dbconns[i],
+                                               txn,
+                                               buf,
+                                               "keydb",
+                                               DB_HASH,
+                                               flags,
+                                               0664);
+                               if (ret != 0) {
+                                       logthing(LOGTHING_CRITICAL,
+                                               "Error opening key database:"
+                                               " %s (%s)",
+                                               buf,
+                                               db_strerror(ret));
+                               }
+                       }

                }
 
                }
 

-               snprintf(buf, 1023, "keydb.%d.db", i);
-               flags = DB_CREATE;
-               if (readonly) {
-                       flags = DB_RDONLY;
+       }
+
+       if (ret == 0) {
+               ret = db_create(&worddb, dbenv, 0);
+               if (ret != 0) {
+                       logthing(LOGTHING_CRITICAL, "db_create: %s",
+                                       db_strerror(ret));

                }
                }

-               ret = dbconns[i]->open(dbconns[i],
-                               txn,
-                               buf,
-                               "keydb",
-                               DB_HASH,
+       }
+
+       if (ret == 0) {
+               ret = worddb->set_flags(worddb, DB_DUP);
+       }
+
+       if (ret == 0) {
+               ret = worddb->open(worddb, txn, "worddb", "worddb", DB_BTREE,

                                flags,
                                0664);
                if (ret != 0) {
                        logthing(LOGTHING_CRITICAL,
                                flags,
                                0664);
                if (ret != 0) {
                        logthing(LOGTHING_CRITICAL,

-                               "Error opening key database: %s (%s)",
-                               buf,
-                               db_strerror(ret));
-                       exit(1);
+                                       "Error opening word database: %s (%s)",
+                                       "worddb",
+                                       db_strerror(ret));

                }
        }
 
                }
        }
 

-       ret = db_create(&worddb, dbenv, 0);
-       if (ret != 0) {
-               logthing(LOGTHING_CRITICAL, "db_create: %s", db_strerror(ret));
-               exit(1);
+       if (ret == 0) {
+               ret = db_create(&id32db, dbenv, 0);
+               if (ret != 0) {
+                       logthing(LOGTHING_CRITICAL, "db_create: %s",
+                                       db_strerror(ret));
+               }

        }
        }

-       ret = worddb->set_flags(worddb, DB_DUP);

 
 

-       ret = worddb->open(worddb, txn, "worddb", "worddb", DB_BTREE,
-                       flags,
-                       0664);
-       if (ret != 0) {
-               logthing(LOGTHING_CRITICAL,
-                               "Error opening word database: %s (%s)",
-                               "worddb",
-                               db_strerror(ret));
-               exit(1);
+       if (ret == 0) {
+               ret = id32db->set_flags(id32db, DB_DUP);

        }
 
        }
 

-       ret = db_create(&id32db, dbenv, 0);
-       if (ret != 0) {
-               logthing(LOGTHING_CRITICAL, "db_create: %s", db_strerror(ret));
-               exit(1);
+       if (ret == 0) {
+               ret = id32db->open(id32db, txn, "id32db", "id32db", DB_HASH,
+                               flags,
+                               0664);
+               if (ret != 0) {
+                       logthing(LOGTHING_CRITICAL,
+                                       "Error opening id32 database: %s (%s)",
+                                       "id32db",
+                                       db_strerror(ret));
+               }
+       }
+
+       if (txn != NULL) {
+               endtrans();

        }
        }

-       ret = id32db->set_flags(id32db, DB_DUP);

 
 

-       ret = id32db->open(id32db, txn, "id32db", "id32db", DB_HASH,
-                       flags,
-                       0664);

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

+               cleanupdb();

                logthing(LOGTHING_CRITICAL,
                logthing(LOGTHING_CRITICAL,

-                               "Error opening id32 database: %s (%s)",
-                               "id32db",
-                               db_strerror(ret));
-               exit(1);
+                               "Error opening database; exiting");
+               exit(EXIT_FAILURE);

        }
        }

-       endtrans();

        
        return;
 }
        
        return;
 }


@@ -225,17 +254,25 @@ void cleanupdb(void)
 {
        int i = 0;
 
 {
        int i = 0;
 

-       dbenv->txn_checkpoint(dbenv, 0, 0, 0);
-       id32db->close(id32db, 0);
-       id32db = NULL;
-       worddb->close(worddb, 0);
-       worddb = NULL;
-       for (i = 0; i < numdbs; i++) {
-               dbconns[i]->close(dbconns[i], 0);
-               dbconns[i] = NULL;
+       if (dbenv != NULL) {
+               dbenv->txn_checkpoint(dbenv, 0, 0, 0);
+               if (id32db != NULL) {
+                       id32db->close(id32db, 0);
+                       id32db = NULL;
+               }
+               if (worddb != NULL) {
+                       worddb->close(worddb, 0);
+                       worddb = NULL;
+               }
+               for (i = 0; i < numdbs; i++) {
+                       if (dbconns[i] != NULL) {
+                               dbconns[i]->close(dbconns[i], 0);
+                               dbconns[i] = NULL;
+                       }
+               }
+               dbenv->close(dbenv, 0);
+               dbenv = NULL;

        }
        }

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

 }
 
 /**
 }
 
 /**


@@ -249,8 +286,8 @@ bool starttrans(void)
 {
        int ret;
 
 {
        int ret;
 

-       assert(dbenv != NULL);
-       assert(txn == NULL);
+       log_assert(dbenv != NULL);
+       log_assert(txn == NULL);

 
        ret = dbenv->txn_begin(dbenv,
                NULL, /* No parent transaction */
 
        ret = dbenv->txn_begin(dbenv,
                NULL, /* No parent transaction */


@@ -275,8 +312,8 @@ void endtrans(void)
 {
        int ret;
 
 {
        int ret;
 

-       assert(dbenv != NULL);
-       assert(txn != NULL);
+       log_assert(dbenv != NULL);
+       log_assert(txn != NULL);

 
        ret = txn->commit(txn,
                0);
 
        ret = txn->commit(txn,
                0);


@@ -382,21 +419,21 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey)
        char *searchtext = NULL;
        struct ll *wordlist = NULL;
        struct ll *curword = NULL;
        char *searchtext = NULL;
        struct ll *wordlist = NULL;
        struct ll *curword = NULL;

-       struct ll *keylist = NULL;
-       struct ll *newkeylist = NULL;
+       struct keyarray keylist = { NULL, 0, 0 };
+       struct keyarray newkeylist = { NULL, 0, 0 };

 
        numkeys = 0;
        searchtext = strdup(search);
        wordlist = makewordlist(wordlist, searchtext);
 
 
        numkeys = 0;
        searchtext = strdup(search);
        wordlist = makewordlist(wordlist, searchtext);
 

-       starttrans();
+       for (curword = wordlist; curword != NULL; curword = curword->next) {
+               starttrans();

 
 

-       ret = worddb->cursor(worddb,
-                       txn,
-                       &cursor,
-                       0);   /* flags */
+               ret = worddb->cursor(worddb,
+                               txn,
+                               &cursor,
+                               0);   /* flags */

 
 

-       for (curword = wordlist; curword != NULL; curword = curword->next) {

                memset(&key, 0, sizeof(key));
                memset(&data, 0, sizeof(data));
                key.data = curword->object;
                memset(&key, 0, sizeof(key));
                memset(&data, 0, sizeof(data));
                key.data = curword->object;


@@ -416,54 +453,44 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey)
                                                data.data)[i];
                        }
 
                                                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;
+                       if (keylist.count == 0 ||
+                                       array_find(&keylist, keyid)) {
+                               array_add(&newkeylist, keyid);

                        }
                        }

+
+                       free(data.data);
+                       data.data = NULL;
+

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

-               llfree(keylist, free);
+               array_free(&keylist);

                keylist = newkeylist;
                keylist = newkeylist;

-               newkeylist = NULL;
+               newkeylist.keys = NULL;
+               newkeylist.count = newkeylist.size = 0;

                if (data.data != NULL) {
                        free(data.data);
                        data.data = NULL;
                }
                if (data.data != NULL) {
                        free(data.data);
                        data.data = NULL;
                }

+               ret = cursor->c_close(cursor);
+               cursor = NULL;
+               endtrans();

        }
        llfree(wordlist, NULL);
        wordlist = 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);
+       starttrans();
+       for (i = 0; i < keylist.count; i++) {
+               numkeys += fetch_key(keylist.keys[i],
+                       publickey,
+                       true);

        }
        }

-       llfree(keylist, free);
-       keylist = NULL;
+       array_free(&keylist);

        free(searchtext);
        searchtext = NULL;
 
        free(searchtext);
        searchtext = NULL;
 

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

        endtrans();
        
        return (numkeys);
        endtrans();
        
        return (numkeys);


@@ -631,10 +658,6 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
                uids = NULL;
        }
 
                uids = NULL;
        }
 

-       if (!intrans) {
-               endtrans();
-       }
-

        /*
         * Write the truncated 32 bit keyid so we can lookup the full id for
         * queries.
        /*
         * Write the truncated 32 bit keyid so we can lookup the full id for
         * queries.


@@ -697,6 +720,10 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
                }
        }
 
                }
        }
 

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

        return deadlock ? -1 : 0 ;
 }
 
        return deadlock ? -1 : 0 ;
 }
 


@@ -971,6 +998,72 @@ int dumpdb(char *filenamebase)
        return 0;
 }
 
        return 0;
 }
 

+/**
+ *     iterate_keys - call a function once for each key in the db.
+ *     @iterfunc: The function to call.
+ *     @ctx: A context pointer
+ *
+ *     Calls iterfunc once for each key in the database. ctx is passed
+ *     unaltered to iterfunc. This function is intended to aid database dumps
+ *     and statistic calculations.
+ *
+ *     Returns the number of keys we iterated over.
+ */
+int iterate_keys(void (*iterfunc)(void *ctx, struct openpgp_publickey *key),
+               void *ctx)
+{
+       DBT                         dbkey, data;
+       DBC                        *cursor = NULL;
+       int                         ret = 0;
+       int                         i = 0;
+       int                         numkeys = 0;
+       struct buffer_ctx           fetchbuf;
+       struct openpgp_packet_list *packets = NULL;
+       struct openpgp_publickey   *key = NULL;
+
+       for (i = 0; i < numdbs; i++) {
+               ret = dbconns[i]->cursor(dbconns[i],
+                       NULL,
+                       &cursor,
+                       0);   /* flags */
+
+               memset(&dbkey, 0, sizeof(dbkey));
+               memset(&data, 0, sizeof(data));
+               ret = cursor->c_get(cursor, &dbkey, &data, DB_NEXT);
+               while (ret == 0) {
+                       fetchbuf.buffer = data.data;
+                       fetchbuf.offset = 0;
+                       fetchbuf.size = data.size;
+                       read_openpgp_stream(buffer_fetchchar, &fetchbuf,
+                               &packets, 0);
+                       parse_keys(packets, &key);
+
+                       iterfunc(ctx, key);
+                       
+                       free_publickey(key);
+                       key = NULL;
+                       free_packet_list(packets);
+                       packets = NULL;
+                       
+                       memset(&dbkey, 0, sizeof(dbkey));
+                       memset(&data, 0, sizeof(data));
+                       ret = cursor->c_get(cursor, &dbkey, &data,
+                                       DB_NEXT);
+                       numkeys++;
+               }
+               if (ret != DB_NOTFOUND) {
+                       logthing(LOGTHING_ERROR,
+                               "Problem reading key: %s",
+                               db_strerror(ret));
+               }
+
+               ret = cursor->c_close(cursor);
+               cursor = NULL;
+       }
+       
+       return numkeys;
+}
+

 /**
  *     getfullkeyid - Maps a 32bit key id to a 64bit one.
  *     @keyid: The 32bit keyid.
 /**
  *     getfullkeyid - Maps a 32bit key id to a 64bit one.
  *     @keyid: The 32bit keyid.


@@ -1025,4 +1118,5 @@ uint64_t getfullkeyid(uint64_t keyid)
  */
 #define NEED_GETKEYSIGS 1
 #define NEED_KEYID2UID 1
  */
 #define NEED_GETKEYSIGS 1
 #define NEED_KEYID2UID 1

+#define NEED_UPDATEKEYS 1

 #include "keydb.c"
 #include "keydb.c"