- opaque mq structs

- mq for mesh
- faster hashing for IBFs
- mesh replaces stream in set
- new set profiler (work in progress)

13 files changed, 755 insertions, 487 deletions

diff --git a/src/set/Makefile.am b/src/set/Makefile.am
index 71e71c867..c2449e0ea 100644
--- a/src/set/Makefile.am
+++ b/src/set/Makefile.am
@@ -16,7 +16,7 @@ if USE_COVERAGE
 endif
 
 bin_PROGRAMS = \
- gnunet-set
+ gnunet-set-profiler gnunet-set-ibf-profiler
 
 libexec_PROGRAMS = \
  gnunet-service-set
@@ -24,17 +24,24 @@ libexec_PROGRAMS = \
 lib_LTLIBRARIES = \
   libgnunetset.la
 
-gnunet_set_SOURCES = \
- gnunet-set.c
-gnunet_set_LDADD = \
+gnunet_set_profiler_SOURCES = \
+ gnunet-set-profiler.c
+gnunet_set_profiler_LDADD = \
   $(top_builddir)/src/util/libgnunetutil.la \
   $(top_builddir)/src/set/libgnunetset.la \
-  $(top_builddir)/src/stream/libgnunetstream.la \
-  $(top_builddir)/src/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/testing/libgnunettesting.la \
   $(GN_LIBINTL)
-gnunet_set_DEPENDENCIES = \
+gnunet_set_profiler_DEPENDENCIES = \
   libgnunetset.la
 
+
+gnunet_set_ibf_profiler_SOURCES = \
+ gnunet-set-ibf-profiler.c \
+ ibf.c
+gnunet_set_ibf_profiler_LDADD = \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  $(GN_LIBINTL)
+
 gnunet_service_set_SOURCES = \
  gnunet-service-set.c \
  gnunet-service-set_union.c \
@@ -43,8 +50,7 @@ gnunet_service_set_SOURCES = \
 gnunet_service_set_LDADD = \
   $(top_builddir)/src/util/libgnunetutil.la \
   $(top_builddir)/src/core/libgnunetcore.la \
-  $(top_builddir)/src/stream/libgnunetstream.la \
-  $(top_builddir)/src/mesh/libgnunetmesh.la \
+  $(top_builddir)/src/mesh/libgnunetmesh2.la \
   $(GN_LIBINTL)
 
 libgnunetset_la_SOURCES = \
diff --git a/src/set/gnunet-service-set.c b/src/set/gnunet-service-set.c
index d2f0b48d5..bd934de84 100644
--- a/src/set/gnunet-service-set.c
+++ b/src/set/gnunet-service-set.c
@@ -29,13 +29,16 @@
 
 /**
  * Configuration of our local peer.
+ * (Not declared 'static' as also needed in gnunet-service-set_union.c)
  */
 const struct GNUNET_CONFIGURATION_Handle *configuration;
 
 /**
- * Socket listening for other peers via stream.
+ * Handle to the mesh service, used
+ * to listen for and connect to remote peers.
+ * (Not declared 'static' as also needed in gnunet-service-set_union.c)
  */
-static struct GNUNET_STREAM_ListenSocket *stream_listen_socket;
+struct GNUNET_MESH_Handle *mesh;
 
 /**
  * Sets are held in a doubly linked list.
@@ -78,14 +81,14 @@ static uint32_t accept_id = 1;
 
 
 /**
- * Get set that is owned by the client, if any.
+ * Get set that is owned by the given client, if any.
  *
  * @param client client to look for
  * @return set that the client owns, NULL if the client
  *         does not own a set
  */
 static struct Set *
-get_set (struct GNUNET_SERVER_Client *client)
+set_get (struct GNUNET_SERVER_Client *client)
 {
   struct Set *set;
   for (set = sets_head; NULL != set; set = set->next)
@@ -137,7 +140,7 @@ get_incoming (uint32_t id)
  * @param listener listener to destroy
  */
 static void
-destroy_listener (struct Listener *listener)
+listener_destroy (struct Listener *listener)
 {
   if (NULL != listener->client_mq)
   {
@@ -155,7 +158,7 @@ destroy_listener (struct Listener *listener)
  * @param set the set to destroy
  */
 static void
-destroy_set (struct Set *set)
+set_destroy (struct Set *set)
 {
   switch (set->operation)
   {
@@ -187,12 +190,12 @@ handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
   struct Set *set;
   struct Listener *listener;
 
-  set = get_set (client);
+  set = set_get (client);
   if (NULL != set)
-    destroy_set (set);
+    set_destroy (set);
   listener = get_listener (client);
   if (NULL != listener)
-    destroy_listener (listener);
+    listener_destroy (listener);
 }
 
 
@@ -202,17 +205,14 @@ handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
  * @param incoming remote request to destroy
  */
 static void
-destroy_incoming (struct Incoming *incoming)
+incoming_destroy (struct Incoming *incoming)
 {
-  if (NULL != incoming->mq)
+  if (NULL != incoming->tc)
   {
-    GNUNET_MQ_destroy (incoming->mq);
-    incoming->mq = NULL;
-  }
-  if (NULL != incoming->socket)
-  {
-    GNUNET_STREAM_close (incoming->socket);
-    incoming->socket = NULL;
+    GNUNET_free (incoming->tc);
+    GNUNET_assert (NULL != incoming->tc->tunnel);
+    GNUNET_MESH_tunnel_destroy (incoming->tc->tunnel);
+    incoming->tc = NULL;
   }
   GNUNET_CONTAINER_DLL_remove (incoming_head, incoming_tail, incoming);
   GNUNET_free (incoming);
@@ -237,6 +237,15 @@ get_listener_by_target (enum GNUNET_SET_OperationType op,
 }
 
 
+
+static void
+tunnel_context_destroy (struct TunnelContext *tc)
+{
+  GNUNET_free (tc);
+  /* FIXME destroy the rest */
+}
+
+
 /**
  * Handle a request for a set operation from
  * another peer.
@@ -244,16 +253,31 @@ get_listener_by_target (enum GNUNET_SET_OperationType op,
  * @param cls the incoming socket
  * @param mh the message
  */
-static void
-handle_p2p_operation_request (void *cls, const struct GNUNET_MessageHeader *mh)
+static int
+handle_p2p_operation_request (void *cls,
+                              struct GNUNET_MESH_Tunnel *tunnel,
+                              void **tunnel_ctx,
+                              const struct GNUNET_PeerIdentity *sender,
+                              const struct GNUNET_MessageHeader *mh)
 {
-  struct Incoming *incoming = cls;
+  struct TunnelContext *tc = *tunnel_ctx;
+  struct Incoming *incoming;
   const struct OperationRequestMessage *msg = (const struct OperationRequestMessage *) mh;
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_SET_RequestMessage *cmsg;
   struct Listener *listener;
   const struct GNUNET_MessageHeader *context_msg;
 
+  if (CONTEXT_INCOMING != tc->type)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "unexpected operation request\n");
+    tunnel_context_destroy (tc);
+    /* don't kill the whole mesh connection */
+    return GNUNET_OK;
+  }
+
+  incoming = tc->data;
+
   context_msg = GNUNET_MQ_extract_nested_mh (msg);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "received P2P operation request (op %u, app %s)\n",
               ntohs (msg->operation), GNUNET_h2s (&msg->app_id));
@@ -263,20 +287,26 @@ handle_p2p_operation_request (void *cls, const struct GNUNET_MessageHeader *mh)
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "set operation request from peer failed: "
                 "no set with matching application ID and operation type\n");
-    return;
+    tunnel_context_destroy (tc);
+    /* don't kill the whole mesh connection */
+    return GNUNET_OK;
   }
   mqm = GNUNET_MQ_msg_nested_mh (cmsg, GNUNET_MESSAGE_TYPE_SET_REQUEST, context_msg);
   if (NULL == mqm)
   {
     /* FIXME: disconnect the peer */
     GNUNET_break_op (0);
-    return;
+    tunnel_context_destroy (tc);
+    /* don't kill the whole mesh connection */
+    return GNUNET_OK;
   }
   incoming->accept_id = accept_id++;
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "sending request with accept id %u\n", incoming->accept_id);
   cmsg->accept_id = htonl (incoming->accept_id);
-  cmsg->peer_id = incoming->peer;
+  cmsg->peer_id = incoming->tc->peer;
   GNUNET_MQ_send (listener->client_mq, mqm);
+
+  return GNUNET_OK;
 }
 
 
@@ -298,7 +328,7 @@ handle_client_create (void *cls,
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "client created new set (operation %u)\n",
               ntohs (msg->operation));
 
-  if (NULL != get_set (client))
+  if (NULL != set_get (client))
   {
     GNUNET_break (0);
     GNUNET_SERVER_client_disconnect (client);
@@ -379,7 +409,7 @@ handle_client_remove (void *cls,
 {
   struct Set *set;
 
-  set = get_set (client);
+  set = set_get (client);
   if (NULL == set)
   {
     GNUNET_break (0);
@@ -428,7 +458,7 @@ handle_client_reject (void *cls,
     return;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "peer request rejected by client\n");
-  destroy_incoming (incoming);
+  incoming_destroy (incoming);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
@@ -449,7 +479,7 @@ handle_client_add (void *cls,
 {
   struct Set *set;
 
-  set = get_set (client);
+  set = set_get (client);
   if (NULL == set)
   {
     GNUNET_break (0);
@@ -486,7 +516,7 @@ handle_client_evaluate (void *cls,
 {
   struct Set *set;
 
-  set = get_set (client);
+  set = set_get (client);
   if (NULL == set)
   {
     GNUNET_break (0);
@@ -558,8 +588,7 @@ handle_client_accept (void *cls,
     return;
   }
 
-
-  set = get_set (client);
+  set = set_get (client);
 
   if (NULL == set)
   {
@@ -584,51 +613,12 @@ handle_client_accept (void *cls,
 
   /* note: _GSS_*_accept has to make sure the socket and mq are set to NULL,
    * otherwise they will be destroyed and disconnected */
-  destroy_incoming (incoming);
+  incoming_destroy (incoming);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
 
 /**
- * Functions of this type are called upon new stream connection from other peers
- * or upon binding error which happen when the app_port given in
- * GNUNET_STREAM_listen() is already taken.
- *
- * @param cls the closure from GNUNET_STREAM_listen
- * @param socket the socket representing the stream; NULL on binding error
- * @param initiator the identity of the peer who wants to establish a stream
- *            with us; NULL on binding error
- * @return GNUNET_OK to keep the socket open, GNUNET_SYSERR to close the
- *             stream (the socket will be invalid after the call)
- */
-static int
-stream_listen_cb (void *cls,
-                  struct GNUNET_STREAM_Socket *socket,
-                  const struct GNUNET_PeerIdentity *initiator)
-{
-  struct Incoming *incoming;
-  static const struct GNUNET_MQ_Handler handlers[] = {
-    {handle_p2p_operation_request, GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST},
-    GNUNET_MQ_HANDLERS_END
-  };
-
-  if (NULL == socket)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-
-  incoming = GNUNET_new (struct Incoming);
-  incoming->peer = *initiator;
-  incoming->socket = socket;
-  incoming->mq = GNUNET_STREAM_mq_create (incoming->socket, handlers, NULL, incoming);
-  /* FIXME: timeout for peers that only connect but don't send anything */
-  GNUNET_CONTAINER_DLL_insert_tail (incoming_head, incoming_tail, incoming);
-  return GNUNET_OK;
-}
-
-
-/**
  * Called to clean up, after a shutdown has been requested.
  *
  * @param cls closure
@@ -638,31 +628,126 @@ static void
 shutdown_task (void *cls,
                const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  if (NULL != stream_listen_socket)
+  if (NULL != mesh)
   {
-    GNUNET_STREAM_listen_close (stream_listen_socket);
-    stream_listen_socket = NULL;
+    GNUNET_MESH_disconnect (mesh);
+    mesh = NULL;
   }
 
   while (NULL != incoming_head)
   {
-    destroy_incoming (incoming_head);
+    incoming_destroy (incoming_head);
   }
 
   while (NULL != listeners_head)
   {
-    destroy_listener (listeners_head);
+    listener_destroy (listeners_head);
   }
 
   while (NULL != sets_head)
   {
-    destroy_set (sets_head);
+    set_destroy (sets_head);
   }
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "handled shutdown request\n");
 }
 
 
+
+/**
+ * Signature of the main function of a task.
+ *
+ * @param cls closure
+ * @param tc context information (why was this task triggered now)
+ */
+static void
+incoming_timeout_cb (void *cls,
+                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct Incoming *incoming = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "remote peer timed out");
+  incoming_destroy (incoming);
+}
+
+
+/**
+ * Method called whenever another peer has added us to a tunnel
+ * the other peer initiated.
+ * Only called (once) upon reception of data with a message type which was
+ * subscribed to in GNUNET_MESH_connect. A call to GNUNET_MESH_tunnel_destroy
+ * causes te tunnel to be ignored and no further notifications are sent about
+ * the same tunnel.
+ *
+ * @param cls closure
+ * @param tunnel new handle to the tunnel
+ * @param initiator peer that started the tunnel
+ * @param port Port this tunnel is for.
+ * @return initial tunnel context for the tunnel
+ *         (can be NULL -- that's not an error)
+ */
+static void *
+tunnel_new_cb (void *cls,
+               struct GNUNET_MESH_Tunnel *tunnel,
+               const struct GNUNET_PeerIdentity *initiator,
+               uint32_t port)
+{
+  struct Incoming *incoming;
+  struct TunnelContext *tc;
+
+  GNUNET_assert (port == GNUNET_APPLICATION_TYPE_SET);
+  tc = GNUNET_new (struct TunnelContext);
+  incoming = GNUNET_new (struct Incoming);
+  incoming->tc = tc;
+  tc->peer = *initiator;
+  tc->tunnel = tunnel;
+  tc->mq = GNUNET_MESH_mq_create (tunnel);
+  tc->data = incoming;
+  tc->type = CONTEXT_INCOMING;
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, incoming_timeout_cb, incoming);
+  GNUNET_CONTAINER_DLL_insert_tail (incoming_head, incoming_tail, incoming);
+
+  return tc;
+}
+
+
+/**
+ * Function called whenever a tunnel is destroyed.  Should clean up
+ * any associated state.  This function is NOT called if the client has
+ * explicitly asked for the tunnel to be destroyed using
+ * GNUNET_MESH_tunnel_destroy. It must NOT call GNUNET_MESH_tunnel_destroy on
+ * the tunnel.
+ *
+ * @param cls closure (set from GNUNET_MESH_connect)
+ * @param tunnel connection to the other end (henceforth invalid)
+ * @param tunnel_ctx place where local state associated
+ *                   with the tunnel is stored
+ */
+static void
+tunnel_end_cb (void *cls,
+               const struct GNUNET_MESH_Tunnel *tunnel, void *tunnel_ctx)
+{
+  struct TunnelContext *ctx = tunnel_ctx;
+
+  switch (ctx->type)
+  {
+    case CONTEXT_INCOMING:
+      incoming_destroy ((struct Incoming *) ctx->data);
+      break;
+    case CONTEXT_OPERATION_UNION:
+      _GSS_union_operation_destroy ((struct UnionEvaluateOperation *) ctx->data);
+      break;
+    case CONTEXT_OPERATION_INTERSECTION:
+      GNUNET_assert (0);
+      /* FIXME: cfuchs */
+      break;
+    default:
+      GNUNET_assert (0);
+  }
+
+}
+
+
 /**
  * Function called by the service's run
  * method to run service-specific setup code.
@@ -686,16 +771,40 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
     {handle_client_remove, NULL, GNUNET_MESSAGE_TYPE_SET_REMOVE, 0},
     {NULL, NULL, 0, 0}
   };
+  static const struct GNUNET_MESH_MessageHandler mesh_handlers[] = {
+    {handle_p2p_operation_request,
+      GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, 0},
+    /* messages for the union operation */
+    {_GSS_union_handle_p2p_message,
+      GNUNET_MESSAGE_TYPE_SET_P2P_IBF, 0},
+    {_GSS_union_handle_p2p_message,
+      GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS, 0},
+    {_GSS_union_handle_p2p_message,
+      GNUNET_MESSAGE_TYPE_SET_P2P_DONE, 0},
+    {_GSS_union_handle_p2p_message,
+      GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENT_REQUESTS, 0},
+    {_GSS_union_handle_p2p_message,
+      GNUNET_MESSAGE_TYPE_SET_P2P_SE, 0},
+    /* FIXME: messages for intersection operation */
+    {NULL, 0, 0}
+  };
+  static const uint32_t mesh_ports[] = {GNUNET_APPLICATION_TYPE_SET, 0};
 
   configuration = cfg;
-  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task, NULL);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
+                                &shutdown_task, NULL);
   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
   GNUNET_SERVER_add_handlers (server, server_handlers);
-  stream_listen_socket = GNUNET_STREAM_listen (cfg, GNUNET_APPLICATION_TYPE_SET,
-                                               &stream_listen_cb, NULL,
-                                               GNUNET_STREAM_OPTION_END);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "set service running\n");
+  mesh = GNUNET_MESH_connect (cfg, NULL, tunnel_new_cb, tunnel_end_cb,
+                              mesh_handlers, mesh_ports);
+  if (NULL == mesh)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "could not connect to mesh\n");
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "service started\n");
 }
 
 
@@ -710,7 +819,8 @@ int
 main (int argc, char *const *argv)
 {
   int ret;
-  ret = GNUNET_SERVICE_run (argc, argv, "set", GNUNET_SERVICE_OPTION_NONE, &run, NULL);
+  ret = GNUNET_SERVICE_run (argc, argv, "set",
+                            GNUNET_SERVICE_OPTION_NONE, &run, NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "exit\n");
   return (GNUNET_OK == ret) ? 0 : 1;
 }
diff --git a/src/set/gnunet-service-set.h b/src/set/gnunet-service-set.h
index 15199eba4..66bff4ff1 100644
--- a/src/set/gnunet-service-set.h
+++ b/src/set/gnunet-service-set.h
@@ -33,7 +33,7 @@
 #include "gnunet_applications.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_core_service.h"
-#include "gnunet_stream_lib.h"
+#include "gnunet_mesh2_service.h"
 #include "gnunet_set_service.h"
 #include "set.h"
 
@@ -47,6 +47,8 @@ struct IntersectionState;
  */
 struct UnionState;
 
+struct UnionEvaluateOperation;
+
 
 /**
  * A set that supports a specific operation
@@ -63,7 +65,7 @@ struct Set
   /**
    * Message queue for the client
    */
-  struct GNUNET_MQ_MessageQueue *client_mq;
+  struct GNUNET_MQ_Handle *client_mq;
 
   /**
    * Type of operation supported for this set
@@ -116,7 +118,7 @@ struct Listener
   /**
    * Message queue for the client
    */
-  struct GNUNET_MQ_MessageQueue *client_mq;
+  struct GNUNET_MQ_Handle *client_mq;
 
   /**
    * Type of operation supported for this set
@@ -148,19 +150,17 @@ struct Incoming
   struct Incoming *prev;
 
   /**
-   * Identity of the peer that connected to us
+   * Tunnel context, stores information about
+   * the tunnel and its peer.
    */
-  struct GNUNET_PeerIdentity peer;
+  struct TunnelContext *tc;
 
   /**
-   * Socket connected to the peer
+   * GNUNET_YES if the incoming peer has sent
+   * an operation request (and we are waiting
+   * for the client to ack/nack), GNUNET_NO otherwise.
    */
-  struct GNUNET_STREAM_Socket *socket;
-
-  /**
-   * Message queue for the peer
-   */
-  struct GNUNET_MQ_MessageQueue *mq;
+  int received_request;
 
   /**
    * App code, set once the peer has
@@ -187,18 +187,37 @@ struct Incoming
 
   /**
    * Unique request id for the request from
-   * a remote peer, sent to the client with will
+   * a remote peer, sent to the client, which will
    * accept or reject the request.
    */
   uint32_t accept_id;
 };
 
 
+enum TunnelContextType {
+  CONTEXT_INCOMING,
+  CONTEXT_OPERATION_UNION,
+  CONTEXT_OPERATION_INTERSECTION,
+};
+
+struct TunnelContext
+{
+  struct GNUNET_MESH_Tunnel *tunnel;
+  struct GNUNET_PeerIdentity peer;
+  struct GNUNET_MQ_Handle *mq;
+  enum TunnelContextType type;
+  void *data;
+};
+
+
+
 /**
  * Configuration of the local peer
  */
 extern const struct GNUNET_CONFIGURATION_Handle *configuration;
 
+extern struct GNUNET_MESH_Handle *mesh;
+
 
 /**
  * Create a new set supporting the union operation
@@ -262,4 +281,32 @@ _GSS_union_accept (struct GNUNET_SET_AcceptRejectMessage *m, struct Set *set,
                    struct Incoming *incoming);
 
 
+/**
+ * Destroy a union operation, and free all resources
+ * associated with it.
+ *
+ * @param eo the union operation to destroy
+ */
+void
+_GSS_union_operation_destroy (struct UnionEvaluateOperation *eo);
+
+
+/**
+ * Dispatch messages for a union operation.
+ *
+ * @param cls closure
+ * @param tunnel mesh tunnel
+ * @param tunnel_ctx tunnel context
+ * @param sender ???
+ * @param mh message to process
+ * @return ???
+ */
+int
+_GSS_union_handle_p2p_message (void *cls,
+                               struct GNUNET_MESH_Tunnel *tunnel,
+                               void **tunnel_ctx,
+                               const struct GNUNET_PeerIdentity *sender,
+                               const struct GNUNET_MessageHeader *mh);
+
+
 #endif
diff --git a/src/set/gnunet-service-set_union.c b/src/set/gnunet-service-set_union.c
index 6d9658ee5..2b7a0ccba 100644
--- a/src/set/gnunet-service-set_union.c
+++ b/src/set/gnunet-service-set_union.c
@@ -124,15 +124,10 @@ struct UnionEvaluateOperation
   struct GNUNET_MessageHeader *context_msg;
 
   /**
-   * Stream socket connected to the other peer
+   * Tunnel context for the peer we
+   * evaluate the union operation with.
    */
-  struct GNUNET_STREAM_Socket *socket;
-
-  /**
-   * Message queue for the peer on the other
-   * end
-   */
-  struct GNUNET_MQ_MessageQueue *mq;
+  struct TunnelContext *tc;
 
   /**
    * Request ID to multiplex set operations to
@@ -397,22 +392,19 @@ destroy_key_to_element_iter (void *cls,
  *
  * @param eo the union operation to destroy
  */
-static void
-destroy_union_operation (struct UnionEvaluateOperation *eo)
+void
+_GSS_union_operation_destroy (struct UnionEvaluateOperation *eo)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "destroying union op\n");
   
-  if (NULL != eo->mq)
+  if (NULL != eo->tc)
   {
-    GNUNET_MQ_destroy (eo->mq);
-    eo->mq = NULL;
+    GNUNET_MQ_destroy (eo->tc->mq);
+    GNUNET_MESH_tunnel_destroy (eo->tc->tunnel);
+    GNUNET_free (eo->tc);
+    eo->tc = NULL;
   }
 
-  if (NULL != eo->socket)
-  {
-    GNUNET_STREAM_close (eo->socket);
-    eo->socket = NULL;
-  }
   if (NULL != eo->remote_ibf)
   {
     ibf_destroy (eo->remote_ibf);
@@ -457,14 +449,14 @@ destroy_union_operation (struct UnionEvaluateOperation *eo)
 static void
 fail_union_operation (struct UnionEvaluateOperation *eo)
 {
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_SET_ResultMessage *msg;
 
   mqm = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SET_RESULT);
   msg->result_status = htons (GNUNET_SET_STATUS_FAILURE);
   msg->request_id = htonl (eo->request_id);
   GNUNET_MQ_send (eo->set->client_mq, mqm);
-  destroy_union_operation (eo);
+  _GSS_union_operation_destroy (eo);
 }
 
 
@@ -498,7 +490,7 @@ get_ibf_key (struct GNUNET_HashCode *src, uint16_t salt)
 static void
 send_operation_request (struct UnionEvaluateOperation *eo)
 {
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct OperationRequestMessage *msg;
 
   mqm = GNUNET_MQ_msg_nested_mh (msg, GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, eo->context_msg);
@@ -512,7 +504,7 @@ send_operation_request (struct UnionEvaluateOperation *eo)
   }
   msg->operation = htons (GNUNET_SET_OPERATION_UNION);
   msg->app_id = eo->app_id;
-  GNUNET_MQ_send (eo->mq, mqm);
+  GNUNET_MQ_send (eo->tc->mq, mqm);
 
   if (NULL != eo->context_msg)
   {
@@ -562,7 +554,7 @@ insert_element_iterator (void *cls,
  * Insert an element into the union operation's
  * key-to-element mapping
  *
- * @param the union operation
+ * @param eo the union operation
  * @param ee the element entry
  */
 static void
@@ -685,7 +677,7 @@ send_ibf (struct UnionEvaluateOperation *eo, uint16_t ibf_order)
   while (buckets_sent < (1 << ibf_order))
   {
     unsigned int buckets_in_message;
-    struct GNUNET_MQ_Message *mqm;
+    struct GNUNET_MQ_Envelope *mqm;
     struct IBFMessage *msg;
 
     buckets_in_message = (1 << ibf_order) - buckets_sent;
@@ -700,7 +692,7 @@ send_ibf (struct UnionEvaluateOperation *eo, uint16_t ibf_order)
     ibf_write_slice (ibf, buckets_sent,
                      buckets_in_message, &msg[1]);
     buckets_sent += buckets_in_message;
-    GNUNET_MQ_send (eo->mq, mqm);
+    GNUNET_MQ_send (eo->tc->mq, mqm);
   }
 
   eo->phase = PHASE_EXPECT_ELEMENTS_AND_REQUESTS;
@@ -715,14 +707,14 @@ send_ibf (struct UnionEvaluateOperation *eo, uint16_t ibf_order)
 static void
 send_strata_estimator (struct UnionEvaluateOperation *eo)
 {
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_MessageHeader *strata_msg;
 
   mqm = GNUNET_MQ_msg_header_extra (strata_msg,
                                     SE_STRATA_COUNT * IBF_BUCKET_SIZE * SE_IBF_SIZE,
                                     GNUNET_MESSAGE_TYPE_SET_P2P_SE);
   strata_estimator_write (eo->set->state.u->se, &strata_msg[1]);
-  GNUNET_MQ_send (eo->mq, mqm);
+  GNUNET_MQ_send (eo->tc->mq, mqm);
   eo->phase = PHASE_EXPECT_IBF;
 }
 
@@ -751,7 +743,7 @@ get_order_from_difference (unsigned int diff)
 /**
  * Handle a strata estimator from a remote peer
  *
- * @param the union operation
+ * @param cls the union operation
  * @param mh the message
  */
 static void
@@ -804,7 +796,7 @@ send_element_iterator (void *cls,
   while (NULL != ke)
   {
     const struct GNUNET_SET_Element *const element = &ke->element->element;
-    struct GNUNET_MQ_Message *mqm;
+    struct GNUNET_MQ_Envelope *mqm;
     struct GNUNET_MessageHeader *mh;
 
     GNUNET_assert (ke->ibf_key.key_val == ibf_key.key_val);
@@ -817,7 +809,7 @@ send_element_iterator (void *cls,
     }
     memcpy (&mh[1], element->data, element->size);
     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "sending element to client\n");
-    GNUNET_MQ_send (eo->mq, mqm);
+    GNUNET_MQ_send (eo->tc->mq, mqm);
     ke = ke->next_colliding;
   }
   return GNUNET_NO;
@@ -889,11 +881,11 @@ decode_and_send (struct UnionEvaluateOperation *eo)
     }
     if (GNUNET_NO == res)
     {
-      struct GNUNET_MQ_Message *mqm;
+      struct GNUNET_MQ_Envelope *mqm;
 
       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "transmitted all values, sending DONE\n");
       mqm = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_P2P_DONE);
-      GNUNET_MQ_send (eo->mq, mqm);
+      GNUNET_MQ_send (eo->tc->mq, mqm);
       break;
     }
     if (1 == side)
@@ -902,7 +894,7 @@ decode_and_send (struct UnionEvaluateOperation *eo)
     }
     else
     {
-      struct GNUNET_MQ_Message *mqm;
+      struct GNUNET_MQ_Envelope *mqm;
       struct GNUNET_MessageHeader *msg;
 
       /* FIXME: before sending the request, check if we may just have the element */
@@ -910,7 +902,7 @@ decode_and_send (struct UnionEvaluateOperation *eo)
       mqm = GNUNET_MQ_msg_header_extra (msg, sizeof (struct IBF_Key),
                                         GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENT_REQUESTS);
       *(struct IBF_Key *) &msg[1] = key;
-      GNUNET_MQ_send (eo->mq, mqm);
+      GNUNET_MQ_send (eo->tc->mq, mqm);
     }
   }
   ibf_destroy (diff_ibf);
@@ -987,7 +979,7 @@ static void
 send_client_element (struct UnionEvaluateOperation *eo,
                      struct GNUNET_SET_Element *element)
 {
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_SET_ResultMessage *rm;
 
   GNUNET_assert (0 != eo->request_id);
@@ -1006,39 +998,17 @@ send_client_element (struct UnionEvaluateOperation *eo,
 
 
 /**
- * Completion callback for shutdown
- *
- * @param cls the closure from GNUNET_STREAM_shutdown call
- * @param operation the operation that was shutdown (SHUT_RD, SHUT_WR,
- *          SHUT_RDWR) 
- */
-/*
-static void 
-stream_shutdown_cb (void *cls,
-                    int operation)
-{
-  //struct UnionEvaluateOperation *eo = cls;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "stream shutdown\n");
-
-  // destroy_union_operation (eo);
-}
-*/
-
-
-/**
  * Send a result message to the client indicating
  * that the operation is over.
  * After the result done message has been sent to the client,
  * destroy the evaluate operation.
  *
  * @param eo union operation
- * @param element element to send
  */
 static void
 send_client_done_and_destroy (struct UnionEvaluateOperation *eo)
 {
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_SET_ResultMessage *rm;
 
   GNUNET_assert (0 != eo->request_id);
@@ -1047,7 +1017,6 @@ send_client_done_and_destroy (struct UnionEvaluateOperation *eo)
   rm->result_status = htons (GNUNET_SET_STATUS_DONE);
   GNUNET_MQ_send (eo->set->client_mq, mqm);
 
-  // GNUNET_STREAM_shutdown (eo->socket, SHUT_RDWR, stream_shutdown_cb, eo);
 }
 
 
@@ -1153,13 +1122,13 @@ handle_p2p_done (void *cls, const struct GNUNET_MessageHeader *mh)
   if (eo->phase == PHASE_EXPECT_ELEMENTS_AND_REQUESTS)
   {
     /* we got all requests, but still have to send our elements as response */
-    struct GNUNET_MQ_Message *mqm;
+    struct GNUNET_MQ_Envelope *mqm;
 
     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "got DONE, sending final DONE after elements\n");
     eo->phase = PHASE_FINISHED;
     mqm = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_P2P_DONE);
     GNUNET_MQ_notify_sent (mqm, peer_done_sent_cb, eo);
-    GNUNET_MQ_send (eo->mq, mqm);
+    GNUNET_MQ_send (eo->tc->mq, mqm);
     return;
   }
   if (eo->phase == PHASE_EXPECT_ELEMENTS)
@@ -1175,48 +1144,11 @@ handle_p2p_done (void *cls, const struct GNUNET_MessageHeader *mh)
 
 
 /**
- * The handlers array, used for both evaluate and accept
- */
-static const struct GNUNET_MQ_Handler union_handlers[] = {
-  {handle_p2p_elements, GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS},
-  {handle_p2p_strata_estimator, GNUNET_MESSAGE_TYPE_SET_P2P_SE},
-  {handle_p2p_ibf, GNUNET_MESSAGE_TYPE_SET_P2P_IBF},
-  {handle_p2p_element_requests, GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENT_REQUESTS},
-  {handle_p2p_done, GNUNET_MESSAGE_TYPE_SET_P2P_DONE},
-  GNUNET_MQ_HANDLERS_END
-};
-
-
-/**
- * Functions of this type will be called when a stream is established
- * 
- * @param cls the closure from GNUNET_STREAM_open
- * @param socket socket to use to communicate with the
- *        other side (read/write)
- */
-static void
-stream_open_cb (void *cls,
-                struct GNUNET_STREAM_Socket *socket)
-{
-  struct UnionEvaluateOperation *eo = cls;
-
-  GNUNET_assert (NULL == eo->mq);
-  GNUNET_assert (socket == eo->socket);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
-              "open cb successful\n");
-  eo->mq = GNUNET_STREAM_mq_create (eo->socket, union_handlers, NULL, eo);
-  /* we started the operation, thus we have to send the operation request */
-  send_operation_request (eo);
-  eo->phase = PHASE_EXPECT_SE;
-}
-
-
-/**
  * Evaluate a union operation with
  * a remote peer.
  *
  * @param m the evaluate request message from the client
- * @parem set the set to evaluate the operation with
+ * @param set the set to evaluate the operation with
  */
 void
 _GSS_union_evaluate (struct GNUNET_SET_EvaluateMessage *m, struct Set *set)
@@ -1243,14 +1175,20 @@ _GSS_union_evaluate (struct GNUNET_SET_EvaluateMessage *m, struct Set *set)
               "evaluating union operation, (app %s)\n", 
               GNUNET_h2s (&eo->app_id));
 
-  eo->socket = 
-      GNUNET_STREAM_open (configuration, &eo->peer, GNUNET_APPLICATION_TYPE_SET,
-                          &stream_open_cb, eo,
-                          GNUNET_STREAM_OPTION_END);
+  eo->tc = GNUNET_new (struct TunnelContext);
+  eo->tc->tunnel = GNUNET_MESH_tunnel_create (mesh, eo->tc, &eo->peer,
+                                              GNUNET_APPLICATION_TYPE_SET);
+  GNUNET_assert (NULL != eo->tc->tunnel);
+  eo->tc->peer = eo->peer;
+  eo->tc->mq = GNUNET_MESH_mq_create (eo->tc->tunnel);
+  /* we started the operation, thus we have to send the operation request */
+  eo->phase = PHASE_EXPECT_SE;
+
   GNUNET_CONTAINER_DLL_insert (eo->set->state.u->ops_head,
                                eo->set->state.u->ops_tail,
                                eo);
-  /* the stream open callback will kick off the operation */
+
+  send_operation_request (eo);
 }
 
 
@@ -1270,25 +1208,17 @@ _GSS_union_accept (struct GNUNET_SET_AcceptRejectMessage *m, struct Set *set,
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "accepting set union operation\n");
 
   eo = GNUNET_new (struct UnionEvaluateOperation);
+  eo->tc = incoming->tc;
   eo->generation_created = set->state.u->current_generation++;
   eo->set = set;
-  eo->peer = incoming->peer;
   eo->salt = ntohs (incoming->salt);
   GNUNET_assert (0 != ntohl (m->request_id));
   eo->request_id = ntohl (m->request_id);
   eo->se = strata_estimator_dup (set->state.u->se);
-  eo->mq = incoming->mq;
   /* transfer ownership of mq and socket from incoming to eo */
-  incoming->mq = NULL;
-  eo->socket = incoming->socket;
-  incoming->socket = NULL;
-  /* the peer's socket is now ours, we'll receive all messages */
-  GNUNET_MQ_replace_handlers (eo->mq, union_handlers, eo);
-
   GNUNET_CONTAINER_DLL_insert (eo->set->state.u->ops_head,
                                eo->set->state.u->ops_tail,
                                eo);
-
   /* kick off the operation */
   send_strata_estimator (eo);
 }
@@ -1384,7 +1314,7 @@ _GSS_union_set_destroy (struct Set *set)
 
   while (NULL != set->state.u->ops_head)
   {
-    destroy_union_operation (set->state.u->ops_head);
+    _GSS_union_operation_destroy (set->state.u->ops_head);
   }
 }
 
@@ -1418,3 +1348,57 @@ _GSS_union_remove (struct GNUNET_SET_ElementMessage *m, struct Set *set)
   ee->generation_removed = set->state.u->current_generation;
 }
 
+
+/**
+ * Dispatch messages for a union operation.
+ *
+ * @param cls closure
+ * @param tunnel mesh tunnel
+ * @param tunnel_ctx tunnel context
+ * @param sender ???
+ * @param mh message to process
+ * @return ???
+ */
+int
+_GSS_union_handle_p2p_message (void *cls,
+                               struct GNUNET_MESH_Tunnel *tunnel,
+                               void **tunnel_ctx,
+                               const struct GNUNET_PeerIdentity *sender,
+                               const struct GNUNET_MessageHeader *mh)
+{
+  struct TunnelContext *tc = *tunnel_ctx;
+  struct UnionEvaluateOperation *eo;
+
+  if (CONTEXT_OPERATION_UNION != tc->type)
+  {
+    /* FIXME: kill the tunnel */
+    /* never kill mesh */
+    return GNUNET_OK;
+  }
+
+  eo = tc->data;
+
+  switch (ntohs (mh->type))
+  {
+    case GNUNET_MESSAGE_TYPE_SET_P2P_IBF:
+      handle_p2p_ibf (eo, mh);
+      break;
+    case GNUNET_MESSAGE_TYPE_SET_P2P_SE:
+      handle_p2p_strata_estimator (eo, mh);
+      break;
+    case GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS:
+      handle_p2p_elements (eo, mh);
+      break;
+    case GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENT_REQUESTS:
+      handle_p2p_element_requests (eo, mh);
+      break;
+    case GNUNET_MESSAGE_TYPE_SET_P2P_DONE:
+      handle_p2p_done (eo, mh);
+      break;
+    default:
+      /* something wrong with mesh's message handlers? */
+      GNUNET_assert (0);
+  }
+  /* never kill mesh! */
+  return GNUNET_OK;
+}
diff --git a/src/set/gnunet-set-ibf.c b/src/set/gnunet-set-ibf-profiler.c
index d431795f1..92feb3db4 100644
--- a/src/set/gnunet-set-ibf.c
+++ b/src/set/gnunet-set-ibf-profiler.c
@@ -19,8 +19,8 @@
 */
 
 /**
- * @file consensus/gnunet-consensus-ibf.c
- * @brief tool for reconciling data with invertible bloom filters
+ * @file set/gnunet-set-ibf-profiler.c
+ * @brief tool for profiling the invertible bloom filter implementation
  * @author Florian Dold
  */
 
@@ -35,7 +35,7 @@
 static unsigned int asize = 10;
 static unsigned int bsize = 10;
 static unsigned int csize = 10;
-static unsigned int hash_num = 3;
+static unsigned int hash_num = 4;
 static unsigned int ibf_size = 80;
 
 /* FIXME: add parameter for this */
@@ -181,12 +181,14 @@ run (void *cls, char *const *args, const char *cfgfile,
 
   start_time = GNUNET_TIME_absolute_get ();
 
-  for (;;)
+  for (i = 0; i <= asize + bsize; i++)
   {
     res = ibf_decode (ibf_a, &side, &ibf_key);
     if (GNUNET_SYSERR == res) 
     {
-      printf ("decode failed\n");
+      printf ("decode failed, %u/%u elements left\n",
+         GNUNET_CONTAINER_multihashmap_size (set_a) + GNUNET_CONTAINER_multihashmap_size (set_b),
+         asize + bsize);
       return;
     }
     if (GNUNET_NO == res)
@@ -198,7 +200,9 @@ run (void *cls, char *const *args, const char *cfgfile,
         printf ("decoded successfully in: %s\n", GNUNET_STRINGS_relative_time_to_string (delta_time, GNUNET_NO));
       }
       else
-        printf ("decode missed elements\n");
+      {
+        printf ("decode missed elements (should never happen)\n");
+      }
       return;
     }
 
@@ -207,6 +211,9 @@ run (void *cls, char *const *args, const char *cfgfile,
     if (side == -1)
       iter_hashcodes (ibf_key, remove_iterator, set_b);
   }
+  printf("cyclic IBF, %u/%u elements left\n",
+         GNUNET_CONTAINER_multihashmap_size (set_a) + GNUNET_CONTAINER_multihashmap_size (set_b),
+         asize + bsize);
 }
 
 int
diff --git a/src/set/gnunet-set-profiler.c b/src/set/gnunet-set-profiler.c
new file mode 100644
index 000000000..bbaef7c43
--- /dev/null
+++ b/src/set/gnunet-set-profiler.c
@@ -0,0 +1,320 @@
+/*
+      This file is part of GNUnet
+      (C) 2013 Christian Grothoff (and other contributing authors)
+
+      GNUnet 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; either version 2, or (at your
+      option) any later version.
+
+      GNUnet 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 GNUnet; see the file COPYING.  If not, write to the
+      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+      Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * @file set/gnunet-set-profiler.c
+ * @brief profiling tool for set
+ * @author Florian Dold
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_set_service.h"
+#include "gnunet_testbed_service.h"
+
+
+static int ret;
+
+static unsigned int num_a = 5;
+static unsigned int num_b = 5;
+static unsigned int num_c = 20;
+
+static unsigned int salt = 42;
+
+static char* op_str = "union";
+
+const static struct GNUNET_CONFIGURATION_Handle *config;
+
+struct GNUNET_CONTAINER_MultiHashMap *map_a;
+struct GNUNET_CONTAINER_MultiHashMap *map_b;
+struct GNUNET_CONTAINER_MultiHashMap *map_c;
+
+
+/**
+ * Elements that set a received, should match map_c
+ * in the end.
+ */
+struct GNUNET_CONTAINER_MultiHashMap *map_a_received;
+
+/**
+ * Elements that set b received, should match map_c
+ * in the end.
+ */
+struct GNUNET_CONTAINER_MultiHashMap *map_b_received;
+
+struct GNUNET_SET_Handle *set_a;
+struct GNUNET_SET_Handle *set_b;
+
+struct GNUNET_HashCode app_id;
+
+struct GNUNET_PeerIdentity local_peer;
+
+struct GNUNET_SET_ListenHandle *set_listener;
+
+struct GNUNET_SET_OperationHandle *set_oh1;
+struct GNUNET_SET_OperationHandle *set_oh2;
+
+
+int a_done;
+int b_done;
+
+
+
+static int
+map_remove_iterator (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     void *value)
+{
+  struct GNUNET_CONTAINER_MultiHashMap *m = cls;
+  int ret;
+
+  ret = GNUNET_CONTAINER_multihashmap_remove (m, key, NULL);
+  GNUNET_assert (GNUNET_OK == ret);
+  return GNUNET_YES;
+
+}
+
+
+static void
+set_result_cb_1 (void *cls,
+                 const struct GNUNET_SET_Element *element,
+                 enum GNUNET_SET_Status status)
+{
+  GNUNET_assert (GNUNET_NO == a_done);
+  GNUNET_assert (element->size == sizeof (struct GNUNET_HashCode));
+  switch (status)
+  {
+    case GNUNET_SET_STATUS_DONE:
+    case GNUNET_SET_STATUS_HALF_DONE:
+      a_done = GNUNET_YES;
+      GNUNET_CONTAINER_multihashmap_iterate (map_c, map_remove_iterator, map_a_received);
+      GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (map_a_received));
+      return;
+    case GNUNET_SET_STATUS_FAILURE:
+      GNUNET_assert (0);
+      return;
+    case GNUNET_SET_STATUS_OK:
+      break;
+    default:
+      GNUNET_assert (0);
+  }
+  GNUNET_CONTAINER_multihashmap_put (map_a_received,
+                                     element->data, NULL,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
+}
+
+
+static void
+set_result_cb_2 (void *cls,
+                 const struct GNUNET_SET_Element *element,
+                 enum GNUNET_SET_Status status)
+{
+  GNUNET_assert (GNUNET_NO == b_done);
+  GNUNET_assert (element->size == sizeof (struct GNUNET_HashCode));
+  switch (status)
+  {
+    case GNUNET_SET_STATUS_DONE:
+    case GNUNET_SET_STATUS_HALF_DONE:
+      b_done = GNUNET_YES;
+      GNUNET_CONTAINER_multihashmap_iterate (map_c, map_remove_iterator, map_b_received);
+      GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (map_b_received));
+      return;
+    case GNUNET_SET_STATUS_FAILURE:
+      GNUNET_assert (0);
+      return;
+    case GNUNET_SET_STATUS_OK:
+      break;
+    default:
+      GNUNET_assert (0);
+  }
+  GNUNET_CONTAINER_multihashmap_put (map_b_received,
+                                     element->data, NULL,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
+}
+
+
+static void
+set_listen_cb (void *cls,
+               const struct GNUNET_PeerIdentity *other_peer,
+               const struct GNUNET_MessageHeader *context_msg,
+               struct GNUNET_SET_Request *request)
+{
+  GNUNET_assert (NULL == set_oh2);
+  set_oh2 = GNUNET_SET_accept (request, GNUNET_SET_RESULT_ADDED,
+                               set_result_cb_2, NULL);
+  GNUNET_SET_commit (set_oh2, set_b);
+}
+
+
+
+static int
+set_insert_iterator (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     void *value)
+{
+  struct GNUNET_SET_Handle *set = cls;
+  struct GNUNET_SET_Element *el;
+
+  el = GNUNET_malloc (sizeof *el + sizeof *key);
+  el->type = 0;
+  memcpy (&el[1], key, sizeof *key);
+  el->data = &el[1];
+  el->size = sizeof *key;
+  GNUNET_SET_add_element (set, el, NULL, NULL);
+  GNUNET_free (el);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Signature of the 'main' function for a (single-peer) testcase that
+ * is run using 'GNUNET_TESTING_peer_run'.
+ * 
+ * @param cls closure
+ * @param cfg configuration of the peer that was started
+ * @param peer identity of the peer that was created
+ */
+static void
+test_main (void *cls,
+          const struct GNUNET_CONFIGURATION_Handle *cfg,
+          struct GNUNET_TESTING_Peer *peer)
+{
+  unsigned int i;
+  struct GNUNET_HashCode hash;
+
+  config = cfg;
+
+  if (GNUNET_OK != GNUNET_CRYPTO_get_host_identity (cfg, &local_peer))
+  {
+    GNUNET_assert (0);
+    return;
+  }
+  
+  map_a = GNUNET_CONTAINER_multihashmap_create (num_a, GNUNET_NO);
+  map_b = GNUNET_CONTAINER_multihashmap_create (num_b, GNUNET_NO);
+  map_c = GNUNET_CONTAINER_multihashmap_create (num_c, GNUNET_NO);
+
+  for (i = 0; i < num_a; i++)
+  {
+    GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash);
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_a, &hash))
+    {
+      i--;
+      continue;
+    }
+    GNUNET_CONTAINER_multihashmap_put (map_a, &hash, &hash,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  }
+
+  for (i = 0; i < num_b; i++)
+  {
+    GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash);
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_a, &hash))
+    {
+      i--;
+      continue;
+    }
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_b, &hash))
+    {
+      i--;
+      continue;
+    }
+    GNUNET_CONTAINER_multihashmap_put (map_b, &hash, NULL,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
+  }
+
+  for (i = 0; i < num_c; i++)
+  {
+    GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash);
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_a, &hash))
+    {
+      i--;
+      continue;
+    }
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_b, &hash))
+    {
+      i--;
+      continue;
+    }
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map_c, &hash))
+    {
+      i--;
+      continue;
+    }
+    GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &hash);
+    GNUNET_CONTAINER_multihashmap_put (map_c, &hash, NULL,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
+  }
+
+  /* use last hash for app id */
+  app_id = hash;
+
+  /* FIXME: also implement intersection etc. */
+  set_a = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION);
+  set_b = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION);
+
+  GNUNET_CONTAINER_multihashmap_iterate (map_a, set_insert_iterator, set_a);
+  GNUNET_CONTAINER_multihashmap_iterate (map_b, set_insert_iterator, set_b);
+  GNUNET_CONTAINER_multihashmap_iterate (map_c, set_insert_iterator, set_a);
+  GNUNET_CONTAINER_multihashmap_iterate (map_c, set_insert_iterator, set_b);
+
+  set_listener = GNUNET_SET_listen (config, GNUNET_SET_OPERATION_UNION,
+                                    &app_id, set_listen_cb, NULL);
+
+  set_oh1 = GNUNET_SET_prepare (&local_peer, &app_id, NULL, salt, GNUNET_SET_RESULT_ADDED,
+                       set_result_cb_1, NULL);
+  GNUNET_SET_commit (set_oh1, set_a);
+}
+
+static void
+run (void *cls, char *const *args, const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+
+  ret = GNUNET_TESTING_peer_run ("test_set_api",
+                                 "test_set.conf",
+                                 &test_main, NULL);
+}
+
+
+int
+main (int argc, char **argv)
+{
+   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+      { 'A', "num-first", NULL,
+        gettext_noop ("number of values"),
+        GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_a },
+      { 'B', "num-second", NULL,
+        gettext_noop ("number of values"),
+        GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_b },
+      { 'B', "num-common", NULL,
+        gettext_noop ("number of values"),
+        GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_c },
+      { 'x', "operation", NULL,
+        gettext_noop ("oeration to execute"),
+        GNUNET_YES, &GNUNET_GETOPT_set_string, &op_str },
+      GNUNET_GETOPT_OPTION_END
+  };
+  GNUNET_PROGRAM_run2 (argc, argv, "gnunet-consensus",
+                      "help",
+                      options, &run, NULL, GNUNET_YES);
+  return ret;
+}
+
diff --git a/src/set/gnunet-set.c b/src/set/gnunet-set.c
deleted file mode 100644
index ae84610fc..000000000
--- a/src/set/gnunet-set.c
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
-      This file is part of GNUnet
-      (C) 2012 Christian Grothoff (and other contributing authors)
-
-      GNUnet 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; either version 2, or (at your
-      option) any later version.
-
-      GNUnet 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 GNUnet; see the file COPYING.  If not, write to the
-      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-      Boston, MA 02111-1307, USA.
- */
-
-/**
- * @file set/gnunet-set.c
- * @brief profiling tool for the set service
- * @author Florian Dold
- */
-#include "platform.h"
-#include "gnunet_common.h"
-#include "gnunet_util_lib.h"
-#include "gnunet_testbed_service.h"
-#include "gnunet_set_service.h"
-
-
-static struct GNUNET_PeerIdentity local_id;
-
-static struct GNUNET_HashCode app_id;
-static struct GNUNET_SET_Handle *set1;
-static struct GNUNET_SET_Handle *set2;
-static struct GNUNET_SET_ListenHandle *listen_handle;
-const static struct GNUNET_CONFIGURATION_Handle *config;
-
-int num_done;
-
-
-static void
-result_cb_set1 (void *cls, const struct GNUNET_SET_Element *element,
-                enum GNUNET_SET_Status status)
-{
-  switch (status)
-  {
-    case GNUNET_SET_STATUS_OK:
-      printf ("set 1: got element\n");
-      break;
-    case GNUNET_SET_STATUS_FAILURE:
-      printf ("set 1: failure\n");
-      break;
-    case GNUNET_SET_STATUS_DONE:
-      printf ("set 1: done\n");
-      GNUNET_SET_destroy (set1);
-      break;
-    default:
-      GNUNET_assert (0);
-  }
-}
-
-
-static void
-result_cb_set2 (void *cls, const struct GNUNET_SET_Element *element,
-           enum GNUNET_SET_Status status)
-{
-  switch (status)
-  {
-    case GNUNET_SET_STATUS_OK:
-      printf ("set 2: got element\n");
-      break;
-    case GNUNET_SET_STATUS_FAILURE:
-      printf ("set 2: failure\n");
-      break;
-    case GNUNET_SET_STATUS_DONE:
-      printf ("set 2: done\n");
-      GNUNET_SET_destroy (set2);
-      break;
-    default:
-      GNUNET_assert (0);
-  }
-}
-
-
-static void
-listen_cb (void *cls,
-           const struct GNUNET_PeerIdentity *other_peer,
-           const struct GNUNET_MessageHeader *context_msg,
-           struct GNUNET_SET_Request *request)
-{
-  struct GNUNET_SET_OperationHandle *oh;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "listen cb called\n");
-  GNUNET_SET_listen_cancel (listen_handle);
-
-  oh = GNUNET_SET_accept (request, GNUNET_SET_RESULT_ADDED, result_cb_set2, NULL);
-  GNUNET_SET_conclude (oh, set2);
-}
-
-
-/**
- * Start the set operation.
- *
- * @param cls closure, unused
- */
-static void
-start (void *cls)
-{
-  struct GNUNET_SET_OperationHandle *oh;
-  
-  listen_handle = GNUNET_SET_listen (config, GNUNET_SET_OPERATION_UNION,
-                                     &app_id, listen_cb, NULL);
-  oh = GNUNET_SET_evaluate (&local_id, &app_id, NULL, 42,
-                            GNUNET_SET_RESULT_ADDED,
-                            result_cb_set1, NULL);
-  GNUNET_SET_conclude (oh, set1);
-}
-
-
-/**
- * Initialize the second set, continue
- *
- * @param cls closure, unused
- */
-static void
-init_set2 (void *cls)
-{
-  struct GNUNET_SET_Element element;
-
-
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initializing set 2\n");
-
-  element.data = "hello";
-  element.size = strlen(element.data);
-  GNUNET_SET_add_element (set2, &element, NULL, NULL);
-  element.data = "quux";
-  element.size = strlen(element.data);
-  GNUNET_SET_add_element (set2, &element, start, NULL);
-}
-
-
-/**
- * Initialize the first set, continue.
- */
-static void
-init_set1 (void)
-{
-  struct GNUNET_SET_Element element;
-
-  element.data = "hello";
-  element.size = strlen(element.data);
-  GNUNET_SET_add_element (set1, &element, NULL, NULL);
-  element.data = "bar";
-  element.size = strlen(element.data);
-  GNUNET_SET_add_element (set1, &element, init_set2, NULL);
-
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized set 1\n");
-}
-
-
-/**
- * Main function that will be run.
- *
- * @param cls closure
- * @param args remaining command-line arguments
- * @param cfgfile name of the configuration file used (for saving, can be NULL!)
- * @param cfg configuration
- */
-static void
-run (void *cls, char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
-{
-  static const char* app_str = "gnunet-set";
-
-  config = cfg;
-  
-  GNUNET_CRYPTO_hash (app_str, strlen (app_str), &app_id);
-
-  GNUNET_CRYPTO_get_host_identity (cfg, &local_id);
-
-  set1 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
-  set2 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
-
-  init_set1 ();
-}
-
-
-
-int
-main (int argc, char **argv)
-{
-   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
-      GNUNET_GETOPT_OPTION_END
-  };
-  GNUNET_PROGRAM_run2 (argc, argv, "gnunet-set",
-                      "help",
-                      options, &run, NULL, GNUNET_NO);
-  return 0;
-}
-
diff --git a/src/set/ibf.c b/src/set/ibf.c
index 383ce3daf..e3c5be59a 100644
--- a/src/set/ibf.c
+++ b/src/set/ibf.c
@@ -19,7 +19,7 @@
 */
 
 /**
- * @file consensus/ibf.c
+ * @file set/ibf.c
  * @brief implementation of the invertible bloom filter
  * @author Florian Dold
  */
@@ -27,6 +27,12 @@
 #include "ibf.h"
 
 /**
+ * Compute the key's hash from the key.
+ * Redefine to use a different hash function.
+ */
+#define IBF_KEY_HASH_VAL(k) (GNUNET_CRYPTO_crc32_n (&(k), sizeof (struct IBF_KeyHash)))
+
+/**
  * Create a key from a hashcode.
  *
  * @param hash the hashcode
@@ -89,23 +95,21 @@ static inline void
 ibf_get_indices (const struct InvertibleBloomFilter *ibf,
                  struct IBF_Key key, int *dst)
 {
-  struct GNUNET_HashCode bucket_indices;
-  unsigned int filled;
-  int i;
-  GNUNET_CRYPTO_hash (&key, sizeof key, &bucket_indices);
-  filled = 0;
-  for (i = 0; filled < ibf->hash_num; i++)
+  uint32_t filled;
+  uint32_t i;
+  uint32_t bucket = key.key_val & 0xFFFFFFFF;
+
+  for (i = 0, filled=0; filled < ibf->hash_num; i++)
   {
-    unsigned int bucket;
     unsigned int j;
-    if ( (0 != i) && (0 == (i % 16)) )
-      GNUNET_CRYPTO_hash (&bucket_indices, sizeof (struct GNUNET_HashCode), &bucket_indices);
-    bucket = bucket_indices.bits[i % 16] % ibf->size;
+    uint64_t x;
     for (j = 0; j < filled; j++)
       if (dst[j] == bucket)
         goto try_next;
-    dst[filled++] = bucket;
+    dst[filled++] = bucket % ibf->size;
     try_next: ;
+    x = ((uint64_t) bucket << 32) | i;
+    bucket = GNUNET_CRYPTO_crc32_n (&x, sizeof x);
   }
 }
 
@@ -116,16 +120,14 @@ ibf_insert_into  (struct InvertibleBloomFilter *ibf,
                   const int *buckets, int side)
 {
   int i;
-  struct GNUNET_HashCode key_hash_sha;
-  struct IBF_KeyHash key_hash;
-  GNUNET_CRYPTO_hash (&key, sizeof key, &key_hash_sha);
-  key_hash.key_hash_val = key_hash_sha.bits[0];
+
   for (i = 0; i < ibf->hash_num; i++)
   {
     const int bucket = buckets[i];
     ibf->count[bucket].count_val += side;
     ibf->key_sum[bucket].key_val ^= key.key_val;
-    ibf->key_hash_sum[bucket].key_hash_val ^= key_hash.key_hash_val;
+    ibf->key_hash_sum[bucket].key_hash_val
+        ^= IBF_KEY_HASH_VAL (key);
   }
 }
 
@@ -183,7 +185,6 @@ ibf_decode (struct InvertibleBloomFilter *ibf,
 {
   struct IBF_KeyHash hash;
   int i;
-  struct GNUNET_HashCode key_hash_sha;
   int buckets[ibf->hash_num];
 
   GNUNET_assert (NULL != ibf);
@@ -197,8 +198,7 @@ ibf_decode (struct InvertibleBloomFilter *ibf,
     if ((1 != ibf->count[i].count_val) && (-1 != ibf->count[i].count_val))
       continue;
 
-    GNUNET_CRYPTO_hash (&ibf->key_sum[i], sizeof (struct IBF_Key), &key_hash_sha);
-    hash.key_hash_val = key_hash_sha.bits[0];
+    hash.key_hash_val = IBF_KEY_HASH_VAL (ibf->key_sum[i]);
 
     /* test if the hash matches the key */
     if (hash.key_hash_val != ibf->key_hash_sum[i].key_hash_val)
diff --git a/src/set/ibf.h b/src/set/ibf.h
index 2bf3ef7c7..90ea231c0 100644
--- a/src/set/ibf.h
+++ b/src/set/ibf.h
@@ -19,7 +19,7 @@
 */
 
 /**
- * @file consensus/ibf.h
+ * @file set/ibf.h
  * @brief invertible bloom filter
  * @author Florian Dold
  */
diff --git a/src/set/set_api.c b/src/set/set_api.c
index c74933aa0..e1b6132cb 100644
--- a/src/set/set_api.c
+++ b/src/set/set_api.c
@@ -40,7 +40,7 @@
 struct GNUNET_SET_Handle
 {
   struct GNUNET_CLIENT_Connection *client;
-  struct GNUNET_MQ_MessageQueue *mq;
+  struct GNUNET_MQ_Handle *mq;
   unsigned int messages_since_ack;
 };
 
@@ -73,7 +73,7 @@ struct GNUNET_SET_OperationHandle
    * Message sent to the server on calling conclude,
    * NULL if conclude has been called.
    */
-  struct GNUNET_MQ_Message *conclude_mqm;
+  struct GNUNET_MQ_Envelope *conclude_mqm;
 
   /**
    * Address of the request if in the conclude message,
@@ -89,7 +89,7 @@ struct GNUNET_SET_OperationHandle
 struct GNUNET_SET_ListenHandle
 {
   struct GNUNET_CLIENT_Connection *client;
-  struct GNUNET_MQ_MessageQueue* mq;
+  struct GNUNET_MQ_Handle* mq;
   GNUNET_SET_ListenCallback listen_cb;
   void *listen_cls;
 };
@@ -115,7 +115,7 @@ handle_result (void *cls, const struct GNUNET_MessageHeader *mh)
 
   if (set->messages_since_ack >= GNUNET_SET_ACK_WINDOW/2)
   {
-    struct GNUNET_MQ_Message *mqm;
+    struct GNUNET_MQ_Envelope *mqm;
     mqm = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_ACK);
     GNUNET_MQ_send (set->mq, mqm);
   }
@@ -162,7 +162,7 @@ handle_request (void *cls, const struct GNUNET_MessageHeader *mh)
 
   if (GNUNET_NO == req->accepted)
   {
-    struct GNUNET_MQ_Message *mqm;
+    struct GNUNET_MQ_Envelope *mqm;
     struct GNUNET_SET_AcceptRejectMessage *amsg;
 
     mqm = GNUNET_MQ_msg (amsg, GNUNET_MESSAGE_TYPE_SET_REJECT);
@@ -197,9 +197,9 @@ GNUNET_SET_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
                    enum GNUNET_SET_OperationType op)
 {
   struct GNUNET_SET_Handle *set;
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_SET_CreateMessage *msg;
-  static const struct GNUNET_MQ_Handler mq_handlers[] = {
+  static const struct GNUNET_MQ_MessageHandler mq_handlers[] = {
     {handle_result, GNUNET_MESSAGE_TYPE_SET_RESULT},
     GNUNET_MQ_HANDLERS_END
   };
@@ -234,7 +234,7 @@ GNUNET_SET_add_element (struct GNUNET_SET_Handle *set,
                         GNUNET_SET_Continuation cont,
                         void *cont_cls)
 {
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_SET_ElementMessage *msg;
 
   mqm = GNUNET_MQ_msg_extra (msg, element->size, GNUNET_MESSAGE_TYPE_SET_ADD);
@@ -262,7 +262,7 @@ GNUNET_SET_remove_element (struct GNUNET_SET_Handle *set,
                            GNUNET_SET_Continuation cont,
                            void *cont_cls)
 {
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_SET_ElementMessage *msg;
 
   mqm = GNUNET_MQ_msg_extra (msg, element->size, GNUNET_MESSAGE_TYPE_SET_REMOVE);
@@ -287,9 +287,9 @@ GNUNET_SET_destroy (struct GNUNET_SET_Handle *set)
 
 
 /**
- * Create a set operation for evaluation with another peer.
+ * Prepare a set operation to be evaluated with another peer.
  * The evaluation will not start until the client provides
- * a local set with GNUNET_SET_conclude.
+ * a local set with GNUNET_SET_commit.
  *
  * @param other_peer peer with the other set
  * @param app_id hash for the application using the set
@@ -304,15 +304,15 @@ GNUNET_SET_destroy (struct GNUNET_SET_Handle *set)
  * @return a handle to cancel the operation
  */
 struct GNUNET_SET_OperationHandle *
-GNUNET_SET_evaluate (const struct GNUNET_PeerIdentity *other_peer,
-                     const struct GNUNET_HashCode *app_id,
-                     const struct GNUNET_MessageHeader *context_msg,
-                     uint16_t salt,
-                     enum GNUNET_SET_ResultMode result_mode,
-                     GNUNET_SET_ResultIterator result_cb,
-                     void *result_cls)
+GNUNET_SET_prepare (const struct GNUNET_PeerIdentity *other_peer,
+                    const struct GNUNET_HashCode *app_id,
+                    const struct GNUNET_MessageHeader *context_msg,
+                    uint16_t salt,
+                    enum GNUNET_SET_ResultMode result_mode,
+                    GNUNET_SET_ResultIterator result_cb,
+                    void *result_cls)
 {
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_SET_OperationHandle *oh;
   struct GNUNET_SET_EvaluateMessage *msg;
 
@@ -322,9 +322,6 @@ GNUNET_SET_evaluate (const struct GNUNET_PeerIdentity *other_peer,
 
   mqm = GNUNET_MQ_msg_nested_mh (msg, GNUNET_MESSAGE_TYPE_SET_EVALUATE, context_msg);
 
-  if (NULL != context_msg)
-    LOG (GNUNET_ERROR_TYPE_INFO, "passed context msg\n");
-
   msg->app_id = *app_id;
   msg->target_peer = *other_peer;
   msg->salt = salt;
@@ -356,9 +353,9 @@ GNUNET_SET_listen (const struct GNUNET_CONFIGURATION_Handle *cfg,
                    void *listen_cls)
 {
   struct GNUNET_SET_ListenHandle *lh;
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_SET_ListenMessage *msg;
-  static const struct GNUNET_MQ_Handler mq_handlers[] = {
+  static const struct GNUNET_MQ_MessageHandler mq_handlers[] = {
     {handle_request, GNUNET_MESSAGE_TYPE_SET_REQUEST},
     GNUNET_MQ_HANDLERS_END
   };
@@ -403,7 +400,7 @@ GNUNET_SET_listen_cancel (struct GNUNET_SET_ListenHandle *lh)
  * @param result_mode specified how results will be returned,
  *        see 'GNUNET_SET_ResultMode'.
  * @param result_cb callback for the results
- * @param result_cls closure for result_cb
+ * @param cls closure for result_cb
  * @return a handle to cancel the operation
  */
 struct GNUNET_SET_OperationHandle *
@@ -412,7 +409,7 @@ GNUNET_SET_accept (struct GNUNET_SET_Request *request,
                    GNUNET_SET_ResultIterator result_cb,
                    void *cls)
 {
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_SET_OperationHandle *oh;
   struct GNUNET_SET_AcceptRejectMessage *msg;
 
@@ -441,7 +438,7 @@ GNUNET_SET_accept (struct GNUNET_SET_Request *request,
 void
 GNUNET_SET_operation_cancel (struct GNUNET_SET_OperationHandle *oh)
 {
-  struct GNUNET_MQ_Message *mqm;
+  struct GNUNET_MQ_Envelope *mqm;
   struct GNUNET_SET_OperationHandle *h_assoc;
 
   if (NULL != oh->set)
@@ -460,7 +457,7 @@ GNUNET_SET_operation_cancel (struct GNUNET_SET_OperationHandle *oh)
 
 
 /**
- * Conclude the given set operation using the given set. 
+ * Commit a set to be used with a set operation.
  * This function is called once we have fully constructed
  * the set that we want to use for the operation.  At this
  * time, the P2P protocol can then begin to exchange the
@@ -471,13 +468,13 @@ GNUNET_SET_operation_cancel (struct GNUNET_SET_OperationHandle *oh)
  * @param set the set to use for the operation
  */
 void
-GNUNET_SET_conclude (struct GNUNET_SET_OperationHandle *oh,
+GNUNET_SET_commit (struct GNUNET_SET_OperationHandle *oh,
                      struct GNUNET_SET_Handle *set)
 {
   GNUNET_assert (NULL == oh->set);
   GNUNET_assert (NULL != oh->conclude_mqm);
   oh->set = set;
-  oh->request_id = GNUNET_MQ_assoc_add (oh->set->mq, NULL, oh);
+  oh->request_id = GNUNET_MQ_assoc_add (oh->set->mq, oh);
   *oh->request_id_addr = htonl (oh->request_id);
   GNUNET_MQ_send (oh->set->mq, oh->conclude_mqm);
   oh->conclude_mqm = NULL;
diff --git a/src/set/strata_estimator.c b/src/set/strata_estimator.c
index 024bb99c6..18c127cd6 100644
--- a/src/set/strata_estimator.c
+++ b/src/set/strata_estimator.c
@@ -19,7 +19,7 @@
 */
 
 /**
- * @file consensus/ibf.h
+ * @file set/ibf.h
  * @brief invertible bloom filter
  * @author Florian Dold
  */
diff --git a/src/set/strata_estimator.h b/src/set/strata_estimator.h
index b3f050743..718c996d0 100644
--- a/src/set/strata_estimator.h
+++ b/src/set/strata_estimator.h
@@ -19,7 +19,7 @@
 */
 
 /**
- * @file consensus/strata_estimator.h
+ * @file set/strata_estimator.h
  * @brief estimator of set difference
  * @author Florian Dold
  */
diff --git a/src/set/test_set_api.c b/src/set/test_set_api.c
index f773cebdf..db82b83b4 100644
--- a/src/set/test_set_api.c
+++ b/src/set/test_set_api.c
@@ -95,7 +95,7 @@ listen_cb (void *cls,
   GNUNET_SET_listen_cancel (listen_handle);
 
   oh = GNUNET_SET_accept (request, GNUNET_SET_RESULT_ADDED, result_cb_set2, NULL);
-  GNUNET_SET_conclude (oh, set2);
+  GNUNET_SET_commit (oh, set2);
 }
 
 
@@ -111,10 +111,10 @@ start (void *cls)
 
   listen_handle = GNUNET_SET_listen (config, GNUNET_SET_OPERATION_UNION,
                                      &app_id, listen_cb, NULL);
-  oh = GNUNET_SET_evaluate (&local_id, &app_id, NULL, 42,
-                            GNUNET_SET_RESULT_ADDED,
-                            result_cb_set1, NULL);
-  GNUNET_SET_conclude (oh, set1);
+  oh = GNUNET_SET_prepare (&local_id, &app_id, NULL, 42,
+                           GNUNET_SET_RESULT_ADDED,
+                           result_cb_set1, NULL);
+  GNUNET_SET_commit (oh, set1);
 }