X-Git-Url: http://the.earth.li/gitweb/?a=blobdiff_plain;f=keydb_db4.c;h=9d5dd9009fcf85f2e4e27e04983e598260b11b5c;hb=8e0907be1d73011075a99a0c029c56664e12843e;hp=0d7b46b935de0dd422b7e4cea340aada5b726be1;hpb=01ee2eab14a664ed2d72228f6f9bae6841b47726;p=onak.git diff --git a/keydb_db4.c b/keydb_db4.c index 0d7b46b..9d5dd90 100644 --- a/keydb_db4.c +++ b/keydb_db4.c @@ -1,12 +1,24 @@ /* - * keydb_db4.c - Routines to store and fetch keys in a DB3 database. + * keydb_db4.c - Routines to store and fetch keys in a DB4 database. * - * Jonathan McDowell + * Copyright 2002-2008 Jonathan McDowell * - * 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 +#include #include #include #include @@ -19,6 +31,7 @@ #include #include "charfuncs.h" +#include "keyarray.h" #include "keydb.h" #include "keyid.h" #include "decodekey.h" @@ -29,222 +42,50 @@ #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; +#define DB4_UPGRADE_FILE "db_upgrade.lck" -/** - * txn - our current transaction id. - */ -static DB_TXN *txn = NULL; +struct onak_db4_dbctx { + DB_ENV *dbenv; /* The database environment context */ + int numdbs; /* Number of data databases in use */ + DB **dbconns; /* Connections to the key data databases */ + DB *worddb; /* Connection to the word lookup database */ + DB *id32db; /* Connection to the 32 bit ID lookup database */ + DB *skshashdb; /* Connection to the SKS hash database */ + DB *subkeydb; /* Connection to the subkey ID lookup database */ + DB_TXN *txn; /* Our current transaction ID */ +}; -DB *keydb(uint64_t keyid) +DB *keydb(struct onak_db4_dbctx *privctx, uint64_t keyid) { uint64_t keytrun; keytrun = keyid >> 8; - return(dbconns[keytrun % numdbs]); + return(privctx->dbconns[keytrun % privctx->numdbs]); } /** - * initdb - Initialize the key database. + * db4_errfunc - Direct DB errors to logfile * - * 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. + * Basic function to take errors from the DB library and output them to + * the logfile rather than stderr. */ -void initdb(bool readonly) +#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 { - 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); + if (errpfx) { + logthing(LOGTHING_DEBUG, "db4 error: %s:%s", errpfx, errmsg); + } else { + logthing(LOGTHING_DEBUG, "db4 error: %s", errmsg); } - 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; - - if (dbenv != NULL) { - dbenv->txn_checkpoint(dbenv, 0, 0, 0); - if (id32db != NULL) { - id32db->close(id32db, 0); - id32db = NULL; - } - if (worddb != NULL) { - worddb->close(worddb, 0); - worddb = NULL; - } - for (i = 0; i < numdbs; i++) { - if (dbconns[i] != NULL) { - dbconns[i]->close(dbconns[i], 0); - dbconns[i] = NULL; - } - } - dbenv->close(dbenv, 0); - dbenv = NULL; - } -} - /** * starttrans - Start a transaction. * @@ -252,16 +93,17 @@ void cleanupdb(void) * 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) +static bool db4_starttrans(struct onak_dbctx *dbctx) { + struct onak_db4_dbctx *privctx = (struct onak_db4_dbctx *) dbctx->priv; int ret; - log_assert(dbenv != NULL); - log_assert(txn == NULL); + log_assert(privctx->dbenv != NULL); + log_assert(privctx->txn == NULL); - ret = dbenv->txn_begin(dbenv, + ret = privctx->dbenv->txn_begin(privctx->dbenv, NULL, /* No parent transaction */ - &txn, + &privctx->txn, 0); if (ret != 0) { logthing(LOGTHING_CRITICAL, @@ -278,14 +120,15 @@ bool starttrans(void) * * Ends a transaction. */ -void endtrans(void) +static void db4_endtrans(struct onak_dbctx *dbctx) { + struct onak_db4_dbctx *privctx = (struct onak_db4_dbctx *) dbctx->priv; int ret; - log_assert(dbenv != NULL); - log_assert(txn != NULL); + log_assert(privctx->dbenv != NULL); + log_assert(privctx->txn != NULL); - ret = txn->commit(txn, + ret = privctx->txn->commit(privctx->txn, 0); if (ret != 0) { logthing(LOGTHING_CRITICAL, @@ -293,13 +136,171 @@ void endtrans(void) db_strerror(ret)); exit(1); } - txn = NULL; + privctx->txn = NULL; return; } /** - * fetch_key - Given a keyid fetch the key from storage. + * 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(struct onak_db4_dbctx *privctx) +{ + 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(&privctx->dbenv, 0); + privctx->dbenv->set_errcall(privctx->dbenv, &db4_errfunc); + privctx->dbenv->remove(privctx->dbenv, config.db_dir, 0); + privctx->dbenv = NULL; + for (i = 0; i < privctx->numdbs; 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)); + } + + ret = db_create(&curdb, NULL, 0); + if (ret == 0) { + snprintf(buf, sizeof(buf) - 1, "%s/subkeydb", 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; +} + +/** + * 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. + */ +static uint64_t db4_getfullkeyid(struct onak_dbctx *dbctx, uint64_t keyid) +{ + struct onak_db4_dbctx *privctx = (struct onak_db4_dbctx *) dbctx->priv; + DBT key, data; + DBC *cursor = NULL; + uint32_t shortkeyid = 0; + int ret = 0; + + if (keyid < 0x100000000LL) { + ret = privctx->id32db->cursor(privctx->id32db, + privctx->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; +} + +/** + * fetch_key_id - 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. @@ -310,9 +311,11 @@ 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_id(struct onak_dbctx *dbctx, uint64_t keyid, + struct openpgp_publickey **publickey, bool intrans) { + struct onak_db4_dbctx *privctx = (struct onak_db4_dbctx *) dbctx->priv; struct openpgp_packet_list *packets = NULL; DBT key, data; int ret = 0; @@ -320,7 +323,7 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, struct buffer_ctx fetchbuf; if (keyid < 0x100000000LL) { - keyid = getfullkeyid(keyid); + keyid = db4_getfullkeyid(dbctx, keyid); } memset(&key, 0, sizeof(key)); @@ -333,15 +336,49 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, key.data = &keyid; if (!intrans) { - starttrans(); + db4_starttrans(dbctx); } - ret = keydb(keyid)->get(keydb(keyid), - txn, + ret = keydb(privctx, keyid)->get(keydb(privctx, keyid), + privctx->txn, + &key, + &data, + 0); /* flags*/ + + if (ret == DB_NOTFOUND) { + /* If we didn't find the key ID see if it's a subkey ID */ + memset(&key, 0, sizeof(key)); + memset(&data, 0, sizeof(data)); + data.size = 0; + data.data = NULL; + key.size = sizeof(keyid); + key.data = &keyid; + + ret = privctx->subkeydb->get(privctx->subkeydb, + privctx->txn, &key, &data, 0); /* flags*/ - + + if (ret == 0) { + /* We got a subkey match; retrieve the actual key */ + keyid = *(uint64_t *) data.data; + + memset(&key, 0, sizeof(key)); + memset(&data, 0, sizeof(data)); + data.size = 0; + data.data = NULL; + key.size = sizeof(keyid); + key.data = &keyid; + + ret = keydb(privctx, keyid)->get(keydb(privctx, keyid), + privctx->txn, + &key, + &data, + 0); /* flags*/ + } + } + if (ret == 0) { fetchbuf.buffer = data.data; fetchbuf.offset = 0; @@ -359,7 +396,7 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, } if (!intrans) { - endtrans(); + db4_endtrans(dbctx); } return (numkeys); @@ -378,8 +415,10 @@ 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(struct onak_dbctx *dbctx, const char *search, + struct openpgp_publickey **publickey) { + struct onak_db4_dbctx *privctx = (struct onak_db4_dbctx *) dbctx->priv; DBC *cursor = NULL; DBT key, data; int ret; @@ -389,21 +428,22 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) char *searchtext = NULL; struct ll *wordlist = NULL; struct ll *curword = NULL; - struct ll *keylist = NULL; - struct ll *newkeylist = NULL; + struct keyarray keylist = { NULL, 0, 0 }; + struct keyarray newkeylist = { NULL, 0, 0 }; + int firstpass = 1; numkeys = 0; searchtext = strdup(search); wordlist = makewordlist(wordlist, searchtext); - starttrans(); + for (curword = wordlist; curword != NULL; curword = curword->next) { + db4_starttrans(dbctx); - ret = worddb->cursor(worddb, - txn, - &cursor, - 0); /* flags */ + ret = privctx->worddb->cursor(privctx->worddb, + privctx->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; @@ -423,73 +463,373 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) 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; + /* + * 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); } + + free(data.data); + data.data = NULL; + ret = cursor->c_get(cursor, &key, &data, DB_NEXT); } - llfree(keylist, free); + array_free(&keylist); keylist = newkeylist; - newkeylist = NULL; + 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; + firstpass = 0; + db4_endtrans(dbctx); } 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]; - } + if (keylist.count > config.maxkeys) { + keylist.count = config.maxkeys; + } - numkeys += fetch_key(keyid, - publickey, - true); + db4_starttrans(dbctx); + for (i = 0; i < keylist.count; i++) { + numkeys += db4_fetch_key_id(dbctx, keylist.keys[i], + publickey, + true); } - llfree(keylist, free); - keylist = NULL; + array_free(&keylist); free(searchtext); searchtext = NULL; - ret = cursor->c_close(cursor); - cursor = NULL; + db4_endtrans(dbctx); - 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. - * +static int db4_fetch_key_skshash(struct onak_dbctx *dbctx, + const struct skshash *hash, + struct openpgp_publickey **publickey) +{ + struct onak_db4_dbctx *privctx = (struct onak_db4_dbctx *) dbctx->priv; + DBT key, data; + DBC *cursor = NULL; + uint64_t keyid = 0; + int ret = 0; + + ret = privctx->skshashdb->cursor(privctx->skshashdb, + privctx->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_id(dbctx, keyid, publickey, false); +} + +/** + * 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(struct onak_dbctx *dbctx, + uint64_t keyid, bool intrans) +{ + struct onak_db4_dbctx *privctx = (struct onak_db4_dbctx *) dbctx->priv; + 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; + struct skshash hash; + + if (!intrans) { + db4_starttrans(dbctx); + } + + db4_fetch_key_id(dbctx, 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 = privctx->worddb->cursor(privctx->worddb, + privctx->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 " + "(0x%016" PRIX64 ")", + db_strerror(ret), + keyid); + if (ret == DB_LOCK_DEADLOCK) { + deadlock = true; + } + } + } + ret = cursor->c_close(cursor); + cursor = NULL; + + ret = privctx->skshashdb->cursor(privctx->skshashdb, + privctx->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. + */ + 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 = privctx->id32db->cursor(privctx->id32db, + privctx->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 " + "(0x%016" PRIX64 ")", + db_strerror(ret), + keyid); + if (ret == DB_LOCK_DEADLOCK) { + deadlock = true; + } + } + + subkeyids = keysubkeys(publickey); + i = 0; + while (subkeyids != NULL && subkeyids[i] != 0) { + memset(&key, 0, sizeof(key)); + key.data = &subkeyids[i]; + key.size = sizeof(subkeyids[i]); + privctx->subkeydb->del(privctx->subkeydb, + privctx->txn, &key, 0); + if (ret != 0) { + logthing(LOGTHING_ERROR, + "Problem deleting subkey id: %s " + "(0x%016" PRIX64 ")", + db_strerror(ret), + keyid); + if (ret == DB_LOCK_DEADLOCK) { + deadlock = true; + } + } + + 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 " + "(0x%016" PRIX64 ")", + db_strerror(ret), + keyid); + 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(privctx, keyid)->del(keydb(privctx, keyid), + privctx->txn, + &key, + 0); /* flags */ + } + + if (!intrans) { + db4_endtrans(dbctx); + } + + return deadlock ? (-1) : (ret == DB_NOTFOUND); +} + +/** + * 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) +static int db4_store_key(struct onak_dbctx *dbctx, + struct openpgp_publickey *publickey, bool intrans, + bool update) { + struct onak_db4_dbctx *privctx = (struct onak_db4_dbctx *) dbctx->priv; struct openpgp_packet_list *packets = NULL; struct openpgp_packet_list *list_end = NULL; struct openpgp_publickey *next = NULL; @@ -507,11 +847,15 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) struct ll *wordlist = NULL; struct ll *curword = NULL; bool deadlock = false; + struct skshash hash; - keyid = get_keyid(publickey); + if (get_keyid(publickey, &keyid) != ONAK_E_OK) { + logthing(LOGTHING_ERROR, "Couldn't find key ID for key."); + return 0; + } if (!intrans) { - starttrans(); + db4_starttrans(dbctx); } /* @@ -523,7 +867,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(dbctx, keyid, true) == -1); } /* @@ -535,10 +879,10 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) flatten_publickey(publickey, &packets, &list_end); publickey->next = next; - storebuf.offset = 0; + storebuf.offset = 0; storebuf.size = 8192; storebuf.buffer = malloc(8192); - + write_openpgp_stream(buffer_putchar, &storebuf, packets); /* @@ -552,8 +896,8 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) data.size = storebuf.offset; data.data = storebuf.buffer; - ret = keydb(keyid)->put(keydb(keyid), - txn, + ret = keydb(privctx, keyid)->put(keydb(privctx, keyid), + privctx->txn, &key, &data, 0); /* flags*/ @@ -569,8 +913,8 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) free(storebuf.buffer); storebuf.buffer = NULL; storebuf.size = 0; - storebuf.offset = 0; - + storebuf.offset = 0; + free_packet_list(packets); packets = NULL; } @@ -610,9 +954,9 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) 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, + worddb_data[11] = keyid & 0xFF; + ret = privctx->worddb->put(privctx->worddb, + privctx->txn, &key, &data, 0); @@ -638,10 +982,6 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) uids = NULL; } - if (!intrans) { - endtrans(); - } - /* * Write the truncated 32 bit keyid so we can lookup the full id for * queries. @@ -656,8 +996,8 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) data.data = &keyid; data.size = sizeof(keyid); - ret = id32db->put(id32db, - txn, + ret = privctx->id32db->put(privctx->id32db, + privctx->txn, &key, &data, 0); @@ -675,361 +1015,523 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) subkeyids = keysubkeys(publickey); i = 0; while (subkeyids != NULL && subkeyids[i] != 0) { - shortkeyid = subkeyids[i++] & 0xFFFFFFFF; - + /* Store the subkey ID -> main key ID mapping */ memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); - key.data = &shortkeyid; - key.size = sizeof(shortkeyid); + key.data = &subkeyids[i]; + key.size = sizeof(subkeyids[i]); data.data = &keyid; data.size = sizeof(keyid); - ret = id32db->put(id32db, - txn, + ret = privctx->subkeydb->put(privctx->subkeydb, + privctx->txn, &key, &data, 0); if (ret != 0) { logthing(LOGTHING_ERROR, - "Problem storing short keyid: %s", + "Problem storing subkey 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 */ + /* Store the short subkey ID -> main key ID mapping */ + shortkeyid = subkeyids[i++] & 0xFFFFFFFF; - 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; + key.data = &shortkeyid; + key.size = sizeof(shortkeyid); + data.data = &keyid; + data.size = sizeof(keyid); - ret = cursor->c_get(cursor, + ret = privctx->id32db->put(privctx->id32db, + privctx->txn, &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)); - } - } - + 0); if (ret != 0) { logthing(LOGTHING_ERROR, - "Problem deleting word: %s", + "Problem storing short keyid: %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; + if (subkeyids != NULL) { + free(subkeyids); + subkeyids = NULL; } - free(uids); - uids = NULL; - free_publickey(publickey); - publickey = NULL; } if (!deadlock) { - ret = id32db->cursor(id32db, - txn, - &cursor, - 0); /* flags */ - - shortkeyid = keyid & 0xFFFFFFFF; - + get_skshash(publickey, &hash); memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); - key.data = &shortkeyid; - key.size = sizeof(shortkeyid); + key.data = hash.hash; + key.size = sizeof(hash.hash); data.data = &keyid; data.size = sizeof(keyid); - ret = cursor->c_get(cursor, + ret = privctx->skshashdb->put(privctx->skshashdb, + privctx->txn, &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)); - } - } - + 0); if (ret != 0) { logthing(LOGTHING_ERROR, - "Problem deleting short keyid: %s", + "Problem storing SKS hash: %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; + if (!intrans) { + db4_endtrans(dbctx); + } - memset(&key, 0, sizeof(key)); - memset(&data, 0, sizeof(data)); - key.data = &shortkeyid; - key.size = sizeof(shortkeyid); - data.data = &keyid; - data.size = sizeof(keyid); + return deadlock ? -1 : 0 ; +} - ret = cursor->c_get(cursor, - &key, - &data, - DB_GET_BOTH); +/** + * iterate_keys - call a function once for each key in the db. + * @iterfunc: The function to call. + * @ctx: A context pointer + * + * Calls iterfunc once for each key in the database. ctx is passed + * unaltered to iterfunc. This function is intended to aid database dumps + * and statistic calculations. + * + * Returns the number of keys we iterated over. + */ +static int db4_iterate_keys(struct onak_dbctx *dbctx, + void (*iterfunc)(void *ctx, struct openpgp_publickey *key), + void *ctx) +{ + struct onak_db4_dbctx *privctx = (struct onak_db4_dbctx *) dbctx->priv; + DBT dbkey, data; + DBC *cursor = NULL; + int ret = 0; + int i = 0; + int numkeys = 0; + struct buffer_ctx fetchbuf; + struct openpgp_packet_list *packets = NULL; + struct openpgp_publickey *key = NULL; - if (ret == 0) { - ret = cursor->c_del(cursor, 0); - if (ret != 0) { - logthing(LOGTHING_ERROR, - "Problem deleting short" - " keyid: %s", - db_strerror(ret)); - } - } + for (i = 0; i < privctx->numdbs; i++) { + ret = privctx->dbconns[i]->cursor(privctx->dbconns[i], + NULL, + &cursor, + 0); /* flags */ - if (ret != 0) { - logthing(LOGTHING_ERROR, - "Problem deleting short keyid: %s", - db_strerror(ret)); - if (ret == DB_LOCK_DEADLOCK) { - deadlock = true; - } - } + memset(&dbkey, 0, sizeof(dbkey)); + memset(&data, 0, sizeof(data)); + ret = cursor->c_get(cursor, &dbkey, &data, DB_NEXT); + while (ret == 0) { + fetchbuf.buffer = data.data; + fetchbuf.offset = 0; + fetchbuf.size = data.size; + read_openpgp_stream(buffer_fetchchar, &fetchbuf, + &packets, 0); + parse_keys(packets, &key); + + iterfunc(ctx, key); + + free_publickey(key); + key = NULL; + free_packet_list(packets); + packets = NULL; + + memset(&dbkey, 0, sizeof(dbkey)); + memset(&data, 0, sizeof(data)); + ret = cursor->c_get(cursor, &dbkey, &data, + DB_NEXT); + numkeys++; } - if (subkeyids != NULL) { - free(subkeyids); - subkeyids = NULL; + if (ret != DB_NOTFOUND) { + logthing(LOGTHING_ERROR, + "Problem reading key: %s", + db_strerror(ret)); } ret = cursor->c_close(cursor); cursor = NULL; } - if (!deadlock) { - key.data = &keyid; - key.size = sizeof(keyid); + return numkeys; +} - keydb(keyid)->del(keydb(keyid), - txn, - &key, - 0); /* flags */ - } +/* + * Include the basic keydb routines. + */ +#define NEED_GETKEYSIGS 1 +#define NEED_KEYID2UID 1 +#define NEED_UPDATEKEYS 1 +#define NEED_GET_FP 1 +#include "keydb.c" - if (!intrans) { - endtrans(); +/** + * 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(struct onak_dbctx *dbctx) +{ + struct onak_db4_dbctx *privctx = (struct onak_db4_dbctx *) dbctx->priv; + int i = 0; + + if (privctx->dbenv != NULL) { + privctx->dbenv->txn_checkpoint(privctx->dbenv, 0, 0, 0); + if (privctx->subkeydb != NULL) { + privctx->subkeydb->close(privctx->subkeydb, 0); + privctx->subkeydb = NULL; + } + if (privctx->skshashdb != NULL) { + privctx->skshashdb->close(privctx->skshashdb, 0); + privctx->skshashdb = NULL; + } + if (privctx->id32db != NULL) { + privctx->id32db->close(privctx->id32db, 0); + privctx->id32db = NULL; + } + if (privctx->worddb != NULL) { + privctx->worddb->close(privctx->worddb, 0); + privctx->worddb = NULL; + } + for (i = 0; i < privctx->numdbs; i++) { + if (privctx->dbconns[i] != NULL) { + privctx->dbconns[i]->close(privctx->dbconns[i], + 0); + privctx->dbconns[i] = NULL; + } + } + free(privctx->dbconns); + privctx->dbconns = NULL; + privctx->dbenv->close(privctx->dbenv, 0); + privctx->dbenv = NULL; } - return deadlock ? (-1) : (ret == DB_NOTFOUND); + free(privctx); + dbctx->priv = NULL; + free(dbctx); } /** - * dumpdb - dump the key database - * @filenamebase: The base filename to use for the dump. + * initdb - Initialize the key database. * - * 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. + * 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. */ -int dumpdb(char *filenamebase) +struct onak_dbctx *keydb_db4_init(bool readonly) { - 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 */ + char buf[1024]; + FILE *numdb = NULL; + int ret = 0; + int i = 0; + uint32_t flags = 0; + struct stat statbuf; + int maxlocks; + struct onak_dbctx *dbctx; + struct onak_db4_dbctx *privctx; + + dbctx = malloc(sizeof(*dbctx)); + if (dbctx == NULL) { + return NULL; + } + dbctx->priv = privctx = calloc(1, sizeof(*privctx)); + if (privctx == NULL) { + free(dbctx); + return NULL; + } - 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, + /* Default to 16 key data DBs */ + privctx->numdbs = 16; + + 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"); + if (numdb != NULL) { + if (fgets(buf, sizeof(buf), numdb) != NULL) { + privctx->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", privctx->numdbs); + fclose(numdb); } 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); + logthing(LOGTHING_ERROR, + "Couldn't write num_keydb: %s", + strerror(errno)); + } + } + + privctx->dbconns = calloc(privctx->numdbs, sizeof (DB *)); + if (privctx->dbconns == NULL) { + logthing(LOGTHING_CRITICAL, + "Couldn't allocate memory for dbconns"); + ret = 1; + } + + if (ret == 0) { + ret = db_env_create(&privctx->dbenv, 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "db_env_create: %s", db_strerror(ret)); + } + } + + /* + * 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; + } + privctx->dbenv->set_lk_max_locks(privctx->dbenv, maxlocks); + privctx->dbenv->set_lk_max_objects(privctx->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) { + privctx->dbenv->set_errcall(privctx->dbenv, &db4_errfunc); + ret = privctx->dbenv->set_lk_detect(privctx->dbenv, DB_LOCK_DEFAULT); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "db_env_create: %s", db_strerror(ret)); + } + } + + if (ret == 0) { + ret = privctx->dbenv->open(privctx->dbenv, config.db_dir, + DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_LOCK | + DB_INIT_TXN | + DB_CREATE, + 0); +#ifdef DB_VERSION_MISMATCH + if (ret == DB_VERSION_MISMATCH) { + privctx->dbenv->close(privctx->dbenv, 0); + privctx->dbenv = NULL; + ret = db4_upgradedb(privctx); + if (ret == 0) { + ret = db_env_create(&privctx->dbenv, 0); } - if (ret != DB_NOTFOUND) { - logthing(LOGTHING_ERROR, - "Problem reading key: %s", + if (ret == 0) { + privctx->dbenv->set_errcall(privctx->dbenv, + &db4_errfunc); + privctx->dbenv->set_lk_detect(privctx->dbenv, + DB_LOCK_DEFAULT); + ret = privctx->dbenv->open(privctx->dbenv, + config.db_dir, + DB_INIT_LOG | DB_INIT_MPOOL | + DB_INIT_LOCK | DB_INIT_TXN | + DB_CREATE | DB_RECOVER, + 0); + + if (ret == 0) { + privctx->dbenv->txn_checkpoint( + privctx->dbenv, + 0, + 0, + DB_FORCE); + } + } + } +#endif + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "Error opening db environment: %s (%s)", + config.db_dir, db_strerror(ret)); + privctx->dbenv->close(privctx->dbenv, 0); + privctx->dbenv = NULL; + } + } + + if (ret == 0) { + db4_starttrans(dbctx); + + for (i = 0; !ret && i < privctx->numdbs; i++) { + ret = db_create(&privctx->dbconns[i], + privctx->dbenv, 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "db_create: %s", db_strerror(ret)); + } + + if (ret == 0) { + snprintf(buf, 1023, "keydb.%d.db", i); + flags = DB_CREATE; + if (readonly) { + flags = DB_RDONLY; + } + ret = privctx->dbconns[i]->open( + privctx->dbconns[i], + privctx->txn, + buf, + "keydb", + DB_HASH, + flags, + 0664); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "Error opening key database:" + " %s (%s)", + buf, + db_strerror(ret)); + } } - close(fd); } + } - ret = cursor->c_close(cursor); - cursor = NULL; + if (ret == 0) { + ret = db_create(&privctx->worddb, privctx->dbenv, 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, "db_create: %s", + db_strerror(ret)); + } } - - 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 (ret == 0) { + ret = privctx->worddb->set_flags(privctx->worddb, DB_DUP); + } - if (keyid < 0x100000000LL) { - ret = id32db->cursor(id32db, - txn, - &cursor, - 0); /* flags */ + if (ret == 0) { + ret = privctx->worddb->open(privctx->worddb, privctx->txn, + "worddb", "worddb", DB_BTREE, + flags, + 0664); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "Error opening word database: %s (%s)", + "worddb", + db_strerror(ret)); + } + } - shortkeyid = keyid & 0xFFFFFFFF; + if (ret == 0) { + ret = db_create(&privctx->id32db, privctx->dbenv, 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, "db_create: %s", + db_strerror(ret)); + } + } - memset(&key, 0, sizeof(key)); - memset(&data, 0, sizeof(data)); - key.data = &shortkeyid; - key.size = sizeof(shortkeyid); - data.flags = DB_DBT_MALLOC; + if (ret == 0) { + ret = privctx->id32db->set_flags(privctx->id32db, DB_DUP); + } - ret = cursor->c_get(cursor, - &key, - &data, - DB_SET); + if (ret == 0) { + ret = privctx->id32db->open(privctx->id32db, privctx->txn, + "id32db", "id32db", DB_HASH, + flags, + 0664); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "Error opening id32 database: %s (%s)", + "id32db", + db_strerror(ret)); + } + } - if (ret == 0) { - keyid = *(uint64_t *) data.data; + if (ret == 0) { + ret = db_create(&privctx->skshashdb, privctx->dbenv, 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, "db_create: %s", + db_strerror(ret)); + } + } - if (data.data != NULL) { - free(data.data); - data.data = NULL; - } + if (ret == 0) { + ret = privctx->skshashdb->open(privctx->skshashdb, privctx->txn, + "skshashdb", + "skshashdb", DB_HASH, + flags, + 0664); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "Error opening skshash database: %s (%s)", + "skshashdb", + db_strerror(ret)); } + } - ret = cursor->c_close(cursor); - cursor = NULL; + if (ret == 0) { + ret = db_create(&privctx->subkeydb, privctx->dbenv, 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, "db_create: %s", + db_strerror(ret)); + } } - - return keyid; -} -/* - * Include the basic keydb routines. - */ -#define NEED_GETKEYSIGS 1 -#define NEED_KEYID2UID 1 -#include "keydb.c" + if (ret == 0) { + ret = privctx->subkeydb->open(privctx->subkeydb, privctx->txn, + "subkeydb", "subkeydb", + DB_HASH, + flags, + 0664); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "Error opening subkey database: %s (%s)", + "subkeydb", + db_strerror(ret)); + } + } + + if (privctx->txn != NULL) { + db4_endtrans(dbctx); + } + + if (ret != 0) { + db4_cleanupdb(dbctx); + logthing(LOGTHING_CRITICAL, + "Error opening database; exiting"); + exit(EXIT_FAILURE); + } + + dbctx->cleanupdb = db4_cleanupdb; + dbctx->starttrans = db4_starttrans; + dbctx->endtrans = db4_endtrans; + dbctx->fetch_key_id = db4_fetch_key_id; + dbctx->fetch_key_fp = generic_fetch_key_fp; + dbctx->fetch_key_text = db4_fetch_key_text; + dbctx->fetch_key_skshash = db4_fetch_key_skshash; + dbctx->store_key = db4_store_key; + dbctx->update_keys = generic_update_keys; + dbctx->delete_key = db4_delete_key; + dbctx->getkeysigs = generic_getkeysigs; + dbctx->cached_getkeysigs = generic_cached_getkeysigs; + dbctx->keyid2uid = generic_keyid2uid; + dbctx->getfullkeyid = db4_getfullkeyid; + dbctx->iterate_keys = db4_iterate_keys; + + return dbctx; +}