Add ctags/cscope files to .gitignore + clean rule

[onak.git] / keydb_db4.c

diff --git a/keydb_db4.c b/keydb_db4.c
index 7f6404c492558501239290b53c3b29b5b29c354d..d582eaaf8334c4618c8962d0c5bcd40271468cde 100644 (file)
--- a/keydb_db4.c
+++ b/keydb_db4.c
@@ -1,12 +1,24 @@
 /*
  * keydb_db4.c - Routines to store and fetch keys in a DB4 database.
  *
 /*
  * keydb_db4.c - Routines to store and fetch keys in a DB4 database.
  *

- * Jonathan McDowell <noodles@earth.li>
+ * Copyright 2002-2008 Jonathan McDowell <noodles@earth.li>

  *
  *

- * Copyright 2002-2004 Project Purple
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

  */
 
 #include <sys/types.h>
  */
 
 #include <sys/types.h>

+#include <sys/stat.h>

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


@@ -30,6 +42,8 @@
 #include "parsekey.h"
 #include "wordlist.h"
 
 #include "parsekey.h"
 #include "wordlist.h"
 

+#define DB4_UPGRADE_FILE "db_upgrade.lck"
+

 /**
  *     dbenv - our database environment.
  */
 /**
  *     dbenv - our database environment.
  */


@@ -55,6 +69,11 @@ static DB *worddb = NULL;
  */
 static DB *id32db = NULL;
 
  */
 static DB *id32db = NULL;
 

+/**
+ *     skshashdb - our connection to the SKS hash database.
+ */
+static DB *skshashdb = NULL;
+

 /**
  *     txn - our current transaction id.
  */
 /**
  *     txn - our current transaction id.
  */


@@ -69,6 +88,28 @@ DB *keydb(uint64_t keyid)
        return(dbconns[keytrun % numdbs]);
 }
 
        return(dbconns[keytrun % numdbs]);
 }
 

+/**
+ *     db4_errfunc - Direct DB errors to logfile
+ *
+ *     Basic function to take errors from the DB library and output them to
+ *     the logfile rather than stderr.
+ */
+#if (DB_VERSION_MAJOR == 4) && (DB_VERSION_MINOR < 3)
+static void db4_errfunc(const char *errpfx, const char *errmsg)
+#else
+static void db4_errfunc(const DB_ENV *edbenv, const char *errpfx,
+               const char *errmsg)
+#endif
+{
+       if (errpfx) {
+               logthing(LOGTHING_DEBUG, "db4 error: %s:%s", errpfx, errmsg);
+       } else {
+               logthing(LOGTHING_DEBUG, "db4 error: %s", errmsg);
+       }
+
+       return;
+}
+

 /**
  *     starttrans - Start a transaction.
  *
 /**
  *     starttrans - Start a transaction.
  *


@@ -134,6 +175,10 @@ static void db4_cleanupdb(void)
 
        if (dbenv != NULL) {
                dbenv->txn_checkpoint(dbenv, 0, 0, 0);
 
        if (dbenv != NULL) {
                dbenv->txn_checkpoint(dbenv, 0, 0, 0);

+               if (skshashdb != NULL) {
+                       skshashdb->close(skshashdb, 0);
+                       skshashdb = NULL;
+               }

                if (id32db != NULL) {
                        id32db->close(id32db, 0);
                        id32db = NULL;
                if (id32db != NULL) {
                        id32db->close(id32db, 0);
                        id32db = NULL;


@@ -155,6 +200,102 @@ static void db4_cleanupdb(void)
        }
 }
 
        }
 }
 

+/**
+ *     db4_upgradedb - Upgrade a DB4 database
+ *
+ *     Called if we discover we need to upgrade our DB4 database; ie if
+ *     we're running with a newer version of db4 than the database was
+ *     created with.
+ */
+static int db4_upgradedb(int numdb)
+{
+       DB *curdb = NULL;
+       int ret;
+       int i;
+       char buf[1024];
+       int lockfile_fd;
+       struct stat statbuf;
+
+       snprintf(buf, sizeof(buf) - 1, "%s/%s", config.db_dir,
+                       DB4_UPGRADE_FILE);
+       lockfile_fd = open(buf, O_RDWR | O_CREAT | O_EXCL, 0600);
+       if (lockfile_fd < 0) {
+               if (errno == EEXIST) {
+                       while (stat(buf, &statbuf) == 0) ;
+                       return 0;
+               } else {
+                       logthing(LOGTHING_CRITICAL, "Couldn't open database "
+                               "update lock file: %s", strerror(errno));
+                       return -1;
+               }
+       }
+       snprintf(buf, sizeof(buf) - 1, "%d", getpid());
+       write(lockfile_fd, buf, strlen(buf));
+       close(lockfile_fd);
+
+       logthing(LOGTHING_NOTICE, "Upgrading DB4 database");
+       ret = db_env_create(&dbenv, 0);
+       dbenv->set_errcall(dbenv, &db4_errfunc);
+       dbenv->remove(dbenv, config.db_dir, 0);
+       dbenv = NULL;
+       for (i = 0; i < numdb; i++) {
+               ret = db_create(&curdb, NULL, 0);
+               if (ret == 0) {
+                       snprintf(buf, sizeof(buf) - 1, "%s/keydb.%d.db",
+                               config.db_dir, i);
+                       logthing(LOGTHING_DEBUG, "Upgrading %s", buf);
+                       ret = curdb->upgrade(curdb, buf, 0);
+                       curdb->close(curdb, 0);
+               } else {
+                       logthing(LOGTHING_ERROR, "Error upgrading DB %s : %s",
+                               buf,
+                               db_strerror(ret));
+               }
+       }
+
+       ret = db_create(&curdb, NULL, 0);
+       if (ret == 0) {
+               snprintf(buf, sizeof(buf) - 1, "%s/worddb", config.db_dir);
+               logthing(LOGTHING_DEBUG, "Upgrading %s", buf);
+               ret = curdb->upgrade(curdb, buf, 0);
+               curdb->close(curdb, 0);
+       } else {
+               logthing(LOGTHING_ERROR, "Error upgrading DB %s : %s",
+                       buf,
+                       db_strerror(ret));
+       }
+
+       ret = db_create(&curdb, NULL, 0);
+       if (ret == 0) {
+               snprintf(buf, sizeof(buf) - 1, "%s/id32db", config.db_dir);
+               logthing(LOGTHING_DEBUG, "Upgrading %s", buf);
+               ret = curdb->upgrade(curdb, buf, 0);
+               curdb->close(curdb, 0);
+       } else {
+               logthing(LOGTHING_ERROR, "Error upgrading DB %s : %s",
+                       buf,
+                       db_strerror(ret));
+       }
+
+       ret = db_create(&curdb, NULL, 0);
+       if (ret == 0) {
+               snprintf(buf, sizeof(buf) - 1, "%s/skshashdb", config.db_dir);
+               logthing(LOGTHING_DEBUG, "Upgrading %s", buf);
+               ret = curdb->upgrade(curdb, buf, 0);
+               curdb->close(curdb, 0);
+       } else {
+               logthing(LOGTHING_ERROR, "Error upgrading DB %s : %s",
+                       buf,
+                       db_strerror(ret));
+       }
+
+       snprintf(buf, sizeof(buf) - 1, "%s/%s", config.db_dir,
+                       DB4_UPGRADE_FILE);
+       unlink(buf);
+
+       return ret;
+}
+

 /**
  *     initdb - Initialize the key database.
  *
 /**
  *     initdb - Initialize the key database.
  *


@@ -168,7 +309,24 @@ static void db4_initdb(bool readonly)
        FILE      *numdb = NULL;
        int        ret = 0;
        int        i = 0;
        FILE      *numdb = NULL;
        int        ret = 0;
        int        i = 0;

-       u_int32_t  flags = 0;
+       uint32_t   flags = 0;
+       struct stat statbuf;
+       int        maxlocks;
+
+       snprintf(buf, sizeof(buf) - 1, "%s/%s", config.db_dir,
+                       DB4_UPGRADE_FILE);
+       ret = stat(buf, &statbuf);
+       while ((ret == 0) || (errno != ENOENT)) {
+               if (ret != 0) {
+                       logthing(LOGTHING_CRITICAL, "Couldn't stat upgrade "
+                               "lock file: %s (%d)", strerror(errno), ret);
+                       exit(1);
+               }
+               logthing(LOGTHING_DEBUG, "DB4 upgrade in progress; waiting.");
+               sleep(5);
+               ret = stat(buf, &statbuf);
+       }
+       ret = 0;

 
        snprintf(buf, sizeof(buf) - 1, "%s/num_keydb", config.db_dir);
        numdb = fopen(buf, "r");
 
        snprintf(buf, sizeof(buf) - 1, "%s/num_keydb", config.db_dir);
        numdb = fopen(buf, "r");


@@ -191,7 +349,7 @@ static void db4_initdb(bool readonly)
                }
        }
 
                }
        }
 

-       dbconns = malloc(sizeof (DB *) * numdbs);
+       dbconns = calloc(numdbs, sizeof (DB *));

        if (dbconns == NULL) {
                logthing(LOGTHING_CRITICAL,
                                "Couldn't allocate memory for dbconns");
        if (dbconns == NULL) {
                logthing(LOGTHING_CRITICAL,
                                "Couldn't allocate memory for dbconns");


@@ -206,12 +364,24 @@ static void db4_initdb(bool readonly)
                }
        }
 
                }
        }
 

+       /*
+        * Up the number of locks we're allowed at once. We base this on
+        * the maximum number of keys we're going to return.
+        */
+       maxlocks = config.maxkeys * 16;
+       if (maxlocks < 1000) {
+               maxlocks = 1000;
+       }
+       dbenv->set_lk_max_locks(dbenv, maxlocks);
+       dbenv->set_lk_max_objects(dbenv, maxlocks);
+

        /*
         * 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.
         */
        if (ret == 0) {
        /*
         * 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.
         */
        if (ret == 0) {

+               dbenv->set_errcall(dbenv, &db4_errfunc);

                ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT);
                if (ret != 0) {
                        logthing(LOGTHING_CRITICAL,
                ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT);
                if (ret != 0) {
                        logthing(LOGTHING_CRITICAL,


@@ -225,6 +395,32 @@ static void db4_initdb(bool readonly)
                                DB_INIT_TXN |
                                DB_CREATE,
                                0);
                                DB_INIT_TXN |
                                DB_CREATE,
                                0);

+#ifdef DB_VERSION_MISMATCH
+               if (ret == DB_VERSION_MISMATCH) {
+                       dbenv->close(dbenv, 0);
+                       dbenv = NULL;
+                       ret = db4_upgradedb(numdbs);
+                       if (ret == 0) {
+                               ret = db_env_create(&dbenv, 0);
+                       }
+                       if (ret == 0) {
+                               dbenv->set_errcall(dbenv, &db4_errfunc);
+                               dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT);
+                               ret = dbenv->open(dbenv, config.db_dir,
+                                       DB_INIT_LOG | DB_INIT_MPOOL |
+                                       DB_INIT_LOCK | DB_INIT_TXN |
+                                       DB_CREATE | DB_RECOVER,
+                                       0);
+
+                               if (ret == 0) {
+                                       dbenv->txn_checkpoint(dbenv,
+                                                       0,
+                                                       0,
+                                                       DB_FORCE);
+                               }
+                       }
+               }
+#endif

                if (ret != 0) {
                        logthing(LOGTHING_CRITICAL,
                                        "Error opening db environment: %s (%s)",
                if (ret != 0) {
                        logthing(LOGTHING_CRITICAL,
                                        "Error opening db environment: %s (%s)",


@@ -318,6 +514,27 @@ static void db4_initdb(bool readonly)
                }
        }
 
                }
        }
 

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

        if (txn != NULL) {
                db4_endtrans();
        }
        if (txn != NULL) {
                db4_endtrans();
        }


@@ -475,6 +692,7 @@ static int db4_fetch_key_text(const char *search,
        struct ll *curword = NULL;
        struct keyarray keylist = { NULL, 0, 0 };
        struct keyarray newkeylist = { NULL, 0, 0 };
        struct ll *curword = NULL;
        struct keyarray keylist = { NULL, 0, 0 };
        struct keyarray newkeylist = { NULL, 0, 0 };

+       int firstpass = 1;

 
        numkeys = 0;
        searchtext = strdup(search);
 
        numkeys = 0;
        searchtext = strdup(search);


@@ -507,8 +725,12 @@ static int db4_fetch_key_text(const char *search,
                                                data.data)[i];
                        }
 
                                                data.data)[i];
                        }
 

-                       if (keylist.count == 0 ||
-                                       array_find(&keylist, keyid)) {
+                       /*
+                        * Only add the keys containing this word if this is
+                        * our first pass (ie we have no existing key list),
+                        * or the key contained a previous word.
+                        */
+                       if (firstpass || array_find(&keylist, keyid)) {

                                array_add(&newkeylist, keyid);
                        }
 
                                array_add(&newkeylist, keyid);
                        }
 


@@ -530,10 +752,15 @@ static int db4_fetch_key_text(const char *search,
                }
                ret = cursor->c_close(cursor);
                cursor = NULL;
                }
                ret = cursor->c_close(cursor);
                cursor = NULL;

+               firstpass = 0;

                db4_endtrans();
        }
        llfree(wordlist, NULL);
        wordlist = NULL;
                db4_endtrans();
        }
        llfree(wordlist, NULL);
        wordlist = NULL;

+
+       if (keylist.count > config.maxkeys) {
+               keylist.count = config.maxkeys;
+       }

        
        db4_starttrans();
        for (i = 0; i < keylist.count; i++) {
        
        db4_starttrans();
        for (i = 0; i < keylist.count; i++) {


@@ -550,6 +777,45 @@ static int db4_fetch_key_text(const char *search,
        return (numkeys);
 }
 
        return (numkeys);
 }
 

+static int db4_fetch_key_skshash(const struct skshash *hash,
+               struct openpgp_publickey **publickey)
+{
+       DBT       key, data;
+       DBC      *cursor = NULL;
+       uint64_t  keyid = 0;
+       int       ret = 0;
+
+       ret = skshashdb->cursor(skshashdb,
+                       txn,
+                       &cursor,
+                       0);   /* flags */
+
+       memset(&key, 0, sizeof(key));
+       memset(&data, 0, sizeof(data));
+       key.data = (void *) hash->hash;
+       key.size = sizeof(hash->hash);
+       data.flags = DB_DBT_MALLOC;
+
+       ret = cursor->c_get(cursor,
+               &key,
+               &data,
+               DB_SET);
+
+       if (ret == 0) {
+               keyid = *(uint64_t *) data.data;
+
+               if (data.data != NULL) {
+                       free(data.data);
+                       data.data = NULL;
+               }
+       }
+
+       ret = cursor->c_close(cursor);
+       cursor = NULL;
+
+       return db4_fetch_key(keyid, publickey, false);
+}
+

 /**
  *     delete_key - Given a keyid delete the key from storage.
  *     @keyid: The keyid to delete.
 /**
  *     delete_key - Given a keyid delete the key from storage.
  *     @keyid: The keyid to delete.


@@ -573,6 +839,7 @@ static int db4_delete_key(uint64_t keyid, bool intrans)
        struct ll *wordlist = NULL;
        struct ll *curword  = NULL;
        bool deadlock = false;
        struct ll *wordlist = NULL;
        struct ll *curword  = NULL;
        bool deadlock = false;

+       struct skshash hash;

 
        if (!intrans) {
                db4_starttrans();
 
        if (!intrans) {
                db4_starttrans();


@@ -620,7 +887,7 @@ static int db4_delete_key(uint64_t keyid, bool intrans)
                        worddb_data[ 8] = (keyid >> 24) & 0xFF;
                        worddb_data[ 9] = (keyid >> 16) & 0xFF;
                        worddb_data[10] = (keyid >>  8) & 0xFF;
                        worddb_data[ 8] = (keyid >> 24) & 0xFF;
                        worddb_data[ 9] = (keyid >> 16) & 0xFF;
                        worddb_data[10] = (keyid >>  8) & 0xFF;

-                       worddb_data[11] = keyid & 0xFF; 
+                       worddb_data[11] = keyid & 0xFF;

 
                        ret = cursor->c_get(cursor,
                                &key,
 
                        ret = cursor->c_get(cursor,
                                &key,


@@ -629,17 +896,14 @@ static int db4_delete_key(uint64_t keyid, bool intrans)
 
                        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) {
                                logthing(LOGTHING_ERROR,
                        }
 
                        if (ret != 0) {
                                logthing(LOGTHING_ERROR,

-                                       "Problem deleting word: %s",
-                                       db_strerror(ret));
+                                       "Problem deleting word: %s "
+                                       "(0x%016" PRIX64 ")",
+                                       db_strerror(ret),
+                                       keyid);

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


@@ -648,6 +912,42 @@ static int db4_delete_key(uint64_t keyid, bool intrans)
                ret = cursor->c_close(cursor);
                cursor = NULL;
 
                ret = cursor->c_close(cursor);
                cursor = NULL;
 

+               ret = skshashdb->cursor(skshashdb,
+                       txn,
+                       &cursor,
+                       0);   /* flags */
+               get_skshash(publickey, &hash);
+
+               memset(&key, 0, sizeof(key));
+               memset(&data, 0, sizeof(data));
+               key.data = hash.hash;
+               key.size = sizeof(hash.hash);
+               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 skshash: %s "
+                               "(0x%016" PRIX64 ")",
+                               db_strerror(ret),
+                               keyid);
+                       if (ret == DB_LOCK_DEADLOCK) {
+                               deadlock = true;
+                       }
+               }
+
+               ret = cursor->c_close(cursor);
+               cursor = NULL;
+

                /*
                 * Free our UID and word lists.
                 */
                /*
                 * Free our UID and word lists.
                 */


@@ -684,17 +984,14 @@ static int db4_delete_key(uint64_t keyid, bool intrans)
 
                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 short keyid: %s",
-                                       db_strerror(ret));
-                       }

                }
 
                if (ret != 0) {
                        logthing(LOGTHING_ERROR,
                }
 
                if (ret != 0) {
                        logthing(LOGTHING_ERROR,

-                               "Problem deleting short keyid: %s",
-                               db_strerror(ret));
+                               "Problem deleting short keyid: %s "
+                               "(0x%016" PRIX64 ")",
+                               db_strerror(ret),
+                               keyid);

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


@@ -719,18 +1016,14 @@ static int db4_delete_key(uint64_t keyid, bool intrans)
 
                        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 short"
-                                               " keyid: %s",
-                                               db_strerror(ret));
-                               }

                        }
 
                        if (ret != 0) {
                                logthing(LOGTHING_ERROR,
                        }
 
                        if (ret != 0) {
                                logthing(LOGTHING_ERROR,

-                                       "Problem deleting short keyid: %s",
-                                       db_strerror(ret));
+                                       "Problem deleting short keyid: %s "
+                                       "(0x%016" PRIX64 ")",
+                                       db_strerror(ret),
+                                       keyid);

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


@@ -740,9 +1033,9 @@ static int db4_delete_key(uint64_t keyid, bool intrans)
                        free(subkeyids);
                        subkeyids = NULL;
                }
                        free(subkeyids);
                        subkeyids = NULL;
                }

-

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

+

        }
 
        if (!deadlock) {
        }
 
        if (!deadlock) {


@@ -794,8 +1087,9 @@ static int db4_store_key(struct openpgp_publickey *publickey, bool intrans,
        struct ll *wordlist = NULL;
        struct ll *curword  = NULL;
        bool       deadlock = false;
        struct ll *wordlist = NULL;
        struct ll *curword  = NULL;
        bool       deadlock = false;

+       struct skshash hash;

 
 

-       keyid = get_keyid(publickey);
+       get_keyid(publickey, &keyid);

 
        if (!intrans) {
                db4_starttrans();
 
        if (!intrans) {
                db4_starttrans();


@@ -987,6 +1281,30 @@ static int db4_store_key(struct openpgp_publickey *publickey, bool intrans,
                }
        }
 
                }
        }
 

+       if (!deadlock) {
+               get_skshash(publickey, &hash);
+               memset(&key, 0, sizeof(key));
+               memset(&data, 0, sizeof(data));
+               key.data = hash.hash;
+               key.size = sizeof(hash.hash);
+               data.data = &keyid;
+               data.size = sizeof(keyid);
+
+               ret = skshashdb->put(skshashdb,
+                       txn,
+                       &key,
+                       &data,
+                       0);
+               if (ret != 0) {
+                       logthing(LOGTHING_ERROR,
+                               "Problem storing SKS hash: %s",
+                               db_strerror(ret));
+                       if (ret == DB_LOCK_DEADLOCK) {
+                               deadlock = true;
+                       }
+               }
+       }
+

        if (!intrans) {
                db4_endtrans();
        }
        if (!intrans) {
                db4_endtrans();
        }


@@ -1075,6 +1393,7 @@ struct dbfuncs keydb_db4_funcs = {
        .endtrans               = db4_endtrans,
        .fetch_key              = db4_fetch_key,
        .fetch_key_text         = db4_fetch_key_text,
        .endtrans               = db4_endtrans,
        .fetch_key              = db4_fetch_key,
        .fetch_key_text         = db4_fetch_key_text,

+       .fetch_key_skshash      = db4_fetch_key_skshash,

        .store_key              = db4_store_key,
        .update_keys            = generic_update_keys,
        .delete_key             = db4_delete_key,
        .store_key              = db4_store_key,
        .update_keys            = generic_update_keys,
        .delete_key             = db4_delete_key,