X-Git-Url: https://git.sommitrealweird.co.uk/onak.git/blobdiff_plain/4b8483ae278577a3adc8d84da81d77019704466f..63dd4f45a5b356f7f6bdc4345c7f265ac5d2cd32:/keydb_db2.c?ds=sidebyside diff --git a/keydb_db2.c b/keydb_db2.c index 6aa47c0..affdc4b 100644 --- a/keydb_db2.c +++ b/keydb_db2.c @@ -3,7 +3,7 @@ * * Jonathan McDowell * - * Copyright 2002 Project Purple + * Copyright 2002-2004 Project Purple */ #include @@ -16,14 +16,16 @@ #include #include +#include "charfuncs.h" #include "keydb.h" #include "keyid.h" #include "keyindex.h" #include "keystructs.h" +#include "log.h" #include "mem.h" +#include "onak-conf.h" #include "parsekey.h" -#define DBDIR "/community/pgp-keyserver/db-copy" #define KEYDB_KEYID_BYTES 4 /** @@ -41,40 +43,6 @@ static DB **db2_keydbfiles = NULL; */ static DB_ENV db2_env; -/* - * Shared with CGI buffer stuff... - */ -struct db2_get_ctx { - char *buffer; - int offset; - int size; -}; - -/** - * keydb_fetchchar - Fetches a char from a buffer. - */ -int keydb_fetchchar(void *ctx, int count, unsigned char *c) -{ - struct db2_get_ctx *buf = NULL; - int i; - - buf = (struct db2_get_ctx *) ctx; - for (i = 0; i < count; i++) { - c[i] = buf->buffer[buf->offset++]; - } - - return (((buf->offset) == (buf->size)) ? 1 : 0); -} - -/** - * keydb_putchar - Puts a char to a file. - */ -static int keydb_putchar(void *fd, unsigned char c) -{ -// return !(lo_write(dbconn, *(int *) fd, &c, sizeof(c))); - return 1; -} - DB *keydb(DBT *key) { /* @@ -95,12 +63,26 @@ DB *keydb(DBT *key) * this file are called in order to allow the DB to be initialized ready * for access. */ -void initdb(void) +void initdb(bool readonly) { DB_INFO keydbinfo; int i; int ret; char keydbname[20]; + char buf[1024]; + FILE *numdb = NULL; + + 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) { + db2_numdb = atoi(buf); + } + fclose(numdb); + } else { + logthing(LOGTHING_ERROR, "Couldn't open num_keydb: %s", + strerror(errno)); + } memset(&db2_env, 0, sizeof(db2_env)); @@ -111,7 +93,8 @@ void initdb(void) */ db2_env.mp_size = 20 * 1024 * 1024; - ret = db_appinit(DBDIR, NULL, &db2_env, DB_INIT_MPOOL|DB_INIT_LOCK); + ret = db_appinit(config.db_dir, NULL, + &db2_env, DB_INIT_MPOOL|DB_INIT_LOCK); if (!ret) { db2_keydbfiles = (DB **) malloc(sizeof (DB *) * db2_numdb); memset(&keydbinfo, 0, sizeof(keydbinfo)); @@ -123,13 +106,15 @@ void initdb(void) &db2_env, &keydbinfo, &db2_keydbfiles[i]); if (ret) { - fprintf(stderr, "Error opening db file %d (errno %d)\n", + logthing(LOGTHING_CRITICAL, + "Error opening db file %d (errno %d)", i, ret); exit(1); } } } else { - fprintf(stderr, "Error initializing db (%d).\n", ret); + logthing(LOGTHING_CRITICAL, "Error initializing db (%d).", + ret); exit(1); } } @@ -154,10 +139,33 @@ void cleanupdb(void) db_appexit(&db2_env); } +/** + * 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) +{ + return true; +} + +/** + * endtrans - End a transaction. + * + * Ends a transaction. + */ +void endtrans(void) +{ + return; +} + /** * fetch_key - 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. * * We use the hex representation of the keyid as the filename to fetch the * key from. The key is stored in the file as a binary OpenPGP stream of @@ -165,13 +173,14 @@ void cleanupdb(void) * in and then parse_keys() to parse the packets into a publickey * structure. */ -int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey) +int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, + bool intrans) { struct openpgp_packet_list *packets = NULL; int ret; DBT key, data; char id[KEYDB_KEYID_BYTES]; - struct db2_get_ctx fetchbuf; + struct buffer_ctx fetchbuf; memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); @@ -186,27 +195,43 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey) ret = (*(keydb(&key)->get))(keydb(&key), NULL, &key, &data, 0); if (ret == 0) { - //do stuff with data. fetchbuf.buffer = data.data; fetchbuf.offset = 0; fetchbuf.size = data.size; - read_openpgp_stream(keydb_fetchchar, &fetchbuf, &packets); + read_openpgp_stream(buffer_fetchchar, &fetchbuf, &packets, 0); parse_keys(packets, publickey); + free_packet_list(packets); + packets = NULL; } return (!ret); } +/** + * fetch_key_text - Trys to find the keys that contain the supplied text. + * @search: The text to search for. + * @publickey: A pointer to a structure to return the key in. + * + * 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) +{ + return 0; +} + /** * 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. */ -int store_key(struct openpgp_publickey *publickey) +int store_key(struct openpgp_publickey *publickey, bool intrans, bool update) { return 0; } @@ -214,16 +239,38 @@ int store_key(struct openpgp_publickey *publickey) /** * 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) +int delete_key(uint64_t keyid, bool intrans) { return (1); } +/** + * 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. + */ +int iterate_keys(void (*iterfunc)(void *ctx, struct openpgp_publickey *key), + void *ctx) +{ + return 0; +} + /* * Include the basic keydb routines. */ +#define NEED_KEYID2UID 1 +#define NEED_GETKEYSIGS 1 +#define NEED_GETFULLKEYID 1 +#define NEED_UPDATEKEYS 1 #include "keydb.c"