separate ATS connectivity suggestions from ATS scheduling API

21 files changed, 729 insertions, 303 deletions

diff --git a/src/ats/Makefile.am b/src/ats/Makefile.am
index a165cebb7..27dd80a0d 100644
--- a/src/ats/Makefile.am
+++ b/src/ats/Makefile.am
@@ -51,6 +51,7 @@ gnunet_ats_solver_eval_LDADD = \
  $(LTLIBINTL)
 
 libgnunetats_la_SOURCES = \
+  ats_api_connectivity.c \
   ats_api_scheduling.c \
   ats_api_performance.c
 libgnunetats_la_LIBADD = \
@@ -99,6 +100,7 @@ libexec_PROGRAMS = \
 gnunet_service_ats_SOURCES = \
  gnunet-service-ats.c gnunet-service-ats.h\
  gnunet-service-ats_addresses.c gnunet-service-ats_addresses.h \
+ gnunet-service-ats_connectivity.c gnunet-service-ats_connectivity.h \
  gnunet-service-ats_normalization.c gnunet-service-ats_normalization.h \
  gnunet-service-ats_performance.c gnunet-service-ats_performance.h \
  gnunet-service-ats_scheduling.c gnunet-service-ats_scheduling.h \
diff --git a/src/ats/ats.h b/src/ats/ats.h
index b6750da10..482b7b4b3 100644
--- a/src/ats/ats.h
+++ b/src/ats/ats.h
@@ -50,7 +50,12 @@ enum StartFlag
    * Performance monitoring client that does NOT want to learn
    * about changes in performance characteristics.
    */
-  START_FLAG_PERFORMANCE_NO_PIC = 2
+  START_FLAG_PERFORMANCE_NO_PIC = 2,
+
+  /**
+   * Connection suggestion handle.
+   */
+  START_FLAG_CONNECTION_SUGGESTION = 3
 };
 
 
diff --git a/src/ats/ats_api_connectivity.c b/src/ats/ats_api_connectivity.c
new file mode 100644
index 000000000..9198118a4
--- /dev/null
+++ b/src/ats/ats_api_connectivity.c
@@ -0,0 +1,356 @@
+/*
+     This file is part of GNUnet.
+     (C) 2010-2015 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 3, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+/**
+ * @file ats/ats_api_connectivity.c
+ * @brief enable clients to ask ATS about establishing connections to peers
+ * @author Christian Grothoff
+ * @author Matthias Wachs
+ */
+#include "platform.h"
+#include "gnunet_ats_service.h"
+#include "ats.h"
+
+
+/**
+ * Handle for ATS address suggestion requests.
+ */
+struct GNUNET_ATS_ConnectivitySuggestHandle
+{
+  /**
+   * ID of the peer for which address suggestion was requested.
+   */
+  struct GNUNET_PeerIdentity id;
+
+  /**
+   * Connecitivity handle this suggestion handle belongs to.
+   */
+  struct GNUNET_ATS_ConnectivityHandle *ch;
+};
+
+
+/**
+ * Handle to the ATS subsystem for connectivity management.
+ */
+struct GNUNET_ATS_ConnectivityHandle
+{
+
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Map with the identities of all the peers for which we would
+   * like to have address suggestions.  The key is the PID, the
+   * value is currently the `struct GNUNET_ATS_ConnectivitySuggestHandle`
+   */
+  struct GNUNET_CONTAINER_MultiPeerMap *sug_requests;
+
+  /**
+   * Connection to ATS service.
+   */
+  struct GNUNET_CLIENT_Connection *client;
+
+  /**
+   * Message queue for sending requests to the ATS service.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Task to trigger reconnect.
+   */
+  struct GNUNET_SCHEDULER_Task *task;
+
+};
+
+
+/**
+ * Re-establish the connection to the ATS service.
+ *
+ * @param ch handle to use to re-connect.
+ */
+static void
+reconnect (struct GNUNET_ATS_ConnectivityHandle *ch);
+
+
+/**
+ * Re-establish the connection to the ATS service.
+ *
+ * @param cls handle to use to re-connect.
+ * @param tc scheduler context
+ */
+static void
+reconnect_task (void *cls,
+                const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_ATS_ConnectivityHandle *ch = cls;
+
+  ch->task = NULL;
+  reconnect (ch);
+}
+
+
+/**
+ * Disconnect from ATS and then reconnect.
+ *
+ * @param ch our handle
+ */
+static void
+force_reconnect (struct GNUNET_ATS_ConnectivityHandle *ch)
+{
+  if (NULL != ch->mq)
+  {
+    GNUNET_MQ_destroy (ch->mq);
+    ch->mq = NULL;
+  }
+  if (NULL != ch->client)
+  {
+    GNUNET_CLIENT_disconnect (ch->client);
+    ch->client = NULL;
+  }
+  ch->task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                           &reconnect_task,
+                                           ch);
+}
+
+
+/**
+ * We encountered an error handling the MQ to the
+ * ATS service.  Reconnect.
+ *
+ * @param cls the `struct GNUNET_ATS_ConnectivityHandle`
+ * @param error details about the error
+ */
+static void
+error_handler (void *cls,
+               enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_ATS_ConnectivityHandle *ch = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "ATS connection died (code %d), reconnecting\n",
+              (int) error);
+  force_reconnect (ch);
+}
+
+
+/**
+ * Transmit request for an address suggestion.
+ *
+ * @param cls the `struct GNUNET_ATS_ConnectivityHandle`
+ * @param peer peer to ask for an address suggestion for
+ * @param value the `struct GNUNET_ATS_SuggestHandle`
+ * @return #GNUNET_OK (continue to iterate), #GNUNET_SYSERR on
+ *         failure (message queue no longer exists)
+ */
+static int
+transmit_suggestion (void *cls,
+                     const struct GNUNET_PeerIdentity *peer,
+                     void *value)
+{
+  struct GNUNET_ATS_ConnectivityHandle *ch = cls;
+  struct GNUNET_MQ_Envelope *ev;
+  struct RequestAddressMessage *m;
+
+  if (NULL == ch->mq)
+    return GNUNET_SYSERR;
+  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS);
+  m->reserved = htonl (0);
+  m->peer = *peer;
+  GNUNET_MQ_send (ch->mq, ev);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Re-establish the connection to the ATS service.
+ *
+ * @param ch handle to use to re-connect.
+ */
+static void
+reconnect (struct GNUNET_ATS_ConnectivityHandle *ch)
+{
+  static const struct GNUNET_MQ_MessageHandler handlers[] =
+    { { NULL, 0, 0 } };
+  struct GNUNET_MQ_Envelope *ev;
+  struct ClientStartMessage *init;
+
+  GNUNET_assert (NULL == ch->client);
+  ch->client = GNUNET_CLIENT_connect ("ats", ch->cfg);
+  if (NULL == ch->client)
+  {
+    force_reconnect (ch);
+    return;
+  }
+  ch->mq = GNUNET_MQ_queue_for_connection_client (ch->client,
+                                                  handlers,
+                                                  &error_handler,
+                                                  ch);
+  ev = GNUNET_MQ_msg (init,
+                      GNUNET_MESSAGE_TYPE_ATS_START);
+  init->start_flag = htonl (START_FLAG_CONNECTION_SUGGESTION);
+  GNUNET_MQ_send (ch->mq, ev);
+  if (NULL == ch->mq)
+    return;
+  GNUNET_CONTAINER_multipeermap_iterate (ch->sug_requests,
+                                         &transmit_suggestion,
+                                         ch);
+}
+
+
+/**
+ * Initialize the ATS connectivity suggestion client handle.
+ *
+ * @param cfg configuration to use
+ * @return ats connectivity handle, NULL on error
+ */
+struct GNUNET_ATS_ConnectivityHandle *
+GNUNET_ATS_connectivity_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_ATS_ConnectivityHandle *ch;
+
+  ch = GNUNET_new (struct GNUNET_ATS_ConnectivityHandle);
+  ch->cfg = cfg;
+  ch->sug_requests = GNUNET_CONTAINER_multipeermap_create (32,
+                                                           GNUNET_YES);
+  reconnect (ch);
+  return ch;
+}
+
+
+/**
+ * Function called to free all `struct GNUNET_ATS_SuggestHandles`
+ * in the map.
+ *
+ * @param cls NULL
+ * @param key the key
+ * @param value the value to free
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+free_sug_handle (void *cls,
+                 const struct GNUNET_PeerIdentity *key,
+                 void *value)
+{
+  struct GNUNET_ATS_ConnectivitySuggestHandle *cur = value;
+
+  GNUNET_free (cur);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Client is done with ATS connectivity management, release resources.
+ *
+ * @param ch handle to release
+ */
+void
+GNUNET_ATS_connectivity_done (struct GNUNET_ATS_ConnectivityHandle *ch)
+{
+  if (NULL != ch->mq)
+  {
+    GNUNET_MQ_destroy (ch->mq);
+    ch->mq = NULL;
+  }
+  if (NULL != ch->client)
+  {
+    GNUNET_CLIENT_disconnect (ch->client);
+    ch->client = NULL;
+  }
+  if (NULL != ch->task)
+  {
+    GNUNET_SCHEDULER_cancel (ch->task);
+    ch->task = NULL;
+  }
+  GNUNET_CONTAINER_multipeermap_iterate (ch->sug_requests,
+                                         &free_sug_handle,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (ch->sug_requests);
+  GNUNET_free (ch);
+}
+
+
+/**
+ * We would like to receive address suggestions for a peer. ATS will
+ * respond with a call to the continuation immediately containing an address or
+ * no address if none is available. ATS can suggest more addresses until we call
+ * #GNUNET_ATS_connectivity_suggest_cancel().
+ *
+ * @param ch handle
+ * @param peer identity of the peer we need an address for
+ * @return suggest handle, NULL if a request is already pending
+ */
+struct GNUNET_ATS_ConnectivitySuggestHandle *
+GNUNET_ATS_connectivity_suggest (struct GNUNET_ATS_ConnectivityHandle *ch,
+                                 const struct GNUNET_PeerIdentity *peer)
+{
+  struct GNUNET_ATS_ConnectivitySuggestHandle *s;
+
+  s = GNUNET_new (struct GNUNET_ATS_ConnectivitySuggestHandle);
+  s->ch = ch;
+  s->id = *peer;
+  if (GNUNET_OK !=
+      GNUNET_CONTAINER_multipeermap_put (ch->sug_requests,
+                                         &s->id,
+                                         s,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  if (NULL == ch->mq)
+    return s;
+  (void) transmit_suggestion (ch,
+                              &s->id,
+                              s);
+  return s;
+}
+
+
+/**
+ * We no longer care about being connected to a peer.
+ *
+ * @param sh handle to stop
+ */
+void
+GNUNET_ATS_connectivity_suggest_cancel (struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
+{
+  struct GNUNET_ATS_ConnectivityHandle *ch = sh->ch;
+  struct GNUNET_MQ_Envelope *ev;
+  struct RequestAddressMessage *m;
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multipeermap_remove (ch->sug_requests,
+                                                       &sh->id,
+                                                       sh));
+  if (NULL == ch->mq)
+  {
+    GNUNET_free (sh);
+    return;
+  }
+  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS_CANCEL);
+  m->reserved = htonl (0);
+  m->peer = sh->id;
+  GNUNET_MQ_send (ch->mq, ev);
+  GNUNET_free (sh);
+}
+
+
+/* end of ats_api_connectivity.c */
diff --git a/src/ats/ats_api_scheduling.c b/src/ats/ats_api_scheduling.c
index 21fb583de..2daa45a73 100644
--- a/src/ats/ats_api_scheduling.c
+++ b/src/ats/ats_api_scheduling.c
@@ -146,18 +146,6 @@ struct ATS_Network
 
 
 /**
- * Handle for ATS address suggestion requests.
- */
-struct GNUNET_ATS_SuggestHandle
-{
-  /**
-   * ID of the peer for which address suggestion was requested.
-   */
-  struct GNUNET_PeerIdentity id;
-};
-
-
-/**
  * Handle to the ATS subsystem for bandwidth/transport scheduling information.
  */
 struct GNUNET_ATS_SchedulingHandle
@@ -179,13 +167,6 @@ struct GNUNET_ATS_SchedulingHandle
   void *suggest_cb_cls;
 
   /**
-   * Map with the identities of all the peers for which we would
-   * like to have address suggestions.  The key is the PID, the
-   * value is currently the `struct GNUNET_ATS_SuggestHandle`
-   */
-  struct GNUNET_CONTAINER_MultiPeerMap *sug_requests;
-
-  /**
    * Connection to ATS service.
    */
   struct GNUNET_CLIENT_Connection *client;
@@ -588,34 +569,6 @@ send_add_address_message (struct GNUNET_ATS_SchedulingHandle *sh,
 
 
 /**
- * Transmit request for an address suggestion.
- *
- * @param cls the `struct GNUNET_ATS_SchedulingHandle`
- * @param peer peer to ask for an address suggestion for
- * @param value the `struct GNUNET_ATS_SuggestHandle`
- * @return #GNUNET_OK (continue to iterate), #GNUNET_SYSERR on
- *         failure (message queue no longer exists)
- */
-static int
-transmit_suggestion (void *cls,
-                     const struct GNUNET_PeerIdentity *peer,
-                     void *value)
-{
-  struct GNUNET_ATS_SchedulingHandle *sh = cls;
-  struct GNUNET_MQ_Envelope *ev;
-  struct RequestAddressMessage *m;
-
-  if (NULL == sh->mq)
-    return GNUNET_SYSERR;
-  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS);
-  m->reserved = htonl (0);
-  m->peer = *peer;
-  GNUNET_MQ_send (sh->mq, ev);
-  return GNUNET_OK;
-}
-
-
-/**
  * Generate and transmit the `struct AddressUseMessage` for the given
  * address record.
  *
@@ -687,9 +640,6 @@ reconnect (struct GNUNET_ATS_SchedulingHandle *sh)
     if (NULL == sh->mq)
       return;
   }
-  GNUNET_CONTAINER_multipeermap_iterate (sh->sug_requests,
-                                         &transmit_suggestion,
-                                         sh);
 }
 
 
@@ -1034,8 +984,6 @@ GNUNET_ATS_scheduling_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
   GNUNET_array_grow (sh->session_array,
                      sh->session_array_size,
                      4);
-  sh->sug_requests = GNUNET_CONTAINER_multipeermap_create (32,
-                                                           GNUNET_YES);
   GNUNET_OS_network_interfaces_list (&interface_proc,
                                      sh);
   sh->interface_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_PROCESSING_INTERVAL,
@@ -1047,27 +995,6 @@ GNUNET_ATS_scheduling_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
 
 /**
- * Function called to free all `struct GNUNET_ATS_SuggestHandles`
- * in the map.
- *
- * @param cls NULL
- * @param key the key
- * @param value the value to free
- * @return #GNUNET_OK (continue to iterate)
- */
-static int
-free_sug_handle (void *cls,
-                 const struct GNUNET_PeerIdentity *key,
-                 void *value)
-{
-  struct GNUNET_ATS_SuggestHandle *cur = value;
-
-  GNUNET_free (cur);
-  return GNUNET_OK;
-}
-
-
-/**
  * Client is done with ATS scheduling, release resources.
  *
  * @param sh handle to release
@@ -1090,10 +1017,6 @@ GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *sh)
     GNUNET_SCHEDULER_cancel (sh->task);
     sh->task = NULL;
   }
-  GNUNET_CONTAINER_multipeermap_iterate (sh->sug_requests,
-                                         &free_sug_handle,
-                                         NULL);
-  GNUNET_CONTAINER_multipeermap_destroy (sh->sug_requests);
   if (NULL != sh->interface_task)
   {
     GNUNET_SCHEDULER_cancel (sh->interface_task);
@@ -1129,77 +1052,6 @@ GNUNET_ATS_reset_backoff (struct GNUNET_ATS_SchedulingHandle *sh,
 
 
 /**
- * We would like to receive address suggestions for a peer. ATS will
- * respond with a call to the continuation immediately containing an address or
- * no address if none is available. ATS can suggest more addresses until we call
- * #GNUNET_ATS_suggest_address_cancel().
- *
- * @param sh handle
- * @param peer identity of the peer we need an address for
- * @return suggest handle, NULL if a request is already pending
- */
-struct GNUNET_ATS_SuggestHandle *
-GNUNET_ATS_suggest_address (struct GNUNET_ATS_SchedulingHandle *sh,
-                            const struct GNUNET_PeerIdentity *peer)
-{
-  struct GNUNET_ATS_SuggestHandle *s;
-
-  s = GNUNET_new (struct GNUNET_ATS_SuggestHandle);
-  s->id = *peer;
-  if (GNUNET_OK !=
-      GNUNET_CONTAINER_multipeermap_put (sh->sug_requests,
-                                         &s->id,
-                                         s,
-                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  if (NULL == sh->mq)
-    return s;
-  (void) transmit_suggestion (sh,
-                              &s->id,
-                              s);
-  return s;
-}
-
-
-/**
- * We would like to stop receiving address updates for this peer
- *
- * @param sh handle
- * @param peer identity of the peer
- */
-void
-GNUNET_ATS_suggest_address_cancel (struct GNUNET_ATS_SchedulingHandle *sh,
-                                   const struct GNUNET_PeerIdentity *peer)
-{
-  struct GNUNET_MQ_Envelope *ev;
-  struct RequestAddressMessage *m;
-  struct GNUNET_ATS_SuggestHandle *s;
-
-  s = GNUNET_CONTAINER_multipeermap_get (sh->sug_requests,
-                                         peer);
-  if (NULL == s)
-  {
-    GNUNET_break (0);
-    return;
-  }
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multipeermap_remove (sh->sug_requests,
-                                                       &s->id,
-                                                       s));
-  GNUNET_free (s);
-  if (NULL == sh->mq)
-    return;
-  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS_CANCEL);
-  m->reserved = htonl (0);
-  m->peer = *peer;
-  GNUNET_MQ_send (sh->mq, ev);
-}
-
-
-/**
  * Test if a address and a session is known to ATS
  *
  * @param sh the scheduling handle
diff --git a/src/ats/gnunet-service-ats.c b/src/ats/gnunet-service-ats.c
index edc3b51af..83fa42b35 100644
--- a/src/ats/gnunet-service-ats.c
+++ b/src/ats/gnunet-service-ats.c
@@ -28,6 +28,7 @@
 #include "gnunet_util_lib.h"
 #include "gnunet-service-ats.h"
 #include "gnunet-service-ats_addresses.h"
+#include "gnunet-service-ats_connectivity.h"
 #include "gnunet-service-ats_performance.h"
 #include "gnunet-service-ats_scheduling.h"
 #include "gnunet-service-ats_reservations.h"
@@ -80,6 +81,9 @@ handle_ats_start (void *cls,
   case START_FLAG_PERFORMANCE_NO_PIC:
     GAS_performance_add_client (client, flag);
     break;
+  case START_FLAG_CONNECTION_SUGGESTION:
+    /* This client won't receive messages from us, no need to 'add' */
+    break;
   default:
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
diff --git a/src/ats/gnunet-service-ats_connectivity.c b/src/ats/gnunet-service-ats_connectivity.c
new file mode 100644
index 000000000..da943f984
--- /dev/null
+++ b/src/ats/gnunet-service-ats_connectivity.c
@@ -0,0 +1,86 @@
+/*
+     This file is part of GNUnet.
+     (C) 2011-2015 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 3, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file ats/gnunet-service-ats_connectivity.c
+ * @brief ats service, interaction with 'connecivity' API
+ * @author Matthias Wachs
+ * @author Christian Grothoff
+ *
+ * FIXME:
+ * - we should track requests by client, and if a client
+ *   disconnects cancel all associated requests; right
+ *   now, they will persist forever unless the client
+ *   explicitly sends us a cancel before disconnecting!
+ */
+#include "platform.h"
+#include "gnunet-service-ats.h"
+#include "gnunet-service-ats_addresses.h"
+#include "gnunet-service-ats_connectivity.h"
+#include "ats.h"
+
+/**
+ * Handle 'request address' messages from clients.
+ *
+ * @param cls unused, NULL
+ * @param client client that sent the request
+ * @param message the request message
+ */
+void
+GAS_handle_request_address (void *cls,
+                            struct GNUNET_SERVER_Client *client,
+                            const struct GNUNET_MessageHeader *message)
+{
+  const struct RequestAddressMessage *msg =
+      (const struct RequestAddressMessage *) message;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received `%s' message\n",
+              "REQUEST_ADDRESS");
+  GNUNET_break (0 == ntohl (msg->reserved));
+  GAS_addresses_request_address (&msg->peer);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+}
+
+
+/**
+ * Handle 'request address' messages from clients.
+ *
+ * @param cls unused, NULL
+ * @param client client that sent the request
+ * @param message the request message
+ */
+void
+GAS_handle_request_address_cancel (void *cls,
+                                   struct GNUNET_SERVER_Client *client,
+                                   const struct GNUNET_MessageHeader *message)
+{
+  const struct RequestAddressMessage *msg =
+      (const struct RequestAddressMessage *) message;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received `%s' message\n",
+              "REQUEST_ADDRESS_CANCEL");
+  GNUNET_break (0 == ntohl (msg->reserved));
+  GAS_addresses_request_address_cancel (&msg->peer);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+}
+
+/* end of gnunet-service-ats_connectivity.c */
diff --git a/src/ats/gnunet-service-ats_connectivity.h b/src/ats/gnunet-service-ats_connectivity.h
new file mode 100644
index 000000000..c6b50f445
--- /dev/null
+++ b/src/ats/gnunet-service-ats_connectivity.h
@@ -0,0 +1,58 @@
+/*
+     This file is part of GNUnet.
+     (C) 2011-2015 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 3, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file ats/gnunet-service-ats_connectivity.h
+ * @brief ats service, interaction with 'connecivity' API
+ * @author Matthias Wachs
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_SERVICE_ATS_CONNECTIVITY_H
+#define GNUNET_SERVICE_ATS_CONNECTIVITY_H
+
+
+/**
+ * Handle 'request address' messages from clients.
+ *
+ * @param cls unused, NULL
+ * @param client client that sent the request
+ * @param message the request message
+ */
+void
+GAS_handle_request_address (void *cls,
+                            struct GNUNET_SERVER_Client *client,
+                            const struct GNUNET_MessageHeader *message);
+
+
+/**
+ * Cancel 'request address' messages from clients.
+ *
+ * @param cls unused, NULL
+ * @param client client that sent the request
+ * @param message the request message
+ */
+void
+GAS_handle_request_address_cancel (void *cls,
+                                   struct GNUNET_SERVER_Client *client,
+                                   const struct GNUNET_MessageHeader *message);
+
+
+#endif
+/* end of gnunet-service-ats_connectivity.h */
diff --git a/src/ats/gnunet-service-ats_scheduling.c b/src/ats/gnunet-service-ats_scheduling.c
index 2e11296e3..6b6b6c24f 100644
--- a/src/ats/gnunet-service-ats_scheduling.c
+++ b/src/ats/gnunet-service-ats_scheduling.c
@@ -120,53 +120,6 @@ GAS_scheduling_transmit_address_suggestion (const struct GNUNET_PeerIdentity *pe
 
 
 /**
- * Handle 'request address' messages from clients.
- *
- * @param cls unused, NULL
- * @param client client that sent the request
- * @param message the request message
- */
-void
-GAS_handle_request_address (void *cls,
-                            struct GNUNET_SERVER_Client *client,
-                            const struct GNUNET_MessageHeader *message)
-{
-  const struct RequestAddressMessage *msg =
-      (const struct RequestAddressMessage *) message;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received `%s' message\n",
-              "REQUEST_ADDRESS");
-  GNUNET_break (0 == ntohl (msg->reserved));
-  GAS_addresses_request_address (&msg->peer);
-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
-}
-
-
-/**
- * Handle 'request address' messages from clients.
- *
- * @param cls unused, NULL
- * @param client client that sent the request
- * @param message the request message
- */
-void
-GAS_handle_request_address_cancel (void *cls,
-                                   struct GNUNET_SERVER_Client *client,
-                                   const struct GNUNET_MessageHeader *message)
-{
-  const struct RequestAddressMessage *msg =
-      (const struct RequestAddressMessage *) message;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received `%s' message\n",
-              "REQUEST_ADDRESS_CANCEL");
-  GNUNET_break (0 == ntohl (msg->reserved));
-  GAS_addresses_request_address_cancel (&msg->peer);
-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
-}
-
-
-/**
  * Handle 'reset backoff' messages from clients.
  *
  * @param cls unused, NULL
diff --git a/src/ats/gnunet-service-ats_scheduling.h b/src/ats/gnunet-service-ats_scheduling.h
index 38ade2ae8..fe8adc8c5 100644
--- a/src/ats/gnunet-service-ats_scheduling.h
+++ b/src/ats/gnunet-service-ats_scheduling.h
@@ -80,32 +80,6 @@ GAS_scheduling_transmit_address_suggestion (const struct GNUNET_PeerIdentity *pe
 
 
 /**
- * Handle 'request address' messages from clients.
- *
- * @param cls unused, NULL
- * @param client client that sent the request
- * @param message the request message
- */
-void
-GAS_handle_request_address (void *cls,
-                            struct GNUNET_SERVER_Client *client,
-                            const struct GNUNET_MessageHeader *message);
-
-
-/**
- * Cancel 'request address' messages from clients.
- *
- * @param cls unused, NULL
- * @param client client that sent the request
- * @param message the request message
- */
-void
-GAS_handle_request_address_cancel (void *cls,
-                                   struct GNUNET_SERVER_Client *client,
-                                   const struct GNUNET_MessageHeader *message);
-
-
-/**
  * Handle 'address add' messages from clients.
  *
  * @param cls unused, NULL
diff --git a/src/ats/test_ats_api_bandwidth_consumption.c b/src/ats/test_ats_api_bandwidth_consumption.c
index 9ab0de7a9..366f293ca 100644
--- a/src/ats/test_ats_api_bandwidth_consumption.c
+++ b/src/ats/test_ats_api_bandwidth_consumption.c
@@ -39,7 +39,12 @@ static struct GNUNET_ATS_SchedulingHandle *ats;
 
 static struct GNUNET_ATS_PerformanceHandle *atp;
 
-struct GNUNET_ATS_ReservationContext *sh;
+/**
+ * Connectivity handle
+ */
+static struct GNUNET_ATS_ConnectivityHandle *connect_ats;
+
+static struct GNUNET_ATS_ReservationContext *sh;
 
 static struct PeerContext *p;
 
@@ -75,44 +80,51 @@ struct PeerContext
 
 
 static void
-end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+end ()
 {
-  die_task = NULL;
+  if (NULL != connect_ats)
+  {
+    GNUNET_ATS_connectivity_done (connect_ats);
+    connect_ats = NULL;
+  }
+  if (die_task != NULL)
+  {
+    GNUNET_SCHEDULER_cancel (die_task);
+    die_task = NULL;
+  }
   if (consume_task != NULL)
   {
     GNUNET_SCHEDULER_cancel (consume_task);
     consume_task = NULL;
   }
   if (sh != NULL)
+  {
     GNUNET_ATS_reserve_bandwidth_cancel (sh);
+    sh = NULL;
+  }
   if (ats != NULL)
+  {
     GNUNET_ATS_scheduling_done (ats);
+    ats = NULL;
+  }
   if (atp != NULL)
+  {
     GNUNET_ATS_performance_done (atp);
+    atp = NULL;
+  }
   GNUNET_free (p->addr);
   GNUNET_free (p);
-  ret = GNUNET_SYSERR;
+  p = NULL;
+  ret = 0;
 }
 
 
 static void
-end ()
+end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  if (die_task != NULL)
-  {
-    GNUNET_SCHEDULER_cancel (die_task);
-    die_task = NULL;
-  }
-  if (consume_task != NULL)
-  {
-    GNUNET_SCHEDULER_cancel (consume_task);
-    consume_task = NULL;
-  }
-  GNUNET_ATS_scheduling_done (ats);
-  GNUNET_ATS_performance_done (atp);
-  GNUNET_free (p->addr);
-  GNUNET_free (p);
-  ret = 0;
+  die_task = NULL;
+  end ();
+  ret = GNUNET_SYSERR;
 }
 
 
@@ -182,6 +194,8 @@ run (void *cls,
 
   ret = GNUNET_SYSERR;
   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
+  connect_ats = GNUNET_ATS_connectivity_init (mycfg);
+
   ats = GNUNET_ATS_scheduling_init (cfg, &address_suggest_cb, NULL);
   if (ats == NULL)
   {
@@ -218,7 +232,7 @@ run (void *cls,
   GNUNET_ATS_address_update (ats, &p->id, addr->plugin, addr->addr,
                              addr->addr_len, addr->session, NULL, 0);
 
-  GNUNET_ATS_suggest_address (ats, &p->id);
+  GNUNET_ATS_connectivity_suggest (connect_ats, &p->id);
 }
 
 
diff --git a/src/ats/test_ats_simplistic_pref_aging.c b/src/ats/test_ats_simplistic_pref_aging.c
index 855e22fbf..654abfa5b 100644
--- a/src/ats/test_ats_simplistic_pref_aging.c
+++ b/src/ats/test_ats_simplistic_pref_aging.c
@@ -48,6 +48,11 @@ static struct GNUNET_SCHEDULER_Task * die_task;
 static struct GNUNET_ATS_SchedulingHandle *sched_ats;
 
 /**
+ * Connectivity handle
+ */
+static struct GNUNET_ATS_ConnectivityHandle *connect_ats;
+
+/**
  * Performance handle
  */
 static struct GNUNET_ATS_PerformanceHandle *perf_ats;
@@ -67,11 +72,15 @@ static struct Test_Address test_addr[2];
  */
 static struct PeerContext p[2];
 
+/**
+ * Connectivity suggestion handles.
+ */
+static struct GNUNET_ATS_ConnectivitySuggestHandle *sh[2];
 
 /**
  * HELLO address
  */
-struct GNUNET_HELLO_Address test_hello_address[2];
+static struct GNUNET_HELLO_Address test_hello_address[2];
 
 /**
  * Session
@@ -81,22 +90,22 @@ static void *test_session[2];
 /**
  * Test ats info
  */
-struct GNUNET_ATS_Information test_ats_info[2];
+static struct GNUNET_ATS_Information test_ats_info[2];
 
 /**
  * Test ats count
  */
-uint32_t test_ats_count;
+static uint32_t test_ats_count;
 
 /**
  * Configured WAN out quota
  */
-unsigned long long wan_quota_out;
+static unsigned long long wan_quota_out;
 
 /**
  * Configured WAN in quota
  */
-unsigned long long wan_quota_in;
+static unsigned long long wan_quota_in;
 
 
 static void
@@ -109,6 +118,11 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_ATS_scheduling_done (sched_ats);
     sched_ats = NULL;
   }
+  if (NULL != connect_ats)
+  {
+    GNUNET_ATS_connectivity_done (connect_ats);
+    connect_ats = NULL;
+  }
   if (perf_ats != NULL)
   {
     GNUNET_ATS_performance_done (perf_ats);
@@ -129,8 +143,8 @@ end ()
     die_task = NULL;
   }
 
-  GNUNET_ATS_suggest_address_cancel (sched_ats, &p[0].id);
-  GNUNET_ATS_suggest_address_cancel (sched_ats, &p[1].id);
+  GNUNET_ATS_connectivity_suggest_cancel (sh[0]);
+  GNUNET_ATS_connectivity_suggest_cancel (sh[1]);
 
   if (NULL != sched_ats)
         GNUNET_ATS_scheduling_done (sched_ats);
@@ -366,6 +380,7 @@ run (void *cls,
   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
 
   /* Connect to ATS scheduling */
+  connect_ats = GNUNET_ATS_connectivity_init (mycfg);
   sched_ats = GNUNET_ATS_scheduling_init (cfg, &address_suggest_cb, NULL);
   if (sched_ats == NULL)
   {
@@ -439,8 +454,8 @@ run (void *cls,
   test_hello_address[1].address_length = test_addr[1].addr_len;
   GNUNET_ATS_address_add (sched_ats, &test_hello_address[1], test_session[1], test_ats_info, test_ats_count);
 
-  GNUNET_ATS_suggest_address (sched_ats, &p[0].id);
-  GNUNET_ATS_suggest_address (sched_ats, &p[1].id);
+  sh[0] = GNUNET_ATS_connectivity_suggest (connect_ats, &p[0].id);
+  sh[1] = GNUNET_ATS_connectivity_suggest (connect_ats, &p[1].id);
 }
 
 
diff --git a/src/ats/test_ats_solver_add_address_and_request.c b/src/ats/test_ats_solver_add_address_and_request.c
index 34ade7d60..6d63cd990 100644
--- a/src/ats/test_ats_solver_add_address_and_request.c
+++ b/src/ats/test_ats_solver_add_address_and_request.c
@@ -51,6 +51,11 @@ static struct GNUNET_STATISTICS_Handle *stats;
 static struct GNUNET_ATS_SchedulingHandle *sched_ats;
 
 /**
+ * Connectivity handle
+ */
+static struct GNUNET_ATS_ConnectivityHandle *connect_ats;
+
+/**
  * Return value
  */
 static int ret;
@@ -106,6 +111,11 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_ATS_scheduling_done (sched_ats);
     sched_ats = NULL;
   }
+  if (NULL != connect_ats)
+  {
+    GNUNET_ATS_connectivity_done (connect_ats);
+    connect_ats = NULL;
+  }
 
   GNUNET_STATISTICS_watch_cancel (stats, "ats", "# addresses", &stat_cb, NULL);
   if (NULL != stats)
@@ -154,7 +164,7 @@ stat_cb (void *cls, const char *subsystem,
          const char *name, uint64_t value,
          int is_persistent)
 {
-  static struct GNUNET_ATS_SuggestHandle *sh;
+  static struct GNUNET_ATS_ConnectivitySuggestHandle *sh;
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "ATS statistics: `%s' `%s' %llu\n",
@@ -162,7 +172,7 @@ stat_cb (void *cls, const char *subsystem,
               name,
               value);
   if (NULL == sh)
-    sh = GNUNET_ATS_suggest_address (sched_ats, &p.id);
+    sh = GNUNET_ATS_connectivity_suggest (connect_ats, &p.id);
   return GNUNET_OK;
 }
 
@@ -177,6 +187,7 @@ run (void *cls,
   GNUNET_STATISTICS_watch (stats, "ats", "# addresses", &stat_cb, NULL);
 
 
+  connect_ats = GNUNET_ATS_connectivity_init (mycfg);
   /* Connect to ATS scheduling */
   sched_ats = GNUNET_ATS_scheduling_init (mycfg, &address_suggest_cb, NULL);
   if (sched_ats == NULL)
diff --git a/src/ats/test_ats_solver_alternative_after_delete_address.c b/src/ats/test_ats_solver_alternative_after_delete_address.c
index 8a14b384e..907ecbfcb 100644
--- a/src/ats/test_ats_solver_alternative_after_delete_address.c
+++ b/src/ats/test_ats_solver_alternative_after_delete_address.c
@@ -45,6 +45,11 @@ static struct GNUNET_STATISTICS_Handle *stats;
 static struct GNUNET_ATS_SchedulingHandle *sched_ats;
 
 /**
+ * Connectivity handle
+ */
+static struct GNUNET_ATS_ConnectivityHandle *connect_ats;
+
+/**
  * Return value
  */
 static int ret;
@@ -125,12 +130,16 @@ stat_cb (void *cls, const char *subsystem, const char *name, uint64_t value,
 static void
 end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  if (die_task != NULL)
+  if (NULL != die_task)
   {
     GNUNET_SCHEDULER_cancel (die_task);
     die_task = NULL;
   }
-
+  if (NULL != connect_ats)
+  {
+    GNUNET_ATS_connectivity_done (connect_ats);
+    connect_ats = NULL;
+  }
   if (NULL != sched_ats)
   {
     GNUNET_ATS_scheduling_done (sched_ats);
@@ -313,7 +322,7 @@ stat_cb(void *cls, const char *subsystem,
                 "All addresses added, requesting....\n");
     /* We have 2 addresses, so we can request */
     addresses_added = GNUNET_YES;
-    GNUNET_ATS_suggest_address (sched_ats, &p.id);
+    GNUNET_ATS_connectivity_suggest (connect_ats, &p.id);
   }
   return GNUNET_OK;
 }
@@ -328,6 +337,7 @@ run (void *cls,
   stats = GNUNET_STATISTICS_create ("ats", mycfg);
   GNUNET_STATISTICS_watch (stats, "ats", "# addresses", &stat_cb, NULL);
 
+  connect_ats = GNUNET_ATS_connectivity_init (mycfg);
 
   /* Connect to ATS scheduling */
   sched_ats = GNUNET_ATS_scheduling_init (mycfg, &address_suggest_cb, NULL);
diff --git a/src/ats/test_ats_solver_convergence.c b/src/ats/test_ats_solver_convergence.c
index e33b138ac..c75ea543d 100644
--- a/src/ats/test_ats_solver_convergence.c
+++ b/src/ats/test_ats_solver_convergence.c
@@ -46,6 +46,11 @@ struct GNUNET_STATISTICS_Handle *stats;
 static struct GNUNET_ATS_SchedulingHandle *sched_ats;
 
 /**
+ * Connectivity handle
+ */
+static struct GNUNET_ATS_ConnectivityHandle *connect_ats;
+
+/**
  * Return value
  */
 static int ret;
@@ -125,6 +130,11 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     sched_ats = NULL;
   }
 
+  if (NULL != connect_ats)
+  {
+    GNUNET_ATS_connectivity_done (connect_ats);
+    connect_ats = NULL;
+  }
   GNUNET_STATISTICS_watch_cancel (stats, "ats", "# addresses", &stat_cb, NULL);
   if (NULL != stats)
   {
@@ -219,7 +229,7 @@ stat_cb(void *cls, const char *subsystem,
               "ATS statistics: `%s' `%s' %llu\n",
               subsystem,name,
               (unsigned long long) value);
-  GNUNET_ATS_suggest_address (sched_ats, &p.id);
+  GNUNET_ATS_connectivity_suggest (connect_ats, &p.id);
   return GNUNET_OK;
 }
 
@@ -233,6 +243,7 @@ run (void *cls, const struct GNUNET_CONFIGURATION_Handle *mycfg,
   stats = GNUNET_STATISTICS_create ("ats", mycfg);
   GNUNET_STATISTICS_watch (stats, "ats", "# addresses", &stat_cb, NULL);
 
+  connect_ats = GNUNET_ATS_connectivity_init (mycfg);
   /* Connect to ATS scheduling */
   sched_ats = GNUNET_ATS_scheduling_init (mycfg, &address_suggest_cb, NULL);
   if (sched_ats == NULL)
diff --git a/src/ats/test_ats_solver_preferences.c b/src/ats/test_ats_solver_preferences.c
index 611f639bf..5c2206c26 100644
--- a/src/ats/test_ats_solver_preferences.c
+++ b/src/ats/test_ats_solver_preferences.c
@@ -51,7 +51,12 @@ static struct GNUNET_STATISTICS_Handle *stats;
 static struct GNUNET_ATS_SchedulingHandle *sched_ats;
 
 /**
- * Scheduling handle
+ * Connectivity handle
+ */
+static struct GNUNET_ATS_ConnectivityHandle *connect_ats;
+
+/**
+ * Performance handle
  */
 static struct GNUNET_ATS_PerformanceHandle *perf_ats;
 
@@ -95,6 +100,7 @@ static int
 stat_cb (void *cls, const char *subsystem, const char *name, uint64_t value,
     int is_persistent);
 
+
 static void
 end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
@@ -111,7 +117,11 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_ATS_scheduling_done (sched_ats);
     sched_ats = NULL;
   }
-
+  if (NULL != connect_ats)
+  {
+    GNUNET_ATS_connectivity_done (connect_ats);
+    connect_ats = NULL;
+  }
   if (NULL != perf_ats)
   {
     GNUNET_ATS_performance_done (perf_ats);
@@ -203,6 +213,7 @@ stat_cb (void *cls, const char *subsystem, const char *name, uint64_t value,
   return GNUNET_OK;
 }
 
+
 static void
 run (void *cls, const struct GNUNET_CONFIGURATION_Handle *mycfg,
     struct GNUNET_TESTING_Peer *peer)
@@ -212,6 +223,8 @@ run (void *cls, const struct GNUNET_CONFIGURATION_Handle *mycfg,
   stats = GNUNET_STATISTICS_create ("ats", mycfg);
   GNUNET_STATISTICS_watch (stats, "ats", "# active performance clients", &stat_cb, NULL );
 
+  connect_ats = GNUNET_ATS_connectivity_init (mycfg);
+
   /* Connect to ATS scheduling */
   sched_ats = GNUNET_ATS_scheduling_init (mycfg, &address_suggest_cb, NULL );
   if (sched_ats == NULL )
@@ -258,7 +271,7 @@ run (void *cls, const struct GNUNET_CONFIGURATION_Handle *mycfg,
   /* Adding address */
   GNUNET_ATS_address_add (sched_ats, &test_hello_address, test_session,
       test_ats_info, test_ats_count);
-  GNUNET_ATS_suggest_address(sched_ats, &test_hello_address.peer);
+  GNUNET_ATS_connectivity_suggest (connect_ats, &test_hello_address.peer);
 }
 
 
diff --git a/src/ats/test_ats_solver_request_and_add_address.c b/src/ats/test_ats_solver_request_and_add_address.c
index 664861b82..75f6bfb99 100644
--- a/src/ats/test_ats_solver_request_and_add_address.c
+++ b/src/ats/test_ats_solver_request_and_add_address.c
@@ -51,6 +51,11 @@ static struct GNUNET_STATISTICS_Handle *stats;
 static struct GNUNET_ATS_SchedulingHandle *sched_ats;
 
 /**
+ * Connectivity handle
+ */
+static struct GNUNET_ATS_ConnectivityHandle *connect_ats;
+
+/**
  * Return value
  */
 static int ret;
@@ -105,7 +110,11 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_ATS_scheduling_done (sched_ats);
     sched_ats = NULL;
   }
-
+  if (NULL != connect_ats)
+  {
+    GNUNET_ATS_connectivity_done (connect_ats);
+    connect_ats = NULL;
+  }
   GNUNET_STATISTICS_watch_cancel (stats, "ats", "# addresses", &stat_cb, NULL);
   if (NULL != stats)
   {
@@ -165,7 +174,7 @@ run (void *cls, const struct GNUNET_CONFIGURATION_Handle *mycfg,
   stats = GNUNET_STATISTICS_create ("ats", mycfg);
   GNUNET_STATISTICS_watch (stats, "ats", "# addresses", &stat_cb, NULL);
 
-
+  connect_ats = GNUNET_ATS_connectivity_init (mycfg);
   /* Connect to ATS scheduling */
   sched_ats = GNUNET_ATS_scheduling_init (mycfg, &address_suggest_cb, NULL);
   if (sched_ats == NULL)
@@ -196,7 +205,7 @@ run (void *cls, const struct GNUNET_CONFIGURATION_Handle *mycfg,
   test_hello_address.address_length = test_addr.addr_len;
 
   /* Request */
-  GNUNET_ATS_suggest_address (sched_ats, &p.id);
+  GNUNET_ATS_connectivity_suggest (connect_ats, &p.id);
 
 
   /* Adding address */
diff --git a/src/ats/test_ats_solver_request_and_delete_address.c b/src/ats/test_ats_solver_request_and_delete_address.c
index 037d26971..089b4b015 100644
--- a/src/ats/test_ats_solver_request_and_delete_address.c
+++ b/src/ats/test_ats_solver_request_and_delete_address.c
@@ -45,6 +45,11 @@ static struct GNUNET_STATISTICS_Handle *stats;
 static struct GNUNET_ATS_SchedulingHandle *sched_ats;
 
 /**
+ * Connectivity handle
+ */
+static struct GNUNET_ATS_ConnectivityHandle *connect_ats;
+
+/**
  * Return value
  */
 static int ret;
@@ -108,6 +113,11 @@ end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     sched_ats = NULL;
   }
 
+  if (NULL != connect_ats)
+  {
+    GNUNET_ATS_connectivity_done (connect_ats);
+    connect_ats = NULL;
+  }
   GNUNET_STATISTICS_watch_cancel (stats, "ats", "# addresses", &stat_cb, NULL);
   if (NULL != stats)
   {
@@ -178,7 +188,7 @@ stat_cb (void *cls, const char *subsystem,
          const char *name, uint64_t value,
          int is_persistent)
 {
-  static struct GNUNET_ATS_SuggestHandle *sh;
+  static struct GNUNET_ATS_ConnectivitySuggestHandle *sh;
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "ATS statistics: `%s' `%s' %llu\n",
@@ -186,7 +196,7 @@ stat_cb (void *cls, const char *subsystem,
               name,
               value);
   if (NULL == sh)
-    sh = GNUNET_ATS_suggest_address (sched_ats, &p.id);
+    sh = GNUNET_ATS_connectivity_suggest (connect_ats, &p.id);
   return GNUNET_OK;
 }
 
@@ -200,6 +210,7 @@ run (void *cls,
   stats = GNUNET_STATISTICS_create ("ats", mycfg);
   GNUNET_STATISTICS_watch (stats, "ats", "# addresses", &stat_cb, NULL);
 
+  connect_ats = GNUNET_ATS_connectivity_init (mycfg);
 
   /* Connect to ATS scheduling */
   sched_ats = GNUNET_ATS_scheduling_init (mycfg, &address_suggest_cb, NULL);
diff --git a/src/include/gnunet_ats_service.h b/src/include/gnunet_ats_service.h
index 74e7c7c80..d506f41ff 100644
--- a/src/include/gnunet_ats_service.h
+++ b/src/include/gnunet_ats_service.h
@@ -304,17 +304,68 @@ struct GNUNET_ATS_Information
 };
 GNUNET_NETWORK_STRUCT_END
 
-/* ******************************** Scheduling API ***************************** */
+
+/* ********************Connection Suggestion API ***************************** */
 
 /**
- * Handle to the ATS subsystem for bandwidth/transport scheduling information.
+ * Handle to the ATS subsystem for making suggestions about
+ * connections the peer would like to have.
  */
-struct GNUNET_ATS_SchedulingHandle;
+struct GNUNET_ATS_ConnectivityHandle;
+
+/**
+ * Handle for address suggestion requests.
+ */
+struct GNUNET_ATS_ConnectivitySuggestHandle;
+
+
+/**
+ * Initialize the ATS connectivity suggestion client handle.
+ *
+ * @param cfg configuration to use
+ * @return ats connectivity handle, NULL on error
+ */
+struct GNUNET_ATS_ConnectivityHandle *
+GNUNET_ATS_connectivity_init (const struct GNUNET_CONFIGURATION_Handle *cfg);
+
 
 /**
- * Handle for address suggestion requests
+ * Shutdown ATS connectivity suggestion client.
+ *
+ * @param ch handle to destroy
+ */
+void
+GNUNET_ATS_connectivity_done (struct GNUNET_ATS_ConnectivityHandle *ch);
+
+
+/**
+ * We would like to establish a new connection with a peer.  ATS
+ * should suggest a good address to begin with.
+ *
+ * @param ch handle
+ * @param peer identity of the peer we need an address for
+ * @return suggestion handle, NULL if request is already pending
  */
-struct GNUNET_ATS_SuggestHandle;
+struct GNUNET_ATS_ConnectivitySuggestHandle *
+GNUNET_ATS_connectivity_suggest (struct GNUNET_ATS_ConnectivityHandle *ch,
+                                 const struct GNUNET_PeerIdentity *peer);
+
+
+/**
+ * We no longer care about being connected to a peer.
+ *
+ * @param sh handle
+ */
+void
+GNUNET_ATS_connectivity_suggest_cancel (struct GNUNET_ATS_ConnectivitySuggestHandle *sh);
+
+
+/* ******************************** Scheduling API ***************************** */
+
+/**
+ * Handle to the ATS subsystem for bandwidth/transport scheduling information.
+ */
+struct GNUNET_ATS_SchedulingHandle;
 
 /**
  * Opaque session handle, defined by plugins.  Contents not known to ATS.
@@ -343,7 +394,7 @@ typedef void
 
 
 /**
- * Initialize the ATS subsystem.
+ * Initialize the ATS scheduling subsystem.
  *
  * @param cfg configuration to use
  * @param suggest_cb notification to call whenever the suggestation changed
@@ -377,30 +428,6 @@ GNUNET_ATS_reset_backoff (struct GNUNET_ATS_SchedulingHandle *sh,
 
 
 /**
- * We would like to establish a new connection with a peer.  ATS
- * should suggest a good address to begin with.
- *
- * @param sh handle
- * @param peer identity of the peer we need an address for
- * @return suggestion handle, NULL if a request is already pending
- */
-struct GNUNET_ATS_SuggestHandle *
-GNUNET_ATS_suggest_address (struct GNUNET_ATS_SchedulingHandle *sh,
-                            const struct GNUNET_PeerIdentity *peer);
-
-
-/**
- * We want to cancel ATS suggesting addresses for a peer.
- *
- * @param sh handle
- * @param peer identity of the peer
- */
-void
-GNUNET_ATS_suggest_address_cancel (struct GNUNET_ATS_SchedulingHandle *sh,
-                                   const struct GNUNET_PeerIdentity *peer);
-
-
-/**
  * Convert a ATS property to a string
  *
  * @param type the property type
diff --git a/src/transport/gnunet-service-transport.c b/src/transport/gnunet-service-transport.c
index 2f0a17360..e65af664c 100644
--- a/src/transport/gnunet-service-transport.c
+++ b/src/transport/gnunet-service-transport.c
@@ -122,11 +122,16 @@ static struct GNUNET_SERVER_Handle *GST_server;
 struct GNUNET_CRYPTO_EddsaPrivateKey *GST_my_private_key;
 
 /**
- * ATS handle.
+ * ATS scheduling handle.
  */
 struct GNUNET_ATS_SchedulingHandle *GST_ats;
 
 /**
+ * ATS connectivity handle.
+ */
+struct GNUNET_ATS_ConnectivityHandle *GST_ats_connect;
+
+/**
  * Hello address expiration
  */
 struct GNUNET_TIME_Relative hello_expiration;
@@ -857,6 +862,8 @@ shutdown_task (void *cls,
   GST_ats_done ();
   GNUNET_ATS_scheduling_done (GST_ats);
   GST_ats = NULL;
+  GNUNET_ATS_connectivity_done (GST_ats_connect);
+  GST_ats_connect = NULL;
   GST_clients_stop ();
   GST_blacklist_stop ();
   GST_hello_stop ();
@@ -986,6 +993,7 @@ run (void *cls,
   GST_hello_start (friend_only, &process_hello_update, NULL );
   GNUNET_assert(NULL != GST_hello_get());
   GST_blacklist_start (GST_server, GST_cfg, &GST_my_identity);
+  GST_ats_connect = GNUNET_ATS_connectivity_init (GST_cfg);
   GST_ats = GNUNET_ATS_scheduling_init (GST_cfg,
                                         &ats_request_address_change,
                                         NULL);
diff --git a/src/transport/gnunet-service-transport.h b/src/transport/gnunet-service-transport.h
index 350ae5b6c..f60f18692 100644
--- a/src/transport/gnunet-service-transport.h
+++ b/src/transport/gnunet-service-transport.h
@@ -63,6 +63,11 @@ extern struct GNUNET_CRYPTO_EddsaPrivateKey *GST_my_private_key;
  */
 extern struct GNUNET_ATS_SchedulingHandle *GST_ats;
 
+/**
+ * ATS connectivity handle.
+ */
+extern struct GNUNET_ATS_ConnectivityHandle *GST_ats_connect;
+
 
 /**
  * Function to call when a peer's address has changed
diff --git a/src/transport/gnunet-service-transport_neighbours.c b/src/transport/gnunet-service-transport_neighbours.c
index bcbc4601e..49b026e7a 100644
--- a/src/transport/gnunet-service-transport_neighbours.c
+++ b/src/transport/gnunet-service-transport_neighbours.c
@@ -373,7 +373,7 @@ struct NeighbourMapEntry
   /**
    * ATS address suggest handle
    */
-  struct GNUNET_ATS_SuggestHandle *suggest_handle;
+  struct GNUNET_ATS_ConnectivitySuggestHandle *suggest_handle;
 
   /**
    * Time where we should cut the connection (timeout) if we don't
@@ -1047,7 +1047,7 @@ free_neighbour (struct NeighbourMapEntry *n,
   /* Cancel address requests for this peer */
   if (NULL != n->suggest_handle)
   {
-    GNUNET_ATS_suggest_address_cancel (GST_ats, &n->id);
+    GNUNET_ATS_connectivity_suggest_cancel (n->suggest_handle);
     n->suggest_handle = NULL;
   }
 
@@ -2173,8 +2173,8 @@ try_connect_bl_check_cont (void *cls,
                          GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
   GNUNET_ATS_reset_backoff (GST_ats, peer);
   GNUNET_assert (NULL == n->suggest_handle);
-  n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats,
-                                                  peer);
+  n->suggest_handle = GNUNET_ATS_connectivity_suggest (GST_ats_connect,
+                                                       peer);
 }
 
 
@@ -2321,7 +2321,8 @@ GST_neighbours_handle_session_syn (const struct GNUNET_MessageHeader *message,
     set_state_and_timeout (n, GNUNET_TRANSPORT_PS_SYN_RECV_ATS,
         GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
     if (NULL == n->suggest_handle)
-      n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, peer);
+      n->suggest_handle = GNUNET_ATS_connectivity_suggest (GST_ats_connect,
+                                                           peer);
     break;
   case GNUNET_TRANSPORT_PS_INIT_ATS:
     /* SYN message takes priority over us asking ATS for address:
@@ -2375,7 +2376,8 @@ GST_neighbours_handle_session_syn (const struct GNUNET_MessageHeader *message,
     n->ack_state = ACK_SEND_SYN_ACK;
     n->connect_ack_timestamp = ts;
     /* Request an address for the peer */
-    n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, peer);
+    n->suggest_handle = GNUNET_ATS_connectivity_suggest (GST_ats_connect,
+                                                         peer);
     GNUNET_ATS_reset_backoff (GST_ats, peer);
     set_state (n, GNUNET_TRANSPORT_PS_SYN_RECV_ATS);
     break;