X-Git-Url: https://git.sommitrealweird.co.uk/onak.git/blobdiff_plain/d43d055372a663f85055bf255356271fdfe105e1..d27407c824b63bd0b9c78479453c3ce4799afac8:/keydb.c?ds=sidebyside diff --git a/keydb.c b/keydb.c index 3acf711..0039057 100644 --- a/keydb.c +++ b/keydb.c @@ -3,7 +3,7 @@ * * Jonathan McDowell * - * Copyright 2002 Project Purple + * Copyright 2002-2004 Project Purple */ /** @@ -16,26 +16,30 @@ #include +#include "decodekey.h" +#include "hash.h" #include "keydb.h" #include "keyid.h" -#include "keyindex.h" #include "keystructs.h" #include "mem.h" +#include "merge.h" #include "parsekey.h" +#include "sendsync.h" #ifdef NEED_KEYID2UID /** * keyid2uid - Takes a keyid and returns the primary UID for it. * @keyid: The keyid to lookup. */ -char *keyid2uid(uint64_t keyid) +char *generic_keyid2uid(uint64_t keyid) { struct openpgp_publickey *publickey = NULL; struct openpgp_signedpacket_list *curuid = NULL; char buf[1024]; buf[0]=0; - if (fetch_key(keyid, &publickey, false) && publickey != NULL) { + if (config.dbbackend->fetch_key(keyid, &publickey, false) && + publickey != NULL) { curuid = publickey->uids; while (curuid != NULL && buf[0] == 0) { if (curuid->packet->tag == 13) { @@ -60,22 +64,27 @@ char *keyid2uid(uint64_t keyid) /** * getkeysigs - Gets a linked list of the signatures on a key. * @keyid: The keyid to get the sigs for. + * @revoked: Is the key revoked? * * This function gets the list of signatures on a key. Used for key - * indexing and doing stats bits. + * indexing and doing stats bits. If revoked is non-NULL then if the key + * is revoked it's set to true. */ -struct ll *getkeysigs(uint64_t keyid) +struct ll *generic_getkeysigs(uint64_t keyid, bool *revoked) { struct ll *sigs = NULL; struct openpgp_signedpacket_list *uids = NULL; struct openpgp_publickey *publickey = NULL; - fetch_key(keyid, &publickey, false); + config.dbbackend->fetch_key(keyid, &publickey, false); if (publickey != NULL) { for (uids = publickey->uids; uids != NULL; uids = uids->next) { sigs = keysigs(sigs, uids->sigs); } + if (revoked != NULL) { + *revoked = publickey->revoked; + } free_publickey(publickey); } @@ -83,6 +92,41 @@ struct ll *getkeysigs(uint64_t keyid) } #endif +/** + * cached_getkeysigs - Gets the signatures on a key. + * @keyid: The key we want the signatures for. + * + * This function gets the signatures on a key. It's the same as the + * getkeysigs function above except we use the hash module to cache the + * data so if we need it again it's already loaded. + */ +struct ll *generic_cached_getkeysigs(uint64_t keyid) +{ + struct stats_key *key = NULL; + struct stats_key *signedkey = NULL; + struct ll *cursig = NULL; + bool revoked = false; + + if (keyid == 0) { + return NULL; + } + + key = createandaddtohash(keyid); + + if (key->gotsigs == false) { + key->sigs = config.dbbackend->getkeysigs(key->keyid, &revoked); + key->revoked = revoked; + for (cursig = key->sigs; cursig != NULL; + cursig = cursig->next) { + signedkey = (struct stats_key *) cursig->object; + signedkey->signs = lladd(signedkey->signs, key); + } + key->gotsigs = true; + } + + return key->sigs; +} + #ifdef NEED_GETFULLKEYID /** * getfullkeyid - Maps a 32bit key id to a 64bit one. @@ -91,12 +135,12 @@ struct ll *getkeysigs(uint64_t 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) +uint64_t generic_getfullkeyid(uint64_t keyid) { struct openpgp_publickey *publickey = NULL; if (keyid < 0x100000000LL) { - fetch_key(keyid, &publickey, false); + config.dbbackend->fetch_key(keyid, &publickey, false); if (publickey != NULL) { keyid = get_keyid(publickey); free_publickey(publickey); @@ -109,3 +153,77 @@ uint64_t getfullkeyid(uint64_t keyid) return keyid; } #endif + +#ifdef NEED_UPDATEKEYS +/** + * update_keys - Takes a list of public keys and updates them in the DB. + * @keys: The keys to update in the DB. + * @sendsync: Should we send a sync mail to our peers. + * + * Takes a list of keys and adds them to the database, merging them with + * the key in the database if it's already present there. The key list is + * update to contain the minimum set of updates required to get from what + * we had before to what we have now (ie the set of data that was added to + * the DB). Returns the number of entirely new keys added. + */ +int generic_update_keys(struct openpgp_publickey **keys, bool sendsync) +{ + struct openpgp_publickey *curkey = NULL; + struct openpgp_publickey *oldkey = NULL; + struct openpgp_publickey *prev = NULL; + int newkeys = 0; + bool intrans; + + for (curkey = *keys; curkey != NULL; curkey = curkey->next) { + intrans = config.dbbackend->starttrans(); + logthing(LOGTHING_INFO, + "Fetching key 0x%llX, result: %d", + get_keyid(curkey), + config.dbbackend->fetch_key(get_keyid(curkey), &oldkey, + intrans)); + + /* + * If we already have the key stored in the DB then merge it + * with the new one that's been supplied. Otherwise the key + * we've just got is the one that goes in the DB and also the + * one that we send out. + */ + if (oldkey != NULL) { + merge_keys(oldkey, curkey); + if (curkey->sigs == NULL && + curkey->uids == NULL && + curkey->subkeys == NULL) { + if (prev == NULL) { + *keys = curkey->next; + } else { + prev->next = curkey->next; + curkey->next = NULL; + free_publickey(curkey); + curkey = prev; + } + } else { + prev = curkey; + logthing(LOGTHING_INFO, + "Merged key; storing updated key."); + config.dbbackend->store_key(oldkey, intrans, + true); + } + free_publickey(oldkey); + oldkey = NULL; + } else { + logthing(LOGTHING_INFO, + "Storing completely new key."); + config.dbbackend->store_key(curkey, intrans, false); + newkeys++; + } + config.dbbackend->endtrans(); + intrans = false; + } + + if (sendsync && keys != NULL) { + sendkeysync(*keys); + } + + return newkeys; +} +#endif /* NEED_UPDATEKEYS */