X-Git-Url: https://git.sommitrealweird.co.uk/onak.git/blobdiff_plain/4b8483ae278577a3adc8d84da81d77019704466f..a953676d714ba11d3b9509bbea747ad0858b28ba:/merge.c?ds=sidebyside diff --git a/merge.c b/merge.c index c1410e1..6954337 100644 --- a/merge.c +++ b/merge.c @@ -10,7 +10,9 @@ #include #include +#include "keydb.h" #include "keyid.h" +#include "keyindex.h" #include "keystructs.h" #include "ll.h" #include "mem.h" @@ -18,10 +20,11 @@ /** * compare_packets - Check to see if 2 OpenPGP packets are the same. - * @a: The first key to compare. - * @b: The second key to compare. + * @a: The first packet to compare. + * @b: The second packet to compare. * - * Takes 2 keys and returns true if they are the same and false otherwise. + * Takes 2 packets and returns true if they are the same and false + * otherwise. */ bool compare_packets(struct openpgp_packet *a, struct openpgp_packet *b) { @@ -29,6 +32,19 @@ bool compare_packets(struct openpgp_packet *a, struct openpgp_packet *b) !memcmp(a->data, b->data, b->length)); } +/** + * compare_signatures - Check to see if 2 OpenPGP signatures are the same. + * @a: The first signature to compare. + * @b: The second signature to compare. + * + * Takes 2 signature packets and returns true if they are the same and + * false otherwise. + */ +bool compare_signatures(struct openpgp_packet *a, struct openpgp_packet *b) +{ + return (sig_keyid(a) == sig_keyid(b)); +} + /** * find_packet - Checks to see if an OpenPGP packet exists in a list. * @packet_list: The list of packets to look in. @@ -52,6 +68,31 @@ bool find_packet(struct openpgp_packet_list *packet_list, return found; } +/** + * find_signature - Checks to see if an OpenPGP signature exists in a list. + * @packet_list: The list of packets to look in. + * @packet: The signature to look for. + * + * Walks through the packet_list checking to see if the signature given is + * present in it. Returns a pointer to it if it is, NULL otherwise. + * + */ +struct openpgp_packet_list *find_signature( + struct openpgp_packet_list *packet_list, + struct openpgp_packet *packet) +{ + struct openpgp_packet_list *found = NULL; + + while (!found && packet_list != NULL) { + if (compare_signatures(packet_list->packet, packet)) { + found = packet_list; + } + packet_list = packet_list -> next; + } + + return found; +} + /** * get_signed_packet - Gets a signed packet from a list. * @packet_list: The list of packets to look in. @@ -104,7 +145,9 @@ bool remove_signed_packet(struct openpgp_signedpacket_list **packet_list, if (cur->next == NULL) { *list_end = prev; } + // TODO: Free the removed signed packet... } + prev = cur; } return found; @@ -132,7 +175,13 @@ int merge_packet_sigs(struct openpgp_signedpacket_list *old, curpacket = new->sigs; while (curpacket != NULL) { nextpacket = curpacket->next; - if (find_packet(old->sigs, curpacket->packet)) { + /* + * TODO: We should be checking the signature and then + * potentially merging/replacing it depending on the subpackets + * really. For now this stops us adding the same one twice + * however. + */ + if (find_signature(old->sigs, curpacket->packet)) { /* * We already have this sig, remove it from the * difference list and free the memory allocated for @@ -191,25 +240,29 @@ int merge_signed_packets(struct openpgp_signedpacket_list **old, if (newelem->sigs == NULL) { remove_signed_packet(new, new_end, - curelem->packet); + newelem->packet); } } } /* - * If *new != NULL now then there are UIDs on the new key that weren't - * on the old key. Add them. + * If *new != NULL now then there might be UIDs on the new key that + * weren't on the old key. Walk through them, checking if the UID is + * on the old key and if not adding them to it. */ for (curelem = *new; curelem != NULL; curelem = curelem->next) { - ADD_PACKET_TO_LIST((*old_end), + + if (find_signed_packet(*old, curelem->packet) == NULL) { + ADD_PACKET_TO_LIST((*old_end), packet_dup(curelem->packet)); - if (*old == NULL) { - *old = *old_end; - } - packet_list_add(&(*old_end)->sigs, + if (*old == NULL) { + *old = *old_end; + } + packet_list_add(&(*old_end)->sigs, &(*old_end)->last_sig, curelem->sigs); + } } return 0; @@ -289,10 +342,79 @@ int merge_keys(struct openpgp_publickey *a, struct openpgp_publickey *b) */ merge_signed_packets(&a->uids, &a->last_uid, &b->uids, &b->last_uid); - merge_signed_packets(&a->subkeys, &a->last_uid, + merge_signed_packets(&a->subkeys, &a->last_subkey, &b->subkeys, &b->last_subkey); } return rc; } + +/** + * update_keys - Takes a list of public keys and updates them in the DB. + * @keys: The keys to update in the DB. + * @verbose: Should we output more information as we add keys? + * + * 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 update_keys(struct openpgp_publickey **keys, bool verbose) +{ + 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 = starttrans(); + if (verbose) { + fprintf(stderr, "Fetching key 0x%llX, result: %d\n", + get_keyid(curkey), + fetch_key(get_keyid(curkey), &oldkey, intrans)); + } else { + 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->revocations == NULL && + curkey->uids == NULL && + curkey->subkeys == NULL) { + if (prev == NULL) { + *keys = curkey->next; + } else { + prev->next = curkey->next; + prev = curkey->next; + } + } else { + prev = curkey; + if (verbose) { + fprintf(stderr, "Merged key; storing updated key.\n"); + } + store_key(oldkey, intrans, true); + } + free_publickey(oldkey); + oldkey = NULL; + } else { + if (verbose) { + fprintf(stderr, "Storing completely new key.\n"); + } + store_key(curkey, intrans, false); + newkeys++; + } + endtrans(); + intrans = false; + } + + return newkeys; +}