#include <stdio.h>
#include <stdlib.h>
+#include "keydb.h"
#include "keyid.h"
+#include "keyindex.h"
#include "keystructs.h"
#include "ll.h"
#include "mem.h"
/**
* 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)
{
!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.
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.
if (cur->next == NULL) {
*list_end = prev;
}
+ // TODO: Free the removed signed packet...
}
+ prev = cur;
}
return found;
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
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;
*/
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;
+}
projects / onak.git / blobdiff