X-Git-Url: https://git.sommitrealweird.co.uk/onak.git/blobdiff_plain/e02c731dfbb288c736f2cd09a9b6df0507c59ddd..refs/heads/master:/keydb.c diff --git a/keydb.c b/keydb.c index 3ebb056..c257eb5 100644 --- a/keydb.c +++ b/keydb.c @@ -1,9 +1,20 @@ /* * keydb.c - Routines for DB access that just use store/fetch. * - * Jonathan McDowell + * Copyright 2002-2004 Jonathan McDowell * - * Copyright 2002 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. */ /** @@ -16,29 +27,34 @@ #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 "openpgp.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; - static char buf[1024]; + 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) { + if (curuid->packet->tag == OPENPGP_PACKET_UID) { snprintf(buf, 1023, "%.*s", (int) curuid->packet->length, curuid->packet->data); @@ -51,7 +67,7 @@ char *keyid2uid(uint64_t keyid) if (buf[0] == 0) { return NULL; } else { - return buf; + return strdup(buf); } } #endif @@ -60,22 +76,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,24 +104,148 @@ 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; + struct ll *sigs = NULL; + bool revoked = false; + + if (keyid == 0) { + return NULL; + } + + key = findinhash(keyid); + + if (key == NULL || key->gotsigs == false) { + sigs = config.dbbackend->getkeysigs(keyid, &revoked); + if (sigs == NULL) { + return NULL; + } + if (key == NULL) { + key = createandaddtohash(keyid); + } + key->sigs = sigs; + 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. * @keyid: The 32bit keyid. * * This function maps a 32bit key id to the full 64bit one. It returns the - * full keyid. + * 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 < 0x100000000) { - fetch_key(keyid, &publickey, false); - keyid = get_keyid(publickey); - free_publickey(publickey); + if (keyid < 0x100000000LL) { + config.dbbackend->fetch_key(keyid, &publickey, false); + if (publickey != NULL) { + get_keyid(publickey, &keyid); + free_publickey(publickey); + publickey = NULL; + } else { + keyid = 0; + } } 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; + uint64_t keyid; + + for (curkey = *keys; curkey != NULL; curkey = curkey->next) { + intrans = config.dbbackend->starttrans(); + get_keyid(curkey, &keyid); + logthing(LOGTHING_INFO, + "Fetching key 0x%" PRIX64 ", result: %d", + keyid, + config.dbbackend->fetch_key(keyid, &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 */