fixing collect_generation_garbage() complexity, doxygen, etc.

4 files changed, 272 insertions, 207 deletions

diff --git a/src/set/gnunet-service-set.c b/src/set/gnunet-service-set.c
index 3a3f91217..ec2bb6484 100644
--- a/src/set/gnunet-service-set.c
+++ b/src/set/gnunet-service-set.c
@@ -42,25 +42,24 @@ struct OperationState
   struct GNUNET_PeerIdentity peer;
 
   /**
-   * Unique request id for the request from
-   * a remote peer, sent to the client, which will
-   * accept or reject the request.
-   * Set to '0' iff the request has not been
-   * suggested yet.
-   */
-  uint32_t suggest_id;
-
-  /**
    * Timeout task, if the incoming peer has not been accepted
    * after the timeout, it will be disconnected.
    */
   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+
+  /**
+   * Unique request id for the request from a remote peer, sent to the
+   * client, which will accept or reject the request.  Set to '0' iff
+   * the request has not been suggested yet.
+   */
+  uint32_t suggest_id;
+
 };
 
 
 /**
- * A listener is inhabited by a client, and
- * waits for evaluation requests from remote peers.
+ * A listener is inhabited by a client, and waits for evaluation
+ * requests from remote peers.
  */
 struct Listener
 {
@@ -86,15 +85,15 @@ struct Listener
   struct GNUNET_MQ_Handle *client_mq;
 
   /**
-   * The type of the operation.
-   */
-  enum GNUNET_SET_OperationType operation;
-
-  /**
    * Application ID for the operation, used to distinguish
    * multiple operations of the same type with the same peer.
    */
   struct GNUNET_HashCode app_id;
+
+  /**
+   * The type of the operation.
+   */
+  enum GNUNET_SET_OperationType operation;
 };
 
 
@@ -104,8 +103,8 @@ struct Listener
 static const struct GNUNET_CONFIGURATION_Handle *configuration;
 
 /**
- * Handle to the cadet service, used
- * to listen for and connect to remote peers.
+ * Handle to the cadet service, used to listen for and connect to
+ * remote peers.
  */
 static struct GNUNET_CADET_Handle *cadet;
 
@@ -130,21 +129,21 @@ static struct Listener *listeners_head;
 static struct Listener *listeners_tail;
 
 /**
- * Incoming sockets from remote peers are
- * held in a doubly linked list.
+ * Incoming sockets from remote peers are held in a doubly linked
+ * list.
  */
 static struct Operation *incoming_head;
 
 /**
- * Incoming sockets from remote peers are
- * held in a doubly linked list.
+ * Incoming sockets from remote peers are held in a doubly linked
+ * list.
  */
 static struct Operation *incoming_tail;
 
 /**
- * Counter for allocating unique IDs for clients,
- * used to identify incoming operation requests from remote peers,
- * that the client can choose to accept or refuse.
+ * Counter for allocating unique IDs for clients, used to identify
+ * incoming operation requests from remote peers, that the client can
+ * choose to accept or refuse.
  */
 static uint32_t suggest_id = 1;
 
@@ -223,8 +222,10 @@ listener_destroy (struct Listener *listener)
   if (NULL != listener->client)
   {
     struct GNUNET_SERVER_Client *client = listener->client;
+
     listener->client = NULL;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "disconnecting listener client\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "disconnecting listener client\n");
     GNUNET_SERVER_client_disconnect (client);
     return;
   }
@@ -233,48 +234,95 @@ listener_destroy (struct Listener *listener)
     GNUNET_MQ_destroy (listener->client_mq);
     listener->client_mq = NULL;
   }
-  GNUNET_CONTAINER_DLL_remove (listeners_head, listeners_tail, listener);
+  GNUNET_CONTAINER_DLL_remove (listeners_head,
+                               listeners_tail,
+                               listener);
   GNUNET_free (listener);
 }
 
 
 /**
+ * Context for the #garbage_collect_cb().
+ */
+struct GarbageContext
+{
+
+  /**
+   * Map for which we are garbage collecting removed elements.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *map;
+
+  /**
+   * Lowest generation for which an operation is still pending.
+   */
+  unsigned int min_op_generation;
+
+  /**
+   * Largest generation for which an operation is still pending.
+   */
+  unsigned int max_op_generation;
+
+};
+
+
+/**
+ * Function invoked to check if an element can be removed from
+ * the set's history because it is no longer needed.
+ *
+ * @param cls the `struct GarbageContext *`
+ * @param key key of the element in the map
+ * @param value the `struct ElementEntry *`
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+garbage_collect_cb (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
+{
+  struct GarbageContext *gc = cls;
+  struct ElementEntry *ee = value;
+
+  if (GNUNET_YES != ee->removed)
+    return GNUNET_OK;
+  if ( (gc->max_op_generation < ee->generation_added) ||
+       (ee->generation_removed > gc->min_op_generation) )
+  {
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_remove (gc->map,
+                                                         key,
+                                                         ee));
+    GNUNET_free (ee);
+  }
+  return GNUNET_OK;
+}
+
+
+/**
  * Collect and destroy elements that are not needed anymore, because
- * their lifetime (as determined by their generation) does not overlap with any active
- * set operation.
+ * their lifetime (as determined by their generation) does not overlap
+ * with any active set operation.
  *
- * We hereby replace the old element hashmap with a new one, instead of removing elements.
+ * @param set set to garbage collect
  */
-void
+static void
 collect_generation_garbage (struct Set *set)
 {
-  struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
-  struct ElementEntry *ee;
-  struct GNUNET_CONTAINER_MultiHashMap *new_elements;
-  int res;
   struct Operation *op;
+  struct GarbageContext gc;
 
-  new_elements = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
-  iter = GNUNET_CONTAINER_multihashmap_iterator_create (set->elements);
-  while (GNUNET_OK ==
-         (res = GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL, (const void **) &ee)))
+  gc.min_op_generation = UINT_MAX;
+  gc.max_op_generation = 0;
+  for (op = set->ops_head; NULL != op; op = op->next)
   {
-    if (GNUNET_NO == ee->removed)
-      goto still_needed;
-    for (op = set->ops_head; NULL != op; op = op->next)
-      if ((op->generation_created >= ee->generation_added) &&
-          (op->generation_created < ee->generation_removed))
-        goto still_needed;
-    GNUNET_free (ee);
-    continue;
-still_needed:
-    // we don't expect collisions, thus the replace option
-    GNUNET_CONTAINER_multihashmap_put (new_elements, &ee->element_hash, ee,
-                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
+    gc.min_op_generation = GNUNET_MIN (gc.min_op_generation,
+                                       op->generation_created);
+    gc.max_op_generation = GNUNET_MAX (gc.max_op_generation,
+                                       op->generation_created);
   }
-  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
-  GNUNET_CONTAINER_multihashmap_destroy (set->elements);
-  set->elements = new_elements;
+  gc.map = set->elements;
+  GNUNET_CONTAINER_multihashmap_iterate (set->elements,
+                                         &garbage_collect_cb,
+                                         &gc);
 }
 
 
diff --git a/src/set/gnunet-service-set.h b/src/set/gnunet-service-set.h
index d8450e242..b92eb47ff 100644
--- a/src/set/gnunet-service-set.h
+++ b/src/set/gnunet-service-set.h
@@ -22,8 +22,8 @@
  * @file set/gnunet-service-set.h
  * @brief common components for the implementation the different set operations
  * @author Florian Dold
+ * @author Christian Grothoff
  */
-
 #ifndef GNUNET_SERVICE_SET_H_PRIVATE
 #define GNUNET_SERVICE_SET_H_PRIVATE
 
@@ -38,24 +38,33 @@
 
 
 /**
- * Implementation-specific set state.
- * Used as opaque pointer, and specified further
- * in the respective implementation.
+ * Implementation-specific set state.  Used as opaque pointer, and
+ * specified further in the respective implementation.
  */
 struct SetState;
 
-
 /**
- * Implementation-specific set operation.
- * Used as opaque pointer, and specified further
- * in the respective implementation.
+ * Implementation-specific set operation.  Used as opaque pointer, and
+ * specified further in the respective implementation.
  */
 struct OperationState;
 
-
-/* forward declarations */
+/**
+ * A set that supports a specific operation with other peers.
+ */
 struct Set;
+
+/**
+ * Information about an element element in the set.  All elements are
+ * stored in a hash-table from their hash-code to their 'struct
+ * Element', so that the remove and add operations are reasonably
+ * fast.
+ */
 struct ElementEntry;
+
+/**
+ * Operation context used to execute a set operation.
+ */
 struct Operation;
 
 
@@ -64,13 +73,9 @@ struct Operation;
  */
 struct OperationSpecification
 {
-  /**
-   * The type of the operation.
-   */
-  enum GNUNET_SET_OperationType operation;
 
   /**
-   * The remove peer we evaluate the operation with
+   * The remove peer we evaluate the operation with.
    */
   struct GNUNET_PeerIdentity peer;
 
@@ -86,6 +91,12 @@ struct OperationSpecification
   struct GNUNET_MessageHeader *context_msg;
 
   /**
+   * Set associated with the operation, NULL until the spec has been
+   * associated with a set.
+   */
+  struct Set *set;
+
+  /**
    * Salt to use for the operation.
    */
   uint32_t salt;
@@ -101,10 +112,9 @@ struct OperationSpecification
   uint32_t client_request_id;
 
   /**
-   * Set associated with the operation, NULL until the spec has been associated
-   * with a set.
+   * The type of the operation.
    */
-  struct Set *set;
+  enum GNUNET_SET_OperationType operation;
 
   /**
    * When are elements sent to the client, and which elements are sent?
@@ -113,15 +123,14 @@ struct OperationSpecification
 };
 
 
-
-
 /**
  * Signature of functions that create the implementation-specific
  * state for a set supporting a specific operation.
  *
  * @return a set state specific to the supported operation
  */
-typedef struct SetState *(*CreateImpl) (void);
+typedef struct SetState *
+(*CreateImpl) (void);
 
 
 /**
@@ -129,18 +138,21 @@ typedef struct SetState *(*CreateImpl) (void);
  * for a set supporting a specific operation.
  *
  * @param set implementation-specific set state
- * @param msg element message from the client
+ * @param ee element message from the client
  */
-typedef void (*AddRemoveImpl) (struct SetState *state, struct ElementEntry *ee);
+typedef void
+(*AddRemoveImpl) (struct SetState *state,
+                  struct ElementEntry *ee);
 
 
 /**
- * Signature of functions that handle disconnection
- * of the remote peer.
+ * Signature of functions that handle disconnection of the remote
+ * peer.
  *
  * @param op the set operation, contains implementation-specific data
  */
-typedef void (*PeerDisconnectImpl) (struct Operation *op);
+typedef void
+(*PeerDisconnectImpl) (struct Operation *op);
 
 
 /**
@@ -149,16 +161,18 @@ typedef void (*PeerDisconnectImpl) (struct Operation *op);
  *
  * @param state the set state, contains implementation-specific data
  */
-typedef void (*DestroySetImpl) (struct SetState *state);
+typedef void
+(*DestroySetImpl) (struct SetState *state);
 
 
 /**
  * Signature of functions that implement the creation of set operations
- * (currently evaluate and accept).
+ * (currently "evaluate" and "accept").
  *
  * @param op operation that is created, should be initialized by the implementation
  */
-typedef void (*OpCreateImpl) (struct Operation *op);
+typedef void
+(*OpCreateImpl) (struct Operation *op);
 
 
 /**
@@ -167,24 +181,26 @@ typedef void (*OpCreateImpl) (struct Operation *op);
  *
  * @param op operation state
  * @param msg received message
- * @return GNUNET_OK on success, GNUNET_SYSERR to
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR to
  *         destroy the operation and the tunnel
  */
-typedef int (*MsgHandlerImpl) (struct Operation *op,
-                               const struct GNUNET_MessageHeader *msg);
+typedef int
+(*MsgHandlerImpl) (struct Operation *op,
+                   const struct GNUNET_MessageHeader *msg);
+
 
 /**
  * Signature of functions that implement operation cancellation
  *
  * @param op operation state
  */
-typedef void (*CancelImpl) (struct Operation *op);
+typedef void
+(*CancelImpl) (struct Operation *op);
 
 
 /**
- * Dispatch table for a specific set operation.
- * Every set operation has to implement the callback
- * in this struct.
+ * Dispatch table for a specific set operation.  Every set operation
+ * has to implement the callback in this struct.
  */
 struct SetVT
 {
@@ -224,24 +240,21 @@ struct SetVT
   MsgHandlerImpl msg_handler;
 
   /**
-   * Callback for handling the remote peer's
-   * disconnect.
+   * Callback for handling the remote peer's disconnect.
    */
   PeerDisconnectImpl peer_disconnect;
 
   /**
-   * Callback for canceling an operation by
-   * its ID.
+   * Callback for canceling an operation by its ID.
    */
   CancelImpl cancel;
 };
 
 
 /**
- * Information about an element element in the set.
- * All elements are stored in a hash-table
- * from their hash-code to their 'struct Element',
- * so that the remove and add operations are reasonably
+ * Information about an element element in the set.  All elements are
+ * stored in a hash-table from their hash-code to their `struct
+ * Element`, so that the remove and add operations are reasonably
  * fast.
  */
 struct ElementEntry
@@ -253,10 +266,8 @@ struct ElementEntry
   struct GNUNET_SET_Element element;
 
   /**
-   * Hash of the element.
-   * For set union:
-   * Will be used to derive the different IBF keys
-   * for different salts.
+   * Hash of the element.  For set union: Will be used to derive the
+   * different IBF keys for different salts.
    */
   struct GNUNET_HashCode element_hash;
 
@@ -267,32 +278,32 @@ struct ElementEntry
   unsigned int generation_added;
 
   /**
-   * GNUNET_YES if the element has been removed in some generation.
-   */
-  int removed;
-
-  /**
    * Generation the element was removed by the client.
    * Operations of later generations will not consider the element.
-   * Only valid if is_removed is GNUNET_YES.
+   * Only valid if @e removed is #GNUNET_YES.
    */
   unsigned int generation_removed;
 
   /**
-   * GNUNET_YES if the element is a remote element, and does not belong
+   * #GNUNET_YES if the element has been removed in some generation.
+   */
+  int removed;
+
+  /**
+   * #GNUNET_YES if the element is a remote element, and does not belong
    * to the operation's set.
-   *
-   * //TODO: Move to Union, unless additional set-operations are implemented ever
    */
   int remote;
 };
 
 
+/**
+ * Operation context used to execute a set operation.
+ */
 struct Operation
 {
   /**
-   * V-Table for the operation belonging
-   * to the tunnel contest.
+   * V-Table for the operation belonging to the tunnel contest.
    *
    * Used for all operation specific operations after receiving the ops request
    */
@@ -309,21 +320,8 @@ struct Operation
   struct GNUNET_MQ_Handle *mq;
 
   /**
-   * GNUNET_YES if this is not a "real" set operation yet, and we still
-   * need to wait for the other peer to give us more details.
-   */
-  int is_incoming;
-
-  /**
-   * Generation in which the operation handle
-   * was created.
-   */
-  unsigned int generation_created;
-
-  /**
-   * Detail information about the set operation,
-   * including the set to use.
-   * When 'spec' is NULL, the operation is not yet entirely
+   * Detail information about the set operation, including the set to
+   * use.  When 'spec' is NULL, the operation is not yet entirely
    * initialized.
    */
   struct OperationSpecification *spec;
@@ -334,65 +332,70 @@ struct Operation
   struct OperationState *state;
 
   /**
-   * Evaluate operations are held in
-   * a linked list.
+   * Evaluate operations are held in a linked list.
    */
   struct Operation *next;
 
-   /**
-    * Evaluate operations are held in
-    * a linked list.
-    */
+  /**
+   * Evaluate operations are held in a linked list.
+   */
   struct Operation *prev;
 
   /**
-   * Set to GNUNET_YES if the set service should not free
-   * the operation, as it is still needed (e.g. in some scheduled task).
+   * #GNUNET_YES if this is not a "real" set operation yet, and we still
+   * need to wait for the other peer to give us more details.
+   */
+  int is_incoming;
+
+  /**
+   * Generation in which the operation handle
+   * was created.
+   */
+  unsigned int generation_created;
+
+  /**
+   * Set to #GNUNET_YES if the set service should not free the
+   * operation, as it is still needed (e.g. in some scheduled task).
    */
   int keep;
 };
 
 
 /**
- * A set that supports a specific operation
- * with other peers.
+ * A set that supports a specific operation with other peers.
  */
 struct Set
 {
-  /**
-   * Client that owns the set.
-   * Only one client may own a set.
-   */
-  struct GNUNET_SERVER_Client *client;
 
   /**
-   * Message queue for the client
+   * Sets are held in a doubly linked list (in `sets_head` and `sets_tail`).
    */
-  struct GNUNET_MQ_Handle *client_mq;
+  struct Set *next;
 
   /**
-   * Type of operation supported for this set
+   * Sets are held in a doubly linked list.
    */
-  enum GNUNET_SET_OperationType operation;
+  struct Set *prev;
 
   /**
-   * Virtual table for this set.
-   * Determined by the operation type of this set.
-   *
-   * Used only for Add/remove of elements and when receiving an incoming
-   * operation from a remote peer.
+   * Client that owns the set.  Only one client may own a set,
+   * and there can only be one set per client.
    */
-  const struct SetVT *vt;
+  struct GNUNET_SERVER_Client *client;
 
   /**
-   * Sets are held in a doubly linked list.
+   * Message queue for the client.
    */
-  struct Set *next;
+  struct GNUNET_MQ_Handle *client_mq;
 
   /**
-   * Sets are held in a doubly linked list.
+   * Virtual table for this set.  Determined by the operation type of
+   * this set.
+   *
+   * Used only for Add/remove of elements and when receiving an incoming
+   * operation from a remote peer.
    */
-  struct Set *prev;
+  const struct SetVT *vt;
 
   /**
    * Implementation-specific state.
@@ -406,34 +409,39 @@ struct Set
   struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
 
   /**
-   * Maps 'struct GNUNET_HashCode' to 'struct ElementEntry'.
+   * Maps `struct GNUNET_HashCode *` to `struct ElementEntry *`.
    */
   struct GNUNET_CONTAINER_MultiHashMap *elements;
 
   /**
-   * Current generation, that is, number of
-   * previously executed operations on this set
+   * Evaluate operations are held in a linked list.
    */
-  unsigned int current_generation;
+  struct Operation *ops_head;
 
   /**
-   * Evaluate operations are held in
-   * a linked list.
+   * Evaluate operations are held in a linked list.
    */
-  struct Operation *ops_head;
+  struct Operation *ops_tail;
 
   /**
-   * Evaluate operations are held in
-   * a linked list.
+   * Current generation, that is, number of previously executed
+   * operations on this set
    */
-  struct Operation *ops_tail;
+  unsigned int current_generation;
+
+  /**
+   * Type of operation supported for this set
+   */
+  enum GNUNET_SET_OperationType operation;
+
 };
 
 
 /**
- * Destroy the given operation.  Call the implementation-specific cancel function
- * of the operation.  Disconnects from the remote peer.
- * Does not disconnect the client, as there may be multiple operations per set.
+ * Destroy the given operation.  Call the implementation-specific
+ * cancel function of the operation.  Disconnects from the remote
+ * peer.  Does not disconnect the client, as there may be multiple
+ * operations per set.
  *
  * @param op operation to destroy
  */
@@ -442,8 +450,7 @@ _GSS_operation_destroy (struct Operation *op);
 
 
 /**
- * Get the table with implementing functions for
- * set union.
+ * Get the table with implementing functions for set union.
  *
  * @return the operation specific VTable
  */
@@ -452,8 +459,7 @@ _GSS_union_vt (void);
 
 
 /**
- * Get the table with implementing functions for
- * set intersection.
+ * Get the table with implementing functions for set intersection.
  *
  * @return the operation specific VTable
  */
diff --git a/src/set/gnunet-service-set_intersection.c b/src/set/gnunet-service-set_intersection.c
index 27110077e..20fe8682b 100644
--- a/src/set/gnunet-service-set_intersection.c
+++ b/src/set/gnunet-service-set_intersection.c
@@ -17,7 +17,6 @@
       Free Software Foundation, Inc., 59 Temple Place - Suite 330,
       Boston, MA 02111-1307, USA.
 */
-
 /**
  * @file set/gnunet-service-set_intersection.c
  * @brief two-peer set intersection
@@ -86,30 +85,24 @@ struct OperationState
   struct GNUNET_CONTAINER_BloomFilter *local_bf;
 
   /**
-   * for multipart msgs we have to store the bloomfilter-data until we fully sent it.
-   */
-  char * bf_data;
-
-  /**
-   * size of the bloomfilter
+   * Iterator for sending elements on the key to element mapping to the client.
    */
-  uint32_t bf_data_size;
+  struct GNUNET_CONTAINER_MultiHashMapIterator *full_result_iter;
 
   /**
-   * size of the bloomfilter
+   * Evaluate operations are held in a linked list.
    */
-  uint32_t bf_bits_per_element;
+  struct OperationState *next;
 
   /**
-   * Current state of the operation.
+   * Evaluate operations are held in a linked list.
    */
-  enum IntersectionOperationPhase phase;
+  struct OperationState *prev;
 
   /**
-   * Generation in which the operation handle
-   * was created.
+   * for multipart msgs we have to store the bloomfilter-data until we fully sent it.
    */
-  unsigned int generation_created;
+  char *bf_data;
 
   /**
    * Maps element-id-hashes to 'elements in our set'.
@@ -117,26 +110,30 @@ struct OperationState
   struct GNUNET_CONTAINER_MultiHashMap *my_elements;
 
   /**
-   * Current element count contained within contained_elements
+   * Current element count contained within @e my_elements
    */
   uint32_t my_element_count;
 
   /**
-   * Iterator for sending elements on the key to element mapping to the client.
+   * size of the bloomfilter in @e bf_data.
    */
-  struct GNUNET_CONTAINER_MultiHashMapIterator *full_result_iter;
+  uint32_t bf_data_size;
 
   /**
-   * Evaluate operations are held in
-   * a linked list.
+   * size of the bloomfilter
    */
-  struct OperationState *next;
+  uint32_t bf_bits_per_element;
 
-   /**
-    * Evaluate operations are held in
-    * a linked list.
-    */
-  struct OperationState *prev;
+  /**
+   * Current state of the operation.
+   */
+  enum IntersectionOperationPhase phase;
+
+  /**
+   * Generation in which the operation handle
+   * was created.
+   */
+  unsigned int generation_created;
 
   /**
    * Did we send the client that we are done?
@@ -237,6 +234,7 @@ iterator_initialization_by_alice (void *cls,
   return GNUNET_YES;
 }
 
+
 /**
  * fills the contained-elements hashmap with all relevant
  * elements and adds their mutated hashes to our local bloomfilter
@@ -1093,9 +1091,16 @@ intersection_op_cancel (struct Operation *op)
   }*/
   GNUNET_free (op->state);
   op->state = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "destroying intersection op done\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "destroying intersection op done\n");
 }
 
+
+/**
+ * Get the table with implementing functions for set intersection.
+ *
+ * @return the operation specific VTable
+ */
 const struct SetVT *
 _GSS_intersection_vt ()
 {
diff --git a/src/set/gnunet-service-set_union.c b/src/set/gnunet-service-set_union.c
index f7f94cb21..10579779b 100644
--- a/src/set/gnunet-service-set_union.c
+++ b/src/set/gnunet-service-set_union.c
@@ -478,7 +478,8 @@ op_has_element (struct Operation *op, const struct GNUNET_HashCode *element_hash
  * @param ee the element entry
  */
 static void
-op_register_element (struct Operation *op, struct ElementEntry *ee)
+op_register_element (struct Operation *op,
+                     struct ElementEntry *ee)
 {
   int ret;
   struct IBF_Key ibf_key;
@@ -1089,7 +1090,8 @@ handle_p2p_elements (void *cls, const struct GNUNET_MessageHeader *mh)
   struct ElementEntry *ee;
   uint16_t element_size;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got element from peer\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "got element from peer\n");
 
   if ( (op->state->phase != PHASE_EXPECT_ELEMENTS) &&
        (op->state->phase != PHASE_EXPECT_ELEMENTS_AND_REQUESTS) )
@@ -1099,16 +1101,19 @@ handle_p2p_elements (void *cls, const struct GNUNET_MessageHeader *mh)
     return;
   }
   element_size = ntohs (mh->size) - sizeof (struct GNUNET_MessageHeader);
-  ee = GNUNET_malloc (sizeof *ee + element_size);
+  ee = GNUNET_malloc (sizeof (struct ElementEntry) + element_size);
   memcpy (&ee[1], &mh[1], element_size);
   ee->element.size = element_size;
   ee->element.data = &ee[1];
   ee->remote = GNUNET_YES;
-  GNUNET_CRYPTO_hash (ee->element.data, ee->element.size, &ee->element_hash);
+  GNUNET_CRYPTO_hash (ee->element.data,
+                      ee->element.size,
+                      &ee->element_hash);
 
   if (GNUNET_YES == op_has_element (op, &ee->element_hash))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got existing element from peer\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "got existing element from peer\n");
     GNUNET_free (ee);
     return;
   }
@@ -1127,7 +1132,8 @@ handle_p2p_elements (void *cls, const struct GNUNET_MessageHeader *mh)
  * @param mh the message
  */
 static void
-handle_p2p_element_requests (void *cls, const struct GNUNET_MessageHeader *mh)
+handle_p2p_element_requests (void *cls,
+                             const struct GNUNET_MessageHeader *mh)
 {
   struct Operation *op = cls;
   struct IBF_Key *ibf_key;