X-Git-Url: https://git.sommitrealweird.co.uk/onak.git/blobdiff_plain/5b3f77c7fbafb036d20a1577ed74f475e94ed821..4860ab5af538fd20c7e92e01b883dbbc556863a5:/keydb_db4.c?ds=sidebyside diff --git a/keydb_db4.c b/keydb_db4.c index 2f6033a..638be28 100644 --- 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. * - * 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 @@ -30,6 +42,8 @@ #include "parsekey.h" #include "wordlist.h" +#define DB4_UPGRADE_FILE "db_upgrade.lck" + /** * dbenv - our database environment. */ @@ -55,6 +69,11 @@ static DB *worddb = NULL; */ static DB *id32db = NULL; +/** + * skshashdb - our connection to the SKS hash database. + */ +static DB *skshashdb = NULL; + /** * txn - our current transaction id. */ @@ -69,6 +88,28 @@ DB *keydb(uint64_t keyid) 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. * @@ -122,6 +163,139 @@ static void db4_endtrans(void) return; } +/** + * cleanupdb - De-initialize the key database. + * + * This function should be called upon program exit to allow the DB to + * cleanup after itself. + */ +static void db4_cleanupdb(void) +{ + int i = 0; + + if (dbenv != NULL) { + dbenv->txn_checkpoint(dbenv, 0, 0, 0); + if (skshashdb != NULL) { + skshashdb->close(skshashdb, 0); + skshashdb = NULL; + } + if (id32db != NULL) { + id32db->close(id32db, 0); + id32db = NULL; + } + if (worddb != NULL) { + worddb->close(worddb, 0); + worddb = NULL; + } + for (i = 0; i < numdbs; i++) { + if (dbconns[i] != NULL) { + dbconns[i]->close(dbconns[i], 0); + dbconns[i] = NULL; + } + } + free(dbconns); + dbconns = NULL; + dbenv->close(dbenv, 0); + dbenv = NULL; + } +} + +/** + * 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. * @@ -135,7 +309,24 @@ static void db4_initdb(bool readonly) 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"); @@ -158,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"); @@ -173,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) { + dbenv->set_errcall(dbenv, &db4_errfunc); ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT); if (ret != 0) { logthing(LOGTHING_CRITICAL, @@ -192,6 +395,32 @@ static void db4_initdb(bool readonly) 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)", @@ -285,12 +514,33 @@ 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) { - endtrans(); + db4_endtrans(); } if (ret != 0) { - cleanupdb(); + db4_cleanupdb(); logthing(LOGTHING_CRITICAL, "Error opening database; exiting"); exit(EXIT_FAILURE); @@ -300,36 +550,52 @@ static void db4_initdb(bool readonly) } /** - * cleanupdb - De-initialize the key database. + * getfullkeyid - Maps a 32bit key id to a 64bit one. + * @keyid: The 32bit keyid. * - * This function should be called upon program exit to allow the DB to - * cleanup after itself. + * 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 void db4_cleanupdb(void) +static uint64_t db4_getfullkeyid(uint64_t keyid) { - int i = 0; + DBT key, data; + DBC *cursor = NULL; + uint32_t shortkeyid = 0; + int ret = 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; + 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; } } - free(dbconns); - dbconns = NULL; - dbenv->close(dbenv, 0); - dbenv = NULL; + + ret = cursor->c_close(cursor); + cursor = NULL; } + + return keyid; } /** @@ -354,7 +620,7 @@ static int db4_fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, struct buffer_ctx fetchbuf; if (keyid < 0x100000000LL) { - keyid = getfullkeyid(keyid); + keyid = db4_getfullkeyid(keyid); } memset(&key, 0, sizeof(key)); @@ -393,7 +659,7 @@ static int db4_fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, } if (!intrans) { - endtrans(); + db4_endtrans(); } return (numkeys); @@ -426,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 }; + int firstpass = 1; numkeys = 0; searchtext = strdup(search); @@ -458,8 +725,12 @@ static int db4_fetch_key_text(const char *search, 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); } @@ -481,14 +752,19 @@ static int db4_fetch_key_text(const char *search, } ret = cursor->c_close(cursor); cursor = NULL; - endtrans(); + firstpass = 0; + 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++) { - numkeys += fetch_key(keylist.keys[i], + numkeys += db4_fetch_key(keylist.keys[i], publickey, true); } @@ -496,121 +772,96 @@ static int db4_fetch_key_text(const char *search, free(searchtext); searchtext = NULL; - endtrans(); + db4_endtrans(); 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); +} + /** - * store_key - Takes a key and stores it. - * @publickey: A pointer to the public key to store. + * delete_key - Given a keyid delete the key from storage. + * @keyid: The keyid to delete. * @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. + * This function deletes a public key from whatever storage mechanism we + * are using. Returns 0 if the key existed. */ -static int db4_store_key(struct openpgp_publickey *publickey, bool intrans, - bool update) +static int db4_delete_key(uint64_t keyid, bool intrans) { - 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; + struct openpgp_publickey *publickey = NULL; + DBT key, data; + DBC *cursor = NULL; uint32_t shortkeyid = 0; uint64_t *subkeyids = NULL; - char **uids = NULL; - char *primary = 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; - - keyid = get_keyid(publickey); + bool deadlock = false; + struct skshash hash; if (!intrans) { db4_starttrans(); } + db4_fetch_key(keyid, &publickey, true); + /* - * 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. + * Walk through the uids removing the words from the worddb. */ - if (update) { - deadlock = (delete_key(keyid, true) == -1); + if (publickey != NULL) { + uids = keyuids(publickey, &primary); } - - /* - * 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]); - } + 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) { @@ -637,20 +888,32 @@ static int db4_store_key(struct openpgp_publickey *publickey, bool intrans, worddb_data[ 9] = (keyid >> 16) & 0xFF; worddb_data[10] = (keyid >> 8) & 0xFF; worddb_data[11] = keyid & 0xFF; - ret = worddb->put(worddb, - txn, + + ret = cursor->c_get(cursor, &key, &data, - 0); + 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 storing word: %s", + "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. @@ -662,13 +925,16 @@ static int db4_store_key(struct openpgp_publickey *publickey, bool intrans, } free(uids); uids = NULL; + free_publickey(publickey); + publickey = NULL; } - /* - * Write the truncated 32 bit keyid so we can lookup the full id for - * queries. - */ if (!deadlock) { + ret = id32db->cursor(id32db, + txn, + &cursor, + 0); /* flags */ + shortkeyid = keyid & 0xFFFFFFFF; memset(&key, 0, sizeof(key)); @@ -678,22 +944,29 @@ static int db4_store_key(struct openpgp_publickey *publickey, bool intrans, data.data = &keyid; data.size = sizeof(keyid); - ret = id32db->put(id32db, - txn, + ret = cursor->c_get(cursor, &key, &data, - 0); + 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 storing short keyid: %s", + "Problem deleting 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) { @@ -706,14 +979,24 @@ static int db4_store_key(struct openpgp_publickey *publickey, bool intrans, data.data = &keyid; data.size = sizeof(keyid); - ret = id32db->put(id32db, - txn, + ret = cursor->c_get(cursor, &key, &data, - 0); + 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 storing short keyid: %s", + "Problem deleting short keyid: %s", db_strerror(ret)); if (ret == DB_LOCK_DEADLOCK) { deadlock = true; @@ -724,60 +1007,171 @@ static int db4_store_key(struct openpgp_publickey *publickey, bool intrans, free(subkeyids); subkeyids = NULL; } + ret = cursor->c_close(cursor); + cursor = NULL; + + } + + 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 = 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", + db_strerror(ret)); + if (ret == DB_LOCK_DEADLOCK) { + deadlock = true; + } + } + + 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(); + db4_endtrans(); } - return deadlock ? -1 : 0 ; + return deadlock ? (-1) : (ret == DB_NOTFOUND); } /** - * delete_key - Given a keyid delete the key from storage. - * @keyid: The keyid to delete. + * 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. * - * This function deletes a public key from whatever storage mechanism we - * are using. Returns 0 if the key existed. + * 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. */ -static int db4_delete_key(uint64_t keyid, bool intrans) +static int db4_store_key(struct openpgp_publickey *publickey, bool intrans, + bool update) { - struct openpgp_publickey *publickey = NULL; - DBT key, data; - DBC *cursor = NULL; + 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; - int ret = 0; - int i; - char **uids = NULL; - char *primary = NULL; + char **uids = NULL; + char *primary = NULL; unsigned char worddb_data[12]; struct ll *wordlist = NULL; struct ll *curword = NULL; - bool deadlock = false; + bool deadlock = false; + struct skshash hash; + + keyid = get_keyid(publickey); if (!intrans) { db4_starttrans(); } - fetch_key(keyid, &publickey, true); + /* + * 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 = (db4_delete_key(keyid, true) == -1); + } /* - * Walk through the uids removing the words from the worddb. + * Convert the key to a flat set of binary data. */ - if (publickey != NULL) { + 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]); } - - ret = worddb->cursor(worddb, - txn, - &cursor, - 0); /* flags */ for (curword = wordlist; curword != NULL && !deadlock; curword = curword->next) { @@ -804,32 +1198,20 @@ static int db4_delete_key(uint64_t keyid, bool intrans) worddb_data[ 9] = (keyid >> 16) & 0xFF; worddb_data[10] = (keyid >> 8) & 0xFF; worddb_data[11] = keyid & 0xFF; - - ret = cursor->c_get(cursor, + ret = worddb->put(worddb, + 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 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. @@ -841,16 +1223,13 @@ static int db4_delete_key(uint64_t keyid, bool intrans) } free(uids); uids = NULL; - free_publickey(publickey); - publickey = NULL; } + /* + * Write the truncated 32 bit keyid so we can lookup the full id for + * queries. + */ if (!deadlock) { - ret = id32db->cursor(id32db, - txn, - &cursor, - 0); /* flags */ - shortkeyid = keyid & 0xFFFFFFFF; memset(&key, 0, sizeof(key)); @@ -860,29 +1239,22 @@ static int db4_delete_key(uint64_t keyid, bool intrans) data.data = &keyid; data.size = sizeof(keyid); - ret = cursor->c_get(cursor, + ret = id32db->put(id32db, + 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 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) { @@ -895,24 +1267,14 @@ static int db4_delete_key(uint64_t keyid, bool intrans) data.data = &keyid; data.size = sizeof(keyid); - ret = cursor->c_get(cursor, + ret = id32db->put(id32db, + 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 short keyid: %s", db_strerror(ret)); if (ret == DB_LOCK_DEADLOCK) { deadlock = true; @@ -923,26 +1285,37 @@ static int db4_delete_key(uint64_t keyid, bool intrans) free(subkeyids); subkeyids = NULL; } - - ret = cursor->c_close(cursor); - cursor = NULL; } if (!deadlock) { - key.data = &keyid; - key.size = sizeof(keyid); + 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); - keydb(keyid)->del(keydb(keyid), - txn, - &key, - 0); /* flags */ + 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) { - endtrans(); + db4_endtrans(); } - return deadlock ? (-1) : (ret == DB_NOTFOUND); + return deadlock ? -1 : 0 ; } /** @@ -1011,55 +1384,6 @@ static int db4_iterate_keys(void (*iterfunc)(void *ctx, return numkeys; } -/** - * 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(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. */ @@ -1067,3 +1391,21 @@ static uint64_t db4_getfullkeyid(uint64_t keyid) #define NEED_KEYID2UID 1 #define NEED_UPDATEKEYS 1 #include "keydb.c" + +struct dbfuncs keydb_db4_funcs = { + .initdb = db4_initdb, + .cleanupdb = db4_cleanupdb, + .starttrans = db4_starttrans, + .endtrans = db4_endtrans, + .fetch_key = db4_fetch_key, + .fetch_key_text = db4_fetch_key_text, + .fetch_key_skshash = db4_fetch_key_skshash, + .store_key = db4_store_key, + .update_keys = generic_update_keys, + .delete_key = db4_delete_key, + .getkeysigs = generic_getkeysigs, + .cached_getkeysigs = generic_cached_getkeysigs, + .keyid2uid = generic_keyid2uid, + .getfullkeyid = db4_getfullkeyid, + .iterate_keys = db4_iterate_keys, +};