12 files changed, 284 insertions, 214 deletions

diff --git a/doc/documentation/chapters/user.texi b/doc/documentation/chapters/user.texi
index 35afdf5f7..50b795197 100644
--- a/doc/documentation/chapters/user.texi
+++ b/doc/documentation/chapters/user.texi
@@ -1920,17 +1920,17 @@ $ gnunet-identity -C "username"
 
 Henceforth, you can manage a new user profile of the user ``username''.
 
-To add an email address to your user profile, simply use the @command{gnunet-idp} command line tool::
+To add an email address to your user profile, simply use the @command{gnunet-reclaim} command line tool::
 
 @example
-$ gnunet-idp -e "username" -a "email" -V "username@@example.gnunet"
+$ gnunet-reclaim -e "username" -a "email" -V "username@@example.gnunet"
 @end example
 
-All of your attributes can be listed using the @command{gnunet-idp}
+All of your attributes can be listed using the @command{gnunet-reclaim}
 command line tool as well:
 
 @example
-$ gnunet-idp -e "username" -D
+$ gnunet-reclaim -e "username" -D
 @end example
 
 Currently, and by default, attribute values are interpreted as plain text.
@@ -1942,7 +1942,7 @@ In the future there might be more value types such as X.509 certificate credenti
 If you want to allow a third party such as a website or friend to access to your attributes (or a subset thereof) execute:
 
 @example
-$ gnunet-idp -e "username" -r "PKEY" -i "attribute1,attribute2,..."
+$ gnunet-reclaim -e "username" -r "PKEY" -i "attribute1,attribute2,..."
 @end example
 
 Where "PKEY" is the public key of the third party and "attribute1,attribute2,..." is a comma-separated list of attribute names, such as "email", that you want to share.
@@ -1953,7 +1953,7 @@ You must give this "ticket" to the requesting third party.
 The third party can then retrieve your shared identity attributes using:
 
 @example
-$ gnunet-idp -e "friend" -C "ticket"
+$ gnunet-reclaim -e "friend" -C "ticket"
 @end example
 
 This will retrieve and list the shared identity attributes.
@@ -1962,7 +1962,7 @@ Further, the "ticket" can be re-used later to retrieve up-to-date attributes in
 
 To list all given authorizations (tickets) you can execute:
 @example
-$ gnunet-idp -e "friend" -T (TODO there is only a REST API for this ATM) 
+$ gnunet-reclaim -e "friend" -T (TODO there is only a REST API for this ATM) 
 @end example
 
 
diff --git a/src/cadet/cadet_api.c b/src/cadet/cadet_api.c
index 92dd39b97..e2ca461a5 100644
--- a/src/cadet/cadet_api.c
+++ b/src/cadet/cadet_api.c
@@ -1277,7 +1277,7 @@ GNUNET_CADET_close_port (struct GNUNET_CADET_Port *p)
 /**
  * Destroy an existing channel.
  *
- * The existing end callback for the channel will be called immediately.
+ * The existing end callback for the channel will NOT be called.
  * Any pending outgoing messages will be sent but no incoming messages will be
  * accepted and no data callbacks will be called.
  *
@@ -1300,6 +1300,7 @@ GNUNET_CADET_channel_destroy (struct GNUNET_CADET_Channel *channel)
   }
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Destroying channel due to GNUNET_CADET_channel_destroy()\n");
+  channel->disconnects = NULL;
   destroy_channel (channel);
 }
 
diff --git a/src/conversation/gnunet-service-conversation.c b/src/conversation/gnunet-service-conversation.c
index fb9eec26e..059bb158b 100644
--- a/src/conversation/gnunet-service-conversation.c
+++ b/src/conversation/gnunet-service-conversation.c
@@ -303,6 +303,47 @@ handle_client_pickup_message (void *cls,
 
 
 /**
+ * Channel went down, notify client and free data
+ * structure.
+ *
+ * @param ch channel that went down
+ */
+static void
+clean_up_channel (struct Channel *ch)
+{
+  struct Line *line = ch->line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhoneHangupMessage *hup;
+
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+  case CS_CALLEE_SHUTDOWN:
+  case CS_CALLER_SHUTDOWN:
+    break;
+  case CS_CALLEE_RINGING:
+  case CS_CALLEE_CONNECTED:
+  case CS_CALLER_CALLING:
+  case CS_CALLER_CONNECTED:
+    if (NULL != line)
+    {
+      env = GNUNET_MQ_msg (hup,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
+      hup->cid = ch->cid;
+      GNUNET_MQ_send (line->mq,
+                      env);
+    }
+    break;
+  }
+  if (NULL != line)
+    GNUNET_CONTAINER_DLL_remove (line->channel_head,
+                                 line->channel_tail,
+                                 ch);
+  GNUNET_free (ch);
+}
+
+
+/**
  * Destroy a channel.
  *
  * @param ch channel to destroy.
@@ -313,7 +354,11 @@ destroy_line_cadet_channels (struct Channel *ch)
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Destroying cadet channels\n");
   if (NULL != ch->channel)
+  {
     GNUNET_CADET_channel_destroy (ch->channel);
+    ch->channel = NULL;
+  }
+  clean_up_channel (ch);
 }
 
 
@@ -1027,40 +1072,13 @@ inbound_end (void *cls,
              const struct GNUNET_CADET_Channel *channel)
 {
   struct Channel *ch = cls;
-  struct Line *line = ch->line;
-  struct GNUNET_MQ_Envelope *env;
-  struct ClientPhoneHangupMessage *hup;
 
   GNUNET_assert (channel == ch->channel);
   ch->channel = NULL;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Channel destroyed by CADET in state %d\n",
               ch->status);
-  switch (ch->status)
-  {
-  case CS_CALLEE_INIT:
-  case CS_CALLEE_SHUTDOWN:
-  case CS_CALLER_SHUTDOWN:
-    break;
-  case CS_CALLEE_RINGING:
-  case CS_CALLEE_CONNECTED:
-  case CS_CALLER_CALLING:
-  case CS_CALLER_CONNECTED:
-    if (NULL != line)
-    {
-      env = GNUNET_MQ_msg (hup,
-                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
-      hup->cid = ch->cid;
-      GNUNET_MQ_send (line->mq,
-                      env);
-    }
-    break;
-  }
-  if (NULL != line)
-    GNUNET_CONTAINER_DLL_remove (line->channel_head,
-                                 line->channel_tail,
-                                 ch);
-  GNUNET_free (ch);
+  clean_up_channel (ch);
 }
 
 
diff --git a/src/include/gnunet_cadet_service.h b/src/include/gnunet_cadet_service.h
index 552763055..276fe4dbc 100644
--- a/src/include/gnunet_cadet_service.h
+++ b/src/include/gnunet_cadet_service.h
@@ -151,7 +151,7 @@ typedef void *
 
 
 /**
- * Function called whenever an MQ-channel is destroyed, even if the destruction
+ * Function called whenever an MQ-channel is destroyed, unless the destruction
  * was requested by #GNUNET_CADET_channel_destroy.
  * It must NOT call #GNUNET_CADET_channel_destroy on the channel.
  *
@@ -277,7 +277,7 @@ GNUNET_CADET_channel_create (struct GNUNET_CADET_Handle *h,
 /**
  * Destroy an existing channel.
  *
- * The existing end callback for the channel will be called immediately.
+ * The existing end callback for the channel will NOT be called.
  * Any pending outgoing messages will be sent but no incoming messages will be
  * accepted and no data callbacks will be called.
  *
diff --git a/src/reclaim-attribute/reclaim_attribute.c b/src/reclaim-attribute/reclaim_attribute.c
index 74d668ea8..1ffa9618f 100644
--- a/src/reclaim-attribute/reclaim_attribute.c
+++ b/src/reclaim-attribute/reclaim_attribute.c
@@ -218,23 +218,27 @@ GNUNET_RECLAIM_ATTRIBUTE_claim_new (const char* attr_name,
 {
   struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr;
   char *write_ptr;
+  char *attr_name_tmp = GNUNET_strdup (attr_name);
+
+  GNUNET_STRINGS_utf8_tolower (attr_name, attr_name_tmp);
 
   attr = GNUNET_malloc (sizeof (struct GNUNET_RECLAIM_ATTRIBUTE_Claim) +
-                        strlen (attr_name) + 1 +
+                        strlen (attr_name_tmp) + 1 +
                         data_size);
   attr->type = type;
   attr->data_size = data_size;
   attr->version = 0;
   write_ptr = (char*)&attr[1];
   GNUNET_memcpy (write_ptr,
-                 attr_name,
-                 strlen (attr_name) + 1);
+                 attr_name_tmp,
+                 strlen (attr_name_tmp) + 1);
   attr->name = write_ptr;
   write_ptr += strlen (attr->name) + 1;
   GNUNET_memcpy (write_ptr,
                  data,
                  data_size);
   attr->data = write_ptr;
+  GNUNET_free (attr_name_tmp);
   return attr;
 }
 
diff --git a/src/reclaim/gnunet-reclaim.c b/src/reclaim/gnunet-reclaim.c
index 9947eac6d..677e9f49f 100644
--- a/src/reclaim/gnunet-reclaim.c
+++ b/src/reclaim/gnunet-reclaim.c
@@ -134,9 +134,20 @@ static struct GNUNET_TIME_Relative exp_interval;
  */
 static struct GNUNET_SCHEDULER_Task *timeout;
 
+/**
+ * Cleanup task
+ */
+static struct GNUNET_SCHEDULER_Task *cleanup_task;
+
+/**
+ * Claim to store
+ */
+struct GNUNET_RECLAIM_ATTRIBUTE_Claim *claim;
+
 static void
 do_cleanup(void *cls)
 {
+  cleanup_task = NULL;
   if (NULL != timeout)
     GNUNET_SCHEDULER_cancel (timeout);
   if (NULL != reclaim_op)
@@ -166,7 +177,7 @@ ticket_issue_cb (void* cls,
            ticket_str);
     GNUNET_free (ticket_str);
   }
-  GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
+  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
 static void
@@ -176,10 +187,10 @@ store_attr_cont (void *cls,
 {
   reclaim_op = NULL;
   if (GNUNET_SYSERR == success) {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "%s\n", emsg);
+    fprintf (stderr,
+             "%s\n", emsg);
   }
-  GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
+  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
 static void
@@ -188,10 +199,12 @@ process_attrs (void *cls,
          const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
 {
   char *value_str;
+  const char* attr_type;
+
   if (NULL == identity)
   {
     reclaim_op = NULL;
-    GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
+    cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
     return;
   }
   if (NULL == attr)
@@ -202,8 +215,9 @@ process_attrs (void *cls,
   value_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type,
                                                         attr->data,
                                                         attr->data_size);
-  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
-              "%s: %s\n", attr->name, value_str);
+  attr_type = GNUNET_RECLAIM_ATTRIBUTE_number_to_typename (attr->type);
+  fprintf (stdout,
+           "%s: %s [%s,v%u]\n", attr->name, value_str, attr_type, attr->version);
 }
 
 
@@ -211,9 +225,9 @@ static void
 iter_error (void *cls)
 {
   attr_iterator = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Failed to iterate over attributes\n");
-  GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
+  fprintf (stderr,
+           "Failed to iterate over attributes\n");
+  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
 static void
@@ -221,9 +235,10 @@ timeout_task (void *cls)
 {
   timeout = NULL;
   ret = 1;
-  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
-              "Timeout\n");
-  GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
+  fprintf (stderr,
+           "Timeout\n");
+  if (NULL == cleanup_task)
+    cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
 static void
@@ -232,17 +247,16 @@ process_rvk (void *cls, int success, const char* msg)
   reclaim_op = NULL;
   if (GNUNET_OK != success)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
-                "Revocation failed.\n");
+    fprintf (stderr,
+             "Revocation failed.\n");
     ret = 1;
   }
-  GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
+  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
 static void
 iter_finished (void *cls)
 {
-  struct GNUNET_RECLAIM_ATTRIBUTE_Claim *claim;
   char *data;
   size_t data_size;
   int type;
@@ -250,7 +264,7 @@ iter_finished (void *cls)
   attr_iterator = NULL;
   if (list)
   {
-    GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
+    cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
     return;
   }
 
@@ -296,19 +310,30 @@ iter_finished (void *cls)
                                                                               attr_value,
                                                                               (void**)&data,
                                                                               &data_size));
-    claim = GNUNET_RECLAIM_ATTRIBUTE_claim_new (attr_name,
-                                                 type,
-                                                 data,
-                                                 data_size);
+    if (NULL != claim)
+    {
+      claim->type = type;
+      claim->data = data;
+      claim->data_size = data_size;
+    }
+    else
+    {
+      claim = GNUNET_RECLAIM_ATTRIBUTE_claim_new (attr_name,
+                                                  type,
+                                                  data,
+                                                  data_size);
+    }
     reclaim_op = GNUNET_RECLAIM_attribute_store (reclaim_handle,
                                                  pkey,
                                                  claim,
                                                  &exp_interval,
                                                  &store_attr_cont,
                                                  NULL);
+    GNUNET_free (data);
+    GNUNET_free (claim);
     return;
   }
-  GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
+  cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
 static void
@@ -319,13 +344,24 @@ iter_cb (void *cls,
   struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *le;
   char *attrs_tmp;
   char *attr_str;
+  const char *attr_type;
 
-  if (issue_attrs)
+  if ((NULL != attr_name) && (NULL != claim))
+  {
+    if (0 == strcasecmp (attr_name, attr->name))
+    {
+      claim = GNUNET_RECLAIM_ATTRIBUTE_claim_new (attr->name,
+                                                            attr->type,
+                                                            attr->data,
+                                                            attr->data_size);
+    }
+  }
+  else if (issue_attrs)
   {
     attrs_tmp = GNUNET_strdup (issue_attrs);
     attr_str = strtok (attrs_tmp, ",");
     while (NULL != attr_str) {
-      if (0 != strcmp (attr_str, attr->name)) {
+      if (0 != strcasecmp (attr_str, attr->name)) {
         attr_str = strtok (NULL, ",");
         continue;
       }
@@ -334,26 +370,34 @@ iter_cb (void *cls,
                                                       attr->type,
                                                       attr->data,
                                                       attr->data_size);
+      le->claim->version = attr->version;
       GNUNET_CONTAINER_DLL_insert (attr_list->list_head,
                                    attr_list->list_tail,
                                    le);
       break;
     }
     GNUNET_free (attrs_tmp);
-  } else if (list) {
-    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
-                "%s: %s\n", attr->name, (char*)attr->data);
+  } 
+  else if (list)
+  {
+    attr_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type,
+                                                         attr->data,
+                                                         attr->data_size);
+    attr_type = GNUNET_RECLAIM_ATTRIBUTE_number_to_typename (attr->type);
+    fprintf (stdout,
+             "%s: %s [%s,v%u]\n", attr->name, attr_str, attr_type, attr->version);
   }
   GNUNET_RECLAIM_get_attributes_next (attr_iterator);
 }
 
 static void
-ego_iter_finished (void *cls)
+start_get_attributes ()
 {
   if (NULL == pkey)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
-                "Ego %s not found\n", ego_name);
+    fprintf (stderr,
+             "Ego %s not found\n", ego_name);
+    cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
     return;
   }
 
@@ -372,9 +416,8 @@ ego_iter_finished (void *cls)
                                    &ticket,
                                    sizeof (struct GNUNET_RECLAIM_Ticket));
 
-
   attr_list = GNUNET_new (struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList);
-
+  claim = NULL;
   attr_iterator = GNUNET_RECLAIM_get_attributes_start (reclaim_handle,
                                                        pkey,
                                                        &iter_error,
@@ -398,7 +441,7 @@ ego_cb (void *cls,
   if (NULL == name) {
     if (GNUNET_YES == init) {
       init = GNUNET_NO;
-      GNUNET_SCHEDULER_add_now (&ego_iter_finished, NULL);
+      start_get_attributes();
     }
     return;
   }
@@ -418,24 +461,24 @@ run (void *cls,
   if (NULL == ego_name)
   {
     ret = 1;
-    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
-                _("Ego is required\n"));
+    fprintf (stderr,
+             _("Ego is required\n"));
     return;
   }
 
   if ( (NULL == attr_value) && (NULL != attr_name) )
   {
     ret = 1;
-    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
-                _("Attribute value missing!\n"));
+    fprintf (stderr,
+             _("Attribute value missing!\n"));
     return;
   }
 
   if ( (NULL == rp) && (NULL != issue_attrs) )
   {
     ret = 1;
-    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
-                _("Requesting party key is required!\n"));
+    fprintf (stderr,
+             _("Requesting party key is required!\n"));
     return;
   }
 
diff --git a/src/reclaim/gnunet-service-reclaim.c b/src/reclaim/gnunet-service-reclaim.c
index bf8780a92..3321a79d8 100644
--- a/src/reclaim/gnunet-service-reclaim.c
+++ b/src/reclaim/gnunet-service-reclaim.c
@@ -1439,9 +1439,9 @@ check_attr_cb (void *cls,
 
   buf_size = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size (rh->attrs->list_head->claim);
   buf = GNUNET_malloc (buf_size);
+  rh->attrs->list_head->claim->version++;
   GNUNET_RECLAIM_ATTRIBUTE_serialize (rh->attrs->list_head->claim,
                                        buf);
-  rh->attrs->list_head->claim->version++;
   GNUNET_asprintf (&policy, "%s_%lu",
                    rh->attrs->list_head->claim->name,
                    rh->attrs->list_head->claim->version);
diff --git a/src/rps/gnunet-service-rps.c b/src/rps/gnunet-service-rps.c
index 21963ee42..6b0ecc58c 100644
--- a/src/rps/gnunet-service-rps.c
+++ b/src/rps/gnunet-service-rps.c
@@ -823,7 +823,7 @@ check_operation_scheduled (const struct GNUNET_PeerIdentity *peer,
   return GNUNET_NO;
 }
 
-int
+static int
 Peers_remove_peer (const struct GNUNET_PeerIdentity *peer);
 
 /**
@@ -1099,12 +1099,12 @@ Peers_initialise (char* fn_valid_peers,
 /**
  * @brief Delete storage of peers that was created with #Peers_initialise ()
  */
-void
-Peers_terminate ()
+static void
+peers_terminate ()
 {
   if (GNUNET_SYSERR ==
       GNUNET_CONTAINER_multipeermap_iterate (peer_map,
-                                             peermap_clear_iterator,
+                                             &peermap_clear_iterator,
                                              NULL))
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
@@ -1114,7 +1114,9 @@ Peers_terminate ()
   peer_map = NULL;
   store_valid_peers ();
   GNUNET_free (filename_valid_peers);
+  filename_valid_peers = NULL;
   GNUNET_CONTAINER_multipeermap_destroy (valid_peers);
+  valid_peers = NULL;
 }
 
 
@@ -1257,6 +1259,11 @@ Peers_get_channel_flag (const struct GNUNET_PeerIdentity *peer,
 int
 Peers_check_channel_flag (uint32_t *channel_flags, enum Peers_ChannelFlags flags);
 
+/**
+ * @brief Callback for the scheduler to destroy the knowledge of a peer.
+ *
+ * @param cls Context of the peer
+ */
 static void
 destroy_peer (void *cls)
 {
@@ -1267,10 +1274,18 @@ destroy_peer (void *cls)
   Peers_remove_peer (&peer_ctx->peer_id);
 }
 
+
 static void
 destroy_channel (void *cls);
 
 
+/**
+ * @brief Schedule the destruction of the given channel.
+ *
+ * Do so only if it was not already scheduled and not during shutdown.
+ *
+ * @param channel_ctx The context of the channel to destroy.
+ */
 static void
 schedule_channel_destruction (struct ChannelCtx *channel_ctx)
 {
@@ -1279,11 +1294,19 @@ schedule_channel_destruction (struct ChannelCtx *channel_ctx)
       GNUNET_NO == in_shutdown)
   {
     channel_ctx->destruction_task =
-      GNUNET_SCHEDULER_add_now (destroy_channel, channel_ctx);
+      GNUNET_SCHEDULER_add_now (&destroy_channel,
+                                channel_ctx);
   }
 }
 
 
+/**
+ * @brief Schedule the destruction of the given peer.
+ *
+ * Do so only if it was not already scheduled and not during shutdown.
+ *
+ * @param peer_ctx The context of the peer to destroy.
+ */
 static void
 schedule_peer_destruction (struct PeerContext *peer_ctx)
 {
@@ -1292,7 +1315,8 @@ schedule_peer_destruction (struct PeerContext *peer_ctx)
       GNUNET_NO == in_shutdown)
   {
     peer_ctx->destruction_task =
-      GNUNET_SCHEDULER_add_now (destroy_peer, peer_ctx);
+      GNUNET_SCHEDULER_add_now (&destroy_peer,
+                                peer_ctx);
   }
 }
 
@@ -1304,18 +1328,18 @@ schedule_peer_destruction (struct PeerContext *peer_ctx)
  * @return #GNUNET_YES if peer was removed
  *         #GNUNET_NO  otherwise
  */
-int
+static int
 Peers_remove_peer (const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerContext *peer_ctx;
 
   GNUNET_assert (NULL != peer_map);
-
-  if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (peer_map, peer))
+  if (GNUNET_NO ==
+      GNUNET_CONTAINER_multipeermap_contains (peer_map,
+                                              peer))
   {
     return GNUNET_NO;
   }
-
   peer_ctx = get_peer_ctx (peer);
   set_peer_flag (peer_ctx, Peers_TO_DESTROY);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -1326,14 +1350,15 @@ Peers_remove_peer (const struct GNUNET_PeerIdentity *peer)
   /* Clear list of pending operations */
   // TODO this probably leaks memory
   //      ('only' the cls to the function. Not sure what to do with it)
-  GNUNET_array_grow (peer_ctx->pending_ops, peer_ctx->num_pending_ops, 0);
-
+  GNUNET_array_grow (peer_ctx->pending_ops,
+                     peer_ctx->num_pending_ops,
+                     0);
   /* Remove all pending messages */
   while (NULL != peer_ctx->pending_messages_head)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-        "Removing unsent %s\n",
-        peer_ctx->pending_messages_head->type);
+         "Removing unsent %s\n",
+         peer_ctx->pending_messages_head->type);
     /* Cancle pending message, too */
     if ( (NULL != peer_ctx->liveliness_check_pending) &&
          (0 == memcmp (peer_ctx->pending_messages_head,
@@ -1343,7 +1368,8 @@ Peers_remove_peer (const struct GNUNET_PeerIdentity *peer)
         // TODO this may leak memory
         peer_ctx->liveliness_check_pending = NULL;
       }
-    remove_pending_message (peer_ctx->pending_messages_head, GNUNET_YES);
+    remove_pending_message (peer_ctx->pending_messages_head,
+                            GNUNET_YES);
   }
 
   /* If we are still waiting for notification whether this peer is live
@@ -1351,11 +1377,12 @@ Peers_remove_peer (const struct GNUNET_PeerIdentity *peer)
   if (NULL != peer_ctx->liveliness_check_pending)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-         "Removing pending liveliness check for peer %s\n",
-         GNUNET_i2s (&peer_ctx->peer_id));
+                "Removing pending liveliness check for peer %s\n",
+                GNUNET_i2s (&peer_ctx->peer_id));
     // TODO wait until cadet sets mq->cancel_impl
     //GNUNET_MQ_send_cancel (peer_ctx->liveliness_check_pending->ev);
-    remove_pending_message (peer_ctx->liveliness_check_pending, GNUNET_YES);
+    remove_pending_message (peer_ctx->liveliness_check_pending,
+                            GNUNET_YES);
     peer_ctx->liveliness_check_pending = NULL;
   }
 
@@ -1363,8 +1390,7 @@ Peers_remove_peer (const struct GNUNET_PeerIdentity *peer)
   /* Do we still have to wait for destruction of channels
    * or issue the destruction? */
   if (NULL != peer_ctx->send_channel_ctx &&
-      NULL != peer_ctx->send_channel_ctx->destruction_task
-      )
+      NULL != peer_ctx->send_channel_ctx->destruction_task)
   {
     schedule_peer_destruction (peer_ctx);
     return GNUNET_NO;
@@ -1393,14 +1419,18 @@ Peers_remove_peer (const struct GNUNET_PeerIdentity *peer)
     GNUNET_SCHEDULER_cancel (peer_ctx->destruction_task);
   }
 
-  if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove_all (peer_map, &peer_ctx->peer_id))
+  if (GNUNET_YES !=
+      GNUNET_CONTAINER_multipeermap_remove_all (peer_map,
+                                                &peer_ctx->peer_id))
   {
-    LOG (GNUNET_ERROR_TYPE_WARNING, "removing peer from peer_map failed\n");
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "removing peer from peer_map failed\n");
   }
   GNUNET_free (peer_ctx);
   return GNUNET_YES;
 }
 
+
 /**
  * @brief set flags on a given peer.
  *
@@ -1571,6 +1601,7 @@ Peers_handle_inbound_channel (void *cls,
         "Already got one receive channel. Destroying old one.\n");
     GNUNET_break_op (0);
     GNUNET_CADET_channel_destroy (peer_ctx->recv_channel_ctx->channel);
+    peer_ctx->recv_channel_ctx->channel = NULL;
     remove_channel_ctx (peer_ctx->recv_channel_ctx);
     peer_ctx->recv_channel_ctx = channel_ctx;
     /* return the channel context */
@@ -1678,6 +1709,11 @@ Peers_destroy_sending_channel (const struct GNUNET_PeerIdentity *peer)
   return GNUNET_NO;
 }
 
+/**
+ * @brief Callback for scheduler to destroy a channel
+ *
+ * @param cls Context of the channel
+ */
 static void
 destroy_channel (void *cls)
 {
@@ -1692,58 +1728,6 @@ destroy_channel (void *cls)
   remove_channel_ctx (peer_ctx->send_channel_ctx);
 }
 
-/**
- * This is called when a channel is destroyed.
- *
- * @param cls The closure
- * @param channel The channel being closed
- */
-void
-Peers_cleanup_destroyed_channel (void *cls,
-                                 const struct GNUNET_CADET_Channel *channel)
-{
-  struct ChannelCtx *channel_ctx = cls;
-  const struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
-  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
-
-  if (GNUNET_NO == Peers_check_peer_known (peer))
-  {/* We don't want to implicitly create a context that we're about to kill */
-  LOG (GNUNET_ERROR_TYPE_WARNING,
-       "channel (%s) without associated context was destroyed\n",
-       GNUNET_i2s (peer));
-    return;
-  }
-
-  /* If our peer issued the destruction of the channel, the #Peers_TO_DESTROY
-   * flag will be set. In this case simply make sure that the channels are
-   * cleaned. */
-  /* The distinction seems to be redundant */
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-      "Peer is NOT in the process of being destroyed\n");
-  if ( (NULL != peer_ctx->send_channel_ctx) &&
-       (channel == peer_ctx->send_channel_ctx->channel) )
-  { /* Something (but us) killd the channel - clean up peer */
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-        "send channel (%s) was destroyed - cleaning up\n",
-        GNUNET_i2s (peer));
-    remove_channel_ctx (peer_ctx->send_channel_ctx);
-  }
-  else if ( (NULL != peer_ctx->recv_channel_ctx) &&
-       (channel == peer_ctx->recv_channel_ctx->channel) )
-  { /* Other peer doesn't want to send us messages anymore */
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Peer %s destroyed recv channel - cleaning up channel\n",
-         GNUNET_i2s (peer));
-    remove_channel_ctx (peer_ctx->send_channel_ctx);
-  }
-  else
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "unknown channel (%s) was destroyed\n",
-         GNUNET_i2s (peer));
-  }
-  (void) Peers_check_connected (peer);
-}
 
 /**
  * @brief Send a message to another peer.
@@ -2680,6 +2664,7 @@ add_channel_ctx (struct PeerContext *peer_ctx)
   return channel_ctx;
 }
 
+
 /**
  * @brief Remove the channel context from the DLL and free the memory.
  *
@@ -2689,12 +2674,12 @@ static void
 remove_channel_ctx (struct ChannelCtx *channel_ctx)
 {
   struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
+
   if (NULL != channel_ctx->destruction_task)
   {
     GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
   }
   GNUNET_free (channel_ctx);
-
   if (channel_ctx == peer_ctx->send_channel_ctx)
   {
     peer_ctx->send_channel_ctx = NULL;
@@ -2706,16 +2691,11 @@ remove_channel_ctx (struct ChannelCtx *channel_ctx)
   }
   else
   {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-        "Trying to remove channel_ctx that is not associated with a peer\n");
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-        "\trecv: %p\n", peer_ctx->recv_channel_ctx);
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-        "\tsend: %p\n", peer_ctx->send_channel_ctx);
     GNUNET_assert (0);
   }
 }
 
+
 /**
  * @brief This is called when a channel is destroyed.
  *
@@ -2733,21 +2713,7 @@ cleanup_destroyed_channel (void *cls,
                            const struct GNUNET_CADET_Channel *channel)
 {
   struct ChannelCtx *channel_ctx = cls;
-  struct GNUNET_PeerIdentity *peer = &channel_ctx->peer_ctx->peer_id;
-  struct PeerContext *peer_ctx;
-
-  GNUNET_assert (NULL != peer);
-
-  if (GNUNET_NO == Peers_check_peer_known (peer))
-  { /* We don't know a context to that peer */
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         "channel (%s) without associated context was destroyed\n",
-         GNUNET_i2s (peer));
-    remove_channel_ctx (channel_ctx);
-    return;
-  }
-
-  peer_ctx = get_peer_ctx (peer);
+  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
 
   // What should be done here:
   //  * cleanup everything related to the channel
@@ -4118,12 +4084,14 @@ shutdown_task (void *cls)
                                    reply_cls);
       GNUNET_free (reply_cls);
     }
-    GNUNET_CONTAINER_DLL_remove (cli_ctx_head, cli_ctx_tail, client_ctx);
+    GNUNET_CONTAINER_DLL_remove (cli_ctx_head,
+                                 cli_ctx_tail,
+                                 client_ctx);
     GNUNET_free (client_ctx);
   }
   GNUNET_PEERINFO_notify_cancel (peerinfo_notify_handle);
   GNUNET_PEERINFO_disconnect (peerinfo_handle);
-
+  peerinfo_handle = NULL;
   if (NULL != do_round_task)
   {
     GNUNET_SCHEDULER_cancel (do_round_task);
@@ -4142,18 +4110,21 @@ shutdown_task (void *cls)
   CustomPeerMap_destroy (pull_map);
   if (NULL != stats)
   {
-    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+    GNUNET_STATISTICS_destroy (stats,
+                               GNUNET_NO);
     stats = NULL;
   }
-  #ifdef ENABLE_MALICIOUS
+#ifdef ENABLE_MALICIOUS
   struct AttackedPeer *tmp_att_peer;
   /* it is ok to free this const during shutdown: */
   GNUNET_free ((char *) file_name_view_log);
-  #ifdef TO_FILE
+#ifdef TO_FILE
   GNUNET_free ((char *) file_name_observed_log);
   GNUNET_CONTAINER_multipeermap_destroy (observed_unique_peers);
-  #endif /* TO_FILE */
-  GNUNET_array_grow (mal_peers, num_mal_peers, 0);
+#endif /* TO_FILE */
+  GNUNET_array_grow (mal_peers,
+                     num_mal_peers,
+                     0);
   if (NULL != mal_peer_set)
     GNUNET_CONTAINER_multipeermap_destroy (mal_peer_set);
   if (NULL != att_peer_set)
@@ -4161,10 +4132,12 @@ shutdown_task (void *cls)
   while (NULL != att_peers_head)
   {
     tmp_att_peer = att_peers_head;
-    GNUNET_CONTAINER_DLL_remove (att_peers_head, att_peers_tail, tmp_att_peer);
+    GNUNET_CONTAINER_DLL_remove (att_peers_head,
+                                 att_peers_tail,
+                                 tmp_att_peer);
     GNUNET_free (tmp_att_peer);
   }
-  #endif /* ENABLE_MALICIOUS */
+#endif /* ENABLE_MALICIOUS */
 }
 
 
@@ -4211,6 +4184,7 @@ client_disconnect_cb (void *cls,
 {
   struct ClientContext *cli_ctx = internal_cls;
 
+  (void) cls;
   GNUNET_assert (client == cli_ctx->client);
   if (NULL == client)
   {/* shutdown task - destroy all clients */
@@ -4238,28 +4212,31 @@ run (void *cls,
      const struct GNUNET_CONFIGURATION_Handle *c,
      struct GNUNET_SERVICE_Handle *service)
 {
-  char* fn_valid_peers;
+  char *fn_valid_peers;
 
-  GNUNET_log_setup ("rps", GNUNET_error_type_to_string (GNUNET_ERROR_TYPE_DEBUG), NULL);
+  (void) cls;
+  (void) service;
+  GNUNET_log_setup ("rps",
+                    GNUNET_error_type_to_string (GNUNET_ERROR_TYPE_DEBUG),
+                    NULL);
   cfg = c;
-
-
   /* Get own ID */
-  GNUNET_CRYPTO_get_peer_identity (cfg, &own_identity); // TODO check return value
+  GNUNET_CRYPTO_get_peer_identity (cfg,
+                                   &own_identity); // TODO check return value
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "STARTING SERVICE (rps) for peer [%s]\n",
               GNUNET_i2s (&own_identity));
-  #ifdef ENABLE_MALICIOUS
+#ifdef ENABLE_MALICIOUS
   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
               "Malicious execution compiled in.\n");
-  #endif /* ENABLE_MALICIOUS */
-
-
+#endif /* ENABLE_MALICIOUS */
 
   /* Get time interval from the configuration */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg, "RPS",
-                                                        "ROUNDINTERVAL",
-                                                        &round_interval))
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_time (cfg,
+                                           "RPS",
+                                           "ROUNDINTERVAL",
+                                           &round_interval))
   {
     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                                "RPS", "ROUNDINTERVAL");
@@ -4341,7 +4318,7 @@ run (void *cls,
                                        &Peers_handle_inbound_channel, /* Connect handler */
                                        NULL, /* cls */
                                        NULL, /* WindowSize handler */
-                                       cleanup_destroyed_channel, /* Disconnect handler */
+                                       &cleanup_destroyed_channel, /* Disconnect handler */
                                        cadet_handlers);
   if (NULL == cadet_port)
   {
diff --git a/src/rps/gnunet-service-rps_view.c b/src/rps/gnunet-service-rps_view.c
index 1fa75fc53..26a0b22bc 100644
--- a/src/rps/gnunet-service-rps_view.c
+++ b/src/rps/gnunet-service-rps_view.c
@@ -229,11 +229,10 @@ View_get_peer_by_index (uint32_t index)
 void
 View_clear ()
 {
-  uint32_t i;
-  uint32_t *index;
-
-  for (i = 0; 0 < View_size (); i++)
+  for (uint32_t i = 0; 0 < View_size (); i++)
   { /* Need to free indices stored at peers */
+    uint32_t *index;
+
     GNUNET_assert (GNUNET_YES ==
         GNUNET_CONTAINER_multipeermap_contains (mpm, &array[i]));
     index = GNUNET_CONTAINER_multipeermap_get (mpm, &array[i]);
@@ -244,6 +243,7 @@ View_clear ()
   GNUNET_assert (0 == View_size ());
 }
 
+
 /**
  * Destroy peermap.
  *
diff --git a/src/set/gnunet-service-set.c b/src/set/gnunet-service-set.c
index 217b89d6d..75122395d 100644
--- a/src/set/gnunet-service-set.c
+++ b/src/set/gnunet-service-set.c
@@ -221,11 +221,7 @@ incoming_destroy (struct Operation *op)
     GNUNET_SCHEDULER_cancel (op->timeout_task);
     op->timeout_task = NULL;
   }
-  if (NULL != (channel = op->channel))
-  {
-    op->channel = NULL;
-    GNUNET_CADET_channel_destroy (channel);
-  }
+  _GSS_operation_destroy2 (op);
 }
 
 
@@ -1199,9 +1195,30 @@ channel_end_cb (void *channel_ctx,
 {
   struct Operation *op = channel_ctx;
 
+  op->channel = NULL;
+  _GSS_operation_destroy2 (op);
+}
+
+
+/**
+ * This function probably should not exist
+ * and be replaced by inlining more specific
+ * logic in the various places where it is called.
+ */
+void
+_GSS_operation_destroy2 (struct Operation *op)
+{
+  struct GNUNET_CADET_Channel *channel;
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "channel_end_cb called\n");
-  op->channel = NULL;
+  if (NULL != (channel = op->channel))
+  {
+    /* This will free op; called conditionally as this helper function
+       is also called from within the channel disconnect handler. */
+    op->channel = NULL;
+    GNUNET_CADET_channel_destroy (channel);
+  }
   if (NULL != op->listener)
     incoming_destroy (op);
   else if (NULL != op->set)
@@ -1376,7 +1393,7 @@ handle_client_reject (void *cls,
               "Peer request (op %u, app %s) rejected by client\n",
               op->listener->operation,
               GNUNET_h2s (&cs->listener->app_id));
-  GNUNET_CADET_channel_destroy (op->channel);
+  _GSS_operation_destroy2 (op);
   GNUNET_SERVICE_client_continue (cs->client);
 }
 
diff --git a/src/set/gnunet-service-set.h b/src/set/gnunet-service-set.h
index f7c262eac..a58b22995 100644
--- a/src/set/gnunet-service-set.h
+++ b/src/set/gnunet-service-set.h
@@ -630,6 +630,15 @@ _GSS_operation_destroy (struct Operation *op,
 
 
 /**
+ * This function probably should not exist
+ * and be replaced by inlining more specific
+ * logic in the various places where it is called.
+ */
+void
+_GSS_operation_destroy2 (struct Operation *op);
+
+
+/**
  * Get the table with implementing functions for set union.
  *
  * @return the operation specific VTable
diff --git a/src/set/gnunet-service-set_union.c b/src/set/gnunet-service-set_union.c
index c1268948a..73d3f5c83 100644
--- a/src/set/gnunet-service-set_union.c
+++ b/src/set/gnunet-service-set_union.c
@@ -1399,7 +1399,8 @@ send_client_done (void *cls)
   struct GNUNET_MQ_Envelope *ev;
   struct GNUNET_SET_ResultMessage *rm;
 
-  if (GNUNET_YES == op->state->client_done_sent) {
+  if (GNUNET_YES == op->state->client_done_sent)
+  {
     return;
   }
 
@@ -1476,7 +1477,7 @@ maybe_finish (struct Operation *op)
     {
       op->state->phase = PHASE_DONE;
       send_client_done (op);
-      destroy_channel (op);
+      _GSS_operation_destroy2 (op);
     }
   }
 }
@@ -1905,7 +1906,7 @@ handle_union_p2p_full_done (void *cls,
       op->state->phase = PHASE_DONE;
       GNUNET_CADET_receive_done (op->channel);
       send_client_done (op);
-      destroy_channel (op);
+      _GSS_operation_destroy2 (op);
       return;
     }
     break;