X-Git-Url: https://git.sommitrealweird.co.uk/onak.git/blobdiff_plain/a57a146ebc3f15f1ba2dfe8ecb9b59702fb8f799..refs/heads/switch-to-debhelper:/keydb_fs.c diff --git a/keydb_fs.c b/keydb_fs.c index 73d9758..eacf1c6 100644 --- a/keydb_fs.c +++ b/keydb_fs.c @@ -1,9 +1,20 @@ /* - * keydb.h - Routines to store and fetch keys. + * keydb_fs.c - Routines to store and fetch keys in a filesystem hierarchy. * - * Daniel Silverstone + * Copyright 2004 Daniel Silverstone * - * Copyright 2004 Daniel Silverstone and 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 @@ -30,6 +41,11 @@ #include "log.h" #include "wordlist.h" +/* Hack: We should really dynamically allocate our path buffers */ +#ifndef PATH_MAX +#define PATH_MAX 1024 +#endif + static int keydb_lockfile_fd = -1; static bool keydb_lockfile_readonly; @@ -54,62 +70,66 @@ static uint32_t calchash(uint8_t * ptr) } -void keypath(char *buffer, uint64_t _keyid) +static void keypath(char *buffer, size_t length, uint64_t _keyid) { uint64_t keyid = _keyid << 32; - snprintf(buffer, PATH_MAX, "%s/key/%02X/%02X/%08X/%016llX", + snprintf(buffer, length, "%s/key/%02X/%02X/%08X/%016" PRIX64, config.db_dir, (uint8_t) ((keyid >> 56) & 0xFF), (uint8_t) ((keyid >> 48) & 0xFF), (uint32_t) (keyid >> 32), _keyid); } -void keydir(char *buffer, uint64_t _keyid) +static void keydir(char *buffer, size_t length, uint64_t _keyid) { uint64_t keyid = _keyid << 32; - snprintf(buffer, PATH_MAX, "%s/key/%02X/%02X/%08X", config.db_dir, + snprintf(buffer, length, "%s/key/%02X/%02X/%08X", config.db_dir, (uint8_t) ((keyid >> 56) & 0xFF), (uint8_t) ((keyid >> 48) & 0xFF), (uint32_t) (keyid >> 32)); } -void prove_path_to(uint64_t keyid, char *what) +static void prove_path_to(uint64_t keyid, char *what) { - static char buffer[1024]; - snprintf(buffer, PATH_MAX, "%s/%s", config.db_dir, what); + static char buffer[PATH_MAX]; + snprintf(buffer, sizeof(buffer), "%s/%s", config.db_dir, what); mkdir(buffer, 0777); - snprintf(buffer, PATH_MAX, "%s/%s/%02X", config.db_dir, what, + snprintf(buffer, sizeof(buffer), "%s/%s/%02X", config.db_dir, what, (uint8_t) ((keyid >> 24) & 0xFF)); mkdir(buffer, 0777); - snprintf(buffer, PATH_MAX, "%s/%s/%02X/%02X", config.db_dir, what, + snprintf(buffer, sizeof(buffer), "%s/%s/%02X/%02X", config.db_dir, + what, (uint8_t) ((keyid >> 24) & 0xFF), (uint8_t) ((keyid >> 16) & 0xFF)); mkdir(buffer, 0777); - snprintf(buffer, PATH_MAX, "%s/%s/%02X/%02X/%08X", config.db_dir, what, + snprintf(buffer, sizeof(buffer), "%s/%s/%02X/%02X/%08X", config.db_dir, + what, (uint8_t) ((keyid >> 24) & 0xFF), (uint8_t) ((keyid >> 16) & 0xFF), (uint32_t) (keyid)); mkdir(buffer, 0777); } -void wordpath(char *buffer, char *word, uint32_t hash, uint64_t keyid) +static void wordpath(char *buffer, size_t length, char *word, uint32_t hash, + uint64_t keyid) { - snprintf(buffer, PATH_MAX, "%s/words/%02X/%02X/%08X/%s/%016llX", + snprintf(buffer, length, "%s/words/%02X/%02X/%08X/%s/%016" PRIX64, config.db_dir, (uint8_t) ((hash >> 24) & 0xFF), (uint8_t) ((hash >> 16) & 0xFF), hash, word, keyid); } -void worddir(char *buffer, char *word, uint32_t hash) +static void worddir(char *buffer, size_t length, char *word, uint32_t hash) { - snprintf(buffer, PATH_MAX, "%s/words/%02X/%02X/%08X/%s", config.db_dir, + snprintf(buffer, length, "%s/words/%02X/%02X/%08X/%s", config.db_dir, (uint8_t) ((hash >> 24) & 0xFF), (uint8_t) ((hash >> 16) & 0xFF), hash, word); } -void subkeypath(char *buffer, uint64_t subkey, uint64_t keyid) +static void subkeypath(char *buffer, size_t length, uint64_t subkey, + uint64_t keyid) { - snprintf(buffer, PATH_MAX, "%s/subkeys/%02X/%02X/%08X/%016llX", + snprintf(buffer, length, "%s/subkeys/%02X/%02X/%08X/%016" PRIX64, config.db_dir, (uint8_t) ((subkey >> 24) & 0xFF), (uint8_t) ((subkey >> 16) & 0xFF), @@ -117,9 +137,22 @@ void subkeypath(char *buffer, uint64_t subkey, uint64_t keyid) keyid); } -void subkeydir(char *buffer, uint64_t subkey) +static void skshashpath(char *buffer, size_t length, + const struct skshash *hash) +{ + snprintf(buffer, length, "%s/skshash/%02X/%02X/%02X%02X%02X%02X/" + "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", + config.db_dir, + hash->hash[0], hash->hash[1], + hash->hash[0], hash->hash[1], hash->hash[2], hash->hash[3], + hash->hash[4], hash->hash[5], hash->hash[6], hash->hash[7], + hash->hash[8], hash->hash[9], hash->hash[10], hash->hash[11], + hash->hash[12], hash->hash[13], hash->hash[14], + hash->hash[15]); +} +static void subkeydir(char *buffer, size_t length, uint64_t subkey) { - snprintf(buffer, PATH_MAX, "%s/subkeys/%02X/%02X/%08X", + snprintf(buffer, length, "%s/subkeys/%02X/%02X/%08X", config.db_dir, (uint8_t) ((subkey >> 24) & 0xFF), (uint8_t) ((subkey >> 16) & 0xFF), @@ -131,13 +164,13 @@ void subkeydir(char *buffer, uint64_t subkey) /** * initdb - Initialize the key database. */ -void initdb(bool readonly) +static void fs_initdb(bool readonly) { char buffer[PATH_MAX]; keydb_lockfile_readonly = readonly; - snprintf(buffer, PATH_MAX, "%s/.lock", config.db_dir); + snprintf(buffer, sizeof(buffer), "%s/.lock", config.db_dir); if (access(config.db_dir, R_OK | W_OK | X_OK) == -1) { if (errno != ENOENT) { @@ -167,7 +200,7 @@ void initdb(bool readonly) /** * cleanupdb - De-initialize the key database. */ -void cleanupdb(void) +static void fs_cleanupdb(void) { /* Mmmm nothing to do here? */ close(keydb_lockfile_fd); @@ -176,7 +209,7 @@ void cleanupdb(void) /** * starttrans - Start a transaction. */ -bool starttrans(void) +static bool fs_starttrans(void) { struct flock lockstruct; int remaining = 20; @@ -197,7 +230,7 @@ bool starttrans(void) /** * endtrans - End a transaction. */ -void endtrans(void) +static void fs_endtrans(void) { struct flock lockstruct; @@ -208,13 +241,51 @@ void endtrans(void) fcntl(keydb_lockfile_fd, F_SETLK, &lockstruct); } +static uint64_t fs_getfullkeyid(uint64_t keyid) +{ + static char buffer[PATH_MAX]; + DIR *d = NULL; + struct dirent *de = NULL; + uint64_t ret = 0; + + keydir(buffer, sizeof(buffer), keyid); + + d = opendir(buffer); + if (d) { + do { + de = readdir(d); + if (de && de->d_name[0] != '.') { + ret = strtoull(de->d_name, NULL, 16); + } + } while (de && de->d_name[0] == '.'); + closedir(d); + } + + if (ret == 0) { + subkeydir(buffer, sizeof(buffer), keyid); + + d = opendir(buffer); + if (d) { + do { + de = readdir(d); + if (de && de->d_name[0] != '.') { + ret = strtoull(de->d_name, NULL, 16); + } + } while (de && de->d_name[0] == '.'); + closedir(d); + } + } + + return ret; +} + /** * 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. */ -int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, +static int fs_fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, bool intrans) { static char buffer[PATH_MAX]; @@ -222,12 +293,12 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, struct openpgp_packet_list *packets = NULL; if (!intrans) - starttrans(); + fs_starttrans(); if ((keyid >> 32) == 0) - keyid = getfullkeyid(keyid); + keyid = fs_getfullkeyid(keyid); - keypath(buffer, keyid); + keypath(buffer, sizeof(buffer), keyid); if ((fd = open(buffer, O_RDONLY)) != -1) { /* File is present, load it in... */ read_openpgp_stream(file_fetchchar, &fd, &packets, 0); @@ -239,7 +310,7 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, } if (!intrans) - endtrans(); + fs_endtrans(); return ret; } @@ -249,7 +320,7 @@ int fetch_key(uint64_t keyid, struct openpgp_publickey **publickey, * @intrans: If we're already in a transaction. * @update: If true the key exists and should be updated. */ -int store_key(struct openpgp_publickey *publickey, bool intrans, +static int fs_store_key(struct openpgp_publickey *publickey, bool intrans, bool update) { static char buffer[PATH_MAX]; @@ -258,17 +329,20 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, struct openpgp_packet_list *packets = NULL; struct openpgp_packet_list *list_end = NULL; struct openpgp_publickey *next = NULL; - uint64_t keyid = get_keyid(publickey); + uint64_t keyid; struct ll *wordlist = NULL, *wl = NULL; + struct skshash hash; uint64_t *subkeyids = NULL; + uint32_t hashid; int i = 0; + get_keyid(publickey, &keyid); if (!intrans) - starttrans(); + fs_starttrans(); prove_path_to(keyid, "key"); - keypath(buffer, keyid); + keypath(buffer, sizeof(buffer), keyid); if ((fd = open(buffer, O_WRONLY | (update ? O_TRUNC : O_CREAT), @@ -291,9 +365,10 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, uint32_t hash = calchash((uint8_t *) (wl->object)); prove_path_to(hash, "words"); - worddir(wbuffer, wl->object, hash); + worddir(wbuffer, sizeof(wbuffer), wl->object, hash); mkdir(wbuffer, 0777); - wordpath(wbuffer, wl->object, hash, keyid); + wordpath(wbuffer, sizeof(wbuffer), wl->object, hash, + keyid); link(buffer, wbuffer); wl = wl->next; @@ -305,9 +380,10 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, while (subkeyids != NULL && subkeyids[i] != 0) { prove_path_to(subkeyids[i], "subkeys"); - subkeydir(wbuffer, subkeyids[i]); + subkeydir(wbuffer, sizeof(wbuffer), subkeyids[i]); mkdir(wbuffer, 0777); - subkeypath(wbuffer, subkeyids[i], keyid); + subkeypath(wbuffer, sizeof(wbuffer), subkeyids[i], + keyid); link(buffer, wbuffer); i++; @@ -316,10 +392,17 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, free(subkeyids); subkeyids = NULL; } + + get_skshash(publickey, &hash); + hashid = (hash.hash[0] << 24) + (hash.hash[1] << 16) + + (hash.hash[2] << 8) + hash.hash[3]; + prove_path_to(hashid, "skshash"); + skshashpath(wbuffer, sizeof(wbuffer), &hash); + link(buffer, wbuffer); } if (!intrans) - endtrans(); + fs_endtrans(); return ret; } @@ -328,34 +411,36 @@ int store_key(struct openpgp_publickey *publickey, bool intrans, * @keyid: The keyid to delete. * @intrans: If we're already in a transaction. */ -int delete_key(uint64_t keyid, bool intrans) +static int fs_delete_key(uint64_t keyid, bool intrans) { static char buffer[PATH_MAX]; int ret; struct openpgp_publickey *pk = NULL; + struct skshash hash; struct ll *wordlist = NULL, *wl = NULL; uint64_t *subkeyids = NULL; int i = 0; if ((keyid >> 32) == 0) - keyid = getfullkeyid(keyid); + keyid = fs_getfullkeyid(keyid); if (!intrans) - starttrans(); + fs_starttrans(); - ret = fetch_key(keyid, &pk, true); + ret = fs_fetch_key(keyid, &pk, true); if (ret) { - logthing(LOGTHING_DEBUG, "Wordlist for key %016llX", + logthing(LOGTHING_DEBUG, "Wordlist for key %016" PRIX64, keyid); wl = wordlist = makewordlistfromkey(wordlist, pk); logthing(LOGTHING_DEBUG, - "Wordlist for key %016llX done", keyid); + "Wordlist for key %016" PRIX64 " done", keyid); while (wl) { uint32_t hash = calchash((uint8_t *) (wl->object)); prove_path_to(hash, "words"); - wordpath(buffer, wl->object, hash, keyid); + wordpath(buffer, sizeof(buffer), wl->object, hash, + keyid); unlink(buffer); wl = wl->next; @@ -366,7 +451,8 @@ int delete_key(uint64_t keyid, bool intrans) while (subkeyids != NULL && subkeyids[i] != 0) { prove_path_to(subkeyids[i], "subkeys"); - subkeypath(buffer, subkeyids[i], keyid); + subkeypath(buffer, sizeof(buffer), subkeyids[i], + keyid); unlink(buffer); i++; @@ -376,13 +462,16 @@ int delete_key(uint64_t keyid, bool intrans) subkeyids = NULL; } + get_skshash(pk, &hash); + skshashpath(buffer, sizeof(buffer), &hash); + unlink(buffer); } - keypath(buffer, keyid); + keypath(buffer, sizeof(buffer), keyid); unlink(buffer); if (!intrans) - endtrans(); + fs_endtrans(); return 1; } @@ -394,7 +483,7 @@ static struct ll *internal_get_key_by_word(char *word, struct ll *mct) uint32_t hash = calchash((uint8_t *) (word)); struct dirent *de; - worddir(buffer, word, hash); + worddir(buffer, sizeof(buffer), word, hash); d = opendir(buffer); logthing(LOGTHING_DEBUG, "Scanning for word %s in dir %s", word, buffer); @@ -426,7 +515,7 @@ static struct ll *internal_get_key_by_word(char *word, struct ll *mct) * @search: The text to search for. * @publickey: A pointer to a structure to return the key in. */ -int fetch_key_text(const char *search, +static int fs_fetch_key_text(const char *search, struct openpgp_publickey **publickey) { struct ll *wordlist = NULL, *wl = NULL; @@ -471,7 +560,7 @@ int fetch_key_text(const char *search, while (wl) { logthing(LOGTHING_DEBUG, "Adding key: %s", wl->object); addedkeys += - fetch_key(strtoull(wl->object, NULL, 16), publickey, + fs_fetch_key(strtoull(wl->object, NULL, 16), publickey, false); if (addedkeys >= config.maxkeys) break; @@ -485,53 +574,49 @@ int fetch_key_text(const char *search, return addedkeys; } -/* - * dumpdb - dump the key database - * @filenamebase: The base filename to use for the dump. +/** + * fetch_key_skshash - Given an SKS hash fetch the key from storage. + * @hash: The hash to fetch. + * @publickey: A pointer to a structure to return the key in. + * @intrans: If we're already in a transaction. */ -int dumpdb(char *filenamebase) -{ - return 0; -} - -uint64_t getfullkeyid(uint64_t keyid) +static int fs_fetch_key_skshash(const struct skshash *hash, + struct openpgp_publickey **publickey) { static char buffer[PATH_MAX]; - DIR *d = NULL; - struct dirent *de = NULL; - uint64_t ret = 0; - - keydir(buffer, keyid); + int ret = 0, fd; + struct openpgp_packet_list *packets = NULL; - d = opendir(buffer); - if (d) { - do { - de = readdir(d); - if (de && de->d_name[0] != '.') { - ret = strtoull(de->d_name, NULL, 16); - } - } while (de && de->d_name[0] == '.'); - closedir(d); + skshashpath(buffer, sizeof(buffer), hash); + if ((fd = open(buffer, O_RDONLY)) != -1) { + read_openpgp_stream(file_fetchchar, &fd, &packets, 0); + parse_keys(packets, publickey); + free_packet_list(packets); + packets = NULL; + close(fd); + ret = 1; } - if (ret == 0) { - subkeydir(buffer, keyid); - - d = opendir(buffer); - if (d) { - do { - de = readdir(d); - if (de && de->d_name[0] != '.') { - ret = strtoull(de->d_name, NULL, 16); - } - } while (de && de->d_name[0] == '.'); - closedir(d); - } - } - return ret; } +/** + * 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. + */ +static int fs_iterate_keys(void (*iterfunc)(void *ctx, + struct openpgp_publickey *key), void *ctx) +{ + return 0; +} + /* * Include the basic keydb routines. */ @@ -539,3 +624,21 @@ uint64_t getfullkeyid(uint64_t keyid) #define NEED_GETKEYSIGS 1 #define NEED_UPDATEKEYS 1 #include "keydb.c" + +struct dbfuncs keydb_fs_funcs = { + .initdb = fs_initdb, + .cleanupdb = fs_cleanupdb, + .starttrans = fs_starttrans, + .endtrans = fs_endtrans, + .fetch_key = fs_fetch_key, + .fetch_key_text = fs_fetch_key_text, + .fetch_key_skshash = fs_fetch_key_skshash, + .store_key = fs_store_key, + .update_keys = generic_update_keys, + .delete_key = fs_delete_key, + .getkeysigs = generic_getkeysigs, + .cached_getkeysigs = generic_cached_getkeysigs, + .keyid2uid = generic_keyid2uid, + .getfullkeyid = fs_getfullkeyid, + .iterate_keys = fs_iterate_keys, +};