X-Git-Url: https://git.sommitrealweird.co.uk/onak.git/blobdiff_plain/87fbdd69b1885c6588ec924e37b734f2c3c5ed35..8e402a211ee3b1225481a6ff8efaa7c3d3a65272:/keydb_db3.c?ds=inline diff --git a/keydb_db3.c b/keydb_db3.c index 4d1bcca..0f4239b 100644 --- a/keydb_db3.c +++ b/keydb_db3.c @@ -25,6 +25,7 @@ #include "decodekey.h" #include "keystructs.h" #include "mem.h" +#include "log.h" #include "onak-conf.h" #include "parsekey.h" @@ -107,25 +108,26 @@ struct ll *makewordlist(struct ll *wordlist, char *word) */ void initdb(void) { - char buf[1024]; int ret = 0; ret = db_env_create(&dbenv, 0); if (ret != 0) { - fprintf(stderr, "db_env_create: %s\n", db_strerror(ret)); + logthing(LOGTHING_CRITICAL, + "db_env_create: %s", db_strerror(ret)); exit(1); } /* - * This is a bit of a kludge. Either we run a separate process for - * deadlock detection or we do this every time we run. What we really - * want to do is specify that our locks are exclusive locks when we - * start to do an update. + * 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 = lock_detect(dbenv, - 0, /* flags */ - DB_LOCK_RANDOM, - NULL); /* If non null int* for number broken */ + 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 | @@ -133,13 +135,17 @@ void initdb(void) DB_CREATE, 0); if (ret != 0) { - dbenv->err(dbenv, ret, "%s", config.db_dir); + 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) { - fprintf(stderr, "db_create: %s\n", db_strerror(ret)); + logthing(LOGTHING_CRITICAL, + "db_create: %s", db_strerror(ret)); exit(1); } @@ -149,13 +155,16 @@ void initdb(void) DB_CREATE, 0664); if (ret != 0) { - dbconn->err(dbconn, ret, "keydb.db"); + logthing(LOGTHING_CRITICAL, + "Error opening key database: %s (%s)", + "keydb.db", + db_strerror(ret)); exit(1); } 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); @@ -164,7 +173,10 @@ void initdb(void) DB_CREATE, 0664); if (ret != 0) { - worddb->err(worddb, ret, "worddb"); + logthing(LOGTHING_CRITICAL, + "Error opening word database: %s (%s)", + "worddb", + db_strerror(ret)); exit(1); } @@ -179,6 +191,7 @@ void initdb(void) */ void cleanupdb(void) { + txn_checkpoint(dbenv, 0, 0, 0); worddb->close(worddb, 0); worddb = NULL; dbconn->close(dbconn, 0); @@ -198,6 +211,7 @@ bool starttrans(void) { int ret; + assert(dbenv != NULL); assert(txn == NULL); ret = txn_begin(dbenv, @@ -205,7 +219,9 @@ bool starttrans(void) &txn, 0); if (ret != 0) { - dbenv->err(dbenv, ret, "starttrans():"); + logthing(LOGTHING_CRITICAL, + "Error starting transaction: %s", + db_strerror(ret)); exit(1); } @@ -221,12 +237,15 @@ void endtrans(void) { int ret; + assert(dbenv != NULL); assert(txn != NULL); ret = txn_commit(txn, 0); if (ret != 0) { - dbenv->err(dbenv, ret, "endtrans():"); + logthing(LOGTHING_CRITICAL, + "Error ending transaction: %s", + db_strerror(ret)); exit(1); } txn = NULL; @@ -286,7 +305,9 @@ 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) { @@ -488,7 +509,9 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) &data, 0); /* flags*/ if (ret != 0) { - dbconn->err(dbconn, ret, "Problem storing key"); + logthing(LOGTHING_ERROR, + "Problem storing key: %s", + db_strerror(ret)); if (ret == DB_LOCK_DEADLOCK) { deadlock = true; } @@ -545,8 +568,9 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) &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; } @@ -652,14 +676,16 @@ int delete_key(uint64_t keyid, bool intrans) if (ret == 0) { ret = cursor->c_del(cursor, 0); if (ret != 0) { - worddb->err(worddb, ret, - "Problem deleting word."); + 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; } @@ -699,6 +725,52 @@ int delete_key(uint64_t keyid, bool intrans) 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); + } + logthing(LOGTHING_ERROR, "Problem reading key: %s", db_strerror(ret)); + + close(fd); + + ret = cursor->c_close(cursor); + cursor = NULL; + + endtrans(); + + return 0; +} + /* * Include the basic keydb routines. */