From: Jonathan McDowell Date: Sun, 1 Aug 2004 11:33:19 +0000 (+0000) Subject: Upgrade db3 backend to db4. X-Git-Tag: 0.3.0~23 X-Git-Url: https://the.earth.li/gitweb/?p=onak.git;a=commitdiff_plain;h=28052481c1892cd06a2626a1ecd7221c3814f0e6 Upgrade db3 backend to db4. Upgrade db3 backend to db4. Hopefully this will fix the locking issues that have been seen - certainly no issues have been seen in testing over the past week. --- diff --git a/configure.ac b/configure.ac index e8f7022..a3468aa 100644 --- a/configure.ac +++ b/configure.ac @@ -7,16 +7,36 @@ AC_PROG_CC AC_C_BIGENDIAN -AC_ARG_ENABLE(backend,AC_HELP_STRING([--enable-backend=],[Choose the backend database to use. Defaults to db3.]), [], [enable_backend="db3"]) +AC_ARG_ENABLE(backend,AC_HELP_STRING([--enable-backend=],[Choose the backend database to use. Defaults to db4.]), [], [enable_backend="db4"]) AC_MSG_CHECKING([which key database backend to use]) AC_MSG_RESULT([$enable_backend]) AC_CHECK_FILE([$srcdir/keydb_$enable_backend.c], ,AC_MSG_ERROR([non existent key database backend $enable_backend])) -if test "x$enable_backend" = "xdb3" +if test "x$enable_backend" = "xdb4" then - AC_CHECK_LIB(db3, db_env_create,, - AC_MSG_ERROR([cannot compile DB3 backend without libdb3])) + AC_CHECK_HEADER(db.h, have_db_h="yes", have_db_h="no") + AC_MSG_CHECKING(for libdb version in db.h) + printf "#include \nDB_VERSION_MAJOR DB_VERSION_MINOR\n" >conftest.c + set `eval $ac_cpp conftest.c | egrep '^ *[[0-9]] *'`; v="$1"; vv="$2" + AC_MSG_RESULT($v.$vv) + if test "$v" -ne 4; then + AC_MSG_RESULT([ * onak requires libdb version 4]) + fi + for db in "db-$v.$vv" "db$v.$vv" "db-$v" "db$v" "db"; do + AC_MSG_CHECKING(for db_create in lib$db) + oldLIBS="$LIBS" + LIBS="$LIBS -l$db" + AC_TRY_LINK([#include ], db_create(0, 0, 0), + have_libdb="yes", have_libdb="no") + AC_MSG_RESULT($have_libdb) + if test "$have_libdb" != "no"; then break; fi + LIBS="$oldLIBS" + done + if test "$have_libdb" = "no" -o "$have_db_h" = "no"; then + AC_MSG_ERROR(libdb not found.) + fi + AC_DEFINE(HAVE_LIBDB, 1, [libdb found]) else if test "x$enable_backend" = "xpg" then AC_CHECK_LIB(pq, PQsetdbLogin,, diff --git a/keydb_db3.c b/keydb_db3.c deleted file mode 100644 index 7cc3b1e..0000000 --- a/keydb_db3.c +++ /dev/null @@ -1,1023 +0,0 @@ -/* - * keydb_db3.c - Routines to store and fetch keys in a DB3 database. - * - * Jonathan McDowell - * - * Copyright 2002 Project Purple - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include "charfuncs.h" -#include "keydb.h" -#include "keyid.h" -#include "decodekey.h" -#include "keystructs.h" -#include "mem.h" -#include "log.h" -#include "onak-conf.h" -#include "parsekey.h" -#include "wordlist.h" - -/** - * dbenv - our database environment. - */ -static DB_ENV *dbenv = NULL; - -/** - * numdb - The number of database files we have. - */ -static int numdbs = 16; - -/** - * dbconn - our connections to the key database files. - */ -static DB **dbconns = NULL; - -/** - * worddb - our connection to the word database. - */ -static DB *worddb = NULL; - -/** - * id32db - our connection to the 32bit ID database. - */ -static DB *id32db = NULL; - -/** - * txn - our current transaction id. - */ -static DB_TXN *txn = NULL; - -DB *keydb(uint64_t keyid) -{ - uint64_t keytrun; - - keytrun = keyid >> 8; - - return(dbconns[keytrun % numdbs]); -} - -/** - * initdb - Initialize the key database. - * - * This function should be called before any of the other functions in - * this file are called in order to allow the DB to be initialized ready - * for access. - */ -void initdb(bool readonly) -{ - char buf[1024]; - FILE *numdb = NULL; - int ret = 0; - int i = 0; - u_int32_t flags = 0; - - snprintf(buf, sizeof(buf) - 1, "%s/num_keydb", config.db_dir); - numdb = fopen(buf, "r"); - if (numdb != NULL) { - if (fgets(buf, sizeof(buf), numdb) != NULL) { - numdbs = atoi(buf); - } - fclose(numdb); - } else if (!readonly) { - logthing(LOGTHING_ERROR, "Couldn't open num_keydb: %s", - strerror(errno)); - numdb = fopen(buf, "w"); - if (numdb != NULL) { - fprintf(numdb, "%d", numdbs); - fclose(numdb); - } else { - logthing(LOGTHING_ERROR, - "Couldn't write num_keydb: %s", - strerror(errno)); - } - } - - dbconns = malloc(sizeof (DB *) * numdbs); - if (dbconns == NULL) { - logthing(LOGTHING_CRITICAL, - "Couldn't allocate memory for dbconns"); - exit(1); - } - - ret = db_env_create(&dbenv, 0); - if (ret != 0) { - 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, - "Error opening db environment: %s (%s)", - config.db_dir, - db_strerror(ret)); - exit(1); - } - - for (i = 0; i < numdbs; i++) { - ret = db_create(&dbconns[i], dbenv, 0); - if (ret != 0) { - logthing(LOGTHING_CRITICAL, - "db_create: %s", db_strerror(ret)); - exit(1); - } - - snprintf(buf, 1023, "keydb.%d.db", i); - flags = DB_CREATE; - if (readonly) { - flags = DB_RDONLY; - } - ret = dbconns[i]->open(dbconns[i], buf, - NULL, - DB_HASH, - flags, - 0664); - if (ret != 0) { - logthing(LOGTHING_CRITICAL, - "Error opening key database: %s (%s)", - buf, - db_strerror(ret)); - exit(1); - } - } - - ret = db_create(&worddb, dbenv, 0); - if (ret != 0) { - logthing(LOGTHING_CRITICAL, "db_create: %s", db_strerror(ret)); - exit(1); - } - ret = worddb->set_flags(worddb, DB_DUP); - - ret = worddb->open(worddb, "worddb", NULL, DB_BTREE, - flags, - 0664); - if (ret != 0) { - logthing(LOGTHING_CRITICAL, - "Error opening word database: %s (%s)", - "worddb", - db_strerror(ret)); - exit(1); - } - - ret = db_create(&id32db, dbenv, 0); - if (ret != 0) { - logthing(LOGTHING_CRITICAL, "db_create: %s", db_strerror(ret)); - exit(1); - } - ret = id32db->set_flags(id32db, DB_DUP); - - ret = id32db->open(id32db, "id32db", NULL, DB_HASH, - flags, - 0664); - if (ret != 0) { - logthing(LOGTHING_CRITICAL, - "Error opening id32 database: %s (%s)", - "id32db", - db_strerror(ret)); - exit(1); - } - - 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; - - 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; - } - 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; - - 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; -} - -/** - * endtrans - End a transaction. - * - * Ends a transaction. - */ -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; -} - -/** - * fetch_key - Given a keyid fetch the key from storage. - * @keyid: The keyid to fetch. - * @publickey: A pointer to a structure to return the key in. - * @intrans: If we're already in a transaction. - * - * We use the hex representation of the keyid as the filename to fetch the - * key from. The key is stored in the file as a binary OpenPGP stream of - * packets, so we can just use read_openpgp_stream() to read the packets - * in and then parse_keys() to parse the packets into a publickey - * structure. - */ -int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, - bool intrans) -{ - struct openpgp_packet_list *packets = NULL; - DBT key, data; - int ret = 0; - int numkeys = 0; - struct buffer_ctx fetchbuf; - - if (keyid < 0x100000000LL) { - keyid = getfullkeyid(keyid); - } - - memset(&key, 0, sizeof(key)); - memset(&data, 0, sizeof(data)); - - data.size = 0; - data.data = NULL; - - key.size = sizeof(keyid); - key.data = &keyid; - - if (!intrans) { - starttrans(); - } - - ret = keydb(keyid)->get(keydb(keyid), - txn, - &key, - &data, - 0); /* flags*/ - - if (ret == 0) { - fetchbuf.buffer = data.data; - fetchbuf.offset = 0; - fetchbuf.size = data.size; - read_openpgp_stream(buffer_fetchchar, &fetchbuf, - &packets, 0); - parse_keys(packets, publickey); - free_packet_list(packets); - packets = NULL; - numkeys++; - } else if (ret != DB_NOTFOUND) { - logthing(LOGTHING_ERROR, - "Problem retrieving key: %s", - db_strerror(ret)); - } - - if (!intrans) { - endtrans(); - } - - return (numkeys); -} - -int worddb_cmp(const void *d1, const void *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. - * @publickey: A pointer to a structure to return the key in. - * - * 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) -{ - DBC *cursor = NULL; - DBT key, data; - int ret; - 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; - searchtext = strdup(search); - wordlist = makewordlist(wordlist, searchtext); - - starttrans(); - - 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; - key.size = strlen(curword->object); - data.flags = DB_DBT_MALLOC; - ret = cursor->c_get(cursor, - &key, - &data, - DB_SET); - 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 += ((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; - } - ret = cursor->c_get(cursor, - &key, - &data, - DB_NEXT); - } - 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); -} - -/** - * store_key - Takes a key and stores it. - * @publickey: A pointer to the public key to store. - * @intrans: If we're already in a transaction. - * @update: If true the key exists and should be updated. - * - * Again we just use the hex representation of the keyid as the filename - * to store the key to. We flatten the public key to a list of OpenPGP - * packets and then use write_openpgp_stream() to write the stream out to - * 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) -{ - struct openpgp_packet_list *packets = NULL; - struct openpgp_packet_list *list_end = NULL; - struct openpgp_publickey *next = NULL; - int ret = 0; - int i = 0; - struct buffer_ctx storebuf; - DBT key; - DBT data; - uint64_t keyid = 0; - uint32_t shortkeyid = 0; - uint64_t *subkeyids = NULL; - char **uids = NULL; - char *primary = NULL; - unsigned char worddb_data[12]; - struct ll *wordlist = NULL; - struct ll *curword = NULL; - bool deadlock = false; - - keyid = get_keyid(publickey); - - if (!intrans) { - starttrans(); - } - - /* - * Delete the key if we already have it. - * - * TODO: Can we optimize this perhaps? Possibly when other data is - * involved as well? I suspect this is easiest and doesn't make a lot - * of difference though - the largest chunk of data is the keydata and - * it definitely needs updated. - */ - if (update) { - deadlock = (delete_key(keyid, true) == -1); - } - - /* - * Convert the key to a flat set of binary data. - */ - 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); - - /* - * 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); - data.size = storebuf.offset; - data.data = storebuf.buffer; - - ret = keydb(keyid)->put(keydb(keyid), - 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; - } - } - - 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. - */ - if (!deadlock) { - uids = keyuids(publickey, &primary); - } - if (uids != NULL) { - for (i = 0; ret == 0 && uids[i] != NULL; i++) { - wordlist = makewordlist(wordlist, uids[i]); - } - - 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 = worddb->put(worddb, - txn, - &key, - &data, - 0); - if (ret != 0) { - logthing(LOGTHING_ERROR, - "Problem storing word: %s", - db_strerror(ret)); - if (ret == DB_LOCK_DEADLOCK) { - deadlock = true; - } - } - } - - /* - * 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; - } - - if (!intrans) { - endtrans(); - } - - /* - * Write the truncated 32 bit keyid so we can lookup the full id for - * queries. - */ - if (!deadlock) { - 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 = id32db->put(id32db, - txn, - &key, - &data, - 0); - if (ret != 0) { - logthing(LOGTHING_ERROR, - "Problem storing short keyid: %s", - db_strerror(ret)); - if (ret == DB_LOCK_DEADLOCK) { - deadlock = true; - } - } - } - - if (!deadlock) { - 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 = id32db->put(id32db, - txn, - &key, - &data, - 0); - if (ret != 0) { - logthing(LOGTHING_ERROR, - "Problem storing short keyid: %s", - db_strerror(ret)); - if (ret == DB_LOCK_DEADLOCK) { - deadlock = true; - } - } - } - if (subkeyids != NULL) { - free(subkeyids); - subkeyids = NULL; - } - } - - 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); -} - -/** - * 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; - int i = 0; - char filename[1024]; - - filename[1023] = 0; - for (i = 0; i < numdbs; i++) { - ret = dbconns[i]->cursor(dbconns[i], - NULL, - &cursor, - 0); /* flags */ - - snprintf(filename, 1023, "%s.%d.pgp", filenamebase, i); - fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0640); - if (fd == -1) { - logthing(LOGTHING_ERROR, - "Error opening keydump file (%s): %s", - filename, - strerror(errno)); - } else { - memset(&key, 0, sizeof(key)); - memset(&data, 0, sizeof(data)); - ret = cursor->c_get(cursor, &key, &data, DB_NEXT); - while (ret == 0) { - write(fd, data.data, data.size); - memset(&key, 0, sizeof(key)); - memset(&data, 0, sizeof(data)); - ret = cursor->c_get(cursor, &key, &data, - DB_NEXT); - } - if (ret != DB_NOTFOUND) { - logthing(LOGTHING_ERROR, - "Problem reading key: %s", - db_strerror(ret)); - } - close(fd); - } - - ret = cursor->c_close(cursor); - cursor = NULL; - } - - return 0; -} - -/** - * getfullkeyid - Maps a 32bit key id to a 64bit one. - * @keyid: The 32bit keyid. - * - * 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) -{ - DBT key, data; - DBC *cursor = NULL; - uint32_t shortkeyid = 0; - int ret = 0; - - if (keyid < 0x100000000LL) { - 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.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 keyid; -} - -/* - * Include the basic keydb routines. - */ -#define NEED_GETKEYSIGS 1 -#define NEED_KEYID2UID 1 -#include "keydb.c" diff --git a/keydb_db4.c b/keydb_db4.c new file mode 100644 index 0000000..04949d0 --- /dev/null +++ b/keydb_db4.c @@ -0,0 +1,1028 @@ +/* + * keydb_db4.c - Routines to store and fetch keys in a DB3 database. + * + * Jonathan McDowell + * + * Copyright 2002-2004 Project Purple + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "charfuncs.h" +#include "keydb.h" +#include "keyid.h" +#include "decodekey.h" +#include "keystructs.h" +#include "mem.h" +#include "log.h" +#include "onak-conf.h" +#include "parsekey.h" +#include "wordlist.h" + +/** + * dbenv - our database environment. + */ +static DB_ENV *dbenv = NULL; + +/** + * numdb - The number of database files we have. + */ +static int numdbs = 16; + +/** + * dbconn - our connections to the key database files. + */ +static DB **dbconns = NULL; + +/** + * worddb - our connection to the word database. + */ +static DB *worddb = NULL; + +/** + * id32db - our connection to the 32bit ID database. + */ +static DB *id32db = NULL; + +/** + * txn - our current transaction id. + */ +static DB_TXN *txn = NULL; + +DB *keydb(uint64_t keyid) +{ + uint64_t keytrun; + + keytrun = keyid >> 8; + + return(dbconns[keytrun % numdbs]); +} + +/** + * initdb - Initialize the key database. + * + * This function should be called before any of the other functions in + * this file are called in order to allow the DB to be initialized ready + * for access. + */ +void initdb(bool readonly) +{ + char buf[1024]; + FILE *numdb = NULL; + int ret = 0; + int i = 0; + u_int32_t flags = 0; + + snprintf(buf, sizeof(buf) - 1, "%s/num_keydb", config.db_dir); + numdb = fopen(buf, "r"); + if (numdb != NULL) { + if (fgets(buf, sizeof(buf), numdb) != NULL) { + numdbs = atoi(buf); + } + fclose(numdb); + } else if (!readonly) { + logthing(LOGTHING_ERROR, "Couldn't open num_keydb: %s", + strerror(errno)); + numdb = fopen(buf, "w"); + if (numdb != NULL) { + fprintf(numdb, "%d", numdbs); + fclose(numdb); + } else { + logthing(LOGTHING_ERROR, + "Couldn't write num_keydb: %s", + strerror(errno)); + } + } + + dbconns = malloc(sizeof (DB *) * numdbs); + if (dbconns == NULL) { + logthing(LOGTHING_CRITICAL, + "Couldn't allocate memory for dbconns"); + exit(1); + } + + ret = db_env_create(&dbenv, 0); + if (ret != 0) { + 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, + "Error opening db environment: %s (%s)", + config.db_dir, + db_strerror(ret)); + exit(1); + } + + 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); + } + + 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)); + exit(1); + } + } + + ret = db_create(&worddb, dbenv, 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, "db_create: %s", db_strerror(ret)); + exit(1); + } + 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); + } + + ret = db_create(&id32db, dbenv, 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, "db_create: %s", db_strerror(ret)); + exit(1); + } + ret = id32db->set_flags(id32db, DB_DUP); + + 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)); + exit(1); + } + endtrans(); + + 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; + + 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; + } + 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; + + assert(dbenv != NULL); + 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; + + 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; +} + +/** + * fetch_key - Given a keyid fetch the key from storage. + * @keyid: The keyid to fetch. + * @publickey: A pointer to a structure to return the key in. + * @intrans: If we're already in a transaction. + * + * We use the hex representation of the keyid as the filename to fetch the + * key from. The key is stored in the file as a binary OpenPGP stream of + * packets, so we can just use read_openpgp_stream() to read the packets + * in and then parse_keys() to parse the packets into a publickey + * structure. + */ +int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, + bool intrans) +{ + struct openpgp_packet_list *packets = NULL; + DBT key, data; + int ret = 0; + int numkeys = 0; + struct buffer_ctx fetchbuf; + + if (keyid < 0x100000000LL) { + keyid = getfullkeyid(keyid); + } + + memset(&key, 0, sizeof(key)); + memset(&data, 0, sizeof(data)); + + data.size = 0; + data.data = NULL; + + key.size = sizeof(keyid); + key.data = &keyid; + + if (!intrans) { + starttrans(); + } + + ret = keydb(keyid)->get(keydb(keyid), + txn, + &key, + &data, + 0); /* flags*/ + + if (ret == 0) { + fetchbuf.buffer = data.data; + fetchbuf.offset = 0; + fetchbuf.size = data.size; + read_openpgp_stream(buffer_fetchchar, &fetchbuf, + &packets, 0); + parse_keys(packets, publickey); + free_packet_list(packets); + packets = NULL; + numkeys++; + } else if (ret != DB_NOTFOUND) { + logthing(LOGTHING_ERROR, + "Problem retrieving key: %s", + db_strerror(ret)); + } + + if (!intrans) { + endtrans(); + } + + return (numkeys); +} + +int worddb_cmp(const void *d1, const void *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. + * @publickey: A pointer to a structure to return the key in. + * + * 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) +{ + DBC *cursor = NULL; + DBT key, data; + int ret; + 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; + searchtext = strdup(search); + wordlist = makewordlist(wordlist, searchtext); + + starttrans(); + + 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; + key.size = strlen(curword->object); + data.flags = DB_DBT_MALLOC; + ret = cursor->c_get(cursor, + &key, + &data, + DB_SET); + 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 += ((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; + } + ret = cursor->c_get(cursor, + &key, + &data, + DB_NEXT); + } + 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); +} + +/** + * store_key - Takes a key and stores it. + * @publickey: A pointer to the public key to store. + * @intrans: If we're already in a transaction. + * @update: If true the key exists and should be updated. + * + * Again we just use the hex representation of the keyid as the filename + * to store the key to. We flatten the public key to a list of OpenPGP + * packets and then use write_openpgp_stream() to write the stream out to + * 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) +{ + struct openpgp_packet_list *packets = NULL; + struct openpgp_packet_list *list_end = NULL; + struct openpgp_publickey *next = NULL; + int ret = 0; + int i = 0; + struct buffer_ctx storebuf; + DBT key; + DBT data; + uint64_t keyid = 0; + uint32_t shortkeyid = 0; + uint64_t *subkeyids = NULL; + char **uids = NULL; + char *primary = NULL; + unsigned char worddb_data[12]; + struct ll *wordlist = NULL; + struct ll *curword = NULL; + bool deadlock = false; + + keyid = get_keyid(publickey); + + if (!intrans) { + starttrans(); + } + + /* + * Delete the key if we already have it. + * + * TODO: Can we optimize this perhaps? Possibly when other data is + * involved as well? I suspect this is easiest and doesn't make a lot + * of difference though - the largest chunk of data is the keydata and + * it definitely needs updated. + */ + if (update) { + deadlock = (delete_key(keyid, true) == -1); + } + + /* + * Convert the key to a flat set of binary data. + */ + 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); + + /* + * 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); + data.size = storebuf.offset; + data.data = storebuf.buffer; + + ret = keydb(keyid)->put(keydb(keyid), + 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; + } + } + + 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. + */ + if (!deadlock) { + uids = keyuids(publickey, &primary); + } + if (uids != NULL) { + for (i = 0; ret == 0 && uids[i] != NULL; i++) { + wordlist = makewordlist(wordlist, uids[i]); + } + + 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 = worddb->put(worddb, + txn, + &key, + &data, + 0); + if (ret != 0) { + logthing(LOGTHING_ERROR, + "Problem storing word: %s", + db_strerror(ret)); + if (ret == DB_LOCK_DEADLOCK) { + deadlock = true; + } + } + } + + /* + * 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; + } + + if (!intrans) { + endtrans(); + } + + /* + * Write the truncated 32 bit keyid so we can lookup the full id for + * queries. + */ + if (!deadlock) { + 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 = id32db->put(id32db, + txn, + &key, + &data, + 0); + if (ret != 0) { + logthing(LOGTHING_ERROR, + "Problem storing short keyid: %s", + db_strerror(ret)); + if (ret == DB_LOCK_DEADLOCK) { + deadlock = true; + } + } + } + + if (!deadlock) { + 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 = id32db->put(id32db, + txn, + &key, + &data, + 0); + if (ret != 0) { + logthing(LOGTHING_ERROR, + "Problem storing short keyid: %s", + db_strerror(ret)); + if (ret == DB_LOCK_DEADLOCK) { + deadlock = true; + } + } + } + if (subkeyids != NULL) { + free(subkeyids); + subkeyids = NULL; + } + } + + 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); +} + +/** + * 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; + int i = 0; + char filename[1024]; + + filename[1023] = 0; + for (i = 0; i < numdbs; i++) { + ret = dbconns[i]->cursor(dbconns[i], + NULL, + &cursor, + 0); /* flags */ + + snprintf(filename, 1023, "%s.%d.pgp", filenamebase, i); + fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0640); + if (fd == -1) { + logthing(LOGTHING_ERROR, + "Error opening keydump file (%s): %s", + filename, + strerror(errno)); + } else { + memset(&key, 0, sizeof(key)); + memset(&data, 0, sizeof(data)); + ret = cursor->c_get(cursor, &key, &data, DB_NEXT); + while (ret == 0) { + write(fd, data.data, data.size); + memset(&key, 0, sizeof(key)); + memset(&data, 0, sizeof(data)); + ret = cursor->c_get(cursor, &key, &data, + DB_NEXT); + } + if (ret != DB_NOTFOUND) { + logthing(LOGTHING_ERROR, + "Problem reading key: %s", + db_strerror(ret)); + } + close(fd); + } + + ret = cursor->c_close(cursor); + cursor = NULL; + } + + return 0; +} + +/** + * getfullkeyid - Maps a 32bit key id to a 64bit one. + * @keyid: The 32bit keyid. + * + * 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) +{ + DBT key, data; + DBC *cursor = NULL; + uint32_t shortkeyid = 0; + int ret = 0; + + if (keyid < 0x100000000LL) { + 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.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 keyid; +} + +/* + * Include the basic keydb routines. + */ +#define NEED_GETKEYSIGS 1 +#define NEED_KEYID2UID 1 +#include "keydb.c"