towards fixing #3363: replacing old iteration API with new monitoring API for core (needs testing, gnunet-core incomplete)

9 files changed, 455 insertions, 400 deletions

diff --git a/src/core/core.h b/src/core/core.h
index 1c6e0bc72..fba9ad1f3 100644
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -62,7 +62,7 @@ struct InitMessage
 {
 
   /**
-   * Header with type GNUNET_MESSAGE_TYPE_CORE_INIT.
+   * Header with type #GNUNET_MESSAGE_TYPE_CORE_INIT.
    */
   struct GNUNET_MessageHeader header;
 
@@ -82,7 +82,7 @@ struct InitReplyMessage
 {
 
   /**
-   * Header with type GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY
+   * Header with type #GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY
    */
   struct GNUNET_MessageHeader header;
 
@@ -106,7 +106,7 @@ struct InitReplyMessage
 struct ConnectNotifyMessage
 {
   /**
-   * Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT
+   * Header with type #GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT
    */
   struct GNUNET_MessageHeader header;
 
@@ -130,7 +130,7 @@ struct ConnectNotifyMessage
 struct DisconnectNotifyMessage
 {
   /**
-   * Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT.
+   * Header with type #GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT.
    */
   struct GNUNET_MessageHeader header;
 
@@ -159,8 +159,8 @@ struct DisconnectNotifyMessage
 struct NotifyTrafficMessage
 {
   /**
-   * Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND
-   * or GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND.
+   * Header with type #GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND
+   * or #GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND.
    */
   struct GNUNET_MessageHeader header;
 
@@ -291,6 +291,35 @@ struct SendMessage
 };
 
 
+/**
+ * Message sent by the service to monitor clients to notify them
+ * about a peer changing status.
+ */
+struct MonitorNotifyMessage
+{
+  /**
+   * Header with type #GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * New peer state, an `enum GNUNET_CORE_KxState` in NBO.
+   */
+  uint32_t state GNUNET_PACKED;
+
+  /**
+   * Identity of the peer.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * How long will we stay in this state (if nothing else happens)?
+   */
+  struct GNUNET_TIME_AbsoluteNBO timeout;
+
+};
+
+
 GNUNET_NETWORK_STRUCT_END
 #endif
 /* end of core.h */
diff --git a/src/core/core_api_iterate_peers.c b/src/core/core_api_iterate_peers.c
index 4889e638a..425d3579c 100644
--- a/src/core/core_api_iterate_peers.c
+++ b/src/core/core_api_iterate_peers.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2009, 2010 Christian Grothoff (and other contributing authors)
+     (C) 2009-2014 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
@@ -19,7 +19,7 @@
 */
 
 /**
- * @file core/core_api_iterate_peers.c
+ * @file core/core_api_monitor_peers.c
  * @brief implementation of the peer_iterate function
  * @author Christian Grothoff
  * @author Nathan Evans
@@ -29,15 +29,23 @@
 #include "core.h"
 
 
-struct GNUNET_CORE_RequestContext
+/**
+ * Handle to a CORE monitoring operation.
+ */
+struct GNUNET_CORE_MonitorHandle
 {
+
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
   /**
    * Our connection to the service.
    */
   struct GNUNET_CLIENT_Connection *client;
 
   /**
-
    * Handle for transmitting a request.
    */
   struct GNUNET_CLIENT_TransmitHandle *th;
@@ -45,140 +53,200 @@ struct GNUNET_CORE_RequestContext
   /**
    * Function called with the peer.
    */
-  GNUNET_CORE_ConnectEventHandler peer_cb;
+  GNUNET_CORE_MonitorCallback peer_cb;
 
   /**
-   * Peer to check for.
+   * Closure for @e peer_cb.
    */
-  struct GNUNET_PeerIdentity *peer;
-
-  /**
-   * Closure for peer_cb.
-   */
-  void *cb_cls;
+  void *peer_cb_cls;
 
 };
 
 
 /**
- * Receive reply from core service with information about a peer.
+ * Transmits the monitor request to the CORE service.
+ *
+ * Function is called to notify a client about the socket begin ready
+ * to queue more data.  @a buf will be NULL and @a size zero if the
+ * socket was closed for writing in the meantime.
+ *
+ * @param cls closure, our `struct GNUNET_CORE_MonitorHandle *`
+ * @param size number of bytes available in @a buf
+ * @param buf where the callee should write the message
+ * @return number of bytes written to @a buf
+ */
+static size_t
+transmit_monitor_request (void *cls,
+                          size_t size,
+                          void *buf);
+
+
+/**
+ * Protocol error, reconnect to CORE service and notify
+ * client.
+ *
+ * @param mh monitoring session to reconnect to CORE
+ */
+static void
+reconnect (struct GNUNET_CORE_MonitorHandle *mh)
+{
+  GNUNET_CLIENT_disconnect (mh->client);
+  /* FIXME: use backoff? */
+  mh->client = GNUNET_CLIENT_connect ("core", mh->cfg);
+  GNUNET_assert (NULL != mh->client);
+  mh->th =
+    GNUNET_CLIENT_notify_transmit_ready (mh->client,
+                                         sizeof (struct GNUNET_MessageHeader),
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         GNUNET_YES,
+                                         &transmit_monitor_request, mh);
+  /* notify callback about reconnect */
+  mh->peer_cb (mh->peer_cb_cls,
+               NULL,
+               GNUNET_CORE_KX_CORE_DISCONNECT,
+               GNUNET_TIME_UNIT_FOREVER_ABS);
+}
+
+
+/**
+ * Receive reply from CORE service with information about a peer.
  *
- * @param cls our 'struct  GNUNET_CORE_RequestContext *'
+ * @param cls our `struct  GNUNET_CORE_MonitorHandle *`
  * @param msg NULL on error or last entry
  */
 static void
-receive_info (void *cls, const struct GNUNET_MessageHeader *msg)
+receive_info (void *cls,
+              const struct GNUNET_MessageHeader *msg)
 {
-  struct GNUNET_CORE_RequestContext *request_context = cls;
-  const struct ConnectNotifyMessage *connect_message;
+  struct GNUNET_CORE_MonitorHandle *mh = cls;
+  const struct MonitorNotifyMessage *mon_message;
   uint16_t msize;
 
-  /* Handle last message or error case, disconnect and clean up */
-  if ((msg == NULL) ||
-      ((ntohs (msg->type) == GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS_END) &&
-       (ntohs (msg->size) == sizeof (struct GNUNET_MessageHeader))))
+  if (NULL == msg)
   {
-    if (request_context->peer_cb != NULL)
-      request_context->peer_cb (request_context->cb_cls, NULL);
-    GNUNET_CLIENT_disconnect (request_context->client);
-    GNUNET_free (request_context);
+    reconnect (mh);
     return;
   }
-
   msize = ntohs (msg->size);
   /* Handle incorrect message type or size, disconnect and clean up */
-  if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT) ||
-      (msize < sizeof (struct ConnectNotifyMessage)))
+  if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY) ||
+      (sizeof (struct MonitorNotifyMessage) != msize))
   {
     GNUNET_break (0);
-    if (request_context->peer_cb != NULL)
-      request_context->peer_cb (request_context->cb_cls, NULL);
-    GNUNET_CLIENT_disconnect (request_context->client);
-    GNUNET_free (request_context);
+    reconnect (mh);
     return;
   }
-  connect_message = (const struct ConnectNotifyMessage *) msg;
-  if (msize != sizeof (struct ConnectNotifyMessage))
-  {
-    GNUNET_break (0);
-    if (request_context->peer_cb != NULL)
-      request_context->peer_cb (request_context->cb_cls, NULL);
-    GNUNET_CLIENT_disconnect (request_context->client);
-    GNUNET_free (request_context);
-    return;
-  }
-  /* Normal case */
-  if (request_context->peer_cb != NULL)
-    request_context->peer_cb (request_context->cb_cls, &connect_message->peer);
-  GNUNET_CLIENT_receive (request_context->client, &receive_info,
-                         request_context, GNUNET_TIME_UNIT_FOREVER_REL);
+  mon_message = (const struct MonitorNotifyMessage *) msg;
+  GNUNET_CLIENT_receive (mh->client,
+                         &receive_info, mh,
+                         GNUNET_TIME_UNIT_FOREVER_REL);
+  mh->peer_cb (mh->peer_cb_cls,
+               &mon_message->peer,
+               (enum GNUNET_CORE_KxState) ntohl (mon_message->state),
+               GNUNET_TIME_absolute_ntoh (mon_message->timeout));
 }
 
 
 /**
- * Function called to notify a client about the socket
- * begin ready to queue more data.  "buf" will be
- * NULL and "size" zero if the socket was closed for
- * writing in the meantime.
+ * Transmits the monitor request to the CORE service.
  *
- * @param cls closure, always NULL
- * @param size number of bytes available in buf
+ * Function is called to notify a client about the socket begin ready
+ * to queue more data.  @a buf will be NULL and @a size zero if the
+ * socket was closed for writing in the meantime.
+ *
+ * @param cls closure, our `struct GNUNET_CORE_MonitorHandle *`
+ * @param size number of bytes available in @a buf
  * @param buf where the callee should write the message
- * @return number of bytes written to buf
+ * @return number of bytes written to @a buf
  */
 static size_t
-transmit_request (void *cls, size_t size, void *buf)
+transmit_monitor_request (void *cls,
+                          size_t size,
+                          void *buf)
 {
+  struct GNUNET_CORE_MonitorHandle *mh = cls;
   struct GNUNET_MessageHeader *msg;
   int msize;
 
   msize = sizeof (struct GNUNET_MessageHeader);
-  if ((size < msize) || (buf == NULL))
+  if ((size < msize) || (NULL == buf))
+  {
+    reconnect (mh);
     return 0;
+  }
   msg = (struct GNUNET_MessageHeader *) buf;
   msg->size = htons (msize);
-  msg->type = htons (GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS);
-
+  msg->type = htons (GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS);
+  GNUNET_CLIENT_receive (mh->client,
+                         &receive_info, mh,
+                         GNUNET_TIME_UNIT_FOREVER_REL);
   return msize;
 }
 
 
 /**
- * Iterate over all currently connected peers.
- * Calls peer_cb with each connected peer, and then
- * once with NULL to indicate that all peers have
- * been handled.
+ * Monitor connectivity and KX status of all peers known to CORE.
+ * Calls @a peer_cb with the current status for each connected peer,
+ * and then once with NULL to indicate that all peers that are
+ * currently active have been handled.  After that, the iteration
+ * continues until it is cancelled.  Normal users of the CORE API are
+ * not expected to use this function.  It is different in that it
+ * truly lists all connections (including those where the KX is in
+ * progress), not just those relevant to the application.  This
+ * function is used by special applications for diagnostics.
  *
- * @param cfg configuration to use
+ * @param cfg configuration handle
  * @param peer_cb function to call with the peer information
- * @param cb_cls closure for @a peer_cb
- * @return #GNUNET_OK if iterating, #GNUNET_SYSERR on error
+ * @param peer_cb_cls closure for @a peer_cb
+ * @return NULL on error
  */
-int
-GNUNET_CORE_iterate_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                           GNUNET_CORE_ConnectEventHandler peer_cb,
-                           void *cb_cls)
+struct GNUNET_CORE_MonitorHandle *
+GNUNET_CORE_monitor_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                           GNUNET_CORE_MonitorCallback peer_cb,
+                           void *peer_cb_cls)
 {
-  struct GNUNET_CORE_RequestContext *request_context;
+  struct GNUNET_CORE_MonitorHandle *mh;
   struct GNUNET_CLIENT_Connection *client;
 
+  GNUNET_assert (NULL != peer_cb);
   client = GNUNET_CLIENT_connect ("core", cfg);
-  if (client == NULL)
-    return GNUNET_SYSERR;
-  request_context = GNUNET_new (struct GNUNET_CORE_RequestContext);
-  request_context->client = client;
-  request_context->peer_cb = peer_cb;
-  request_context->cb_cls = cb_cls;
-
-  request_context->th =
-      GNUNET_CLIENT_notify_transmit_ready (client,
-                                           sizeof (struct GNUNET_MessageHeader),
-                                           GNUNET_TIME_UNIT_FOREVER_REL,
-                                           GNUNET_YES, &transmit_request, NULL);
-
-  GNUNET_CLIENT_receive (client, &receive_info, request_context,
-                         GNUNET_TIME_UNIT_FOREVER_REL);
-  return GNUNET_OK;
+  if (NULL == client)
+    return NULL;
+  mh = GNUNET_new (struct GNUNET_CORE_MonitorHandle);
+  mh->cfg = cfg;
+  mh->client = client;
+  mh->peer_cb = peer_cb;
+  mh->peer_cb_cls = peer_cb_cls;
+  mh->th =
+    GNUNET_CLIENT_notify_transmit_ready (client,
+                                         sizeof (struct GNUNET_MessageHeader),
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         GNUNET_YES,
+                                         &transmit_monitor_request, mh);
+  return mh;
 }
 
-/* end of core_api_iterate_peers.c */
+
+/**
+ * Stop monitoring CORE activity.
+ *
+ * @param mh monitor to stop
+ */
+void
+GNUNET_CORE_monitor_stop (struct GNUNET_CORE_MonitorHandle *mh)
+{
+  if (NULL != mh->th)
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (mh->th);
+    mh->th = NULL;
+  }
+  if (NULL != mh->client)
+  {
+    GNUNET_CLIENT_disconnect (mh->client);
+    mh->client = NULL;
+  }
+  GNUNET_free (mh);
+}
+
+
+/* end of core_api_monitor_peers.c */
diff --git a/src/core/gnunet-core.c b/src/core/gnunet-core.c
index 6309b39e0..36dc5fc6f 100644
--- a/src/core/gnunet-core.c
+++ b/src/core/gnunet-core.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2011, 2012 Christian Grothoff (and other contributing authors)
+     (C) 2011, 2012, 2014 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
@@ -24,13 +24,9 @@
  * @author Nathan Evans
  */
 #include "platform.h"
-#include "gnunet_crypto_lib.h"
-#include "gnunet_configuration_lib.h"
-#include "gnunet_getopt_lib.h"
-#include "gnunet_peerinfo_service.h"
-#include "gnunet_transport_service.h"
+#include "gnunet_util_lib.h"
 #include "gnunet_core_service.h"
-#include "gnunet_program_lib.h"
+
 
 /**
  * Option -m.
@@ -40,11 +36,13 @@ static int monitor_connections;
 /**
  * Current number of connections in monitor mode
  */
-static int monitor_connections_counter;
+// static unsigned int monitor_connections_counter;
 
-static struct GNUNET_CORE_Handle *ch;
+/**
+ * Handle to the CORE monitor.
+ */
+static struct GNUNET_CORE_MonitorHandle *mh;
 
-static struct GNUNET_PeerIdentity my_id;
 
 /**
  * Task run in monitor mode when the user presses CTRL-C to abort.
@@ -57,143 +55,81 @@ static void
 shutdown_task (void *cls,
                const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  if (NULL != ch)
+  if (NULL != mh)
   {
-    GNUNET_CORE_disconnect (ch);
-    ch = NULL;
+    GNUNET_CORE_monitor_stop (mh);
+    mh = NULL;
   }
 }
 
 
 /**
- * Callback for retrieving a list of connected peers.
- *
- * @param cls closure (unused)
- * @param peer peer identity this notification is about
- */
-static void
-connected_peer_callback (void *cls,
-                         const struct GNUNET_PeerIdentity *peer)
-{
-  if (NULL == peer)
-    return;
-  printf (_("Peer `%s'\n"),
-          GNUNET_i2s_full (peer));
-}
-
-
-static void
-monitor_notify_startup (void *cls,
-                        const struct GNUNET_PeerIdentity *my_identity)
-{
-  my_id = (*my_identity);
-}
-
-
-/**
  * Function called to notify core users that another
- * peer connected to us.
+ * peer changed its state with us.
  *
  * @param cls closure
- * @param peer the peer that connected
+ * @param peer the peer that changed state
+ * @param state new state of the peer
+ * @param timeout timeout for the new state
  */
 static void
-monitor_notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer)
+monitor_cb (void *cls,
+            const struct GNUNET_PeerIdentity *peer,
+            enum GNUNET_CORE_KxState state,
+            struct GNUNET_TIME_Absolute timeout)
 {
   struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get();
   const char *now_str;
 
-  if (0 != memcmp (&my_id, peer, sizeof (my_id)))
+  if ( (NULL == peer) &&
+       (GNUNET_NO == monitor_connections) )
   {
-    monitor_connections_counter ++;
-    now_str = GNUNET_STRINGS_absolute_time_to_string (now);
-    FPRINTF (stdout, _("%24s: %-17s %4s   (%u connections in total)\n"),
-             now_str,
-             _("Connected to"),
-             GNUNET_i2s (peer),
-             monitor_connections_counter);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
   }
+  now_str = GNUNET_STRINGS_absolute_time_to_string (now);
+  FPRINTF (stdout,
+           _("%24s: %-17s %d %4s\n"),
+           now_str,
+           "FIXME",
+           state,
+           GNUNET_i2s (peer));
 }
 
 
 /**
- * Function called to notify core users that another
- * peer disconnected from us.
- *
- * @param cls closure
- * @param peer the peer that disconnected
- */
-static void
-monitor_notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
-{
-  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get();
-  const char *now_str;
-
-  if (0 != memcmp (&my_id, peer, sizeof (my_id)))
-  {
-    now_str = GNUNET_STRINGS_absolute_time_to_string (now);
-
-    GNUNET_assert (monitor_connections_counter > 0);
-    monitor_connections_counter--;
-    FPRINTF (stdout, _("%24s: %-17s %4s   (%u connections in total)\n"),
-             now_str,
-             _("Disconnected from"),
-             GNUNET_i2s (peer),
-             monitor_connections_counter);
-  }
-}
-
-/**
- * Function called with the result of the check if the 'transport'
+ * Function called with the result of the check if the CORE
  * service is running.
  *
  * @param cls closure with our configuration
- * @param result #GNUNET_YES if transport is running
+ * @param result #GNUNET_YES if CORE is running
  */
 static void
-testservice_task (void *cls, int result)
+testservice_task (void *cls,
+                  int result)
 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
-  static const struct GNUNET_CORE_MessageHandler handlers[] = {
-    {NULL, 0, 0}
-  };
-
-  if (result != GNUNET_OK)
-    {
-      FPRINTF (stderr, _("Service `%s' is not running\n"), "core");
-      return;
-    }
 
-  if (GNUNET_NO == monitor_connections)
+  if (GNUNET_OK != result)
   {
-    if (GNUNET_OK != GNUNET_CORE_iterate_peers (cfg, &connected_peer_callback, NULL))
-    {
-      fprintf (stderr, ("Failed to connect to CORE service to iterate peers!\n"));
-      return;
-    }
+    FPRINTF (stderr, _("Service `%s' is not running\n"), "core");
+    return;
   }
-  else
+
+  mh = GNUNET_CORE_monitor_start (cfg,
+                                  &monitor_cb,
+                                  NULL);
+  if (NULL == mh)
   {
-    memset(&my_id, '\0', sizeof (my_id));
-    ch = GNUNET_CORE_connect (cfg, NULL,
-                              monitor_notify_startup,
-                              monitor_notify_connect,
-                              monitor_notify_disconnect,
-                              NULL, GNUNET_NO,
-                              NULL, GNUNET_NO,
-                              handlers);
-
-    if (NULL == ch)
-    {
-      GNUNET_SCHEDULER_add_now (shutdown_task, NULL);
-      fprintf (stderr, ("Failed to connect to CORE service!\n"));
-      return;
-    }
-    else
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, shutdown_task, NULL);
+    GNUNET_SCHEDULER_add_now (shutdown_task, NULL);
+    fprintf (stderr, ("Failed to connect to CORE service!\n"));
+    return;
   }
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
+                                &shutdown_task, NULL);
 }
 
+
 /**
  * Main function that will be run by the scheduler.
  *
@@ -206,19 +142,21 @@ static void
 run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  if (args[0] != NULL)
+  if (NULL != args[0])
   {
-    FPRINTF (stderr, _("Invalid command line argument `%s'\n"), args[0]);
+    FPRINTF (stderr,
+             _("Invalid command line argument `%s'\n"),
+             args[0]);
     return;
   }
-
-  GNUNET_CLIENT_service_test ("core", cfg, GNUNET_TIME_UNIT_SECONDS,
-      &testservice_task, (void *) cfg);
+  GNUNET_CLIENT_service_test ("core", cfg,
+                              GNUNET_TIME_UNIT_SECONDS,
+                              &testservice_task, (void *) cfg);
 }
 
 
 /**
- * The main function to obtain peer information.
+ * The main function to obtain peer information from CORE.
  *
  * @param argc number of arguments from the command line
  * @param argv command line arguments
@@ -237,19 +175,15 @@ main (int argc, char *const *argv)
 
   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
-
-
   res = GNUNET_PROGRAM_run (argc, argv, "gnunet-core",
-                      gettext_noop
-                      ("Print information about connected peers."),
-                      options, &run, NULL);
+                            gettext_noop
+                            ("Print information about connected peers."),
+                            options, &run, NULL);
 
   GNUNET_free ((void *) argv);
-
   if (GNUNET_OK == res)
     return 0;
-  else
-    return 1;
+  return 1;
 }
 
 /* end of gnunet-core.c */
diff --git a/src/core/gnunet-service-core.c b/src/core/gnunet-service-core.c
index c6eeb070b..05e461278 100644
--- a/src/core/gnunet-service-core.c
+++ b/src/core/gnunet-service-core.c
@@ -101,20 +101,21 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
                                                &keyfile))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _
-                ("Core service is lacking HOSTKEY configuration setting.  Exiting.\n"));
+                _("Core service is lacking HOSTKEY configuration setting.  Exiting.\n"));
     GNUNET_SCHEDULER_shutdown ();
     return;
   }
   GSC_stats = GNUNET_STATISTICS_create ("core", GSC_cfg);
-  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
+                                &shutdown_task,
                                 NULL);
   GNUNET_SERVER_suspend (server);
   GSC_TYPEMAP_init ();
   pk = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile);
   GNUNET_free (keyfile);
   GNUNET_assert (NULL != pk);
-  if ((GNUNET_OK != GSC_KX_init (pk)) ||
+  if ((GNUNET_OK != GSC_KX_init (pk,
+                                 server)) ||
       (GNUNET_OK != GSC_NEIGHBOURS_init ()))
   {
     GNUNET_SCHEDULER_shutdown ();
@@ -123,7 +124,8 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
   GSC_SESSIONS_init ();
   GSC_CLIENTS_init (GSC_server);
   GNUNET_SERVER_resume (GSC_server);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Core service of `%4s' ready.\n"),
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _("Core service of `%4s' ready.\n"),
               GNUNET_i2s (&GSC_my_identity));
 }
 
@@ -139,7 +141,8 @@ int
 main (int argc, char *const *argv)
 {
   return (GNUNET_OK ==
-          GNUNET_SERVICE_run (argc, argv, "core", GNUNET_SERVICE_OPTION_NONE,
+          GNUNET_SERVICE_run (argc, argv, "core",
+                              GNUNET_SERVICE_OPTION_NONE,
                               &run, NULL)) ? 0 : 1;
 }
 
diff --git a/src/core/gnunet-service-core_clients.c b/src/core/gnunet-service-core_clients.c
index 5a30138a0..634959674 100644
--- a/src/core/gnunet-service-core_clients.c
+++ b/src/core/gnunet-service-core_clients.c
@@ -600,11 +600,12 @@ destroy_active_client_request (void *cls,
  * @param client identification of the client
  */
 static void
-handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
+handle_client_disconnect (void *cls,
+                          struct GNUNET_SERVER_Client *client)
 {
   struct GSC_Client *c;
 
-  if (client == NULL)
+  if (NULL == client)
     return;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Client %p has disconnected from core service.\n", client);
@@ -840,8 +841,8 @@ GSC_CLIENTS_init (struct GNUNET_SERVER_Handle *server)
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
     {&handle_client_init, NULL,
      GNUNET_MESSAGE_TYPE_CORE_INIT, 0},
-    {&GSC_SESSIONS_handle_client_iterate_peers, NULL,
-     GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS,
+    {&GSC_KX_handle_client_monitor_peers, NULL,
+     GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS,
      sizeof (struct GNUNET_MessageHeader)},
     {&handle_client_send_request, NULL,
      GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST,
@@ -855,7 +856,8 @@ GSC_CLIENTS_init (struct GNUNET_SERVER_Handle *server)
   client_mst = GNUNET_SERVER_mst_create (&client_tokenizer_callback, NULL);
   notifier =
       GNUNET_SERVER_notification_context_create (server, MAX_NOTIFY_QUEUE);
-  GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
+  GNUNET_SERVER_disconnect_notify (server,
+                                   &handle_client_disconnect, NULL);
   GNUNET_SERVER_add_handlers (server, handlers);
 }
 
diff --git a/src/core/gnunet-service-core_kx.c b/src/core/gnunet-service-core_kx.c
index 4a516461f..4ab902fbe 100644
--- a/src/core/gnunet-service-core_kx.c
+++ b/src/core/gnunet-service-core_kx.c
@@ -237,50 +237,6 @@ GNUNET_NETWORK_STRUCT_END
 
 
 /**
- * State machine for our P2P encryption handshake.  Everyone starts in
- * "DOWN", if we receive the other peer's key (other peer initiated)
- * we start in state RECEIVED (since we will immediately send our
- * own); otherwise we start in SENT.  If we get back a PONG from
- * within either state, we move up to CONFIRMED (the PONG will always
- * be sent back encrypted with the key we sent to the other peer).
- */
-enum KxStateMachine
-{
-  /**
-   * No handshake yet.
-   */
-  KX_STATE_DOWN,
-
-  /**
-   * We've sent our session key.
-   */
-  KX_STATE_KEY_SENT,
-
-  /**
-   * We've received the other peers session key.
-   */
-  KX_STATE_KEY_RECEIVED,
-
-  /**
-   * The other peer has confirmed our session key + PING with a PONG
-   * message encrypted with his session key (which we got).  Key
-   * exchange is done.
-   */
-  KX_STATE_UP,
-
-  /**
-   * We're rekeying (or had a timeout), so we have sent the other peer
-   * our new ephemeral key, but we did not get a matching PONG yet.
-   * This is equivalent to being 'KX_STATE_KEY_RECEIVED', except that
-   * the session is marked as 'up' with sessions (as we don't want to
-   * drop and re-establish P2P connections simply due to rekeying).
-   */
-  KX_STATE_REKEY_SENT
-
-};
-
-
-/**
  * Information about the status of a key exchange with another peer.
  */
 struct GSC_KeyExchangeInfo
@@ -373,7 +329,7 @@ struct GSC_KeyExchangeInfo
   /**
    * What is our connection status?
    */
-  enum KxStateMachine status;
+  enum GNUNET_CORE_KxState status;
 
 };
 
@@ -414,6 +370,57 @@ static struct GSC_KeyExchangeInfo *kx_tail;
  */
 static GNUNET_SCHEDULER_TaskIdentifier rekey_task;
 
+/**
+ * Notification context for all monitors.
+ */
+static struct GNUNET_SERVER_NotificationContext *nc;
+
+
+/**
+ * Inform the given monitor about the KX state of
+ * the given peer.
+ *
+ * @param mc monitor to inform
+ * @param kx key exchange state to inform about
+ */
+static void
+monitor_notify (struct GNUNET_SERVER_Client *client,
+                struct GSC_KeyExchangeInfo *kx)
+{
+  struct MonitorNotifyMessage msg;
+
+  msg.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY);
+  msg.header.size = htons (sizeof (msg));
+  msg.state = htonl ((uint32_t) kx->status);
+  msg.peer = kx->peer;
+  msg.timeout = GNUNET_TIME_absolute_hton (kx->timeout);
+  GNUNET_SERVER_notification_context_unicast (nc,
+                                              client,
+                                              &msg.header,
+                                              GNUNET_NO);
+}
+
+
+/**
+ * Inform all monitors about the KX state of the given peer.
+ *
+ * @param kx key exchange state to inform about
+ */
+static void
+monitor_notify_all (struct GSC_KeyExchangeInfo *kx)
+{
+  struct MonitorNotifyMessage msg;
+
+  msg.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY);
+  msg.header.size = htons (sizeof (msg));
+  msg.state = htonl ((uint32_t) kx->status);
+  msg.peer = kx->peer;
+  msg.timeout = GNUNET_TIME_absolute_hton (kx->timeout);
+  GNUNET_SERVER_notification_context_broadcast (nc,
+                                                &msg.header,
+                                                GNUNET_NO);
+}
+
 
 /**
  * Derive an authentication key from "set key" information
@@ -570,8 +577,9 @@ do_decrypt (struct GSC_KeyExchangeInfo *kx,
     GNUNET_break (0);
     return GNUNET_NO;
   }
-  if ( (kx->status != KX_STATE_KEY_RECEIVED) && (kx->status != KX_STATE_UP) &&
-       (kx->status != KX_STATE_REKEY_SENT) )
+  if ( (kx->status != GNUNET_CORE_KX_STATE_KEY_RECEIVED) &&
+       (kx->status != GNUNET_CORE_KX_STATE_UP) &&
+       (kx->status != GNUNET_CORE_KX_STATE_REKEY_SENT) )
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
@@ -622,7 +630,7 @@ set_key_retry_task (void *cls,
 
   kx->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
   kx->set_key_retry_frequency = GNUNET_TIME_STD_BACKOFF (kx->set_key_retry_frequency);
-  GNUNET_assert (KX_STATE_DOWN != kx->status);
+  GNUNET_assert (GNUNET_CORE_KX_STATE_DOWN != kx->status);
   send_key (kx);
 }
 
@@ -678,10 +686,14 @@ GSC_KX_start (const struct GNUNET_PeerIdentity *pid)
   GNUNET_CONTAINER_DLL_insert (kx_head,
                                kx_tail,
                                kx);
-  GNUNET_CRYPTO_hash (pid, sizeof (struct GNUNET_PeerIdentity), &h1);
-  GNUNET_CRYPTO_hash (&GSC_my_identity, sizeof (struct GNUNET_PeerIdentity), &h2);
-
-  kx->status = KX_STATE_KEY_SENT;
+  kx->status = GNUNET_CORE_KX_STATE_KEY_SENT;
+  monitor_notify_all (kx);
+  GNUNET_CRYPTO_hash (pid,
+                      sizeof (struct GNUNET_PeerIdentity),
+                      &h1);
+  GNUNET_CRYPTO_hash (&GSC_my_identity,
+                      sizeof (struct GNUNET_PeerIdentity),
+                      &h2);
   if (0 < GNUNET_CRYPTO_hash_cmp (&h1,
                                   &h2))
   {
@@ -722,6 +734,8 @@ GSC_KX_stop (struct GSC_KeyExchangeInfo *kx)
     GNUNET_SCHEDULER_cancel (kx->keep_alive_task);
     kx->keep_alive_task = GNUNET_SCHEDULER_NO_TASK;
   }
+  kx->status = GNUNET_CORE_KX_PEER_DISCONNECT;
+  monitor_notify_all (kx);
   GNUNET_CONTAINER_DLL_remove (kx_head,
                                kx_tail,
                                kx);
@@ -791,7 +805,7 @@ GSC_KX_handle_ephemeral_key (struct GSC_KeyExchangeInfo *kx,
   struct GNUNET_TIME_Absolute start_t;
   struct GNUNET_TIME_Absolute end_t;
   struct GNUNET_TIME_Absolute now;
-  enum KxStateMachine sender_status;
+  enum GNUNET_CORE_KxState sender_status;
   uint16_t size;
 
   size = ntohs (msg->size);
@@ -802,9 +816,9 @@ GSC_KX_handle_ephemeral_key (struct GSC_KeyExchangeInfo *kx,
   }
   m = (const struct EphemeralKeyMessage *) msg;
   end_t = GNUNET_TIME_absolute_ntoh (m->expiration_time);
-  if ( ( (KX_STATE_KEY_RECEIVED == kx->status) ||
-         (KX_STATE_UP == kx->status) ||
-         (KX_STATE_REKEY_SENT == kx->status) ) &&
+  if ( ( (GNUNET_CORE_KX_STATE_KEY_RECEIVED == kx->status) ||
+         (GNUNET_CORE_KX_STATE_UP == kx->status) ||
+         (GNUNET_CORE_KX_STATE_REKEY_SENT == kx->status) ) &&
        (end_t.abs_value_us <= kx->foreign_key_expires.abs_value_us) )
   {
     GNUNET_STATISTICS_update (GSC_stats, gettext_noop ("# old ephemeral keys ignored"),
@@ -862,18 +876,18 @@ GSC_KX_handle_ephemeral_key (struct GSC_KeyExchangeInfo *kx,
                             GNUNET_NO);
 
   /* check if we still need to send the sender our key */
-  sender_status = (enum KxStateMachine) ntohl (m->sender_status);
+  sender_status = (enum GNUNET_CORE_KxState) ntohl (m->sender_status);
   switch (sender_status)
   {
-  case KX_STATE_DOWN:
+  case GNUNET_CORE_KX_STATE_DOWN:
     GNUNET_break_op (0);
     break;
-  case KX_STATE_KEY_SENT:
+  case GNUNET_CORE_KX_STATE_KEY_SENT:
     /* fine, need to send our key after updating our status, see below */
     break;
-  case KX_STATE_KEY_RECEIVED:
-  case KX_STATE_UP:
-  case KX_STATE_REKEY_SENT:
+  case GNUNET_CORE_KX_STATE_KEY_RECEIVED:
+  case GNUNET_CORE_KX_STATE_UP:
+  case GNUNET_CORE_KX_STATE_REKEY_SENT:
     /* other peer already got our key */
     break;
   default:
@@ -883,35 +897,38 @@ GSC_KX_handle_ephemeral_key (struct GSC_KeyExchangeInfo *kx,
   /* check if we need to confirm everything is fine via PING + PONG */
   switch (kx->status)
   {
-  case KX_STATE_DOWN:
+  case GNUNET_CORE_KX_STATE_DOWN:
     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == kx->keep_alive_task);
-    kx->status = KX_STATE_KEY_RECEIVED;
-    if (KX_STATE_KEY_SENT == sender_status)
+    kx->status = GNUNET_CORE_KX_STATE_KEY_RECEIVED;
+    monitor_notify_all (kx);
+    if (GNUNET_CORE_KX_STATE_KEY_SENT == sender_status)
       send_key (kx);
     send_ping (kx);
     break;
-  case KX_STATE_KEY_SENT:
+  case GNUNET_CORE_KX_STATE_KEY_SENT:
     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == kx->keep_alive_task);
-    kx->status = KX_STATE_KEY_RECEIVED;
-    if (KX_STATE_KEY_SENT == sender_status)
+    kx->status = GNUNET_CORE_KX_STATE_KEY_RECEIVED;
+    monitor_notify_all (kx);
+    if (GNUNET_CORE_KX_STATE_KEY_SENT == sender_status)
       send_key (kx);
     send_ping (kx);
     break;
-  case KX_STATE_KEY_RECEIVED:
+  case GNUNET_CORE_KX_STATE_KEY_RECEIVED:
     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == kx->keep_alive_task);
-    if (KX_STATE_KEY_SENT == sender_status)
+    if (GNUNET_CORE_KX_STATE_KEY_SENT == sender_status)
       send_key (kx);
     send_ping (kx);
     break;
-  case KX_STATE_UP:
-    kx->status = KX_STATE_REKEY_SENT;
-    if (KX_STATE_KEY_SENT == sender_status)
+  case GNUNET_CORE_KX_STATE_UP:
+    kx->status = GNUNET_CORE_KX_STATE_REKEY_SENT;
+    monitor_notify_all (kx);
+    if (GNUNET_CORE_KX_STATE_KEY_SENT == sender_status)
       send_key (kx);
     /* we got a new key, need to reconfirm! */
     send_ping (kx);
     break;
-  case KX_STATE_REKEY_SENT:
-    if (KX_STATE_KEY_SENT == sender_status)
+  case GNUNET_CORE_KX_STATE_REKEY_SENT:
+    if (GNUNET_CORE_KX_STATE_KEY_SENT == sender_status)
       send_key (kx);
     /* we got a new key, need to reconfirm! */
     send_ping (kx);
@@ -950,9 +967,9 @@ GSC_KX_handle_ping (struct GSC_KeyExchangeInfo *kx,
   GNUNET_STATISTICS_update (GSC_stats,
                             gettext_noop ("# PING messages received"), 1,
                             GNUNET_NO);
-  if ( (kx->status != KX_STATE_KEY_RECEIVED) &&
-       (kx->status != KX_STATE_UP) &&
-       (kx->status != KX_STATE_REKEY_SENT))
+  if ( (kx->status != GNUNET_CORE_KX_STATE_KEY_RECEIVED) &&
+       (kx->status != GNUNET_CORE_KX_STATE_UP) &&
+       (kx->status != GNUNET_CORE_KX_STATE_REKEY_SENT))
   {
     /* ignore */
     GNUNET_STATISTICS_update (GSC_stats,
@@ -1029,7 +1046,8 @@ send_keep_alive (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                               gettext_noop ("# sessions terminated by timeout"),
                               1, GNUNET_NO);
     GSC_SESSIONS_end (&kx->peer);
-    kx->status = KX_STATE_KEY_SENT;
+    kx->status = GNUNET_CORE_KX_STATE_KEY_SENT;
+    monitor_notify_all (kx);
     send_key (kx);
     return;
   }
@@ -1097,21 +1115,21 @@ GSC_KX_handle_pong (struct GSC_KeyExchangeInfo *kx,
                             GNUNET_NO);
   switch (kx->status)
   {
-  case KX_STATE_DOWN:
+  case GNUNET_CORE_KX_STATE_DOWN:
     GNUNET_STATISTICS_update (GSC_stats,
                               gettext_noop ("# PONG messages dropped (connection down)"), 1,
                               GNUNET_NO);
     return;
-  case KX_STATE_KEY_SENT:
+  case GNUNET_CORE_KX_STATE_KEY_SENT:
     GNUNET_STATISTICS_update (GSC_stats,
                               gettext_noop ("# PONG messages dropped (out of order)"), 1,
                               GNUNET_NO);
     return;
-  case KX_STATE_KEY_RECEIVED:
+  case GNUNET_CORE_KX_STATE_KEY_RECEIVED:
     break;
-  case KX_STATE_UP:
+  case GNUNET_CORE_KX_STATE_UP:
     break;
-  case KX_STATE_REKEY_SENT:
+  case GNUNET_CORE_KX_STATE_REKEY_SENT:
     break;
   default:
     GNUNET_break (0);
@@ -1159,35 +1177,37 @@ GSC_KX_handle_pong (struct GSC_KeyExchangeInfo *kx,
   }
   switch (kx->status)
   {
-  case KX_STATE_DOWN:
+  case GNUNET_CORE_KX_STATE_DOWN:
     GNUNET_assert (0);           /* should be impossible */
     return;
-  case KX_STATE_KEY_SENT:
+  case GNUNET_CORE_KX_STATE_KEY_SENT:
     GNUNET_assert (0);           /* should be impossible */
     return;
-  case KX_STATE_KEY_RECEIVED:
+  case GNUNET_CORE_KX_STATE_KEY_RECEIVED:
     GNUNET_STATISTICS_update (GSC_stats,
                               gettext_noop
                               ("# session keys confirmed via PONG"), 1,
                               GNUNET_NO);
-    kx->status = KX_STATE_UP;
+    kx->status = GNUNET_CORE_KX_STATE_UP;
+    monitor_notify_all (kx);
     GSC_SESSIONS_create (&kx->peer, kx);
     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == kx->keep_alive_task);
     update_timeout (kx);
     break;
-  case KX_STATE_UP:
+  case GNUNET_CORE_KX_STATE_UP:
     GNUNET_STATISTICS_update (GSC_stats,
                               gettext_noop
                               ("# timeouts prevented via PONG"), 1,
                               GNUNET_NO);
     update_timeout (kx);
     break;
-  case KX_STATE_REKEY_SENT:
+  case GNUNET_CORE_KX_STATE_REKEY_SENT:
     GNUNET_STATISTICS_update (GSC_stats,
                               gettext_noop
                               ("# rekey operations confirmed via PONG"), 1,
                               GNUNET_NO);
-    kx->status = KX_STATE_UP;
+    kx->status = GNUNET_CORE_KX_STATE_UP;
+    monitor_notify_all (kx);
     update_timeout (kx);
     break;
   default:
@@ -1205,7 +1225,7 @@ GSC_KX_handle_pong (struct GSC_KeyExchangeInfo *kx,
 static void
 send_key (struct GSC_KeyExchangeInfo *kx)
 {
-  GNUNET_assert (KX_STATE_DOWN != kx->status);
+  GNUNET_assert (GNUNET_CORE_KX_STATE_DOWN != kx->status);
   if (GNUNET_SCHEDULER_NO_TASK != kx->retry_set_key_task)
   {
      GNUNET_SCHEDULER_cancel (kx->retry_set_key_task);
@@ -1321,7 +1341,7 @@ GSC_KX_handle_encrypted_message (struct GSC_KeyExchangeInfo *kx,
     return;
   }
   m = (const struct EncryptedMessage *) msg;
-  if (KX_STATE_UP != kx->status)
+  if (GNUNET_CORE_KX_STATE_UP != kx->status)
   {
     GNUNET_STATISTICS_update (GSC_stats,
                               gettext_noop
@@ -1343,7 +1363,8 @@ GSC_KX_handle_encrypted_message (struct GSC_KeyExchangeInfo *kx,
       GNUNET_SCHEDULER_cancel (kx->keep_alive_task);
       kx->keep_alive_task = GNUNET_SCHEDULER_NO_TASK;
     }
-    kx->status = KX_STATE_KEY_SENT;
+    kx->status = GNUNET_CORE_KX_STATE_KEY_SENT;
+    monitor_notify_all (kx);
     send_key (kx);
     return;
   }
@@ -1473,7 +1494,7 @@ deliver_message (void *cls,
 {
   struct DeliverMessageContext *dmc = client;
 
-  if (KX_STATE_UP != dmc->kx->status)
+  if (GNUNET_CORE_KX_STATE_UP != dmc->kx->status)
   {
     GNUNET_STATISTICS_update (GSC_stats,
                               gettext_noop
@@ -1560,15 +1581,18 @@ do_rekey (void *cls,
   sign_ephemeral_key ();
   for (pos = kx_head; NULL != pos; pos = pos->next)
   {
-    if (KX_STATE_UP == pos->status)
+    if (GNUNET_CORE_KX_STATE_UP == pos->status)
     {
-      pos->status = KX_STATE_REKEY_SENT;
+      pos->status = GNUNET_CORE_KX_STATE_REKEY_SENT;
+      monitor_notify_all (pos);
       derive_session_keys (pos);
     }
-    if (KX_STATE_DOWN == pos->status)
+    if (GNUNET_CORE_KX_STATE_DOWN == pos->status)
     {
-      pos->status = KX_STATE_KEY_SENT;
+      pos->status = GNUNET_CORE_KX_STATE_KEY_SENT;
+      monitor_notify_all (pos);
     }
+    monitor_notify_all (pos);
     send_key (pos);
   }
 }
@@ -1578,11 +1602,15 @@ do_rekey (void *cls,
  * Initialize KX subsystem.
  *
  * @param pk private key to use for the peer
+ * @param server the server of the CORE service
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GSC_KX_init (struct GNUNET_CRYPTO_EddsaPrivateKey *pk)
+GSC_KX_init (struct GNUNET_CRYPTO_EddsaPrivateKey *pk,
+             struct GNUNET_SERVER_Handle *server)
 {
+  nc = GNUNET_SERVER_notification_context_create (server,
+                                                  1);
   my_private_key = pk;
   GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
                                                   &GSC_my_identity.public_key);
@@ -1629,6 +1657,46 @@ GSC_KX_done ()
     GNUNET_SERVER_mst_destroy (mst);
     mst = NULL;
   }
+  if (NULL != nc)
+  {
+    GNUNET_SERVER_notification_context_destroy (nc);
+    nc = NULL;
+  }
 }
 
+
+/**
+ * Handle #GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request.  For this
+ * request type, the client does not have to have transmitted an INIT
+ * request.  All current peers are returned, regardless of which
+ * message types they accept.
+ *
+ * @param cls unused
+ * @param client client sending the iteration request
+ * @param message iteration request message
+ */
+void
+GSC_KX_handle_client_monitor_peers (void *cls,
+                                    struct GNUNET_SERVER_Client *client,
+                                    const struct GNUNET_MessageHeader *message)
+{
+  struct MonitorNotifyMessage done_msg;
+  struct GSC_KeyExchangeInfo *kx;
+
+  GNUNET_SERVER_notification_context_add (nc,
+                                          client);
+  for (kx = kx_head; NULL != kx; kx = kx->next)
+    monitor_notify (client, kx);
+  done_msg.header.size = htons (sizeof (struct MonitorNotifyMessage));
+  done_msg.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_MONITOR_NOTIFY);
+  done_msg.state = htonl ((uint32_t) GNUNET_CORE_KX_ITERATION_FINISHED);
+  memset (&done_msg.peer, 0, sizeof (struct GNUNET_PeerIdentity));
+  done_msg.timeout = GNUNET_TIME_absolute_hton (GNUNET_TIME_UNIT_FOREVER_ABS);
+  GNUNET_SERVER_notification_context_unicast (nc,
+                                              client,
+                                              &done_msg.header,
+                                              GNUNET_NO);
+}
+
+
 /* end of gnunet-service-core_kx.c */
diff --git a/src/core/gnunet-service-core_kx.h b/src/core/gnunet-service-core_kx.h
index c6b346ec3..abe6c3ccd 100644
--- a/src/core/gnunet-service-core_kx.h
+++ b/src/core/gnunet-service-core_kx.h
@@ -118,10 +118,12 @@ GSC_KX_stop (struct GSC_KeyExchangeInfo *kx);
  * Initialize KX subsystem.
  *
  * @param pk private key to use for the peer
+ * @param server the server of the CORE service
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GSC_KX_init (struct GNUNET_CRYPTO_EddsaPrivateKey *pk);
+GSC_KX_init (struct GNUNET_CRYPTO_EddsaPrivateKey *pk,
+             struct GNUNET_SERVER_Handle *server);
 
 
 /**
@@ -130,5 +132,22 @@ GSC_KX_init (struct GNUNET_CRYPTO_EddsaPrivateKey *pk);
 void
 GSC_KX_done (void);
 
+
+/**
+ * Handle #GNUNET_MESSAGE_TYPE_CORE_MONITOR_PEERS request.  For this
+ * request type, the client does not have to have transmitted an INIT
+ * request.  All current peers are returned, regardless of which
+ * message types they accept.
+ *
+ * @param cls unused
+ * @param client client sending the iteration request
+ * @param message iteration request message
+ */
+void
+GSC_KX_handle_client_monitor_peers (void *cls,
+                                    struct GNUNET_SERVER_Client *client,
+                                    const struct GNUNET_MessageHeader *message);
+
+
 #endif
 /* end of gnunet-service-core_kx.h */
diff --git a/src/core/gnunet-service-core_sessions.c b/src/core/gnunet-service-core_sessions.c
index 5e8bd537f..eb0013790 100644
--- a/src/core/gnunet-service-core_sessions.c
+++ b/src/core/gnunet-service-core_sessions.c
@@ -732,59 +732,6 @@ GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest *car,
 
 
 /**
- * Helper function for #GSC_SESSIONS_handle_client_iterate_peers().
- *
- * @param cls the `struct GNUNET_SERVER_TransmitContext` to queue replies
- * @param key identity of the connected peer
- * @param value the `struct Neighbour` for the peer
- * @return #GNUNET_OK (continue to iterate)
- */
-static int
-queue_connect_message (void *cls,
-                       const struct GNUNET_PeerIdentity *key,
-                       void *value)
-{
-  struct GNUNET_SERVER_TransmitContext *tc = cls;
-  struct Session *session = value;
-  struct ConnectNotifyMessage cnm;
-
-  /* FIXME: code duplication with clients... */
-  cnm.header.size = htons (sizeof (struct ConnectNotifyMessage));
-  cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
-  cnm.reserved = htonl (0);
-  cnm.peer = session->peer;
-  GNUNET_SERVER_transmit_context_append_message (tc, &cnm.header);
-  return GNUNET_OK;
-}
-
-
-/**
- * Handle CORE_ITERATE_PEERS request. For this request type, the client
- * does not have to have transmitted an INIT request.  All current peers
- * are returned, regardless of which message types they accept.
- *
- * @param cls unused
- * @param client client sending the iteration request
- * @param message iteration request message
- */
-void
-GSC_SESSIONS_handle_client_iterate_peers (void *cls,
-                                          struct GNUNET_SERVER_Client *client,
-                                          const struct GNUNET_MessageHeader *message)
-{
-  struct GNUNET_MessageHeader done_msg;
-  struct GNUNET_SERVER_TransmitContext *tc;
-
-  tc = GNUNET_SERVER_transmit_context_create (client);
-  GNUNET_CONTAINER_multipeermap_iterate (sessions, &queue_connect_message, tc);
-  done_msg.size = htons (sizeof (struct GNUNET_MessageHeader));
-  done_msg.type = htons (GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS_END);
-  GNUNET_SERVER_transmit_context_append_message (tc, &done_msg);
-  GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
-}
-
-
-/**
  * We've received a typemap message from a peer, update ours.
  * Notifies clients about the session.
  *
diff --git a/src/core/gnunet-service-core_sessions.h b/src/core/gnunet-service-core_sessions.h
index 034026bb8..81581e84d 100644
--- a/src/core/gnunet-service-core_sessions.h
+++ b/src/core/gnunet-service-core_sessions.h
@@ -118,6 +118,7 @@ GSC_SESSIONS_broadcast (const struct GNUNET_MessageHeader *msg);
 void
 GSC_SESSIONS_notify_client_about_sessions (struct GSC_Client *client);
 
+
 /**
  * We've received a typemap message from a peer, update ours.
  * Notifies clients about the session.
@@ -144,22 +145,6 @@ GSC_SESSIONS_add_to_typemap (const struct GNUNET_PeerIdentity *peer,
 
 
 /**
- * Handle CORE_ITERATE_PEERS request.  For this request type, the client
- * does not have to have transmitted an INIT request.  All current peers
- * are returned, regardless of which message types they accept.
- *
- * @param cls unused
- * @param client client sending the iteration request
- * @param message iteration request message
- */
-void
-GSC_SESSIONS_handle_client_iterate_peers (void *cls,
-                                          struct GNUNET_SERVER_Client *client,
-                                          const struct GNUNET_MessageHeader
-                                          *message);
-
-
-/**
  * Initialize sessions subsystem.
  */
 void