]> git.sommitrealweird.co.uk Git - onak.git/blobdiff - keydb_db4.c
(Hopefully) really fix the DB4 backend issues.
[onak.git] / keydb_db4.c
index 1596e5b97f4c7f60167eebd1318c8322f130e4aa..b443942aea33530a8db6c97001896dcccd226075 100644 (file)
@@ -69,6 +69,92 @@ DB *keydb(uint64_t keyid)
        return(dbconns[keytrun % numdbs]);
 }
 
+/**
+ *     starttrans - Start a transaction.
+ *
+ *     Start a transaction. Intended to be used if we're about to perform many
+ *     operations on the database to help speed it all up, or if we want
+ *     something to only succeed if all relevant operations are successful.
+ */
+static bool db4_starttrans(void)
+{
+       int ret;
+
+       log_assert(dbenv != NULL);
+       log_assert(txn == NULL);
+
+       ret = dbenv->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;
+}
+
+/**
+ *     endtrans - End a transaction.
+ *
+ *     Ends a transaction.
+ */
+static void db4_endtrans(void)
+{
+       int ret;
+
+       log_assert(dbenv != NULL);
+       log_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;
+}
+
+/**
+ *     cleanupdb - De-initialize the key database.
+ *
+ *     This function should be called upon program exit to allow the DB to
+ *     cleanup after itself.
+ */
+static void db4_cleanupdb(void)
+{
+       int i = 0;
+
+       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;
+                       }
+               }
+               free(dbconns);
+               dbconns = NULL;
+               dbenv->close(dbenv, 0);
+               dbenv = NULL;
+       }
+}
+
 /**
  *     initdb - Initialize the key database.
  *
@@ -76,7 +162,7 @@ DB *keydb(uint64_t keyid)
  *     this file are called in order to allow the DB to be initialized ready
  *     for access.
  */
-void initdb(bool readonly)
+static void db4_initdb(bool readonly)
 {
        char       buf[1024];
        FILE      *numdb = NULL;
@@ -144,11 +230,13 @@ void initdb(bool readonly)
                                        "Error opening db environment: %s (%s)",
                                        config.db_dir,
                                        db_strerror(ret));
+                       dbenv->close(dbenv, 0);
+                       dbenv = NULL;
                }
        }
 
        if (ret == 0) {
-               starttrans();
+               db4_starttrans();
 
                for (i = 0; !ret && i < numdbs; i++) {
                        ret = db_create(&dbconns[i], dbenv, 0);
@@ -231,11 +319,11 @@ void initdb(bool readonly)
        }
 
        if (txn != NULL) {
-               endtrans();
+               db4_endtrans();
        }
 
        if (ret != 0) {
-               cleanupdb();
+               db4_cleanupdb();
                logthing(LOGTHING_CRITICAL,
                                "Error opening database; exiting");
                exit(EXIT_FAILURE);
@@ -244,92 +332,6 @@ void initdb(bool readonly)
        return;
 }
 
-/**
- *     cleanupdb - De-initialize the key database.
- *
- *     This function should be called upon program exit to allow the DB to
- *     cleanup after itself.
- */
-void cleanupdb(void)
-{
-       int i = 0;
-
-       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;
-                       }
-               }
-               free(dbconns);
-               dbconns = NULL;
-               dbenv->close(dbenv, 0);
-               dbenv = NULL;
-       }
-}
-
-/**
- *     starttrans - Start a transaction.
- *
- *     Start a transaction. Intended to be used if we're about to perform many
- *     operations on the database to help speed it all up, or if we want
- *     something to only succeed if all relevant operations are successful.
- */
-bool starttrans(void)
-{
-       int ret;
-
-       log_assert(dbenv != NULL);
-       log_assert(txn == NULL);
-
-       ret = dbenv->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;
-}
-
-/**
- *     endtrans - End a transaction.
- *
- *     Ends a transaction.
- */
-void endtrans(void)
-{
-       int ret;
-
-       log_assert(dbenv != NULL);
-       log_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;
-}
-
 /**
  *     fetch_key - Given a keyid fetch the key from storage.
  *     @keyid: The keyid to fetch.
@@ -342,7 +344,7 @@ void endtrans(void)
  *     in and then parse_keys() to parse the packets into a publickey
  *     structure.
  */
-int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
+static int db4_fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
                bool intrans)
 {
        struct openpgp_packet_list *packets = NULL;
@@ -365,7 +367,7 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
        key.data = &keyid;
 
        if (!intrans) {
-               starttrans();
+               db4_starttrans();
        }
 
        ret = keydb(keyid)->get(keydb(keyid),
@@ -391,7 +393,7 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey,
        }
 
        if (!intrans) {
-               endtrans();
+               db4_endtrans();
        }
 
        return (numkeys);
@@ -410,7 +412,8 @@ int worddb_cmp(const void *d1, const void *d2)
  *     This function searches for the supplied text and returns the keys that
  *     contain it.
  */
-int fetch_key_text(const char *search, struct openpgp_publickey **publickey)
+static int db4_fetch_key_text(const char *search,
+               struct openpgp_publickey **publickey)
 {
        DBC *cursor = NULL;
        DBT key, data;
@@ -429,7 +432,7 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey)
        wordlist = makewordlist(wordlist, searchtext);
 
        for (curword = wordlist; curword != NULL; curword = curword->next) {
-               starttrans();
+               db4_starttrans();
 
                ret = worddb->cursor(worddb,
                                txn,
@@ -463,39 +466,251 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey)
                        free(data.data);
                        data.data = NULL;
 
-                       ret = cursor->c_get(cursor,
-                                       &key,
-                                       &data,
-                                       DB_NEXT);
+                       ret = cursor->c_get(cursor,
+                                       &key,
+                                       &data,
+                                       DB_NEXT);
+               }
+               array_free(&keylist);
+               keylist = newkeylist;
+               newkeylist.keys = NULL;
+               newkeylist.count = newkeylist.size = 0;
+               if (data.data != NULL) {
+                       free(data.data);
+                       data.data = NULL;
+               }
+               ret = cursor->c_close(cursor);
+               cursor = NULL;
+               db4_endtrans();
+       }
+       llfree(wordlist, NULL);
+       wordlist = NULL;
+       
+       db4_starttrans();
+       for (i = 0; i < keylist.count; i++) {
+               numkeys += db4_fetch_key(keylist.keys[i],
+                       publickey,
+                       true);
+       }
+       array_free(&keylist);
+       free(searchtext);
+       searchtext = NULL;
+
+       db4_endtrans();
+       
+       return (numkeys);
+}
+
+/**
+ *     delete_key - Given a keyid delete the key from storage.
+ *     @keyid: The keyid to delete.
+ *     @intrans: If we're already in a transaction.
+ *
+ *     This function deletes a public key from whatever storage mechanism we
+ *     are using. Returns 0 if the key existed.
+ */
+static int db4_delete_key(uint64_t keyid, bool intrans)
+{
+       struct openpgp_publickey *publickey = NULL;
+       DBT key, data;
+       DBC *cursor = NULL;
+       uint32_t   shortkeyid = 0;
+       uint64_t  *subkeyids = NULL;
+       int ret = 0;
+       int i;
+       char **uids = NULL;
+       char *primary = NULL;
+       unsigned char worddb_data[12];
+       struct ll *wordlist = NULL;
+       struct ll *curword  = NULL;
+       bool deadlock = false;
+
+       if (!intrans) {
+               db4_starttrans();
+       }
+
+       db4_fetch_key(keyid, &publickey, true);
+
+       /*
+        * Walk through the uids removing the words from the worddb.
+        */
+       if (publickey != NULL) {
+               uids = keyuids(publickey, &primary);
+       }
+       if (uids != NULL) {
+               for (i = 0; ret == 0 && uids[i] != NULL; i++) {
+                       wordlist = makewordlist(wordlist, uids[i]);
+               }
+                               
+               ret = worddb->cursor(worddb,
+                       txn,
+                       &cursor,
+                       0);   /* flags */
+
+               for (curword = wordlist; curword != NULL && !deadlock;
+                               curword = curword->next) {
+                       memset(&key, 0, sizeof(key));
+                       memset(&data, 0, sizeof(data));
+                       key.data = curword->object;
+                       key.size = strlen(key.data);
+                       data.data = worddb_data;
+                       data.size = sizeof(worddb_data);
+
+                       /*
+                        * Our data is the key creation time followed by the
+                        * key id.
+                        */
+                       worddb_data[ 0] = publickey->publickey->data[1];
+                       worddb_data[ 1] = publickey->publickey->data[2];
+                       worddb_data[ 2] = publickey->publickey->data[3];
+                       worddb_data[ 3] = publickey->publickey->data[4];
+                       worddb_data[ 4] = (keyid >> 56) & 0xFF;
+                       worddb_data[ 5] = (keyid >> 48) & 0xFF;
+                       worddb_data[ 6] = (keyid >> 40) & 0xFF;
+                       worddb_data[ 7] = (keyid >> 32) & 0xFF;
+                       worddb_data[ 8] = (keyid >> 24) & 0xFF;
+                       worddb_data[ 9] = (keyid >> 16) & 0xFF;
+                       worddb_data[10] = (keyid >>  8) & 0xFF;
+                       worddb_data[11] = keyid & 0xFF; 
+
+                       ret = cursor->c_get(cursor,
+                               &key,
+                               &data,
+                               DB_GET_BOTH);
+
+                       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) {
+                               logthing(LOGTHING_ERROR,
+                                       "Problem deleting word: %s",
+                                       db_strerror(ret));
+                               if (ret == DB_LOCK_DEADLOCK) {
+                                       deadlock = true;
+                               }
+                       }
+               }
+               ret = cursor->c_close(cursor);
+               cursor = NULL;
+
+               /*
+                * Free our UID and word lists.
+                */
+               llfree(wordlist, NULL);
+               for (i = 0; uids[i] != NULL; i++) {
+                       free(uids[i]);
+                       uids[i] = NULL;
+               }
+               free(uids);
+               uids = NULL;
+               free_publickey(publickey);
+               publickey = NULL;
+       }
+
+       if (!deadlock) {
+               ret = id32db->cursor(id32db,
+                       txn,
+                       &cursor,
+                       0);   /* flags */
+
+               shortkeyid = keyid & 0xFFFFFFFF;
+
+               memset(&key, 0, sizeof(key));
+               memset(&data, 0, sizeof(data));
+               key.data = &shortkeyid;
+               key.size = sizeof(shortkeyid);
+               data.data = &keyid;
+               data.size = sizeof(keyid);
+
+               ret = cursor->c_get(cursor,
+                       &key,
+                       &data,
+                       DB_GET_BOTH);
+
+               if (ret == 0) {
+                       ret = cursor->c_del(cursor, 0);
+                       if (ret != 0) {
+                               logthing(LOGTHING_ERROR,
+                                       "Problem deleting short keyid: %s",
+                                       db_strerror(ret));
+                       }
+               }
+
+               if (ret != 0) {
+                       logthing(LOGTHING_ERROR,
+                               "Problem deleting short keyid: %s",
+                               db_strerror(ret));
+                       if (ret == DB_LOCK_DEADLOCK) {
+                               deadlock = true;
+                       }
+               }
+
+               subkeyids = keysubkeys(publickey);
+               i = 0;
+               while (subkeyids != NULL && subkeyids[i] != 0) {
+                       shortkeyid = subkeyids[i++] & 0xFFFFFFFF;
+
+                       memset(&key, 0, sizeof(key));
+                       memset(&data, 0, sizeof(data));
+                       key.data = &shortkeyid;
+                       key.size = sizeof(shortkeyid);
+                       data.data = &keyid;
+                       data.size = sizeof(keyid);
+
+                       ret = cursor->c_get(cursor,
+                               &key,
+                               &data,
+                               DB_GET_BOTH);
+
+                       if (ret == 0) {
+                               ret = cursor->c_del(cursor, 0);
+                               if (ret != 0) {
+                                       logthing(LOGTHING_ERROR,
+                                               "Problem deleting short"
+                                               " keyid: %s",
+                                               db_strerror(ret));
+                               }
+                       }
+
+                       if (ret != 0) {
+                               logthing(LOGTHING_ERROR,
+                                       "Problem deleting short keyid: %s",
+                                       db_strerror(ret));
+                               if (ret == DB_LOCK_DEADLOCK) {
+                                       deadlock = true;
+                               }
+                       }
                }
-               array_free(&keylist);
-               keylist = newkeylist;
-               newkeylist.keys = NULL;
-               newkeylist.count = newkeylist.size = 0;
-               if (data.data != NULL) {
-                       free(data.data);
-                       data.data = NULL;
+               if (subkeyids != NULL) {
+                       free(subkeyids);
+                       subkeyids = NULL;
                }
+
                ret = cursor->c_close(cursor);
                cursor = NULL;
-               endtrans();
        }
-       llfree(wordlist, NULL);
-       wordlist = NULL;
-       
-       starttrans();
-       for (i = 0; i < keylist.count; i++) {
-               numkeys += fetch_key(keylist.keys[i],
-                       publickey,
-                       true);
+
+       if (!deadlock) {
+               key.data = &keyid;
+               key.size = sizeof(keyid);
+
+               keydb(keyid)->del(keydb(keyid),
+                               txn,
+                               &key,
+                               0); /* flags */
        }
-       array_free(&keylist);
-       free(searchtext);
-       searchtext = NULL;
 
-       endtrans();
-       
-       return (numkeys);
+       if (!intrans) {
+               db4_endtrans();
+       }
+
+       return deadlock ? (-1) : (ret == DB_NOTFOUND);
 }
 
 /**
@@ -510,7 +725,8 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey)
  *     the file. If update is true then we delete the old key first, otherwise
  *     we trust that it doesn't exist.
  */
-int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
+static int db4_store_key(struct openpgp_publickey *publickey, bool intrans,
+               bool update)
 {
        struct     openpgp_packet_list *packets = NULL;
        struct     openpgp_packet_list *list_end = NULL;
@@ -533,7 +749,7 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
        keyid = get_keyid(publickey);
 
        if (!intrans) {
-               starttrans();
+               db4_starttrans();
        }
 
        /*
@@ -545,7 +761,7 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
         * it definitely needs updated.
         */
        if (update) {
-               deadlock = (delete_key(keyid, true) == -1);
+               deadlock = (db4_delete_key(keyid, true) == -1);
        }
 
        /*
@@ -723,224 +939,12 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update)
        }
 
        if (!intrans) {
-               endtrans();
+               db4_endtrans();
        }
 
        return deadlock ? -1 : 0 ;
 }
 
-/**
- *     delete_key - Given a keyid delete the key from storage.
- *     @keyid: The keyid to delete.
- *     @intrans: If we're already in a transaction.
- *
- *     This function deletes a public key from whatever storage mechanism we
- *     are using. Returns 0 if the key existed.
- */
-int delete_key(uint64_t keyid, bool intrans)
-{
-       struct openpgp_publickey *publickey = NULL;
-       DBT key, data;
-       DBC *cursor = NULL;
-       uint32_t   shortkeyid = 0;
-       uint64_t  *subkeyids = NULL;
-       int ret = 0;
-       int i;
-       char **uids = NULL;
-       char *primary = NULL;
-       unsigned char worddb_data[12];
-       struct ll *wordlist = NULL;
-       struct ll *curword  = NULL;
-       bool deadlock = false;
-
-       if (!intrans) {
-               starttrans();
-       }
-
-       fetch_key(keyid, &publickey, true);
-
-       /*
-        * Walk through the uids removing the words from the worddb.
-        */
-       if (publickey != NULL) {
-               uids = keyuids(publickey, &primary);
-       }
-       if (uids != NULL) {
-               for (i = 0; ret == 0 && uids[i] != NULL; i++) {
-                       wordlist = makewordlist(wordlist, uids[i]);
-               }
-                               
-               ret = worddb->cursor(worddb,
-                       txn,
-                       &cursor,
-                       0);   /* flags */
-
-               for (curword = wordlist; curword != NULL && !deadlock;
-                               curword = curword->next) {
-                       memset(&key, 0, sizeof(key));
-                       memset(&data, 0, sizeof(data));
-                       key.data = curword->object;
-                       key.size = strlen(key.data);
-                       data.data = worddb_data;
-                       data.size = sizeof(worddb_data);
-
-                       /*
-                        * Our data is the key creation time followed by the
-                        * key id.
-                        */
-                       worddb_data[ 0] = publickey->publickey->data[1];
-                       worddb_data[ 1] = publickey->publickey->data[2];
-                       worddb_data[ 2] = publickey->publickey->data[3];
-                       worddb_data[ 3] = publickey->publickey->data[4];
-                       worddb_data[ 4] = (keyid >> 56) & 0xFF;
-                       worddb_data[ 5] = (keyid >> 48) & 0xFF;
-                       worddb_data[ 6] = (keyid >> 40) & 0xFF;
-                       worddb_data[ 7] = (keyid >> 32) & 0xFF;
-                       worddb_data[ 8] = (keyid >> 24) & 0xFF;
-                       worddb_data[ 9] = (keyid >> 16) & 0xFF;
-                       worddb_data[10] = (keyid >>  8) & 0xFF;
-                       worddb_data[11] = keyid & 0xFF; 
-
-                       ret = cursor->c_get(cursor,
-                               &key,
-                               &data,
-                               DB_GET_BOTH);
-
-                       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) {
-                               logthing(LOGTHING_ERROR,
-                                       "Problem deleting word: %s",
-                                       db_strerror(ret));
-                               if (ret == DB_LOCK_DEADLOCK) {
-                                       deadlock = true;
-                               }
-                       }
-               }
-               ret = cursor->c_close(cursor);
-               cursor = NULL;
-
-               /*
-                * Free our UID and word lists.
-                */
-               llfree(wordlist, NULL);
-               for (i = 0; uids[i] != NULL; i++) {
-                       free(uids[i]);
-                       uids[i] = NULL;
-               }
-               free(uids);
-               uids = NULL;
-               free_publickey(publickey);
-               publickey = NULL;
-       }
-
-       if (!deadlock) {
-               ret = id32db->cursor(id32db,
-                       txn,
-                       &cursor,
-                       0);   /* flags */
-
-               shortkeyid = keyid & 0xFFFFFFFF;
-
-               memset(&key, 0, sizeof(key));
-               memset(&data, 0, sizeof(data));
-               key.data = &shortkeyid;
-               key.size = sizeof(shortkeyid);
-               data.data = &keyid;
-               data.size = sizeof(keyid);
-
-               ret = cursor->c_get(cursor,
-                       &key,
-                       &data,
-                       DB_GET_BOTH);
-
-               if (ret == 0) {
-                       ret = cursor->c_del(cursor, 0);
-                       if (ret != 0) {
-                               logthing(LOGTHING_ERROR,
-                                       "Problem deleting short keyid: %s",
-                                       db_strerror(ret));
-                       }
-               }
-
-               if (ret != 0) {
-                       logthing(LOGTHING_ERROR,
-                               "Problem deleting short keyid: %s",
-                               db_strerror(ret));
-                       if (ret == DB_LOCK_DEADLOCK) {
-                               deadlock = true;
-                       }
-               }
-
-               subkeyids = keysubkeys(publickey);
-               i = 0;
-               while (subkeyids != NULL && subkeyids[i] != 0) {
-                       shortkeyid = subkeyids[i++] & 0xFFFFFFFF;
-
-                       memset(&key, 0, sizeof(key));
-                       memset(&data, 0, sizeof(data));
-                       key.data = &shortkeyid;
-                       key.size = sizeof(shortkeyid);
-                       data.data = &keyid;
-                       data.size = sizeof(keyid);
-
-                       ret = cursor->c_get(cursor,
-                               &key,
-                               &data,
-                               DB_GET_BOTH);
-
-                       if (ret == 0) {
-                               ret = cursor->c_del(cursor, 0);
-                               if (ret != 0) {
-                                       logthing(LOGTHING_ERROR,
-                                               "Problem deleting short"
-                                               " keyid: %s",
-                                               db_strerror(ret));
-                               }
-                       }
-
-                       if (ret != 0) {
-                               logthing(LOGTHING_ERROR,
-                                       "Problem deleting short keyid: %s",
-                                       db_strerror(ret));
-                               if (ret == DB_LOCK_DEADLOCK) {
-                                       deadlock = true;
-                               }
-                       }
-               }
-               if (subkeyids != NULL) {
-                       free(subkeyids);
-                       subkeyids = NULL;
-               }
-
-               ret = cursor->c_close(cursor);
-               cursor = NULL;
-       }
-
-       if (!deadlock) {
-               key.data = &keyid;
-               key.size = sizeof(keyid);
-
-               keydb(keyid)->del(keydb(keyid),
-                               txn,
-                               &key,
-                               0); /* flags */
-       }
-
-       if (!intrans) {
-               endtrans();
-       }
-
-       return deadlock ? (-1) : (ret == DB_NOTFOUND);
-}
-
 /**
  *     iterate_keys - call a function once for each key in the db.
  *     @iterfunc: The function to call.
@@ -952,8 +956,8 @@ int delete_key(uint64_t keyid, bool intrans)
  *
  *     Returns the number of keys we iterated over.
  */
-int iterate_keys(void (*iterfunc)(void *ctx, struct openpgp_publickey *key),
-               void *ctx)
+static int db4_iterate_keys(void (*iterfunc)(void *ctx,
+               struct openpgp_publickey *key), void *ctx)
 {
        DBT                         dbkey, data;
        DBC                        *cursor = NULL;
@@ -1014,7 +1018,7 @@ int iterate_keys(void (*iterfunc)(void *ctx, struct openpgp_publickey *key),
  *     This function maps a 32bit key id to the full 64bit one. It returns the
  *     full keyid. If the key isn't found a keyid of 0 is returned.
  */
-uint64_t getfullkeyid(uint64_t keyid)
+static uint64_t db4_getfullkeyid(uint64_t keyid)
 {
        DBT       key, data;
        DBC      *cursor = NULL;
@@ -1063,3 +1067,20 @@ uint64_t getfullkeyid(uint64_t keyid)
 #define NEED_KEYID2UID 1
 #define NEED_UPDATEKEYS 1
 #include "keydb.c"
+
+struct dbfuncs keydb_db4_funcs = {
+       .initdb                 = db4_initdb,
+       .cleanupdb              = db4_cleanupdb,
+       .starttrans             = db4_starttrans,
+       .endtrans               = db4_endtrans,
+       .fetch_key              = db4_fetch_key,
+       .fetch_key_text         = db4_fetch_key_text,
+       .store_key              = db4_store_key,
+       .update_keys            = generic_update_keys,
+       .delete_key             = db4_delete_key,
+       .getkeysigs             = generic_getkeysigs,
+       .cached_getkeysigs      = generic_cached_getkeysigs,
+       .keyid2uid              = generic_keyid2uid,
+       .getfullkeyid           = db4_getfullkeyid,
+       .iterate_keys           = db4_iterate_keys,
+};