X-Git-Url: https://git.sommitrealweird.co.uk/onak.git/blobdiff_plain/34b03028378025ad22c8d29f70e81109cee690c2..2f1b865faa5a6fbd809caa7c70f9b4dddfa35947:/keydb_db3.c?ds=inline diff --git a/keydb_db3.c b/keydb_db3.c index 6d98d38..7ca5312 100644 --- a/keydb_db3.c +++ b/keydb_db3.c @@ -6,6 +6,7 @@ * Copyright 2002 Project Purple */ +#include #include #include #include @@ -21,12 +22,18 @@ #include "charfuncs.h" #include "keydb.h" #include "keyid.h" -#include "keyindex.h" +#include "decodekey.h" #include "keystructs.h" #include "mem.h" +#include "log.h" #include "onak-conf.h" #include "parsekey.h" +/** + * dbenv - our database environment. + */ +static DB_ENV *dbenv = NULL; + /** * dbconn - our connection to the key database. */ @@ -37,6 +44,11 @@ static DB *dbconn = NULL; */ static DB *worddb = NULL; +/** + * txn - our current transaction id. + */ +static DB_TXN *txn = NULL; + /** * makewordlist - Takes a string and splits it into a set of unique words. * @wordlist: The current word list. @@ -96,41 +108,75 @@ struct ll *makewordlist(struct ll *wordlist, char *word) */ void initdb(void) { - char buf[1024]; int ret = 0; - strcpy(buf, config.db_dir); - strcat(buf, "/keydb.db"); - - ret = db_create(&dbconn, NULL, 0); + ret = db_env_create(&dbenv, 0); if (ret != 0) { - fprintf(stderr, "db_create: %s\n", db_strerror(ret)); + logthing(LOGTHING_CRITICAL, + "db_env_create: %s", db_strerror(ret)); exit(1); } - ret = dbconn->open(dbconn, buf, NULL, DB_HASH, + /* + * Enable deadlock detection so that we don't block indefinitely on + * anything. What we really want is simple 2 state locks, but I'm not + * sure how to make the standard DB functions do that yet. + */ + ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "db_env_create: %s", db_strerror(ret)); + exit(1); + } + + ret = dbenv->open(dbenv, config.db_dir, + DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_LOCK | + DB_INIT_TXN | + DB_CREATE, + 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "Erroring opening db environment: %s (%s)", + config.db_dir, + db_strerror(ret)); + exit(1); + } + + ret = db_create(&dbconn, dbenv, 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "db_create: %s", db_strerror(ret)); + exit(1); + } + + ret = dbconn->open(dbconn, "keydb.db", + NULL, + DB_HASH, DB_CREATE, 0664); if (ret != 0) { - dbconn->err(dbconn, ret, "%s", buf); + logthing(LOGTHING_CRITICAL, + "Error opening key database: %s (%s)", + "keydb.db", + db_strerror(ret)); exit(1); } - strcpy(buf, config.db_dir); - strcat(buf, "/worddb"); - - ret = db_create(&worddb, NULL, 0); + ret = db_create(&worddb, dbenv, 0); if (ret != 0) { - fprintf(stderr, "db_create: %s\n", db_strerror(ret)); + logthing(LOGTHING_CRITICAL, "db_create: %s", db_strerror(ret)); exit(1); } ret = worddb->set_flags(worddb, DB_DUP); - ret = worddb->open(worddb, buf, NULL, DB_BTREE, + ret = worddb->open(worddb, "worddb", NULL, DB_BTREE, DB_CREATE, 0664); if (ret != 0) { - worddb->err(worddb, ret, "%s", buf); + logthing(LOGTHING_CRITICAL, + "Error opening word database: %s (%s)", + "worddb", + db_strerror(ret)); exit(1); } @@ -145,10 +191,13 @@ void initdb(void) */ void cleanupdb(void) { + txn_checkpoint(dbenv, 0, 0, 0); worddb->close(worddb, 0); worddb = NULL; dbconn->close(dbconn, 0); dbconn = NULL; + dbenv->close(dbenv, 0); + dbenv = NULL; } /** @@ -160,6 +209,22 @@ void cleanupdb(void) */ bool starttrans(void) { + int ret; + + assert(dbenv != NULL); + assert(txn == NULL); + + ret = txn_begin(dbenv, + NULL, /* No parent transaction */ + &txn, + 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "Error starting transaction: %s", + db_strerror(ret)); + exit(1); + } + return true; } @@ -170,6 +235,21 @@ bool starttrans(void) */ void endtrans(void) { + int ret; + + assert(dbenv != NULL); + assert(txn != NULL); + + ret = txn_commit(txn, + 0); + if (ret != 0) { + logthing(LOGTHING_CRITICAL, + "Error ending transaction: %s", + db_strerror(ret)); + exit(1); + } + txn = NULL; + return; } @@ -204,8 +284,12 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, key.data = &keyid; keyid &= 0xFFFFFFFF; + if (!intrans) { + starttrans(); + } + ret = dbconn->get(dbconn, - NULL, /* txn id */ + txn, &key, &data, 0); /* flags*/ @@ -221,7 +305,13 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, packets = NULL; numkeys++; } else if (ret != DB_NOTFOUND) { - dbconn->err(dbconn, ret, "Problem retrieving key"); + logthing(LOGTHING_ERROR, + "Problem retrieving key: %s", + db_strerror(ret)); + } + + if (!intrans) { + endtrans(); } return (numkeys); @@ -258,9 +348,10 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) searchtext = strdup(search); wordlist = makewordlist(wordlist, searchtext); + starttrans(); ret = worddb->cursor(worddb, - NULL, /* txn */ + txn, &cursor, 0); /* flags */ @@ -309,7 +400,8 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) llfree(wordlist, NULL); wordlist = NULL; - for (newkeylist = keylist; newkeylist != NULL; + for (newkeylist = keylist; + newkeylist != NULL && numkeys < config.maxkeys; newkeylist = newkeylist->next) { keyid = 0; @@ -321,7 +413,7 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) numkeys += fetch_key(keyid, publickey, - false); + true); } llfree(keylist, free); keylist = NULL; @@ -330,6 +422,8 @@ int fetch_key_text(const char *search, struct openpgp_publickey **publickey) ret = cursor->c_close(cursor); cursor = NULL; + + endtrans(); return (numkeys); } @@ -362,9 +456,14 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) unsigned char worddb_data[12]; struct ll *wordlist = NULL; struct ll *curword = NULL; + bool deadlock = false; keyid = get_keyid(publickey); + if (!intrans) { + starttrans(); + } + /* * Delete the key if we already have it. * @@ -374,61 +473,71 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) * it definitely needs updated. */ if (update) { - delete_key(keyid, true); + deadlock = (delete_key(keyid, true) == -1); } /* * Convert the key to a flat set of binary data. */ - 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); + 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); + 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); - keyid &= 0xFFFFFFFF; - data.size = storebuf.offset; - data.data = storebuf.buffer; + /* + * 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); + keyid &= 0xFFFFFFFF; + data.size = storebuf.offset; + data.data = storebuf.buffer; + + ret = dbconn->put(dbconn, + 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; + } + } - ret = dbconn->put(dbconn, - NULL, /* txn id */ - &key, - &data, - 0); /* flags*/ - if (ret != 0) { - dbconn->err(dbconn, ret, "Problem storing key"); + free(storebuf.buffer); + storebuf.buffer = NULL; + storebuf.size = 0; + storebuf.offset = 0; + + free_packet_list(packets); + packets = NULL; } - 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. */ - uids = keyuids(publickey, &primary); + if (!deadlock) { + uids = keyuids(publickey, &primary); + } if (uids != NULL) { for (i = 0; ret == 0 && uids[i] != NULL; i++) { wordlist = makewordlist(wordlist, uids[i]); } - for (curword = wordlist; curword != NULL; + for (curword = wordlist; curword != NULL && !deadlock; curword = curword->next) { memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); @@ -454,13 +563,17 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) worddb_data[10] = (keyid >> 8) & 0xFF; worddb_data[11] = keyid & 0xFF; ret = worddb->put(worddb, - 0, + txn, &key, &data, 0); if (ret != 0) { - worddb->err(worddb, ret, - "Problem storing key"); + logthing(LOGTHING_ERROR, + "Problem storing word: %s", + db_strerror(ret)); + if (ret == DB_LOCK_DEADLOCK) { + deadlock = true; + } } } @@ -476,7 +589,11 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) uids = NULL; } - return 0; + if (!intrans) { + endtrans(); + } + + return deadlock ? -1 : 0 ; } /** @@ -499,10 +616,15 @@ int delete_key(uint64_t keyid, bool intrans) unsigned char worddb_data[12]; struct ll *wordlist = NULL; struct ll *curword = NULL; + bool deadlock = false; keyid &= 0xFFFFFFFF; - fetch_key(keyid, &publickey, intrans); + if (!intrans) { + starttrans(); + } + + fetch_key(keyid, &publickey, true); /* * Walk through the uids removing the words from the worddb. @@ -516,11 +638,11 @@ int delete_key(uint64_t keyid, bool intrans) } ret = worddb->cursor(worddb, - NULL, /* txn */ + txn, &cursor, 0); /* flags */ - for (curword = wordlist; curword != NULL; + for (curword = wordlist; curword != NULL && !deadlock; curword = curword->next) { memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); @@ -550,13 +672,23 @@ int delete_key(uint64_t keyid, bool intrans) &key, &data, DB_GET_BOTH); + if (ret == 0) { ret = cursor->c_del(cursor, 0); + if (ret != 0) { + logthing(LOGTHING_ERROR, + "Problem deleting word: %s", + db_strerror(ret)); + } } if (ret != 0) { - worddb->err(worddb, ret, - "Problem deleting word."); + logthing(LOGTHING_ERROR, + "Problem deleting word: %s", + db_strerror(ret)); + if (ret == DB_LOCK_DEADLOCK) { + deadlock = true; + } } } ret = cursor->c_close(cursor); @@ -576,15 +708,70 @@ int delete_key(uint64_t keyid, bool intrans) publickey = NULL; } - key.data = &keyid; - key.size = sizeof(keyid); + if (!deadlock) { + key.data = &keyid; + key.size = sizeof(keyid); - dbconn->del(dbconn, - NULL, /* txn id */ - &key, - 0); /* flags */ + dbconn->del(dbconn, + txn, + &key, + 0); /* flags */ + } - return (ret == DB_NOTFOUND); + if (!intrans) { + endtrans(); + } + + return deadlock ? (-1) : (ret == DB_NOTFOUND); +} + +/** + * dumpdb - dump the key database + * @filenamebase: The base filename to use for the dump. + * + * Dumps the database into one or more files, which contain pure OpenPGP + * that can be reimported into onak or gpg. filenamebase provides a base + * file name for the dump; several files may be created, all of which will + * begin with this string and then have a unique number and a .pgp + * extension. + */ +int dumpdb(char *filenamebase) +{ + DBT key, data; + DBC *cursor = NULL; + int ret = 0; + int fd = -1; + + starttrans(); + + ret = dbconn->cursor(dbconn, + txn, + &cursor, + 0); /* flags */ + + fd = open(filenamebase, O_CREAT | O_WRONLY | O_TRUNC, 0640); + memset(&key, 0, sizeof(key)); + memset(&data, 0, sizeof(data)); + ret = cursor->c_get(cursor, &key, &data, DB_NEXT); + while (ret == 0) { + write(fd, data.data, data.size); + memset(&key, 0, sizeof(key)); + memset(&data, 0, sizeof(data)); + ret = cursor->c_get(cursor, &key, &data, DB_NEXT); + } + if (ret != DB_NOTFOUND) { + logthing(LOGTHING_ERROR, "Problem reading key: %s", + db_strerror(ret)); + } + + close(fd); + + ret = cursor->c_close(cursor); + cursor = NULL; + + endtrans(); + + return 0; } /*