X-Git-Url: https://git.sommitrealweird.co.uk/onak.git/blobdiff_plain/404bc09a23d44a088ed4970975924469947cb4d5..f9917d386685c7f641d493dbc78eb3eb41fb24bd:/keydb_db4.c?ds=inline diff --git a/keydb_db4.c b/keydb_db4.c index 1596e5b..6fbf9da 100644 --- a/keydb_db4.c +++ b/keydb_db4.c @@ -1,12 +1,11 @@ /* * keydb_db4.c - Routines to store and fetch keys in a DB4 database. * - * Jonathan McDowell - * - * Copyright 2002-2004 Project Purple + * Copyright 2002-2008 Jonathan McDowell */ #include +#include #include #include #include @@ -30,6 +29,8 @@ #include "parsekey.h" #include "wordlist.h" +#define DB4_UPGRADE_FILE "db_upgrade.lck" + /** * dbenv - our database environment. */ @@ -69,6 +70,198 @@ 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. + * + * Start a transaction. Intended to be used if we're about to perform many + * operations on the database to help speed it all up, or if we want + * something to only succeed if all relevant operations are successful. + */ +static bool db4_starttrans(void) +{ + int ret; + + log_assert(dbenv != NULL); + log_assert(txn == NULL); + + ret = dbenv->txn_begin(dbenv, + NULL, /* No parent transaction */ + &txn, + 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "Error starting transaction: %s", + db_strerror(ret)); + exit(1); + } + + return true; +} + +/** + * endtrans - End a transaction. + * + * Ends a transaction. + */ +static void db4_endtrans(void) +{ + int ret; + + log_assert(dbenv != NULL); + log_assert(txn != NULL); + + ret = txn->commit(txn, + 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "Error ending transaction: %s", + db_strerror(ret)); + exit(1); + } + txn = NULL; + + return; +} + +/** + * cleanupdb - De-initialize the key database. + * + * This function should be called upon program exit to allow the DB to + * cleanup after itself. + */ +static void db4_cleanupdb(void) +{ + int i = 0; + + if (dbenv != NULL) { + dbenv->txn_checkpoint(dbenv, 0, 0, 0); + if (id32db != NULL) { + id32db->close(id32db, 0); + id32db = NULL; + } + if (worddb != NULL) { + worddb->close(worddb, 0); + worddb = NULL; + } + for (i = 0; i < numdbs; i++) { + if (dbconns[i] != NULL) { + dbconns[i]->close(dbconns[i], 0); + dbconns[i] = NULL; + } + } + free(dbconns); + dbconns = NULL; + dbenv->close(dbenv, 0); + dbenv = NULL; + } +} + +/** + * 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)); + } + + snprintf(buf, sizeof(buf) - 1, "%s/%s", config.db_dir, + DB4_UPGRADE_FILE); + unlink(buf); + + return ret; +} + /** * initdb - Initialize the key database. * @@ -76,13 +269,30 @@ DB *keydb(uint64_t keyid) * this file are called in order to allow the DB to be initialized ready * for access. */ -void initdb(bool readonly) +static void db4_initdb(bool readonly) { char buf[1024]; FILE *numdb = NULL; int ret = 0; int i = 0; u_int32_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"); @@ -105,7 +315,7 @@ void 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"); @@ -120,12 +330,24 @@ void 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, @@ -139,16 +361,44 @@ void 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)", config.db_dir, db_strerror(ret)); + dbenv->close(dbenv, 0); + dbenv = NULL; } } if (ret == 0) { - starttrans(); + db4_starttrans(); for (i = 0; !ret && i < numdbs; i++) { ret = db_create(&dbconns[i], dbenv, 0); @@ -231,11 +481,11 @@ void initdb(bool readonly) } if (txn != NULL) { - endtrans(); + db4_endtrans(); } if (ret != 0) { - cleanupdb(); + db4_cleanupdb(); logthing(LOGTHING_CRITICAL, "Error opening database; exiting"); exit(EXIT_FAILURE); @@ -245,89 +495,52 @@ void 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. */ -void cleanupdb(void) +static uint64_t db4_getfullkeyid(uint64_t keyid) { - int i = 0; - - if (dbenv != NULL) { - dbenv->txn_checkpoint(dbenv, 0, 0, 0); - if (id32db != NULL) { - id32db->close(id32db, 0); - id32db = NULL; - } - if (worddb != NULL) { - worddb->close(worddb, 0); - worddb = NULL; - } - for (i = 0; i < numdbs; i++) { - if (dbconns[i] != NULL) { - dbconns[i]->close(dbconns[i], 0); - dbconns[i] = NULL; - } - } - free(dbconns); - dbconns = NULL; - dbenv->close(dbenv, 0); - dbenv = NULL; - } -} + DBT key, data; + DBC *cursor = NULL; + uint32_t shortkeyid = 0; + int ret = 0; -/** - * 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; + if (keyid < 0x100000000LL) { + ret = id32db->cursor(id32db, + txn, + &cursor, + 0); /* flags */ - log_assert(dbenv != NULL); - log_assert(txn == NULL); + shortkeyid = keyid & 0xFFFFFFFF; - 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); - } + memset(&key, 0, sizeof(key)); + memset(&data, 0, sizeof(data)); + key.data = &shortkeyid; + key.size = sizeof(shortkeyid); + data.flags = DB_DBT_MALLOC; - return true; -} + ret = cursor->c_get(cursor, + &key, + &data, + DB_SET); -/** - * endtrans - End a transaction. - * - * Ends a transaction. - */ -void endtrans(void) -{ - int ret; + if (ret == 0) { + keyid = *(uint64_t *) data.data; - log_assert(dbenv != NULL); - log_assert(txn != NULL); + if (data.data != NULL) { + free(data.data); + data.data = NULL; + } + } - ret = txn->commit(txn, - 0); - if (ret != 0) { - logthing(LOGTHING_CRITICAL, - "Error ending transaction: %s", - db_strerror(ret)); - exit(1); + ret = cursor->c_close(cursor); + cursor = NULL; } - txn = NULL; - - return; + + return keyid; } /** @@ -342,7 +555,7 @@ void endtrans(void) * in and then parse_keys() to parse the packets into a publickey * structure. */ -int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, +static int db4_fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, bool intrans) { struct openpgp_packet_list *packets = NULL; @@ -352,7 +565,7 @@ int 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)); @@ -365,7 +578,7 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, key.data = &keyid; if (!intrans) { - starttrans(); + db4_starttrans(); } ret = keydb(keyid)->get(keydb(keyid), @@ -391,7 +604,7 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, } if (!intrans) { - endtrans(); + db4_endtrans(); } return (numkeys); @@ -410,7 +623,8 @@ int worddb_cmp(const void *d1, const void *d2) * This function searches for the supplied text and returns the keys that * contain it. */ -int fetch_key_text(const char *search, struct openpgp_publickey **publickey) +static int db4_fetch_key_text(const char *search, + struct openpgp_publickey **publickey) { DBC *cursor = NULL; DBT key, data; @@ -423,13 +637,14 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) struct ll *curword = 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); for (curword = wordlist; curword != NULL; curword = curword->next) { - starttrans(); + db4_starttrans(); ret = worddb->cursor(worddb, txn, @@ -455,8 +670,12 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) 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); } @@ -478,14 +697,19 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) } 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; + } - starttrans(); + db4_starttrans(); for (i = 0; i < keylist.count; i++) { - numkeys += fetch_key(keylist.keys[i], + numkeys += db4_fetch_key(keylist.keys[i], publickey, true); } @@ -493,120 +717,56 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) free(searchtext); searchtext = NULL; - endtrans(); + db4_endtrans(); return (numkeys); } /** - * 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. */ -int 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; if (!intrans) { - starttrans(); + db4_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); - } + db4_fetch_key(keyid, &publickey, true); /* - * 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. + * Walk through the uids removing the words from the worddb. */ - if (!deadlock) { + 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) { @@ -633,20 +793,32 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) 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. @@ -658,13 +830,16 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) } 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)); @@ -674,22 +849,29 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) 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) { @@ -702,14 +884,24 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) 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; @@ -720,60 +912,138 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) 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(); + 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. */ -int 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; + + keyid = get_keyid(publickey); if (!intrans) { - starttrans(); + 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) { @@ -800,32 +1070,20 @@ int 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. @@ -837,16 +1095,13 @@ int 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)); @@ -856,29 +1111,22 @@ int 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) { @@ -891,24 +1139,14 @@ int 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; @@ -919,26 +1157,13 @@ int 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); - - keydb(keyid)->del(keydb(keyid), - txn, - &key, - 0); /* flags */ } if (!intrans) { - endtrans(); + db4_endtrans(); } - return deadlock ? (-1) : (ret == DB_NOTFOUND); + return deadlock ? -1 : 0 ; } /** @@ -952,8 +1177,8 @@ int delete_key(uint64_t keyid, bool intrans) * * Returns the number of keys we iterated over. */ -int iterate_keys(void (*iterfunc)(void *ctx, struct openpgp_publickey *key), - void *ctx) +static int db4_iterate_keys(void (*iterfunc)(void *ctx, + struct openpgp_publickey *key), void *ctx) { DBT dbkey, data; DBC *cursor = NULL; @@ -1007,55 +1232,6 @@ int iterate_keys(void (*iterfunc)(void *ctx, struct openpgp_publickey *key), 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. - */ -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. */ @@ -1063,3 +1239,20 @@ uint64_t getfullkeyid(uint64_t keyid) #define NEED_KEYID2UID 1 #define NEED_UPDATEKEYS 1 #include "keydb.c" + +struct dbfuncs keydb_db4_funcs = { + .initdb = db4_initdb, + .cleanupdb = db4_cleanupdb, + .starttrans = db4_starttrans, + .endtrans = db4_endtrans, + .fetch_key = db4_fetch_key, + .fetch_key_text = db4_fetch_key_text, + .store_key = db4_store_key, + .update_keys = generic_update_keys, + .delete_key = db4_delete_key, + .getkeysigs = generic_getkeysigs, + .cached_getkeysigs = generic_cached_getkeysigs, + .keyid2uid = generic_keyid2uid, + .getfullkeyid = db4_getfullkeyid, + .iterate_keys = db4_iterate_keys, +};