1 files changed, 83 insertions, 1083 deletions

diff --git a/src/ats/gnunet-service-ats_addresses.c b/src/ats/gnunet-service-ats_addresses.c
index 1d2c9d3e5..9ef6a3838 100644
--- a/src/ats/gnunet-service-ats_addresses.c
+++ b/src/ats/gnunet-service-ats_addresses.c
@@ -26,11 +26,11 @@
  */
 #include "platform.h"
 #include "gnunet_ats_service.h"
-#include "gnunet_ats_plugin.h"
 #include "gnunet-service-ats.h"
 #include "gnunet-service-ats_addresses.h"
 #include "gnunet-service-ats_normalization.h"
 #include "gnunet-service-ats_performance.h"
+#include "gnunet-service-ats_plugins.h"
 #include "gnunet-service-ats_scheduling.h"
 #include "gnunet-service-ats_reservations.h"
 
@@ -216,110 +216,13 @@
  */
 
 
-/**
- * Pending Address suggestion requests
- */
-struct GAS_Addresses_Suggestion_Requests
-{
-  /**
-   * Next in DLL
-   */
-  struct GAS_Addresses_Suggestion_Requests *next;
-
-  /**
-   * Previous in DLL
-   */
-  struct GAS_Addresses_Suggestion_Requests *prev;
-
-  /**
-   * Peer ID
-   */
-  struct GNUNET_PeerIdentity id;
-};
-
-/**
- * Pending Address suggestion requests
- */
-struct GAS_Addresses_Preference_Clients
-{
-  /**
-   * Next in DLL
-   */
-  struct GAS_Addresses_Preference_Clients *next;
-
-  /**
-   * Previous in DLL
-   */
-  struct GAS_Addresses_Preference_Clients *prev;
-
-  /**
-   * Peer ID
-   */
-  void *client;
-};
 
 
 /**
- *
- */
-static struct GNUNET_STATISTICS_Handle *stats;
-
-/**
  * A multihashmap to store all addresses
  */
-static struct GNUNET_CONTAINER_MultiPeerMap *addresses;
+struct GNUNET_CONTAINER_MultiPeerMap *GSA_addresses;
 
-/**
- * Is ATS addresses running
- */
-static int running;
-
-/**
- * Preferences clients
- */
-static int pref_clients;
-
-/**
- * Configured ATS solver
- */
-static int ats_mode;
-
-/**
- * Solver handle
- */
-static void *solver;
-
-/**
- * Address suggestion requests DLL head.
- * FIXME: This must become a Multipeermap! O(n) operations
- * galore instead of O(1)!!!
- */
-static struct GAS_Addresses_Suggestion_Requests *pending_requests_head;
-
-/**
- * Address suggestion requests DLL tail
- */
-static struct GAS_Addresses_Suggestion_Requests *pending_requests_tail;
-
-/**
- * Preference requests DLL head
- */
-static struct GAS_Addresses_Preference_Clients *preference_clients_head;
-
-/**
- * Preference requests DLL head
- */
-static struct GAS_Addresses_Preference_Clients *preference_clients_tail;
-
-/**
- * Solver functions
- */
-static struct GNUNET_ATS_PluginEnvironment env;
-
-/**
- * Solver plugin name as string
- */
-static char *plugin;
 
 /**
  * Value we pass for zero bandwidth.
@@ -613,7 +516,7 @@ find_equivalent_address (const struct GNUNET_PeerIdentity *peer,
   cac.exact_address = NULL;
   cac.base_address = NULL;
   cac.search = addr;
-  GNUNET_CONTAINER_multipeermap_get_multiple (addresses,
+  GNUNET_CONTAINER_multipeermap_get_multiple (GSA_addresses,
                                               peer,
                                               &compare_address_it, &cac);
 
@@ -681,7 +584,7 @@ find_exact_address (const struct GNUNET_PeerIdentity *peer,
 
   fac.exact_address = NULL;
   fac.session_id = session_id;
-  GNUNET_CONTAINER_multipeermap_get_multiple (addresses,
+  GNUNET_CONTAINER_multipeermap_get_multiple (GSA_addresses,
                                               peer,
                                               &find_address_cb, &fac);
   return fac.exact_address;
@@ -689,38 +592,6 @@ find_exact_address (const struct GNUNET_PeerIdentity *peer,
 
 
 /**
- * Function allowing the solver to obtain normalized preference
- * values from solver
- *
- * @param cls unused
- * @param id the peer to return the normalized properties for
- * @return array of double values with |GNUNET_ATS_PreferenceCount| elements
- */
-const double *
-get_preferences_cb (void *cls,
-                    const struct GNUNET_PeerIdentity *id)
-{
-  return GAS_normalization_get_preferences_by_peer (id);
-}
-
-
-/**
- * Function allowing the solver to obtain normalized property
- * values for an address from solver
- *
- * @param cls unused
- * @param address the address
- * @return array of double values with |GNUNET_ATS_QualityPropertiesCount| elements
- */
-const double *
-get_property_cb (void *cls,
-                 const struct ATS_Address *address)
-{
-  return GAS_normalization_get_properties (address);
-}
-
-
-/**
  * Extract an ATS performance info from an address
  *
  * @param address the address
@@ -772,18 +643,11 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
   struct GNUNET_ATS_Information *atsi_delta;
   uint32_t atsi_delta_count;
   uint32_t addr_net;
-  uint32_t previous_session;
-  int c1;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' for peer `%s'\n",
               "ADDRESS ADD",
               GNUNET_i2s (peer));
-  if (GNUNET_NO == running)
-  {
-    GNUNET_break (0);
-    return;
-  }
   new_address = create_address (peer,
                                 plugin_name,
                                 plugin_addr,
@@ -802,127 +666,51 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
 
   /* Get existing address or address with session == 0 */
   existing_address = find_equivalent_address (peer, new_address);
-  if (NULL == existing_address)
+  if (NULL != existing_address)
   {
-    /* Add a new address */
-    new_address->t_added = GNUNET_TIME_absolute_get();
-    new_address->t_last_activity = GNUNET_TIME_absolute_get();
-    GNUNET_assert(GNUNET_OK ==
-                  GNUNET_CONTAINER_multipeermap_put (addresses,
-                                                     peer,
-                                                     new_address,
-                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-
-    GNUNET_STATISTICS_set (stats,
-                           "# addresses",
-                           GNUNET_CONTAINER_multipeermap_size (addresses),
-                           GNUNET_NO);
-
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Adding new address %p for peer `%s', length %u, session id %u, %s\n",
-                new_address,
-                GNUNET_i2s (peer),
-                plugin_addr_len,
-                session_id,
-                GNUNET_ATS_print_network_type (addr_net));
-
-    /* Tell solver about new address */
-    env.sf.s_add (solver, new_address, addr_net);
-
-    env.sf.s_bulk_start (solver);
-    GAS_normalization_normalize_property (addresses,
-                                          new_address,
-                                          atsi,
-                                          atsi_count);
-    env.sf.s_bulk_stop (solver);
-
-    /* Notify performance clients about new address */
-    GAS_performance_notify_all_clients (&new_address->peer, new_address->plugin,
-        new_address->addr, new_address->addr_len, new_address->active,
-        new_address->atsi, new_address->atsi_count,
-        GNUNET_BANDWIDTH_value_init (new_address->assigned_bw_out),
-        GNUNET_BANDWIDTH_value_init (new_address->assigned_bw_in));
-    return;
-  }
-
-  /* FIXME: this case should probably not be allowed... */
-  /* We have an existing address we can use, clean up new */
-  GNUNET_free(new_address->plugin);
-  GNUNET_free_non_null(new_address->atsi);
-  GNUNET_free(new_address);
-  new_address = NULL;
-
-  if (0 != existing_address->session_id)
-  {
-    /* Should not happen */
-    GNUNET_break(0);
+    GNUNET_break (0);
+    GNUNET_free(new_address->plugin);
+    GNUNET_free_non_null(new_address->atsi);
+    GNUNET_free(new_address);
     return;
   }
-
-  addr_net = get_performance_info (existing_address, GNUNET_ATS_NETWORK_TYPE);
-  if (GNUNET_ATS_VALUE_UNDEFINED == addr_net)
-    addr_net = GNUNET_ATS_NET_UNSPECIFIED;
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-      "Found existing address for peer `%s' %p with new session %u in network %s\n",
-      GNUNET_i2s (peer), existing_address, session_id,
-      GNUNET_ATS_print_network_type (addr_net));
-  /* We have an address without an session, update this address */
-  existing_address->t_added = GNUNET_TIME_absolute_get();
-  existing_address->t_last_activity = GNUNET_TIME_absolute_get();
-  atsi_delta = NULL;
-  atsi_delta_count = 0;
-  if (GNUNET_YES
-      == disassemble_ats_information (existing_address, atsi, atsi_count,
-          &atsi_delta, &atsi_delta_count))
-  {
-    /* Notify performance clients about properties */
-    GAS_performance_notify_all_clients (&existing_address->peer,
-        existing_address->plugin, existing_address->addr,
-        existing_address->addr_len, existing_address->active,
-        existing_address->atsi, existing_address->atsi_count,
-        GNUNET_BANDWIDTH_value_init (existing_address->assigned_bw_out),
-        GNUNET_BANDWIDTH_value_init (existing_address->assigned_bw_in));
-
-    for (c1 = 0; c1 < atsi_delta_count; c1++)
-    {
-      if ((GNUNET_ATS_NETWORK_TYPE == ntohl (atsi_delta[c1].type))
-          && (addr_net != ntohl (atsi_delta[c1].value)))
-      {
-        /* Network type changed */
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-            "Address for peer `%s' %p changed from network %s to %s\n",
-            GNUNET_i2s (peer), existing_address,
-            GNUNET_ATS_print_network_type (addr_net),
-            GNUNET_ATS_print_network_type (ntohl (atsi_delta[c1].value)));
-        env.sf.s_address_update_network (solver, existing_address,
-            ntohl (atsi_delta[c1].value),
-            get_performance_info (existing_address, GNUNET_ATS_NETWORK_TYPE));
-        addr_net = get_performance_info (existing_address,
-            GNUNET_ATS_NETWORK_TYPE);
-      }
-    }
-    /* Notify solver about update with atsi information and session */
-    env.sf.s_bulk_start (solver);
-    GAS_normalization_normalize_property (addresses, existing_address,
-                                          atsi, atsi_count);
-    env.sf.s_bulk_stop (solver);
-  }
-  GNUNET_free_non_null(atsi_delta);
-
-  /* Notify solver about new session */
-  if (existing_address->session_id == session_id)
-    return; /* possible, can both be 0 since address is revalidated */
-
-  previous_session = existing_address->session_id;
-  existing_address->session_id = session_id;
-  env.sf.s_address_update_session (solver, existing_address,
-      previous_session, session_id);
-
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-      "Updated existing address for peer `%s' %p length %u with new session %u in network %s\n",
-      GNUNET_i2s (peer), existing_address, existing_address->addr_len,
-      session_id, GNUNET_ATS_print_network_type (addr_net));
+  /* Add a new address */
+  new_address->t_added = GNUNET_TIME_absolute_get();
+  new_address->t_last_activity = GNUNET_TIME_absolute_get();
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_CONTAINER_multipeermap_put (GSA_addresses,
+                                                   peer,
+                                                   new_address,
+                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  
+  GNUNET_STATISTICS_set (GSA_stats,
+                         "# addresses",
+                         GNUNET_CONTAINER_multipeermap_size (GSA_addresses),
+                         GNUNET_NO);
+  
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Adding new address %p for peer `%s', length %u, session id %u, %s\n",
+              new_address,
+              GNUNET_i2s (peer),
+              plugin_addr_len,
+              session_id,
+              GNUNET_ATS_print_network_type (addr_net));
+  
+  /* Tell solver about new address */
+  GAS_plugin_new_address (new_address,
+                          addr_net,
+                          atsi,
+                          atsi_count);
+  /* Notify performance clients about new address */
+  GAS_performance_notify_all_clients (&new_address->peer, 
+                                      new_address->plugin,
+                                      new_address->addr,
+                                      new_address->addr_len, 
+                                      new_address->active,
+                                      new_address->atsi, 
+                                      new_address->atsi_count,
+                                      GNUNET_BANDWIDTH_value_init (new_address->assigned_bw_out),
+                                      GNUNET_BANDWIDTH_value_init (new_address->assigned_bw_in));
 }
 
 
@@ -943,12 +731,6 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
   struct ATS_Address *aa;
   struct GNUNET_ATS_Information *atsi_delta;
   uint32_t atsi_delta_count;
-  uint32_t prev_session;
-  int c1;
-
-  if (GNUNET_NO == running)
-    return;
-  GNUNET_assert (NULL != addresses);
 
   /* Get existing address */
   aa = find_exact_address (peer,
@@ -963,7 +745,6 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
     GNUNET_break (0);
     return;
   }
-
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' for peer `%s' address \n",
               "ADDRESS UPDATE",
@@ -972,17 +753,6 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
 
   /* Update address */
   aa->t_last_activity = GNUNET_TIME_absolute_get();
-  if (session_id != aa->session_id)
-  {
-    /* Session changed */
-    prev_session = aa->session_id;
-    aa->session_id = session_id;
-    env.sf.s_address_update_session (solver,
-                                     aa,
-                                     prev_session,
-                                     aa->session_id);
-  }
-
   atsi_delta = NULL;
   atsi_delta_count = 0;
   if (GNUNET_YES ==
@@ -991,30 +761,20 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
                                    &atsi_delta,
                                    &atsi_delta_count))
   {
-    /* ATS properties changed */
-    for (c1 = 0; c1 < atsi_delta_count; c1++)
-    {
-      if (GNUNET_ATS_NETWORK_TYPE == ntohl (atsi_delta[c1].type))
-      {
-        /* Network type changed */
-        env.sf.s_address_update_network (solver, aa,
-            ntohl (atsi_delta[c1].value),
-            get_performance_info (aa, GNUNET_ATS_NETWORK_TYPE));
-      }
-    }
-
     /* Notify performance clients about updated address */
-    GAS_performance_notify_all_clients (&aa->peer, aa->plugin, aa->addr,
-        aa->addr_len, aa->active, aa->atsi, aa->atsi_count,
-        GNUNET_BANDWIDTH_value_init (aa->assigned_bw_out),
-        GNUNET_BANDWIDTH_value_init (aa->assigned_bw_in));
-
-    env.sf.s_bulk_start (solver);
-    GAS_normalization_normalize_property (addresses,
-                                          aa,
-                                          atsi,
-                                          atsi_count);
-    env.sf.s_bulk_stop (solver);
+    GAS_performance_notify_all_clients (&aa->peer, 
+                                        aa->plugin,
+                                        aa->addr,
+                                        aa->addr_len, 
+                                        aa->active, 
+                                        aa->atsi,
+                                        aa->atsi_count,
+                                        GNUNET_BANDWIDTH_value_init (aa->assigned_bw_out),
+                                        GNUNET_BANDWIDTH_value_init (aa->assigned_bw_in));
+
+    GAS_plugin_update_address (aa,
+                               atsi,
+                               atsi_count);
   }
   GNUNET_free_non_null (atsi_delta);
 }
@@ -1032,9 +792,6 @@ GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer,
 {
   struct ATS_Address *ea;
 
-  if (GNUNET_NO == running)
-    return;
-
   /* Get existing address */
   ea = find_exact_address (peer,
                            session_id);
@@ -1054,11 +811,10 @@ GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer,
               GNUNET_i2s (peer),
               ea,
               session_id);
-  GNUNET_CONTAINER_multipeermap_remove (addresses,
+  GNUNET_CONTAINER_multipeermap_remove (GSA_addresses,
                                         peer,
                                         ea);
-
-  env.sf.s_del (solver, ea, GNUNET_NO);
+  GAS_plugin_delete_address (ea);
   GAS_performance_notify_all_clients (peer,
                                       ea->plugin,
                                       ea->addr,
@@ -1068,607 +824,14 @@ GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer,
                                       zero_bw,
                                       zero_bw);
   free_address (ea);
-  GNUNET_STATISTICS_set (stats,
+  GNUNET_STATISTICS_set (GSA_stats,
                          "# addresses",
-                         GNUNET_CONTAINER_multipeermap_size (addresses),
+                         GNUNET_CONTAINER_multipeermap_size (GSA_addresses),
                          GNUNET_NO);
 }
 
 
-/**
- * Cancel address suggestions for a peer
- *
- * @param peer the peer id
- */
-void
-GAS_addresses_request_address_cancel (const struct GNUNET_PeerIdentity *peer)
-{
-  struct GAS_Addresses_Suggestion_Requests *cur = pending_requests_head;
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received request: `%s' for peer %s\n",
-             "request_address_cancel",
-             GNUNET_i2s (peer));
-
-  while (NULL != cur)
-  {
-    if (0 == memcmp (peer, &cur->id, sizeof(cur->id)))
-      break; /* found */
-    cur = cur->next;
-  }
-
-  if (NULL == cur)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "No address requests pending for peer `%s', cannot remove!\n",
-                GNUNET_i2s (peer));
-    return;
-  }
-  env.sf.s_get_stop (solver, peer);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Removed request pending for peer `%s\n",
-              GNUNET_i2s (peer));
-  GNUNET_CONTAINER_DLL_remove (pending_requests_head,
-                               pending_requests_tail,
-                               cur);
-  GNUNET_free(cur);
-}
-
-
-/**
- * Request address suggestions for a peer
- *
- * @param peer the peer id
- */
-void
-GAS_addresses_request_address (const struct GNUNET_PeerIdentity *peer)
-{
-  struct GAS_Addresses_Suggestion_Requests *cur = pending_requests_head;
-  struct ATS_Address *aa;
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received `%s' for peer `%s'\n",
-             "REQUEST ADDRESS",
-             GNUNET_i2s (peer));
-
-  if (GNUNET_NO == running)
-    return;
-  while (NULL != cur)
-  {
-    if (0 == memcmp (peer, &cur->id, sizeof(cur->id)))
-      break; /* already suggesting */
-    cur = cur->next;
-  }
-  if (NULL == cur)
-  {
-    cur = GNUNET_new (struct GAS_Addresses_Suggestion_Requests);
-    cur->id = *peer;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Adding new address suggestion request for `%s'\n",
-                GNUNET_i2s (peer));
-    GNUNET_CONTAINER_DLL_insert (pending_requests_head,
-                                 pending_requests_tail,
-                                 cur);
-  }
-
-  /* Get prefered address from solver */
-  aa = (struct ATS_Address *) env.sf.s_get (solver, peer);
-  if (NULL == aa)
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Cannot suggest address for peer `%s'\n",
-        GNUNET_i2s (peer));
-    return;
-  }
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Suggesting address %p for peer `%s'\n",
-      aa, GNUNET_i2s (peer));
-
-  GAS_scheduling_transmit_address_suggestion (peer,
-                                              aa->session_id,
-                                              GNUNET_BANDWIDTH_value_init (aa->assigned_bw_out),
-                                              GNUNET_BANDWIDTH_value_init (aa->assigned_bw_in));
-
-  aa->block_interval = GNUNET_TIME_relative_add (aa->block_interval,
-      ATS_BLOCKING_DELTA);
-  aa->blocked_until = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
-      aa->block_interval);
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-      "Address %p ready for suggestion, block interval now %llu \n", aa,
-      aa->block_interval);
-}
-
-
-/**
- * Solver information callback
- *
- * @param cls the closure
- * @param op the operation
- * @param status operation status
- * @param add additional information
- */
-static void
-solver_info_cb (void *cls,
-    enum GAS_Solver_Operation op,
-    enum GAS_Solver_Status status,
-    enum GAS_Solver_Additional_Information add)
-{
-  char *add_info;
-
-  switch (add) {
-    case GAS_INFO_NONE:
-      add_info = "GAS_INFO_NONE";
-      break;
-    case GAS_INFO_FULL:
-      add_info = "GAS_INFO_MLP_FULL";
-      break;
-    case GAS_INFO_UPDATED:
-      add_info = "GAS_INFO_MLP_UPDATED";
-      break;
-    case GAS_INFO_PROP_ALL:
-      add_info = "GAS_INFO_PROP_ALL";
-      break;
-    case GAS_INFO_PROP_SINGLE:
-      add_info = "GAS_INFO_PROP_SINGLE";
-      break;
-    default:
-      add_info = "INVALID";
-      break;
-  }
-  switch (op)
-  {
-    case GAS_OP_SOLVE_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-          "Solver notifies `%s' with result `%s' `%s'\n", "GAS_OP_SOLVE_START",
-          (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL", add_info);
-      return;
-    case GAS_OP_SOLVE_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-          "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_STOP",
-          (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL", add_info);
-      return;
-
-    case GAS_OP_SOLVE_SETUP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-          "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_SETUP_START",
-          (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    case GAS_OP_SOLVE_SETUP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-          "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_SETUP_STOP",
-          (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    case GAS_OP_SOLVE_MLP_LP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-          "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_LP_START",
-          (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-    case GAS_OP_SOLVE_MLP_LP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-          "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_LP_STOP",
-          (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-
-    case GAS_OP_SOLVE_MLP_MLP_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-          "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_MLP_START",
-          (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-    case GAS_OP_SOLVE_MLP_MLP_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-          "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_MLP_STOP",
-          (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-    case GAS_OP_SOLVE_UPDATE_NOTIFICATION_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-          "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_UPDATE_NOTIFICATION_START",
-          (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-    case GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-          "Solver notifies `%s' with result `%s'\n", "GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP",
-          (GAS_STAT_SUCCESS == status) ? "SUCCESS" : "FAIL");
-      return;
-    default:
-      break;
-    }
-}
-
-
-/**
- * The preference changed for a peer
- *
- * @param cls NULL
- * @param peer the peer
- * @param kind the ATS kind
- * @param pref_rel the new relative preference value
- */
-static void
-normalized_preference_changed_cb (void *cls,
-                                  const struct GNUNET_PeerIdentity *peer,
-                                  enum GNUNET_ATS_PreferenceKind kind,
-                                  double pref_rel)
-{
-  /* Tell solver about update */
-  env.sf.s_pref (solver, peer, kind, pref_rel);
-}
-
-
-/**
- * The relative value for a property changed
- *
- * @param cls NULL
- * @param address the peer
- * @param type the ATS type
- * @param prop_rel the new relative preference value
- */
-static void
-normalized_property_changed_cb (void *cls,
-                                struct ATS_Address *address,
-                                uint32_t type,
-                                double prop_rel)
-{
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Normalized property %s for peer `%s' changed to %.3f \n",
-             GNUNET_ATS_print_property_type (type),
-             GNUNET_i2s (&address->peer),
-             prop_rel);
-  env.sf.s_address_update_property (solver,
-                                    address,
-                                    type,
-                                    0,
-                                    prop_rel);
-}
-
-
-static struct GAS_Addresses_Preference_Clients *
-find_preference_client (void *client)
-{
-  struct GAS_Addresses_Preference_Clients *cur;
 
-  for (cur = preference_clients_head; NULL != cur; cur = cur->next)
-    if (cur->client == client)
-      return cur;
-  return NULL;
-}
-
-
-/**
- * A performance client disconnected
- *
- * @param client the client
- */
-void
-GAS_addresses_preference_client_disconnect (void *client)
-{
-  struct GAS_Addresses_Preference_Clients *pc;
-
-  if (NULL != (pc = find_preference_client (client)))
-  {
-    GNUNET_CONTAINER_DLL_remove (preference_clients_head,
-                                 preference_clients_tail,
-                                 pc);
-    GNUNET_free (pc);
-    GNUNET_assert (pref_clients > 0);
-    pref_clients --;
-    GNUNET_STATISTICS_set (stats,
-                           "# active performance clients",
-                           pref_clients,
-                           GNUNET_NO);
-  }
-  GAS_normalization_preference_client_disconnect (client);
-}
-
-
-/**
- * Change the preference for a peer
- *
- * @param client the client sending this request
- * @param peer the peer id
- * @param kind the preference kind to change
- * @param score_abs the new preference score
- */
-void
-GAS_addresses_preference_change (void *client,
-                                 const struct GNUNET_PeerIdentity *peer,
-                                 enum GNUNET_ATS_PreferenceKind kind,
-                                 float score_abs)
-{
-  struct GAS_Addresses_Preference_Clients *pc;
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-      "Received `%s' for peer `%s' for client %p\n", "CHANGE PREFERENCE",
-      GNUNET_i2s (peer), client);
-
-  if (GNUNET_NO == running)
-    return;
-
-  if (GNUNET_NO ==
-      GNUNET_CONTAINER_multipeermap_contains (addresses,
-                                              peer))
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-        "Received `%s' for unknown peer `%s' from client %p\n",
-        "CHANGE PREFERENCE", GNUNET_i2s (peer), client);
-    return;
-  }
-
-  if (NULL == find_preference_client (client))
-  {
-    pc = GNUNET_new (struct GAS_Addresses_Preference_Clients);
-    pc->client = client;
-    GNUNET_CONTAINER_DLL_insert (preference_clients_head,
-                                 preference_clients_tail,
-                                 pc);
-    pref_clients ++;
-    GNUNET_STATISTICS_set (stats,
-                           "# active performance clients",
-                           pref_clients,
-                           GNUNET_NO);
-  }
-
-  env.sf.s_bulk_start (solver);
-  /* Tell normalization about change, normalization will call callback if preference changed */
-  GAS_normalization_normalize_preference (client, peer, kind, score_abs);
-  env.sf.s_bulk_stop (solver);
-}
-
-
-/**
- * Change the preference for a peer
- *
- * @param application the client sending this request
- * @param peer the peer id
- * @param scope the time interval for this feedback: [now - scope .. now]
- * @param kind the preference kind to change
- * @param score_abs the new preference score
- */
-void
-GAS_addresses_preference_feedback (void *application,
-                                   const struct GNUNET_PeerIdentity *peer,
-                                   const struct GNUNET_TIME_Relative scope,
-                                   enum GNUNET_ATS_PreferenceKind kind,
-                                   float score_abs)
-{
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received `%s' for peer `%s' for client %p\n",
-             "PREFERENCE FEEDBACK",
-             GNUNET_i2s (peer),
-             application);
-
-  if (GNUNET_NO == running)
-    return;
-
-  if (GNUNET_NO ==
-      GNUNET_CONTAINER_multipeermap_contains (addresses,
-                                              peer))
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-        "Received `%s' for unknown peer `%s' from client %p\n",
-        "PREFERENCE FEEDBACK", GNUNET_i2s (peer), application);
-    return;
-  }
-
-  env.sf.s_feedback (solver, application, peer, scope, kind,
-                     score_abs);
-}
-
-
-/**
- * Load quotas for networks from configuration
- *
- * @param cfg configuration handle
- * @param out_dest where to write outbound quotas
- * @param in_dest where to write inbound quotas
- * @param dest_length length of inbound and outbound arrays
- * @return number of networks loaded
- */
-static unsigned int
-load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
-    unsigned long long *out_dest, unsigned long long *in_dest, int dest_length)
-{
-  char * entry_in = NULL;
-  char * entry_out = NULL;
-  char * quota_out_str;
-  char * quota_in_str;
-  int c;
-  int res;
-
-  for (c = 0; (c < GNUNET_ATS_NetworkTypeCount) && (c < dest_length); c++)
-  {
-    in_dest[c] = 0;
-    out_dest[c] = 0;
-    GNUNET_asprintf (&entry_out,
-                     "%s_QUOTA_OUT",
-                     GNUNET_ATS_print_network_type (c));
-    GNUNET_asprintf (&entry_in,
-                     "%s_QUOTA_IN",
-                     GNUNET_ATS_print_network_type (c));
-
-    /* quota out */
-    if (GNUNET_OK
-        == GNUNET_CONFIGURATION_get_value_string (cfg, "ats", entry_out,
-            &quota_out_str))
-    {
-      res = GNUNET_NO;
-      if (0 == strcmp (quota_out_str, GNUNET_ATS_MaxBandwidthString))
-      {
-        out_dest[c] = GNUNET_ATS_MaxBandwidth;
-        res = GNUNET_YES;
-      }
-      if ((GNUNET_NO == res)
-          && (GNUNET_OK
-              == GNUNET_STRINGS_fancy_size_to_bytes (quota_out_str,
-                  &out_dest[c])))
-        res = GNUNET_YES;
-      if ((GNUNET_NO == res)
-          && (GNUNET_OK
-              == GNUNET_CONFIGURATION_get_value_number (cfg, "ats", entry_out,
-                  &out_dest[c])))
-        res = GNUNET_YES;
-
-      if (GNUNET_NO == res)
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                   _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
-                   GNUNET_ATS_print_network_type (c),
-                   quota_out_str,
-                   GNUNET_ATS_DefaultBandwidth);
-        out_dest[c] = GNUNET_ATS_DefaultBandwidth;
-      }
-      else
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                   _("Outbound quota configure for network `%s' is %llu\n"),
-                   GNUNET_ATS_print_network_type (c),
-                   out_dest[c]);
-      }
-      GNUNET_free(quota_out_str);
-    }
-    else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
-                 GNUNET_ATS_print_network_type (c),
-                 GNUNET_ATS_DefaultBandwidth);
-      out_dest[c] = GNUNET_ATS_DefaultBandwidth;
-    }
-
-    /* quota in */
-    if (GNUNET_OK
-        == GNUNET_CONFIGURATION_get_value_string (cfg, "ats", entry_in,
-            &quota_in_str))
-    {
-      res = GNUNET_NO;
-      if (0 == strcmp (quota_in_str, GNUNET_ATS_MaxBandwidthString))
-      {
-        in_dest[c] = GNUNET_ATS_MaxBandwidth;
-        res = GNUNET_YES;
-      }
-      if ((GNUNET_NO == res)
-          && (GNUNET_OK
-              == GNUNET_STRINGS_fancy_size_to_bytes (quota_in_str, &in_dest[c])))
-        res = GNUNET_YES;
-      if ((GNUNET_NO == res)
-          && (GNUNET_OK
-              == GNUNET_CONFIGURATION_get_value_number (cfg, "ats", entry_in,
-                  &in_dest[c])))
-        res = GNUNET_YES;
-
-      if (GNUNET_NO == res)
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                   _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
-                   GNUNET_ATS_print_network_type (c),
-                   quota_in_str,
-                   GNUNET_ATS_DefaultBandwidth);
-        in_dest[c] = GNUNET_ATS_DefaultBandwidth;
-      }
-      else
-      {
-        GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                   _("Inbound quota configured for network `%s' is %llu\n"),
-                   GNUNET_ATS_print_network_type (c),
-                   in_dest[c]);
-      }
-      GNUNET_free(quota_in_str);
-    }
-    else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
-                 GNUNET_ATS_print_network_type (c),
-                 GNUNET_ATS_DefaultBandwidth);
-      in_dest[c] = GNUNET_ATS_DefaultBandwidth;
-    }
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "Loaded quota for network `%s' (in/out): %llu %llu\n",
-               GNUNET_ATS_print_network_type (c),
-               in_dest[c],
-               out_dest[c]);
-    GNUNET_free(entry_out);
-    GNUNET_free(entry_in);
-  }
-  return GNUNET_ATS_NetworkTypeCount;
-}
-
-
-/**
- * Callback for solver to notify about assignment changes
- *
- * @param cls NULL
- * @param address the address with changes
- */
-static void
-bandwidth_changed_cb (void *cls, struct ATS_Address *address)
-{
-  struct GAS_Addresses_Suggestion_Requests *cur;
-  uint32_t diff_out;
-  uint32_t diff_in;
-
-  GNUNET_assert(address != NULL);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Bandwidth assignment changed for peer %s \n",
-              GNUNET_i2s (&address->peer));
-
-  /* Notify performance clients about changes to address */
-  GAS_performance_notify_all_clients (&address->peer, address->plugin,
-      address->addr, address->addr_len, address->active, address->atsi,
-      address->atsi_count,
-      GNUNET_BANDWIDTH_value_init (address->assigned_bw_out),
-      GNUNET_BANDWIDTH_value_init (address->assigned_bw_in));
-
-  for (cur = pending_requests_head;NULL != cur; cur = cur->next)
-    if (0 == memcmp (&address->peer,
-                     &cur->id,
-                     sizeof(cur->id)))
-      break; /* we have an address request pending*/
-  if (NULL == cur)
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-               "Nobody is interested in peer `%s' :(\n",
-               GNUNET_i2s (&address->peer));
-    return;
-  }
-
-  if ((0 == address->assigned_bw_in) && (0 == address->assigned_bw_out))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-               "Telling transport to disconnect peer `%s'\n",
-                GNUNET_i2s (&address->peer));
-
-    /* Notify scheduling clients about suggestion */
-    GAS_scheduling_transmit_address_suggestion (&address->peer,
-                                                address->session_id,
-                                                zero_bw,
-                                                zero_bw);
-    return;
-  }
-
-  /* Do bandwidth stability check */
-  diff_out = abs (address->assigned_bw_out - address->last_notified_bw_out);
-  diff_in = abs (address->assigned_bw_in - address->last_notified_bw_in);
-
-  if ( (diff_out < htonl(GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__)) &&
-       (diff_in < htonl(GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__)) )
-    return;
-
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-      "Sending bandwidth update for peer `%s': %u %u\n",
-      GNUNET_i2s (&address->peer), address->assigned_bw_out,
-      address->assigned_bw_out);
-
-  /* *Notify scheduling clients about suggestion */
-  GAS_scheduling_transmit_address_suggestion (&address->peer,
-                                              address->session_id,
-                                              GNUNET_BANDWIDTH_value_init (address->assigned_bw_out),
-                                              GNUNET_BANDWIDTH_value_init (address->assigned_bw_in));
-
-  address->last_notified_bw_out = address->assigned_bw_out;
-  address->last_notified_bw_in = address->assigned_bw_in;
-}
 
 
 /**
@@ -1676,146 +839,16 @@ bandwidth_changed_cb (void *cls, struct ATS_Address *address)
  * known and current performance information. It has a solver component
  * responsible for the resource allocation. It tells the solver about changes
  * and receives updates when the solver changes the resource allocation.
- *
- * @param cfg configuration to use
- * @param stats_ the statistics handle to use
- * @return #GNUNET_OK on success, #GNUNET_SYSERR on error (failed to load
- *         solver plugin)
  */
-int
-GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                    struct GNUNET_STATISTICS_Handle *stats_)
+void
+GAS_addresses_init ()
 {
-  unsigned long long quotas_in[GNUNET_ATS_NetworkTypeCount];
-  unsigned long long quotas_out[GNUNET_ATS_NetworkTypeCount];
-  char *mode_str;
-  char *plugin_short;
-  int c;
-
-  running = GNUNET_NO;
-  stats = stats_;
   /* Initialize the addresses database */
-  addresses = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
-  pref_clients = 0;
-
-  /* Figure out configured solution method */
-  if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_string (cfg, "ats", "MODE", &mode_str))
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-               "No resource assignment method configured, using proportional approach\n");
-    ats_mode = MODE_PROPORTIONAL;
-  }
-  else
-  {
-    for (c = 0; c < strlen (mode_str); c++)
-      mode_str[c] = toupper (mode_str[c]);
-    if (0 == strcmp (mode_str, "PROPORTIONAL"))
-      ats_mode = MODE_PROPORTIONAL;
-    else if (0 == strcmp (mode_str, "MLP"))
-    {
-      ats_mode = MODE_MLP;
-#if !HAVE_LIBGLPK
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Assignment method `%s' configured, but GLPK is not available, please install \n",
-                 mode_str);
-      ats_mode = MODE_PROPORTIONAL;
-#endif
-    }
-    else if (0 == strcmp (mode_str, "RIL"))
-      ats_mode = MODE_RIL;
-    else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Invalid resource assignment method `%s' configured, using proportional approach\n",
-                 mode_str);
-      ats_mode = MODE_PROPORTIONAL;
-    }
-    GNUNET_free(mode_str);
-  }
-
-  load_quotas (cfg, quotas_out, quotas_in, GNUNET_ATS_NetworkTypeCount);
-  env.info_cb = &solver_info_cb;
-  env.info_cb_cls = NULL;
-  env.bandwidth_changed_cb = &bandwidth_changed_cb;
-  env.bw_changed_cb_cls = NULL;
-  env.get_preferences = &get_preferences_cb;
-  env.get_preference_cls = NULL;
-  env.get_property = &get_property_cb;
-  env.get_property_cls = NULL;
-  env.cfg = cfg;
-  env.stats = stats;
-  env.addresses = addresses;
-
-  env.network_count = GNUNET_ATS_NetworkTypeCount;
-  int networks[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkType;
-  for (c = 0; c < GNUNET_ATS_NetworkTypeCount; c++)
-  {
-    env.networks[c] = networks[c];
-    env.out_quota[c] = quotas_out[c];
-    env.in_quota[c] = quotas_in[c];
-  }
-
-  switch (ats_mode) {
-    case MODE_PROPORTIONAL:
-      plugin_short = "proportional";
-      break;
-    case MODE_MLP:
-      plugin_short = "mlp";
-      break;
-    case MODE_RIL:
-      plugin_short = "ril";
-      break;
-    default:
-      plugin_short = NULL;
-      break;
-  }
-  GNUNET_asprintf (&plugin,
-                   "libgnunet_plugin_ats_%s",
-                   plugin_short);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Initializing solver `%s '`%s'\n",
-              plugin_short,
-              plugin);
-  if (NULL == (solver = GNUNET_PLUGIN_load (plugin, &env)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to initialize solver `%s'!\n"),
-                plugin);
-    return GNUNET_SYSERR;
-  }
-
-  GNUNET_assert (NULL != env.sf.s_add);
-  GNUNET_assert (NULL != env.sf.s_address_update_property);
-  GNUNET_assert (NULL != env.sf.s_address_update_session);
-  GNUNET_assert (NULL != env.sf.s_address_update_network);
-  GNUNET_assert (NULL != env.sf.s_get);
-  GNUNET_assert (NULL != env.sf.s_get_stop);
-  GNUNET_assert (NULL != env.sf.s_pref);
-  GNUNET_assert (NULL != env.sf.s_feedback);
-  GNUNET_assert (NULL != env.sf.s_del);
-  GNUNET_assert (NULL != env.sf.s_bulk_start);
-  GNUNET_assert (NULL != env.sf.s_bulk_stop);
-
-
-  GAS_normalization_start (&normalized_preference_changed_cb, NULL,
-                           &normalized_property_changed_cb, NULL);
-
-  if (NULL == solver)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to initialize solver!\n"));
-    return GNUNET_SYSERR;
-  }
-  /* up and running */
-  running = GNUNET_YES;
-
-  GNUNET_STATISTICS_set (stats,
+  GSA_addresses = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
+  GNUNET_STATISTICS_set (GSA_stats,
                          "# addresses",
-                         GNUNET_CONTAINER_multipeermap_size (addresses),
+                         GNUNET_CONTAINER_multipeermap_size (GSA_addresses),
                          GNUNET_NO);
-
-  return GNUNET_OK;
 }
 
 
@@ -1835,12 +868,12 @@ destroy_all_address_it (void *cls,
   struct ATS_Address *aa = value;
 
   /* Remove */
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_remove (addresses,
-                                                      key,
-                                                      value));
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (GSA_addresses,
+                                                       key,
+                                                       value));
   /* Notify */
-  env.sf.s_del (solver, aa, GNUNET_NO);
+  GAS_plugin_delete_address (aa);
   /* Destroy */
   GAS_performance_notify_all_clients (&aa->peer,
                                       aa->plugin,
@@ -1861,17 +894,14 @@ destroy_all_address_it (void *cls,
 void
 GAS_addresses_destroy_all ()
 {
-  if (GNUNET_NO == running)
-    return;
-
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Destroying all addresses\n");
-  env.sf.s_bulk_start (solver);
-  if (NULL != addresses)
-    GNUNET_CONTAINER_multipeermap_iterate (addresses,
+  GAS_plugin_solver_lock ();
+  if (NULL != GSA_addresses)
+    GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
                                            &destroy_all_address_it,
                                            NULL);
-  env.sf.s_bulk_start (solver);
+  GAS_plugin_solver_unlock ();
 }
 
 
@@ -1881,41 +911,11 @@ GAS_addresses_destroy_all ()
 void
 GAS_addresses_done ()
 {
-  struct GAS_Addresses_Suggestion_Requests *cur;
-  struct GAS_Addresses_Preference_Clients *pcur;
-
   GNUNET_log(GNUNET_ERROR_TYPE_INFO,
              "Shutting down addresses\n");
- GAS_addresses_destroy_all ();
-  running = GNUNET_NO;
-  GNUNET_CONTAINER_multipeermap_destroy (addresses);
-  addresses = NULL;
-  while (NULL != (cur = pending_requests_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (pending_requests_head,
-                                 pending_requests_tail,
-                                 cur);
-    GNUNET_free(cur);
-  }
-
-  while (NULL != (pcur = preference_clients_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (preference_clients_head,
-                                 preference_clients_tail,
-                                 pcur);
-    GNUNET_assert (pref_clients > 0);
-    pref_clients --;
-    GNUNET_STATISTICS_set (stats,
-                           "# active performance clients",
-                           pref_clients,
-                           GNUNET_NO);
-    GNUNET_free (pcur);
-  }
-  GNUNET_PLUGIN_unload (plugin,
-                        solver);
-  GNUNET_free (plugin);
-  /* Stop configured solution method */
-  GAS_normalization_stop ();
+  GAS_addresses_destroy_all ();
+  GNUNET_CONTAINER_multipeermap_destroy (GSA_addresses);
+  GSA_addresses = NULL;
 }
 
 
@@ -1990,15 +990,15 @@ GAS_addresses_get_peer_info (const struct GNUNET_PeerIdentity *peer,
               (NULL == peer)
               ? "all peers"
               : GNUNET_i2s (peer),
-              (unsigned int) GNUNET_CONTAINER_multipeermap_size (addresses));
+              (unsigned int) GNUNET_CONTAINER_multipeermap_size (GSA_addresses));
   pi_ctx.it = pi_it;
   pi_ctx.it_cls = pi_it_cls;
   if (NULL == peer)
-    GNUNET_CONTAINER_multipeermap_iterate (addresses,
+    GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
                                            &peerinfo_it,
                                            &pi_ctx);
   else
-    GNUNET_CONTAINER_multipeermap_get_multiple (addresses,
+    GNUNET_CONTAINER_multipeermap_get_multiple (GSA_addresses,
                                                 peer,
                                                 &peerinfo_it, &pi_ctx);
   pi_it (pi_it_cls,