Ignore SIGPIPE in keyd

[onak.git] / merge.c

diff --git a/merge.c b/merge.c
index cfe2d97d1c2711bfbb74d79eeba4b2d37f498c0f..be97eb4782b32f5550f8f63a6db0db87d858c9ac 100644 (file)
--- a/merge.c
+++ b/merge.c
@@ -3,18 +3,19 @@
  *
  * Jonathan McDowell <noodles@earth.li>
  *
  *
  * Jonathan McDowell <noodles@earth.li>
  *

- * Copyright 2002 Project Purple
+ * Copyright 2002-2005 Project Purple

  */
 
  */
 

-#include <assert.h>

 #include <stdio.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdlib.h>

+#include <string.h>

 
 

+#include "decodekey.h"

 #include "keydb.h"
 #include "keyid.h"
 #include "keydb.h"
 #include "keyid.h"

-#include "keyindex.h"

 #include "keystructs.h"
 #include "ll.h"
 #include "keystructs.h"
 #include "ll.h"

+#include "log.h"

 #include "mem.h"
 #include "merge.h"
 
 #include "mem.h"
 #include "merge.h"
 


@@ -42,7 +43,20 @@ bool compare_packets(struct openpgp_packet *a, struct openpgp_packet *b)
  */
 bool compare_signatures(struct openpgp_packet *a, struct openpgp_packet *b)
 {
  */
 bool compare_signatures(struct openpgp_packet *a, struct openpgp_packet *b)
 {

-       return (sig_keyid(a) == sig_keyid(b));
+       uint64_t a_keyid, b_keyid;
+       time_t a_creation, b_creation;
+
+       if (a->data[0] != b->data[0]) {
+               /* Different signature versions, so not the same */
+               return false;
+       } else if (a->data[0] == 4 && a->data[1] != b->data[1]) {
+               /* Type 4 signature, but different types */
+               return false;
+       } else {
+               sig_info(a, &a_keyid, &a_creation);
+               sig_info(b, &b_keyid, &b_creation);
+               return (a_creation == b_creation) && (a_keyid == b_keyid);
+       }

 }
 
 /**
 }
 
 /**


@@ -145,7 +159,9 @@ bool remove_signed_packet(struct openpgp_signedpacket_list **packet_list,
                        if (cur->next == NULL) {
                                *list_end = prev;
                        }
                        if (cur->next == NULL) {
                                *list_end = prev;
                        }

-                       // TODO: Free the removed signed packet...
+                       /*
+                        * TODO: Free the removed signed packet...
+                        */

                }
                prev = cur;
        }
                }
                prev = cur;
        }


@@ -170,7 +186,7 @@ int merge_packet_sigs(struct openpgp_signedpacket_list *old,
        struct openpgp_packet_list      *curpacket = NULL;
        struct openpgp_packet_list      *nextpacket = NULL;
 
        struct openpgp_packet_list      *curpacket = NULL;
        struct openpgp_packet_list      *nextpacket = NULL;
 

-       assert(compare_packets(old->packet, new->packet));
+       log_assert(compare_packets(old->packet, new->packet));

 
        curpacket = new->sigs;
        while (curpacket != NULL) {
 
        curpacket = new->sigs;
        while (curpacket != NULL) {


@@ -190,7 +206,7 @@ int merge_packet_sigs(struct openpgp_signedpacket_list *old,
                        if (lastpacket != NULL) {
                                lastpacket->next = curpacket->next;
                        } else {
                        if (lastpacket != NULL) {
                                lastpacket->next = curpacket->next;
                        } else {

-                               assert(curpacket == new->sigs);
+                               log_assert(curpacket == new->sigs);

                                new->sigs = curpacket->next;
                        }
                        curpacket->next = NULL;
                                new->sigs = curpacket->next;
                        }
                        curpacket->next = NULL;


@@ -302,12 +318,12 @@ int merge_keys(struct openpgp_publickey *a, struct openpgp_publickey *b)
                /*
                 * Key IDs are the same, so I guess we have to merge them.
                 */
                /*
                 * Key IDs are the same, so I guess we have to merge them.
                 */

-               curpacket = b->revocations;
+               curpacket = b->sigs;

                while (curpacket != NULL) {
                        nextpacket = curpacket->next;
                while (curpacket != NULL) {
                        nextpacket = curpacket->next;

-                       if (find_packet(a->revocations, curpacket->packet)) {
+                       if (find_packet(a->sigs, curpacket->packet)) {

                                /*
                                /*

-                                * We already have this revocation, remove it
+                                * We already have this signature, remove it

                                 * from the difference list and free the memory
                                 * allocated for it.
                                 */
                                 * from the difference list and free the memory
                                 * allocated for it.
                                 */


@@ -315,8 +331,8 @@ int merge_keys(struct openpgp_publickey *a, struct openpgp_publickey *b)
                                if (lastpacket != NULL) {
                                        lastpacket->next = curpacket->next;
                                } else {
                                if (lastpacket != NULL) {
                                        lastpacket->next = curpacket->next;
                                } else {

-                                       assert(curpacket == b->revocations);
-                                       b->revocations = curpacket->next;
+                                       log_assert(curpacket == b->sigs);
+                                       b->sigs = curpacket->next;

                                }
                                curpacket->next = NULL;
                                free_packet_list(curpacket);
                                }
                                curpacket->next = NULL;
                                free_packet_list(curpacket);


@@ -326,15 +342,15 @@ int merge_keys(struct openpgp_publickey *a, struct openpgp_publickey *b)
                        }
                        curpacket = nextpacket;
                }
                        }
                        curpacket = nextpacket;
                }

-               b->last_revocation = lastpacket;
+               b->last_sig = lastpacket;

 
                /*
 
                /*

-                * Anything left on b->revocations doesn't exist on
-                * a->revocations, so add them to the list.
+                * Anything left on b->sigs doesn't exist on
+                * a->sigs, so add them to the list.

                 */
                 */

-               packet_list_add(&a->revocations,
-                               &a->last_revocation,
-                               b->revocations);
+               packet_list_add(&a->sigs,
+                               &a->last_sig,
+                               b->sigs);

 
                /*
                 * Merge uids (signed list).
 
                /*
                 * Merge uids (signed list).


@@ -347,78 +363,13 @@ int merge_keys(struct openpgp_publickey *a, struct openpgp_publickey *b)
 
        }
 
 
        }
 

-       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;
-                                       curkey->next = NULL;
-                                       free_publickey(curkey);
-                               }
-                       } 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;
+       /*
+        * If either key was revoked, make sure both the new ones are marked as
+        * being so.
+        */
+       if (a->revoked || b->revoked) {
+               a->revoked = b->revoked = true;

        }
 
        }
 

-       return newkeys;
+       return rc;

 }
 }