1 files changed, 324 insertions, 504 deletions

diff --git a/src/rps/gnunet-service-rps.c b/src/rps/gnunet-service-rps.c
index 6b0ecc58c..1f155b14f 100644
--- a/src/rps/gnunet-service-rps.c
+++ b/src/rps/gnunet-service-rps.c
@@ -84,7 +84,7 @@ static struct GNUNET_HashCode port;
 /**
  * Set a peer flag of given peer context.
  */
-#define set_peer_flag(peer_ctx, mask) ((peer_ctx->peer_flags) |= (mask))
+#define SET_PEER_FLAG(peer_ctx, mask) ((peer_ctx->peer_flags) |= (mask))
 
 /**
  * Get peer flag of given peer context.
@@ -95,7 +95,7 @@ static struct GNUNET_HashCode port;
 /**
  * Unset flag of given peer context.
  */
-#define unset_peer_flag(peer_ctx, mask) ((peer_ctx->peer_flags) &= ~(mask))
+#define UNSET_PEER_FLAG(peer_ctx, mask) ((peer_ctx->peer_flags) &= ~(mask))
 
 /**
  * Get channel flag of given channel context.
@@ -233,11 +233,6 @@ struct PeerContext
   struct PendingMessage *pending_messages_tail;
 
   /**
-   * @brief Task to destroy this context.
-   */
-  struct GNUNET_SCHEDULER_Task *destruction_task;
-
-  /**
    * This is pobably followed by 'statistical' data (when we first saw
    * it, how did we get its ID, how many pushes (in a timeinterval),
    * ...)
@@ -282,7 +277,9 @@ struct ChannelCtx
   struct PeerContext *peer_ctx;
 
   /**
-   * @brief Scheduled task that will destroy this context
+   * @brief When channel destruction needs to be delayed (because it is called
+   * from within the cadet routine of another channel destruction) this task
+   * refers to the respective _SCHEDULER_Task.
    */
   struct GNUNET_SCHEDULER_Task *destruction_task;
 };
@@ -314,7 +311,6 @@ static struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
 static struct GNUNET_CADET_Handle *cadet_handle;
 
 
-
 /**
  * @brief Get the #PeerContext associated with a peer
  *
@@ -335,8 +331,28 @@ get_peer_ctx (const struct GNUNET_PeerIdentity *peer)
   return ctx;
 }
 
-int
-Peers_check_peer_known (const struct GNUNET_PeerIdentity *peer);
+/**
+ * @brief Check whether we have information about the given peer.
+ *
+ * FIXME probably deprecated. Make this the new _online.
+ *
+ * @param peer peer in question
+ *
+ * @return #GNUNET_YES if peer is known
+ *         #GNUNET_NO  if peer is not knwon
+ */
+static int
+check_peer_known (const struct GNUNET_PeerIdentity *peer)
+{
+  if (NULL != peer_map)
+  {
+    return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
+  } else
+  {
+    return GNUNET_NO;
+  }
+}
+
 
 /**
  * @brief Create a new #PeerContext and insert it into the peer map
@@ -351,7 +367,7 @@ create_peer_ctx (const struct GNUNET_PeerIdentity *peer)
   struct PeerContext *ctx;
   int ret;
 
-  GNUNET_assert (GNUNET_NO == Peers_check_peer_known (peer));
+  GNUNET_assert (GNUNET_NO == check_peer_known (peer));
 
   ctx = GNUNET_new (struct PeerContext);
   ctx->peer_id = *peer;
@@ -372,18 +388,13 @@ create_peer_ctx (const struct GNUNET_PeerIdentity *peer)
 static struct PeerContext *
 create_or_get_peer_ctx (const struct GNUNET_PeerIdentity *peer)
 {
-  if (GNUNET_NO == Peers_check_peer_known (peer))
+  if (GNUNET_NO == check_peer_known (peer))
   {
     return create_peer_ctx (peer);
   }
   return get_peer_ctx (peer);
 }
 
-void
-Peers_unset_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
-
-void
-Peers_set_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
 
 /**
  * @brief Check whether we have a connection to this @a peer
@@ -395,13 +406,13 @@ Peers_set_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlag
  * @return #GNUNET_YES if we are connected
  *         #GNUNET_NO  otherwise
  */
-int
-Peers_check_connected (const struct GNUNET_PeerIdentity *peer)
+static int
+check_connected (const struct GNUNET_PeerIdentity *peer)
 {
-  const struct PeerContext *peer_ctx;
+  struct PeerContext *peer_ctx;
 
   /* If we don't know about this peer we don't know whether it's online */
-  if (GNUNET_NO == Peers_check_peer_known (peer))
+  if (GNUNET_NO == check_peer_known (peer))
   {
     return GNUNET_NO;
   }
@@ -411,11 +422,11 @@ Peers_check_connected (const struct GNUNET_PeerIdentity *peer)
   if ( (NULL == peer_ctx->send_channel_ctx) &&
        (NULL == peer_ctx->recv_channel_ctx) )
   {
-    Peers_unset_peer_flag (peer, Peers_ONLINE);
+    UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
     return GNUNET_NO;
   }
   /* Otherwise (if we have a channel, we know that it's online */
-  Peers_set_peer_flag (peer, Peers_ONLINE);
+  SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
   return GNUNET_YES;
 }
 
@@ -559,7 +570,7 @@ set_peer_live (struct PeerContext *peer_ctx)
   }
 
   (void) add_valid_peer (peer);
-  set_peer_flag (peer_ctx, Peers_ONLINE);
+  SET_PEER_FLAG (peer_ctx, Peers_ONLINE);
 
   /* Call pending operations */
   for (i = 0; i < peer_ctx->num_pending_ops; i++)
@@ -604,15 +615,37 @@ handle_peer_pull_reply (void *cls,
  * @return The channel context
  */
 static struct ChannelCtx *
-add_channel_ctx (struct PeerContext *peer_ctx);
+add_channel_ctx (struct PeerContext *peer_ctx)
+{
+  struct ChannelCtx *channel_ctx;
+  channel_ctx = GNUNET_new (struct ChannelCtx);
+  channel_ctx->peer_ctx = peer_ctx;
+  return channel_ctx;
+}
+
 
 /**
- * @brief Remove the channel context from the DLL and free the memory.
+ * @brief Free memory and NULL pointers.
  *
  * @param channel_ctx The channel context.
  */
 static void
-remove_channel_ctx (struct ChannelCtx *channel_ctx);
+remove_channel_ctx (struct ChannelCtx *channel_ctx)
+{
+  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
+
+  if (channel_ctx == peer_ctx->send_channel_ctx)
+  {
+    GNUNET_free (channel_ctx);
+    peer_ctx->send_channel_ctx = NULL;
+    peer_ctx->mq = NULL;
+  }
+  else if (channel_ctx == peer_ctx->recv_channel_ctx)
+  {
+    GNUNET_free (channel_ctx);
+    peer_ctx->recv_channel_ctx = NULL;
+  }
+}
 
 
 /**
@@ -664,7 +697,7 @@ get_channel (const struct GNUNET_PeerIdentity *peer)
                                    &port,
                                    GNUNET_CADET_OPTION_RELIABLE,
                                    NULL, /* WindowSize handler */
-                                   cleanup_destroyed_channel, /* Disconnect handler */
+                                   &cleanup_destroyed_channel, /* Disconnect handler */
                                    cadet_handlers);
   }
   GNUNET_assert (NULL != peer_ctx->send_channel_ctx);
@@ -823,8 +856,155 @@ check_operation_scheduled (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 (struct ChannelCtx *channel_ctx)
+{
+  struct GNUNET_CADET_Channel *channel;
+
+  if (NULL != channel_ctx->destruction_task)
+  {
+    GNUNET_SCHEDULER_cancel (channel_ctx->destruction_task);
+    channel_ctx->destruction_task = NULL;
+  }
+  GNUNET_assert (channel_ctx->channel != NULL);
+  channel = channel_ctx->channel;
+  channel_ctx->channel = NULL;
+  GNUNET_CADET_channel_destroy (channel);
+  remove_channel_ctx (channel_ctx);
+}
+
+
+/**
+ * @brief Destroy a cadet channel.
+ *
+ * This satisfies the function signature of #GNUNET_SCHEDULER_TaskCallback.
+ *
+ * @param cls
+ */
+static void
+destroy_channel_cb (void *cls)
+{
+  struct ChannelCtx *channel_ctx = cls;
+
+  channel_ctx->destruction_task = NULL;
+  destroy_channel (channel_ctx);
+}
+
+
+/**
+ * @brief Schedule the destruction of a channel for immediately afterwards.
+ *
+ * In case a channel is to be destroyed from within the callback to the
+ * destruction of another channel (send channel), we cannot call
+ * GNUNET_CADET_channel_destroy directly, but need to use this scheduling
+ * construction.
+ *
+ * @param channel_ctx channel to be destroyed.
+ */
+static void
+schedule_channel_destruction (struct ChannelCtx *channel_ctx)
+{
+  GNUNET_assert (NULL ==
+                 channel_ctx->destruction_task);
+  GNUNET_assert (NULL !=
+                 channel_ctx->channel);
+  channel_ctx->destruction_task =
+    GNUNET_SCHEDULER_add_now (&destroy_channel_cb,
+                              channel_ctx);
+}
+
+
+/**
+ * @brief Remove peer
+ *
+ * @param peer the peer to clean
+ * @return #GNUNET_YES if peer was removed
+ *         #GNUNET_NO  otherwise
+ */
 static int
-Peers_remove_peer (const struct GNUNET_PeerIdentity *peer);
+destroy_peer (struct PeerContext *peer_ctx)
+{
+  GNUNET_assert (NULL != peer_ctx);
+  GNUNET_assert (NULL != peer_map);
+  if (GNUNET_NO ==
+      GNUNET_CONTAINER_multipeermap_contains (peer_map,
+                                              &peer_ctx->peer_id))
+  {
+    return GNUNET_NO;
+  }
+  SET_PEER_FLAG (peer_ctx, Peers_TO_DESTROY);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Going to remove peer %s\n",
+       GNUNET_i2s (&peer_ctx->peer_id));
+  UNSET_PEER_FLAG (peer_ctx, Peers_ONLINE);
+
+  /* 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);
+  /* 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);
+    /* Cancle pending message, too */
+    if ( (NULL != peer_ctx->liveliness_check_pending) &&
+         (0 == memcmp (peer_ctx->pending_messages_head,
+                     peer_ctx->liveliness_check_pending,
+                     sizeof (struct PendingMessage))) )
+      {
+        // TODO this may leak memory
+        peer_ctx->liveliness_check_pending = NULL;
+      }
+    remove_pending_message (peer_ctx->pending_messages_head,
+                            GNUNET_YES);
+  }
+
+  /* If we are still waiting for notification whether this peer is live
+   * cancel the according task */
+  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));
+    // 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);
+    peer_ctx->liveliness_check_pending = NULL;
+  }
+
+  if (NULL != peer_ctx->send_channel_ctx)
+  {
+    /* This is possibly called from within channel destruction */
+    schedule_channel_destruction (peer_ctx->send_channel_ctx);
+  }
+  if (NULL != peer_ctx->recv_channel_ctx)
+  {
+    /* This is possibly called from within channel destruction */
+    schedule_channel_destruction (peer_ctx->recv_channel_ctx);
+  }
+
+  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");
+  }
+  GNUNET_free (peer_ctx);
+  return GNUNET_YES;
+}
+
 
 /**
  * Iterator over hash map entries. Deletes all contexts of peers.
@@ -840,7 +1020,7 @@ peermap_clear_iterator (void *cls,
                         const struct GNUNET_PeerIdentity *key,
                         void *value)
 {
-  Peers_remove_peer (key);
+  destroy_peer (get_peer_ctx (key));
   return GNUNET_YES;
 }
 
@@ -1084,8 +1264,8 @@ restore_valid_peers ()
  * @param cadet_h cadet handle
  * @param own_id own peer identity
  */
-void
-Peers_initialise (char* fn_valid_peers,
+static void
+initialise_peers (char* fn_valid_peers,
                   struct GNUNET_CADET_Handle *cadet_h)
 {
   filename_valid_peers = GNUNET_strdup (fn_valid_peers);
@@ -1097,7 +1277,7 @@ Peers_initialise (char* fn_valid_peers,
 
 
 /**
- * @brief Delete storage of peers that was created with #Peers_initialise ()
+ * @brief Delete storage of peers that was created with #initialise_peers ()
  */
 static void
 peers_terminate ()
@@ -1150,9 +1330,9 @@ valid_peer_iterator (void *cls,
  * @return the number of key value pairs processed,
  *         #GNUNET_SYSERR if it aborted iteration
  */
-int
-Peers_get_valid_peers (PeersIterator iterator,
-                       void *it_cls)
+static int
+get_valid_peers (PeersIterator iterator,
+                 void *it_cls)
 {
   struct PeersIteratorCls *cls;
   int ret;
@@ -1179,10 +1359,10 @@ Peers_get_valid_peers (PeersIterator iterator,
  * @return #GNUNET_YES if peer was inserted
  *         #GNUNET_NO  otherwise
  */
-int
-Peers_insert_peer (const struct GNUNET_PeerIdentity *peer)
+static int
+insert_peer (const struct GNUNET_PeerIdentity *peer)
 {
-  if (GNUNET_YES == Peers_check_peer_known (peer))
+  if (GNUNET_YES == check_peer_known (peer))
   {
     return GNUNET_NO; /* We already know this peer - nothing to do */
   }
@@ -1190,8 +1370,30 @@ Peers_insert_peer (const struct GNUNET_PeerIdentity *peer)
   return GNUNET_YES;
 }
 
-int
-Peers_check_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags);
+
+/**
+ * @brief Check whether flags on a peer are set.
+ *
+ * @param peer the peer to check the flag of
+ * @param flags the flags to check
+ *
+ * @return #GNUNET_SYSERR if peer is not known
+ *         #GNUNET_YES    if all given flags are set
+ *         #GNUNET_NO     otherwise
+ */
+static int
+check_peer_flag (const struct GNUNET_PeerIdentity *peer,
+                 enum Peers_PeerFlags flags)
+{
+  struct PeerContext *peer_ctx;
+
+  if (GNUNET_NO == check_peer_known (peer))
+  {
+    return GNUNET_SYSERR;
+  }
+  peer_ctx = get_peer_ctx (peer);
+  return check_peer_flag_set (peer_ctx, flags);
+}
 
 /**
  * @brief Try connecting to a peer to see whether it is online
@@ -1202,15 +1404,15 @@ Peers_check_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFl
  * @return #GNUNET_YES if peer had to be inserted
  *         #GNUNET_NO  otherwise
  */
-int
-Peers_issue_peer_liveliness_check (const struct GNUNET_PeerIdentity *peer)
+static int
+issue_peer_liveliness_check (const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerContext *peer_ctx;
   int ret;
 
-  ret = Peers_insert_peer (peer);
+  ret = insert_peer (peer);
   peer_ctx = get_peer_ctx (peer);
-  if ( (GNUNET_NO == Peers_check_peer_flag (peer, Peers_ONLINE)) &&
+  if ( (GNUNET_NO == check_peer_flag (peer, Peers_ONLINE)) &&
        (NULL == peer_ctx->liveliness_check_pending) )
   {
     check_peer_live (peer_ctx);
@@ -1232,8 +1434,8 @@ Peers_issue_peer_liveliness_check (const struct GNUNET_PeerIdentity *peer)
  *         #GNUNET_NO     if peer is NOT removable
  *         #GNUNET_SYSERR if peer is not known
  */
-int
-Peers_check_removable (const struct GNUNET_PeerIdentity *peer)
+static int
+check_removable (const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerContext *peer_ctx;
 
@@ -1252,262 +1454,6 @@ Peers_check_removable (const struct GNUNET_PeerIdentity *peer)
   return GNUNET_YES;
 }
 
-uint32_t *
-Peers_get_channel_flag (const struct GNUNET_PeerIdentity *peer,
-                        enum Peers_ChannelRole role);
-
-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)
-{
-  struct PeerContext *peer_ctx = cls;
-
-  GNUNET_assert (NULL != peer_ctx);
-  peer_ctx->destruction_task = NULL;
-  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)
-{
-  GNUNET_assert (NULL != channel_ctx);
-  if (NULL != channel_ctx->destruction_task &&
-      GNUNET_NO == in_shutdown)
-  {
-    channel_ctx->destruction_task =
-      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)
-{
-  GNUNET_assert (NULL != peer_ctx);
-  if (NULL != peer_ctx->destruction_task &&
-      GNUNET_NO == in_shutdown)
-  {
-    peer_ctx->destruction_task =
-      GNUNET_SCHEDULER_add_now (&destroy_peer,
-                                peer_ctx);
-  }
-}
-
-
-/**
- * @brief Remove peer
- *
- * @param peer the peer to clean
- * @return #GNUNET_YES if peer was removed
- *         #GNUNET_NO  otherwise
- */
-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))
-  {
-    return GNUNET_NO;
-  }
-  peer_ctx = get_peer_ctx (peer);
-  set_peer_flag (peer_ctx, Peers_TO_DESTROY);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Going to remove peer %s\n",
-       GNUNET_i2s (&peer_ctx->peer_id));
-  Peers_unset_peer_flag (peer, Peers_ONLINE);
-
-  /* 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);
-  /* 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);
-    /* Cancle pending message, too */
-    if ( (NULL != peer_ctx->liveliness_check_pending) &&
-         (0 == memcmp (peer_ctx->pending_messages_head,
-                     peer_ctx->liveliness_check_pending,
-                     sizeof (struct PendingMessage))) )
-      {
-        // TODO this may leak memory
-        peer_ctx->liveliness_check_pending = NULL;
-      }
-    remove_pending_message (peer_ctx->pending_messages_head,
-                            GNUNET_YES);
-  }
-
-  /* If we are still waiting for notification whether this peer is live
-   * cancel the according task */
-  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));
-    // 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);
-    peer_ctx->liveliness_check_pending = NULL;
-  }
-
-
-  /* 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)
-  {
-    schedule_peer_destruction (peer_ctx);
-    return GNUNET_NO;
-  }
-  if (NULL != peer_ctx->recv_channel_ctx &&
-      NULL != peer_ctx->recv_channel_ctx->destruction_task)
-  {
-    schedule_peer_destruction (peer_ctx);
-    return GNUNET_NO;
-  }
-  if (NULL != peer_ctx->recv_channel_ctx)
-  {
-    schedule_channel_destruction (peer_ctx->recv_channel_ctx);
-    schedule_peer_destruction (peer_ctx);
-    return GNUNET_NO;
-  }
-  if (NULL != peer_ctx->send_channel_ctx)
-  {
-    schedule_channel_destruction (peer_ctx->send_channel_ctx);
-    schedule_peer_destruction (peer_ctx);
-    return GNUNET_NO;
-  }
-
-  if (NULL != peer_ctx->destruction_task)
-  {
-    GNUNET_SCHEDULER_cancel (peer_ctx->destruction_task);
-  }
-
-  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");
-  }
-  GNUNET_free (peer_ctx);
-  return GNUNET_YES;
-}
-
-
-/**
- * @brief set flags on a given peer.
- *
- * @param peer the peer to set flags on
- * @param flags the flags
- */
-void
-Peers_set_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
-{
-  struct PeerContext *peer_ctx;
-
-  peer_ctx = get_peer_ctx (peer);
-  set_peer_flag (peer_ctx, flags);
-}
-
-
-/**
- * @brief unset flags on a given peer.
- *
- * @param peer the peer to unset flags on
- * @param flags the flags
- */
-void
-Peers_unset_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
-{
-  struct PeerContext *peer_ctx;
-
-  peer_ctx = get_peer_ctx (peer);
-  unset_peer_flag (peer_ctx, flags);
-}
-
-
-/**
- * @brief Check whether flags on a peer are set.
- *
- * @param peer the peer to check the flag of
- * @param flags the flags to check
- *
- * @return #GNUNET_SYSERR if peer is not known
- *         #GNUNET_YES    if all given flags are set
- *         #GNUNET_NO     otherwise
- */
-int
-Peers_check_peer_flag (const struct GNUNET_PeerIdentity *peer, enum Peers_PeerFlags flags)
-{
-  struct PeerContext *peer_ctx;
-
-  if (GNUNET_NO == Peers_check_peer_known (peer))
-  {
-    return GNUNET_SYSERR;
-  }
-  peer_ctx = get_peer_ctx (peer);
-  return check_peer_flag_set (peer_ctx, flags);
-}
-
-/**
- * @brief Check whether we have information about the given peer.
- *
- * FIXME probably deprecated. Make this the new _online.
- *
- * @param peer peer in question
- *
- * @return #GNUNET_YES if peer is known
- *         #GNUNET_NO  if peer is not knwon
- */
-int
-Peers_check_peer_known (const struct GNUNET_PeerIdentity *peer)
-{
-  if (NULL != peer_map)
-  {
-    return GNUNET_CONTAINER_multipeermap_contains (peer_map, peer);
-  } else
-  {
-    return GNUNET_NO;
-  }
-}
-
 
 /**
  * @brief Check whether @a peer is actually a peer.
@@ -1519,8 +1465,8 @@ Peers_check_peer_known (const struct GNUNET_PeerIdentity *peer)
  * @return #GNUNET_YES if peer is valid
  *         #GNUNET_NO  if peer is not valid
  */
-int
-Peers_check_peer_valid (const struct GNUNET_PeerIdentity *peer)
+static int
+check_peer_valid (const struct GNUNET_PeerIdentity *peer)
 {
   return GNUNET_CONTAINER_multipeermap_contains (valid_peers, peer);
 }
@@ -1533,10 +1479,10 @@ Peers_check_peer_valid (const struct GNUNET_PeerIdentity *peer)
  *
  * @param peer the peer to establish channel to
  */
-void
-Peers_indicate_sending_intention (const struct GNUNET_PeerIdentity *peer)
+static void
+indicate_sending_intention (const struct GNUNET_PeerIdentity *peer)
 {
-  GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
+  GNUNET_assert (GNUNET_YES == check_peer_known (peer));
   (void) get_channel (peer);
 }
 
@@ -1550,8 +1496,8 @@ Peers_indicate_sending_intention (const struct GNUNET_PeerIdentity *peer)
  * @return #GNUNET_YES if peer has the intention to send
  *         #GNUNET_NO  otherwise
  */
-int
-Peers_check_peer_send_intention (const struct GNUNET_PeerIdentity *peer)
+static int
+check_peer_send_intention (const struct GNUNET_PeerIdentity *peer)
 {
   const struct PeerContext *peer_ctx;
 
@@ -1574,10 +1520,10 @@ Peers_check_peer_send_intention (const struct GNUNET_PeerIdentity *peer)
  * @return initial channel context for the channel
  *         (can be NULL -- that's not an error)
  */
-void *
-Peers_handle_inbound_channel (void *cls,
-                              struct GNUNET_CADET_Channel *channel,
-                              const struct GNUNET_PeerIdentity *initiator)
+static void *
+handle_inbound_channel (void *cls,
+                        struct GNUNET_CADET_Channel *channel,
+                        const struct GNUNET_PeerIdentity *initiator)
 {
   struct PeerContext *peer_ctx;
   struct GNUNET_PeerIdentity *ctx_peer;
@@ -1595,14 +1541,12 @@ Peers_handle_inbound_channel (void *cls,
   channel_ctx = add_channel_ctx (peer_ctx);
   channel_ctx->channel = channel;
   /* We only accept one incoming channel per peer */
-  if (GNUNET_YES == Peers_check_peer_send_intention (initiator))
+  if (GNUNET_YES == check_peer_send_intention (initiator))
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
         "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);
+    destroy_channel (peer_ctx->recv_channel_ctx);
     peer_ctx->recv_channel_ctx = channel_ctx;
     /* return the channel context */
     return channel_ctx;
@@ -1620,12 +1564,12 @@ Peers_handle_inbound_channel (void *cls,
  * @return #GNUNET_YES if a sending channel towards that peer exists
  *         #GNUNET_NO  otherwise
  */
-int
-Peers_check_sending_channel_exists (const struct GNUNET_PeerIdentity *peer)
+static int
+check_sending_channel_exists (const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerContext *peer_ctx;
 
-  if (GNUNET_NO == Peers_check_peer_known (peer))
+  if (GNUNET_NO == check_peer_known (peer))
   { /* If no such peer exists, there is no channel */
     return GNUNET_NO;
   }
@@ -1639,46 +1583,6 @@ Peers_check_sending_channel_exists (const struct GNUNET_PeerIdentity *peer)
 
 
 /**
- * @brief check whether the given channel is the sending channel of the given
- *        peer
- *
- * @param peer the peer in question
- * @param channel the channel to check for
- * @param role either #Peers_CHANNEL_ROLE_SENDING, or
- *                    #Peers_CHANNEL_ROLE_RECEIVING
- *
- * @return #GNUNET_YES if the given chennel is the sending channel of the peer
- *         #GNUNET_NO  otherwise
- */
-int
-Peers_check_channel_role (const struct GNUNET_PeerIdentity *peer,
-                          const struct GNUNET_CADET_Channel *channel,
-                          enum Peers_ChannelRole role)
-{
-  const struct PeerContext *peer_ctx;
-
-  if (GNUNET_NO == Peers_check_peer_known (peer))
-  {
-    return GNUNET_NO;
-  }
-  peer_ctx = get_peer_ctx (peer);
-  if ( (Peers_CHANNEL_ROLE_SENDING == role) &&
-       (NULL != peer_ctx->send_channel_ctx) &&
-       (channel == peer_ctx->send_channel_ctx->channel) )
-  {
-    return GNUNET_YES;
-  }
-  if ( (Peers_CHANNEL_ROLE_RECEIVING == role) &&
-       (NULL != peer_ctx->recv_channel_ctx) &&
-       (channel == peer_ctx->recv_channel_ctx->channel) )
-  {
-    return GNUNET_YES;
-  }
-  return GNUNET_NO;
-}
-
-
-/**
  * @brief Destroy the send channel of a peer e.g. stop indicating a sending
  *        intention to another peer
  *
@@ -1690,46 +1594,26 @@ Peers_check_channel_role (const struct GNUNET_PeerIdentity *peer,
  * @return #GNUNET_YES if channel was destroyed
  *         #GNUNET_NO  otherwise
  */
-int
-Peers_destroy_sending_channel (const struct GNUNET_PeerIdentity *peer)
+static int
+destroy_sending_channel (const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerContext *peer_ctx;
 
-  if (GNUNET_NO == Peers_check_peer_known (peer))
+  if (GNUNET_NO == check_peer_known (peer))
   {
     return GNUNET_NO;
   }
   peer_ctx = get_peer_ctx (peer);
   if (NULL != peer_ctx->send_channel_ctx)
   {
-    schedule_channel_destruction (peer_ctx->send_channel_ctx);
-    (void) Peers_check_connected (peer);
+    destroy_channel (peer_ctx->send_channel_ctx);
+    (void) check_connected (peer);
     return GNUNET_YES;
   }
   return GNUNET_NO;
 }
 
 /**
- * @brief Callback for scheduler to destroy a channel
- *
- * @param cls Context of the channel
- */
-static void
-destroy_channel (void *cls)
-{
-  struct ChannelCtx *channel_ctx = cls;
-  struct PeerContext *peer_ctx = channel_ctx->peer_ctx;
-
-  GNUNET_assert (channel_ctx == peer_ctx->send_channel_ctx ||
-                 channel_ctx == peer_ctx->recv_channel_ctx);
-
-  channel_ctx->destruction_task = NULL;
-  GNUNET_CADET_channel_destroy (channel_ctx->channel);
-  remove_channel_ctx (peer_ctx->send_channel_ctx);
-}
-
-
-/**
  * @brief Send a message to another peer.
  *
  * Keeps track about pending messages so they can be properly removed when the
@@ -1739,10 +1623,10 @@ destroy_channel (void *cls)
  * @param ev envelope of the message
  * @param type type of the message
  */
-void
-Peers_send_message (const struct GNUNET_PeerIdentity *peer,
-                    struct GNUNET_MQ_Envelope *ev,
-                    const char *type)
+static void
+send_message (const struct GNUNET_PeerIdentity *peer,
+              struct GNUNET_MQ_Envelope *ev,
+              const char *type)
 {
   struct PendingMessage *pending_msg;
   struct GNUNET_MQ_Handle *mq;
@@ -1769,14 +1653,14 @@ Peers_send_message (const struct GNUNET_PeerIdentity *peer,
  * @return #GNUNET_YES if the operation was scheduled
  *         #GNUNET_NO  otherwise
  */
-int
-Peers_schedule_operation (const struct GNUNET_PeerIdentity *peer,
+static int
+schedule_operation (const struct GNUNET_PeerIdentity *peer,
                           const PeerOp peer_op)
 {
   struct PeerPendingOp pending_op;
   struct PeerContext *peer_ctx;
 
-  GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
+  GNUNET_assert (GNUNET_YES == check_peer_known (peer));
 
   //TODO if LIVE/ONLINE execute immediately
 
@@ -1793,24 +1677,6 @@ Peers_schedule_operation (const struct GNUNET_PeerIdentity *peer,
   return GNUNET_NO;
 }
 
-/**
- * @brief Get the recv_channel of @a peer.
- * Needed to correctly handle (call #GNUNET_CADET_receive_done()) incoming
- * messages.
- *
- * @param peer The peer to get the recv_channel from.
- *
- * @return The recv_channel.
- */
-struct GNUNET_CADET_Channel *
-Peers_get_recv_channel (const struct GNUNET_PeerIdentity *peer)
-{
-  struct PeerContext *peer_ctx;
-
-  GNUNET_assert (GNUNET_YES == Peers_check_peer_known (peer));
-  peer_ctx = get_peer_ctx (peer);
-  return peer_ctx->recv_channel_ctx->channel;
-}
 /***********************************************************************
  * /Old gnunet-service-rps_peers.c
 ***********************************************************************/
@@ -2266,16 +2132,16 @@ insert_in_view (const struct GNUNET_PeerIdentity *peer)
 {
   int online;
 
-  online = Peers_check_peer_flag (peer, Peers_ONLINE);
+  online = check_peer_flag (peer, Peers_ONLINE);
   if ( (GNUNET_NO == online) ||
        (GNUNET_SYSERR == online) ) /* peer is not even known */
   {
-    (void) Peers_issue_peer_liveliness_check (peer);
-    (void) Peers_schedule_operation (peer, insert_in_view_op);
+    (void) issue_peer_liveliness_check (peer);
+    (void) schedule_operation (peer, insert_in_view_op);
     return GNUNET_NO;
   }
   /* Open channel towards peer to keep connection open */
-  Peers_indicate_sending_intention (peer);
+  indicate_sending_intention (peer);
   return View_put (peer);
 }
 
@@ -2468,7 +2334,7 @@ send_pull_reply (const struct GNUNET_PeerIdentity *peer_id,
   GNUNET_memcpy (&out_msg[1], peer_ids,
          send_size * sizeof (struct GNUNET_PeerIdentity));
 
-  Peers_send_message (peer_id, ev, "PULL REPLY");
+  send_message (peer_id, ev, "PULL REPLY");
   GNUNET_STATISTICS_update(stats, "# pull reply send issued", 1, GNUNET_NO);
   // TODO check with send intention: as send_channel is used/opened we indicate
   // a sending intention without intending it.
@@ -2519,10 +2385,10 @@ insert_in_sampler (void *cls,
   if (0 < RPS_sampler_count_id (prot_sampler, peer))
   {
     /* Make sure we 'know' about this peer */
-    (void) Peers_issue_peer_liveliness_check (peer);
+    (void) issue_peer_liveliness_check (peer);
     /* Establish a channel towards that peer to indicate we are going to send
      * messages to it */
-    //Peers_indicate_sending_intention (peer);
+    //indicate_sending_intention (peer);
   }
   #ifdef TO_FILE
   num_observed_peers++;
@@ -2554,10 +2420,10 @@ static void
 got_peer (const struct GNUNET_PeerIdentity *peer)
 {
   /* If we did not know this peer already, insert it into sampler and view */
-  if (GNUNET_YES == Peers_issue_peer_liveliness_check (peer))
+  if (GNUNET_YES == issue_peer_liveliness_check (peer))
   {
-    Peers_schedule_operation (peer, insert_in_sampler);
-    Peers_schedule_operation (peer, insert_in_view_op);
+    schedule_operation (peer, insert_in_sampler);
+    schedule_operation (peer, insert_in_view_op);
   }
 }
 
@@ -2572,17 +2438,17 @@ static int
 check_sending_channel_needed (const struct GNUNET_PeerIdentity *peer)
 {
   /* struct GNUNET_CADET_Channel *channel; */
-  if (GNUNET_NO == Peers_check_peer_known (peer))
+  if (GNUNET_NO == check_peer_known (peer))
   {
     return GNUNET_NO;
   }
-  if (GNUNET_YES == Peers_check_sending_channel_exists (peer))
+  if (GNUNET_YES == check_sending_channel_exists (peer))
   {
     if ( (0 < RPS_sampler_count_id (prot_sampler, peer)) ||
          (GNUNET_YES == View_contains_peer (peer)) ||
          (GNUNET_YES == CustomPeerMap_contains_peer (push_map, peer)) ||
          (GNUNET_YES == CustomPeerMap_contains_peer (pull_map, peer)) ||
-         (GNUNET_YES == Peers_check_peer_flag (peer, Peers_PULL_REPLY_PENDING)))
+         (GNUNET_YES == check_peer_flag (peer, Peers_PULL_REPLY_PENDING)))
     { /* If we want to keep the connection to peer open */
       return GNUNET_YES;
     }
@@ -2605,7 +2471,7 @@ remove_peer (const struct GNUNET_PeerIdentity *peer)
   CustomPeerMap_remove_peer (push_map, peer);
   RPS_sampler_reinitialise_by_value (prot_sampler, peer);
   RPS_sampler_reinitialise_by_value (client_sampler, peer);
-  schedule_peer_destruction (get_peer_ctx (peer));
+  destroy_peer (get_peer_ctx (peer));
 }
 
 
@@ -2626,19 +2492,19 @@ clean_peer (const struct GNUNET_PeerIdentity *peer)
         GNUNET_i2s (peer));
     #ifdef ENABLE_MALICIOUS
     if (0 != GNUNET_CRYPTO_cmp_peer_identity (&attacked_peer, peer))
-      (void) Peers_destroy_sending_channel (peer);
+      (void) destroy_sending_channel (peer);
     #else /* ENABLE_MALICIOUS */
-    (void) Peers_destroy_sending_channel (peer);
+    (void) destroy_sending_channel (peer);
     #endif /* ENABLE_MALICIOUS */
   }
 
-  if ( (GNUNET_NO == Peers_check_peer_send_intention (peer)) &&
+  if ( (GNUNET_NO == check_peer_send_intention (peer)) &&
        (GNUNET_NO == View_contains_peer (peer)) &&
        (GNUNET_NO == CustomPeerMap_contains_peer (push_map, peer)) &&
        (GNUNET_NO == CustomPeerMap_contains_peer (push_map, peer)) &&
        (0 == RPS_sampler_count_id (prot_sampler,   peer)) &&
        (0 == RPS_sampler_count_id (client_sampler, peer)) &&
-       (GNUNET_NO != Peers_check_removable (peer)) )
+       (GNUNET_NO != check_removable (peer)) )
   { /* We can safely remove this peer */
     LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Going to remove peer %s\n",
@@ -2648,53 +2514,6 @@ clean_peer (const struct GNUNET_PeerIdentity *peer)
   }
 }
 
-/**
- * @brief Allocate memory for a new channel context and insert it into DLL
- *
- * @param peer_ctx context of the according peer
- *
- * @return The channel context
- */
-static struct ChannelCtx *
-add_channel_ctx (struct PeerContext *peer_ctx)
-{
-  struct ChannelCtx *channel_ctx;
-  channel_ctx = GNUNET_new (struct ChannelCtx);
-  channel_ctx->peer_ctx = peer_ctx;
-  return channel_ctx;
-}
-
-
-/**
- * @brief Remove the channel context from the DLL and free the memory.
- *
- * @param channel_ctx The channel context.
- */
-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;
-    peer_ctx->mq = NULL;
-  }
-  else if (channel_ctx == peer_ctx->recv_channel_ctx)
-  {
-    peer_ctx->recv_channel_ctx = NULL;
-  }
-  else
-  {
-    GNUNET_assert (0);
-  }
-}
-
 
 /**
  * @brief This is called when a channel is destroyed.
@@ -2719,7 +2538,7 @@ cleanup_destroyed_channel (void *cls,
   //  * cleanup everything related to the channel
   //    * memory
   //  * remove peer if necessary
-
+  channel_ctx->channel = NULL;
   if (peer_ctx->recv_channel_ctx == channel_ctx)
   {
     remove_channel_ctx (channel_ctx);
@@ -3184,7 +3003,7 @@ handle_peer_push (void *cls,
   /* Add the sending peer to the push_map */
   CustomPeerMap_put (push_map, peer);
 
-  GNUNET_break_op (Peers_check_peer_known (peer));
+  GNUNET_break_op (check_peer_known (peer));
   GNUNET_CADET_receive_done (channel_ctx->channel);
 }
 
@@ -3224,7 +3043,7 @@ handle_peer_pull_request (void *cls,
   }
   #endif /* ENABLE_MALICIOUS */
 
-  GNUNET_break_op (Peers_check_peer_known (peer));
+  GNUNET_break_op (check_peer_known (peer));
   GNUNET_CADET_receive_done (channel_ctx->channel);
   view_array = View_get_as_array ();
   send_pull_reply (peer, view_array, View_size ());
@@ -3262,7 +3081,7 @@ check_peer_pull_reply (void *cls,
     return GNUNET_SYSERR;
   }
 
-  if (GNUNET_YES != Peers_check_peer_flag (sender, Peers_PULL_REPLY_PENDING))
+  if (GNUNET_YES != check_peer_flag (sender, Peers_PULL_REPLY_PENDING))
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
         "Received a pull reply from a peer (%s) we didn't request one from!\n",
@@ -3336,23 +3155,23 @@ handle_peer_pull_reply (void *cls,
     }
     #endif /* ENABLE_MALICIOUS */
     /* Make sure we 'know' about this peer */
-    (void) Peers_insert_peer (&peers[i]);
+    (void) insert_peer (&peers[i]);
 
-    if (GNUNET_YES == Peers_check_peer_valid (&peers[i]))
+    if (GNUNET_YES == check_peer_valid (&peers[i]))
     {
       CustomPeerMap_put (pull_map, &peers[i]);
     }
     else
     {
-      Peers_schedule_operation (&peers[i], insert_in_pull_map);
-      (void) Peers_issue_peer_liveliness_check (&peers[i]);
+      schedule_operation (&peers[i], insert_in_pull_map);
+      (void) issue_peer_liveliness_check (&peers[i]);
     }
   }
 
-  Peers_unset_peer_flag (sender, Peers_PULL_REPLY_PENDING);
+  UNSET_PEER_FLAG (get_peer_ctx (sender), Peers_PULL_REPLY_PENDING);
   clean_peer (sender);
 
-  GNUNET_break_op (Peers_check_peer_known (sender));
+  GNUNET_break_op (check_peer_known (sender));
   GNUNET_CADET_receive_done (channel_ctx->channel);
 }
 
@@ -3416,16 +3235,16 @@ send_pull_request (const struct GNUNET_PeerIdentity *peer)
 {
   struct GNUNET_MQ_Envelope *ev;
 
-  GNUNET_assert (GNUNET_NO == Peers_check_peer_flag (peer,
+  GNUNET_assert (GNUNET_NO == check_peer_flag (peer,
                                                      Peers_PULL_REPLY_PENDING));
-  Peers_set_peer_flag (peer, Peers_PULL_REPLY_PENDING);
+  SET_PEER_FLAG (get_peer_ctx (peer), Peers_PULL_REPLY_PENDING);
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Going to send PULL REQUEST to peer %s.\n",
        GNUNET_i2s (peer));
 
   ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST);
-  Peers_send_message (peer, ev, "PULL REQUEST");
+  send_message (peer, ev, "PULL REQUEST");
   GNUNET_STATISTICS_update(stats, "# pull request send issued", 1, GNUNET_NO);
 }
 
@@ -3445,7 +3264,7 @@ send_push (const struct GNUNET_PeerIdentity *peer_id)
        GNUNET_i2s (peer_id));
 
   ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PUSH);
-  Peers_send_message (peer_id, ev, "PUSH");
+  send_message (peer_id, ev, "PUSH");
   GNUNET_STATISTICS_update(stats, "# push send issued", 1, GNUNET_NO);
 }
 
@@ -3569,9 +3388,9 @@ handle_client_act_malicious (void *cls,
             &msg->attacked_peer,
             sizeof (struct GNUNET_PeerIdentity));
     /* Set the flag of the attacked peer to valid to avoid problems */
-    if (GNUNET_NO == Peers_check_peer_known (&attacked_peer))
+    if (GNUNET_NO == check_peer_known (&attacked_peer))
     {
-      (void) Peers_issue_peer_liveliness_check (&attacked_peer);
+      (void) issue_peer_liveliness_check (&attacked_peer);
     }
 
     LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -3661,8 +3480,8 @@ do_mal_round (void *cls)
      * Send as many pushes to the attacked peer as possible
      * That is one push per round as it will ignore more.
      */
-    (void) Peers_issue_peer_liveliness_check (&attacked_peer);
-    if (GNUNET_YES == Peers_check_peer_flag (&attacked_peer, Peers_ONLINE))
+    (void) issue_peer_liveliness_check (&attacked_peer);
+    if (GNUNET_YES == check_peer_flag (&attacked_peer, Peers_ONLINE))
       send_push (&attacked_peer);
   }
 
@@ -3671,10 +3490,10 @@ do_mal_round (void *cls)
   { /* Combined attack */
 
     /* Send PUSH to attacked peers */
-    if (GNUNET_YES == Peers_check_peer_known (&attacked_peer))
+    if (GNUNET_YES == check_peer_known (&attacked_peer))
     {
-      (void) Peers_issue_peer_liveliness_check (&attacked_peer);
-      if (GNUNET_YES == Peers_check_peer_flag (&attacked_peer, Peers_ONLINE))
+      (void) issue_peer_liveliness_check (&attacked_peer);
+      if (GNUNET_YES == check_peer_flag (&attacked_peer, Peers_ONLINE))
       {
         LOG (GNUNET_ERROR_TYPE_DEBUG,
             "Goding to send push to attacked peer (%s)\n",
@@ -3682,7 +3501,7 @@ do_mal_round (void *cls)
         send_push (&attacked_peer);
       }
     }
-    (void) Peers_issue_peer_liveliness_check (&attacked_peer);
+    (void) issue_peer_liveliness_check (&attacked_peer);
 
     /* The maximum of pushes we're going to send this round */
     num_pushes = GNUNET_MIN (GNUNET_MIN (push_limit - 1,
@@ -3799,7 +3618,7 @@ do_round (void *cls)
     for (i = first_border; i < second_border; i++)
     {
       peer = view_array[permut[i]];
-      if ( GNUNET_NO == Peers_check_peer_flag (&peer, Peers_PULL_REPLY_PENDING))
+      if ( GNUNET_NO == check_peer_flag (&peer, Peers_PULL_REPLY_PENDING))
       { // FIXME if this fails schedule/loop this for later
         send_pull_request (&peer);
       }
@@ -4098,13 +3917,14 @@ shutdown_task (void *cls)
     do_round_task = NULL;
   }
 
-  Peers_terminate ();
+  peers_terminate ();
 
   GNUNET_NSE_disconnect (nse);
   RPS_sampler_destroy (prot_sampler);
   RPS_sampler_destroy (client_sampler);
   GNUNET_CADET_close_port (cadet_port);
   GNUNET_CADET_disconnect (cadet_handle);
+  cadet_handle = NULL;
   View_destroy ();
   CustomPeerMap_destroy (push_map);
   CustomPeerMap_destroy (pull_map);
@@ -4315,7 +4135,7 @@ run (void *cls,
                       &port);
   cadet_port = GNUNET_CADET_open_port (cadet_handle,
                                        &port,
-                                       &Peers_handle_inbound_channel, /* Connect handler */
+                                       &handle_inbound_channel, /* Connect handler */
                                        NULL, /* cls */
                                        NULL, /* WindowSize handler */
                                        &cleanup_destroyed_channel, /* Disconnect handler */
@@ -4330,7 +4150,7 @@ run (void *cls,
 
 
   peerinfo_handle = GNUNET_PEERINFO_connect (cfg);
-  Peers_initialise (fn_valid_peers, cadet_handle);
+  initialise_peers (fn_valid_peers, cadet_handle);
   GNUNET_free (fn_valid_peers);
 
   /* Initialise sampler */
@@ -4353,7 +4173,7 @@ run (void *cls,
   // TODO send push/pull to each of those peers?
   // TODO read stored valid peers from last run
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting stored valid peers\n");
-  Peers_get_valid_peers (valid_peers_iterator, NULL);
+  get_valid_peers (valid_peers_iterator, NULL);
 
   peerinfo_notify_handle = GNUNET_PEERINFO_notify (cfg,
                                                    GNUNET_NO,