X-Git-Url: https://the.earth.li/gitweb/?a=blobdiff_plain;f=keydb.c;h=f92c252667a95eeb23bed61d76f763d69031e6a7;hb=adc800dbc424a1e246dd4a82a0c2e88eeda25531;hp=300e9b9a42690654e37b4649b1d06fbc70033c73;hpb=7350475e98ed6302e0143a7e7c9ab7877ea58a1a;p=onak.git diff --git a/keydb.c b/keydb.c index 300e9b9..f92c252 100644 --- a/keydb.c +++ b/keydb.c @@ -1,9 +1,19 @@ /* * keydb.c - Routines for DB access that just use store/fetch. * - * Jonathan McDowell + * Copyright 2002-2004 Jonathan McDowell * - * Copyright 2002-2004 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, see . */ /** @@ -14,6 +24,7 @@ * slower than custom functions however. */ +#include #include #include "decodekey.h" @@ -21,27 +32,30 @@ #include "keydb.h" #include "keyid.h" #include "keystructs.h" +#include "ll.h" #include "mem.h" #include "merge.h" -#include "parsekey.h" +#include "openpgp.h" #include "sendsync.h" +#include "stats.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(struct onak_dbctx *dbctx, 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 (dbctx->fetch_key_id(dbctx, 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); @@ -69,20 +83,27 @@ char *keyid2uid(uint64_t keyid) * 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, bool *revoked) +struct ll *generic_getkeysigs(struct onak_dbctx *dbctx, + uint64_t keyid, bool *revoked) { struct ll *sigs = NULL; struct openpgp_signedpacket_list *uids = NULL; + struct openpgp_packet_list *cursig; struct openpgp_publickey *publickey = NULL; - fetch_key(keyid, &publickey, false); + dbctx->fetch_key_id(dbctx, keyid, &publickey, false); if (publickey != NULL) { for (uids = publickey->uids; uids != NULL; uids = uids->next) { - sigs = keysigs(sigs, uids->sigs); + for (cursig = uids->sigs; cursig != NULL; + cursig = cursig->next) { + sigs = lladd(sigs, + createandaddtohash(sig_keyid( + cursig->packet))); + } } if (revoked != NULL) { - *revoked = (publickey->revocations != NULL); + *revoked = publickey->revoked; } free_publickey(publickey); } @@ -99,21 +120,29 @@ struct ll *getkeysigs(uint64_t keyid, bool *revoked) * 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 *cached_getkeysigs(uint64_t keyid) +struct ll *generic_cached_getkeysigs(struct onak_dbctx *dbctx, 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 = createandaddtohash(keyid); + key = findinhash(keyid); - if (key->gotsigs == false) { - key->sigs = getkeysigs(key->keyid, &revoked); + if (key == NULL || key->gotsigs == false) { + sigs = dbctx->getkeysigs(dbctx, 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) { @@ -134,14 +163,14 @@ struct ll *cached_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(struct onak_dbctx *dbctx, uint64_t keyid) { struct openpgp_publickey *publickey = NULL; if (keyid < 0x100000000LL) { - fetch_key(keyid, &publickey, false); + dbctx->fetch_key_id(dbctx, keyid, &publickey, false); if (publickey != NULL) { - keyid = get_keyid(publickey); + get_keyid(publickey, &keyid); free_publickey(publickey); publickey = NULL; } else { @@ -165,20 +194,24 @@ uint64_t getfullkeyid(uint64_t keyid) * 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 update_keys(struct openpgp_publickey **keys, bool sendsync) +int generic_update_keys(struct onak_dbctx *dbctx, + 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 = starttrans(); + intrans = dbctx->starttrans(dbctx); + get_keyid(curkey, &keyid); logthing(LOGTHING_INFO, - "Fetching key 0x%llX, result: %d", - get_keyid(curkey), - fetch_key(get_keyid(curkey), &oldkey, intrans)); + "Fetching key 0x%" PRIX64 ", result: %d", + keyid, + dbctx->fetch_key_id(dbctx, keyid, &oldkey, + intrans)); /* * If we already have the key stored in the DB then merge it @@ -188,7 +221,7 @@ int update_keys(struct openpgp_publickey **keys, bool sendsync) */ if (oldkey != NULL) { merge_keys(oldkey, curkey); - if (curkey->revocations == NULL && + if (curkey->sigs == NULL && curkey->uids == NULL && curkey->subkeys == NULL) { if (prev == NULL) { @@ -203,18 +236,18 @@ int update_keys(struct openpgp_publickey **keys, bool sendsync) prev = curkey; logthing(LOGTHING_INFO, "Merged key; storing updated key."); - store_key(oldkey, intrans, true); + dbctx->store_key(dbctx, oldkey, intrans, + true); } free_publickey(oldkey); oldkey = NULL; } else { logthing(LOGTHING_INFO, "Storing completely new key."); - store_key(curkey, intrans, false); + dbctx->store_key(dbctx, curkey, intrans, false); newkeys++; } - endtrans(); - intrans = false; + dbctx->endtrans(dbctx); } if (sendsync && keys != NULL) { @@ -224,3 +257,31 @@ int update_keys(struct openpgp_publickey **keys, bool sendsync) return newkeys; } #endif /* NEED_UPDATEKEYS */ + +#ifdef NEED_GET_FP +static int generic_fetch_key_fp(struct onak_dbctx *dbctx, + struct openpgp_fingerprint *fingerprint, + struct openpgp_publickey **publickey, bool intrans) +{ + uint64_t keyid; + int i; + + if (fingerprint->length > MAX_FINGERPRINT_LEN) { + return 0; + } + + /* + * We assume if the backend is using this function it's not storing + * anything bigger than the 64 bit key ID and just truncate the + * fingerprint to get that value. This doesn't work for v3 keys, + * but there's no way to map from v3 fingerprint to v3 key ID so + * if the backend can't do it we're going to fail anyway. + */ + keyid = 0; + for (i = (fingerprint->length - 8); i < fingerprint->length; i++) { + keyid = (keyid << 8) + fingerprint->fp[i]; + } + + return dbctx->fetch_key_id(dbctx, keyid, publickey, intrans); +} +#endif