X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fats%2Fgnunet-service-ats_addresses.c;h=aff7cede1056f855aa4dea075632a03b1ae8d7cb;hb=07cfe12a0266c84fe0679e0e8908f4d8d9fa3caf;hp=875633a6e15da7787daafe7cda6cb07a25591037;hpb=5838db58281b2f734b29a7801d70f42fda9310cd;p=oweals%2Fgnunet.git

diff --git a/src/ats/gnunet-service-ats_addresses.c b/src/ats/gnunet-service-ats_addresses.c
index 875633a6e..aff7cede1 100644
--- a/src/ats/gnunet-service-ats_addresses.c
+++ b/src/ats/gnunet-service-ats_addresses.c
@@ -31,58 +31,61 @@
 #include "gnunet-service-ats_performance.h"
 #include "gnunet-service-ats_scheduling.h"
 #include "gnunet-service-ats_reservations.h"
+#if HAVE_LIBGLPK
+#include "gnunet-service-ats_addresses_mlp.h"
+#endif
 
-struct ATS_Address
-{
-  struct GNUNET_PeerIdentity peer;
-
-  size_t addr_len;
-
-  uint32_t session_id;
-
-  uint32_t ats_count;
-
-  const void *addr;
-
-  char *plugin;
-
-  struct GNUNET_ATS_Information *ats;
-
-  struct GNUNET_TIME_Relative atsp_latency;
-
-  struct GNUNET_BANDWIDTH_Value32NBO atsp_utilization_in;
-
-  struct GNUNET_BANDWIDTH_Value32NBO atsp_utilization_out;
-
-  uint32_t atsp_distance;
-
-  uint32_t atsp_cost_wan;
-
-  uint32_t atsp_cost_lan;
-
-  uint32_t atsp_cost_wlan;
-
-  uint32_t atsp_network_type;
-
-  struct GNUNET_BANDWIDTH_Value32NBO assigned_bw_in;
+#define VERBOSE GNUNET_NO
 
-  struct GNUNET_BANDWIDTH_Value32NBO assigned_bw_out;
-
-  /**
-   * Is this the active address for this peer?
+enum ATS_Mode
+{
+  /*
+   * Assign each peer an equal amount of bandwidth (bw)
+   *
+   * bw_per_peer = bw_total / #active addresses
    */
-  int active;
+  SIMPLE,
 
+  /*
+   * Use MLP solver to assign bandwidth
+   */
+  MLP
 };
 
 static struct GNUNET_CONTAINER_MultiHashMap *addresses;
 
+#if HAVE_LIBGLPK
+static struct GAS_MLP_Handle *mlp;
+#endif
+
 static unsigned long long wan_quota_in;
 
 static unsigned long long wan_quota_out;
 
 static unsigned int active_addr_count;
 
+static int ats_mode;
+
+static int running;
+
+
+static void
+send_bw_notification (struct ATS_Address *aa)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New bandwidth for peer %s is %u/%u\n",
+              GNUNET_i2s (&aa->peer), ntohl (aa->assigned_bw_in.value__),
+              ntohl (aa->assigned_bw_out.value__));
+  GAS_scheduling_transmit_address_suggestion (&aa->peer, aa->plugin, aa->addr,
+                                              aa->addr_len, aa->session_id,
+                                              aa->ats, aa->ats_count,
+                                              aa->assigned_bw_out,
+                                              aa->assigned_bw_in);
+  GAS_reservations_set_bandwidth (&aa->peer, aa->assigned_bw_in);
+  GAS_performance_notify_clients (&aa->peer, aa->plugin, aa->addr, aa->addr_len,
+                                  aa->ats, aa->ats_count, aa->assigned_bw_out,
+                                  aa->assigned_bw_in);
+}
+
 /**
  * Update a bandwidth assignment for a peer.  This trivial method currently
  * simply assigns the same share to all active connections.
@@ -93,27 +96,21 @@ static unsigned int active_addr_count;
  * @return GNUNET_OK (continue to iterate)
  */
 static int
-update_bw_it (void *cls, const GNUNET_HashCode * key, void *value)
+update_bw_simple_it (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct ATS_Address *aa = value;
 
   if (GNUNET_YES != aa->active)
     return GNUNET_OK;
   GNUNET_assert (active_addr_count > 0);
+
+
+  /* Simple method */
   aa->assigned_bw_in.value__ = htonl (wan_quota_in / active_addr_count);
   aa->assigned_bw_out.value__ = htonl (wan_quota_out / active_addr_count);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New bandwidth for peer %s is %u/%u\n",
-              GNUNET_i2s (&aa->peer), ntohl (aa->assigned_bw_in.value__),
-              ntohl (aa->assigned_bw_out.value__));
-  GAS_scheduling_transmit_address_suggestion (&aa->peer, aa->plugin, aa->addr,
-                                              aa->addr_len, aa->session_id,
-                                              aa->ats, aa->ats_count,
-                                              aa->assigned_bw_out,
-                                              aa->assigned_bw_in);
-  GAS_reservations_set_bandwidth (&aa->peer, aa->assigned_bw_in);
-  GAS_performance_notify_clients (&aa->peer, aa->plugin, aa->addr, aa->addr_len,
-                                  aa->ats, aa->ats_count, aa->assigned_bw_out,
-                                  aa->assigned_bw_in);
+
+  send_bw_notification (aa);
+
   return GNUNET_OK;
 }
 
@@ -131,7 +128,50 @@ recalculate_assigned_bw ()
                             1, GNUNET_NO);
   GNUNET_STATISTICS_set (GSA_stats, "# active addresses", active_addr_count,
                          GNUNET_NO);
-  GNUNET_CONTAINER_multihashmap_iterate (addresses, &update_bw_it, NULL);
+
+  GNUNET_CONTAINER_multihashmap_iterate (addresses, &update_bw_simple_it, NULL);
+}
+
+/**
+ * Free the given address
+ * @param addr address to destroy
+ */
+static void
+free_address (struct ATS_Address *addr)
+{
+  GNUNET_free_non_null (addr->ats);
+  GNUNET_free (addr->plugin);
+  GNUNET_free (addr);
+}
+
+/**
+ * Create a ATS_address with the given information
+ * @param peer peer
+ * @param plugin_name plugin
+ * @param plugin_addr address
+ * @param plugin_addr_len address length
+ * @param session_id session
+ * @return the ATS_Address
+ */
+static struct ATS_Address *
+create_address (const struct GNUNET_PeerIdentity *peer,
+                const char *plugin_name,
+                const void *plugin_addr, size_t plugin_addr_len,
+                uint32_t session_id)
+{
+  struct ATS_Address *aa = NULL;
+
+  aa = GNUNET_malloc (sizeof (struct ATS_Address) + plugin_addr_len);
+  aa->peer = *peer;
+  aa->addr_len = plugin_addr_len;
+  aa->addr = &aa[1];
+  memcpy (&aa[1], plugin_addr, plugin_addr_len);
+  aa->plugin = GNUNET_strdup (plugin_name);
+  aa->session_id = session_id;
+  aa->mlp_information = NULL;
+  aa->next = NULL;
+  aa->prev = NULL;
+  return aa;
 }
 
 
@@ -151,15 +191,19 @@ destroy_address (struct ATS_Address *addr)
                  GNUNET_CONTAINER_multihashmap_remove (addresses,
                                                        &addr->peer.hashPubKey,
                                                        addr));
+
+#if HAVE_LIBGLPK
+  if (ats_mode == MLP)
+    GAS_mlp_address_delete (mlp, addresses, addr);
+#endif
+
   if (GNUNET_YES == addr->active)
   {
     active_addr_count--;
     addr->active = GNUNET_NO;
     ret = GNUNET_YES;
   }
-  GNUNET_free_non_null (addr->ats);
-  GNUNET_free (addr->plugin);
-  GNUNET_free (addr);
+  free_address (addr);
   return ret;
 }
 
@@ -167,7 +211,11 @@ destroy_address (struct ATS_Address *addr)
 struct CompareAddressContext
 {
   const struct ATS_Address *search;
-  struct ATS_Address *result;
+
+  /* exact_address != NULL if address and session is equal */
+  struct ATS_Address *exact_address;
+  /* exact_address != NULL if address and session is 0 */
+  struct ATS_Address *base_address;
 };
 
 
@@ -176,15 +224,35 @@ compare_address_it (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct CompareAddressContext *cac = cls;
   struct ATS_Address *aa = value;
+/*
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Comparing to: %s %s %u session %u\n",
+              GNUNET_i2s (&aa->peer), aa->plugin, aa->addr_len, aa->session_id);
+
+*/
+  /* find an exact matching address: aa->addr == cac->search->addr && aa->session == cac->search->session */
+  if ((aa->addr_len == cac->search->addr_len) && (0 == strcmp (aa->plugin, cac->search->plugin)))
+  {
+      if ((0 == memcmp (aa->addr, cac->search->addr, aa->addr_len)) && (aa->session_id == cac->search->session_id))
+      {
+        cac->exact_address = aa;
+      }
+  }
+
+  /* find an matching address: aa->addr == cac->search->addr && aa->session == 0 */
+  /* this address can be used to be updated */
+  if ((aa->addr_len == cac->search->addr_len) && (0 == strcmp (aa->plugin, cac->search->plugin)))
+  {
+      if ((0 == memcmp (aa->addr, cac->search->addr, aa->addr_len)) && (aa->session_id == 0))
+      {
+        cac->base_address = aa;
+      }
+  }
 
-  if (((aa->addr_len != cac->search->addr_len) ||
-       (0 != strcmp (aa->plugin, cac->search->plugin)) ||
-       (0 != memcmp (aa->addr, cac->search->addr, aa->addr_len))) &&
-      ((aa->session_id != cac->search->session_id) ||
-       (cac->search->session_id == 0)))
+  if (cac->exact_address == NULL)
     return GNUNET_YES;
-  cac->result = aa;
-  return GNUNET_NO;
+  else
+    return GNUNET_NO;
 }
 
 
@@ -203,11 +271,62 @@ find_address (const struct GNUNET_PeerIdentity *peer,
 {
   struct CompareAddressContext cac;
 
-  cac.result = NULL;
+  cac.exact_address = NULL;
+  cac.base_address = NULL;
   cac.search = addr;
   GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey,
                                               &compare_address_it, &cac);
-  return cac.result;
+
+/*
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "exact address: %s           base address: %s\n",
+              (cac.exact_address != NULL) ? "YES" : "NO",
+              (cac.base_address != NULL) ? "YES" : "NO");
+*/
+  if (cac.exact_address == NULL)
+    return cac.base_address;
+  return cac.exact_address;
+}
+
+
+static int
+compare_address_session_it (void *cls, const GNUNET_HashCode * key, void *value)
+{
+  struct CompareAddressContext *cac = cls;
+  struct ATS_Address *aa = value;
+
+  if ((aa->addr_len == cac->search->addr_len) && (0 == strcmp (aa->plugin, cac->search->plugin)))
+  {
+      if ((0 == memcmp (aa->addr, cac->search->addr, aa->addr_len)) && (aa->session_id == cac->search->session_id))
+      {
+        cac->exact_address = aa;
+        return GNUNET_NO;
+      }
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Find an existing equivalent address record.
+ * Compares by peer identity and network address AND by session ID
+ * (one of the two must match).
+ *
+ * @param peer peer to lookup addresses for
+ * @param addr existing address record
+ * @return existing address record, NULL for none
+ */
+struct ATS_Address *
+find_exact_address (const struct GNUNET_PeerIdentity *peer,
+              const struct ATS_Address *addr)
+{
+  struct CompareAddressContext cac;
+
+  cac.exact_address = NULL;
+  cac.search = addr;
+  GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey,
+                                              &compare_address_session_it, &cac);
+  return cac.exact_address;
 }
 
 
@@ -222,16 +341,27 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
   struct ATS_Address *old;
   uint32_t i;
 
-  aa = GNUNET_malloc (sizeof (struct ATS_Address) + plugin_addr_len);
+  if (GNUNET_NO == running)
+    return;
+
+  GNUNET_assert (NULL != addresses);
+
+  aa = create_address (peer,
+                       plugin_name,
+                       plugin_addr, plugin_addr_len,
+                       session_id);
+
+  aa->mlp_information = NULL;
   aa->ats = GNUNET_malloc (atsi_count * sizeof (struct GNUNET_ATS_Information));
-  aa->peer = *peer;
-  aa->addr_len = plugin_addr_len;
   aa->ats_count = atsi_count;
   memcpy (aa->ats, atsi, atsi_count * sizeof (struct GNUNET_ATS_Information));
-  aa->addr = &aa[1];
-  memcpy (&aa[1], plugin_addr, plugin_addr_len);
-  aa->plugin = GNUNET_strdup (plugin_name);
-  aa->session_id = session_id;
+
+#if DEBUG_ATS
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating address for peer `%s' %u\n",
+              GNUNET_i2s (peer),
+              session_id);
+#endif
+  /* Get existing address or address with session == 0 */
   old = find_address (peer, aa);
   if (old == NULL)
   {
@@ -239,15 +369,20 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
                    GNUNET_CONTAINER_multihashmap_put (addresses,
                                                       &peer->hashPubKey, aa,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+#if DEBUG_ATS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added new address for peer `%s' %X\n",
                 GNUNET_i2s (peer), aa);
+#endif
     old = aa;
   }
   else
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Updated existing address for peer `%s' %X \n",
-                GNUNET_i2s (peer), old);
+#if DEBUG_ATS
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Updated existing address for peer `%s' %p old session %u new session %u\n",
+                GNUNET_i2s (peer), old,
+                old->session_id, session_id);
+#endif
     GNUNET_free_non_null (old->ats);
     old->session_id = session_id;
     old->ats = NULL;
@@ -291,12 +426,19 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
       GNUNET_break (0);
       break;
     }
+#if HAVE_LIBGLPK
+  if (ats_mode == MLP)
+    GAS_mlp_address_update (mlp, addresses, old);
+#endif
 }
 
 
 /**
- * Update a bandwidth assignment for a peer.  This trivial method currently
- * simply assigns the same share to all active connections.
+ * Delete an address
+ *
+ * If session != 0, just the session is deleted, the address itself still exists
+ * If session == 0, remove full address
+ * If session == 0 and addrlen == 0, destroy inbound address
  *
  * @param cls unused
  * @param key unused
@@ -312,22 +454,31 @@ destroy_by_session_id (void *cls, const GNUNET_HashCode * key, void *value)
   GNUNET_assert (0 ==
                  memcmp (&aa->peer, &info->peer,
                          sizeof (struct GNUNET_PeerIdentity)));
+  /* session == 0, remove full address  */
   if ((info->session_id == 0) && (0 == strcmp (info->plugin, aa->plugin)) &&
       (aa->addr_len == info->addr_len) &&
       (0 == memcmp (info->addr, aa->addr, aa->addr_len)))
   {
+#if VERBOSE
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Deleting address for peer `%s': `%s'\n",
-                GNUNET_i2s (&aa->peer), aa->plugin);
+                "Deleting address for peer `%s': `%s' %u\n",
+                GNUNET_i2s (&aa->peer), aa->plugin, aa->session_id);
+#endif
     if (GNUNET_YES == destroy_address (aa))
       recalculate_assigned_bw ();
     return GNUNET_OK;
   }
+  /* session != 0, just remove session */
   if (aa->session_id != info->session_id)
     return GNUNET_OK;           /* irrelevant */
   if (aa->session_id != 0)
     GNUNET_break (0 == strcmp (info->plugin, aa->plugin));
   /* session died */
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Deleting session for peer `%s': `%s' %u\n",
+              GNUNET_i2s (&aa->peer), aa->plugin, aa->session_id);
+#endif
   aa->session_id = 0;
 
   if (GNUNET_YES == aa->active)
@@ -339,27 +490,43 @@ destroy_by_session_id (void *cls, const GNUNET_HashCode * key, void *value)
 
   /* session == 0 and addrlen == 0 : destroy address */
   if (aa->addr_len == 0)
+  {
+#if VERBOSE
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Deleting session and address for peer `%s': `%s' %u\n",
+                GNUNET_i2s (&aa->peer), aa->plugin, aa->session_id);
+#endif
     (void) destroy_address (aa);
+  }
+  else
+  {
+    /* session was set to 0, update address */
+#if HAVE_LIBGLPK
+  if (ats_mode == MLP)
+    GAS_mlp_address_update (mlp, addresses, aa);
+#endif
+  }
 
   return GNUNET_OK;
 }
 
-
 void
 GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer,
                        const char *plugin_name, const void *plugin_addr,
                        size_t plugin_addr_len, uint32_t session_id)
 {
-  struct ATS_Address aa;
+  struct ATS_Address *aa;
+
+  if (GNUNET_NO == running)
+    return;
 
   GNUNET_break (0 < strlen (plugin_name));
-  aa.peer = *peer;
-  aa.addr_len = plugin_addr_len;
-  aa.addr = plugin_addr;
-  aa.plugin = (char *) plugin_name;
-  aa.session_id = session_id;
+  aa = create_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id);
+
   GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey,
-                                              &destroy_by_session_id, &aa);
+                                              &destroy_by_session_id, aa);
+
+  free_address (aa);
 }
 
 
@@ -409,36 +576,116 @@ find_address_it (void *cls, const GNUNET_HashCode * key, void *value)
 }
 
 
-void
+int
 GAS_addresses_in_use (const struct GNUNET_PeerIdentity *peer,
                       const char *plugin_name, const void *plugin_addr,
                       size_t plugin_addr_len, uint32_t session_id, int in_use)
 {
-
+#if DEBUG_ATS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' message for peer `%s': %i\n", "ADDRESS_IN_USE",
               GNUNET_i2s (peer), in_use);
+#endif
+
+  struct ATS_Address *aa;
+  struct ATS_Address *old;
+
+  if (GNUNET_NO == running)
+    return GNUNET_SYSERR;
+
+  aa = create_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id);
+  old = find_exact_address (peer, aa);
+  free_address (aa);
+
+  if (NULL == old)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  if (old->used == in_use)
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Address in use called multiple times for peer `%s': %s -> %s \n",
+                GNUNET_i2s (peer),
+                (GNUNET_NO == old->used) ? "NO" : "YES",
+                (GNUNET_NO == in_use) ? "NO" : "YES");
+    return GNUNET_SYSERR;
+  }
+  old->used = in_use;
+#if HAVE_LIBGLPK
+  if (ats_mode == MLP)
+     GAS_mlp_address_update (mlp, addresses, old);
+#endif
+  return GNUNET_OK;
 }
 
-void
-GAS_addresses_request_address (const struct GNUNET_PeerIdentity *peer)
+
+void request_address_mlp (const struct GNUNET_PeerIdentity *peer)
 {
   struct ATS_Address *aa;
+  aa = NULL;
 
+#if HAVE_GLPK
+  /* Get preferred address from MLP */
+  struct ATS_PreferedAddress * paddr = NULL;
+  paddr = GAS_mlp_get_preferred_address (mlp, addresses, peer);
+  aa = paddr->address;
+  aa->assigned_bw_out = GNUNET_BANDWIDTH_value_init(paddr->bandwidth_out);
+  /* FIXME use bw in value */
+  paddr->bandwidth_in = paddr->bandwidth_out;
+  aa->assigned_bw_in = GNUNET_BANDWIDTH_value_init (paddr->bandwidth_in);
+  GNUNET_free (paddr);
+#endif
+
+  if (aa == NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+                "Cannot suggest address for peer `%s'\n", GNUNET_i2s (peer));
+    return;
+  }
+  if (aa->active == GNUNET_NO)
+  {
+    aa->active = GNUNET_YES;
+    active_addr_count++;
+
+    send_bw_notification (aa);
+  }
+  else
+  {
+    /* just to be sure... */
+    GAS_scheduling_transmit_address_suggestion (peer, aa->plugin, aa->addr,
+                                                aa->addr_len, aa->session_id,
+                                                aa->ats, aa->ats_count,
+                                                aa->assigned_bw_out,
+                                                aa->assigned_bw_in);
+  }
+
+}
+
+void request_address_simple (const struct GNUNET_PeerIdentity *peer)
+{
+  struct ATS_Address *aa;
   aa = NULL;
+
+  /* Get address with: stick to current address, lower distance, lower latency */
   GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey,
                                               &find_address_it, &aa);
   if (aa == NULL)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
                 "Cannot suggest address for peer `%s'\n", GNUNET_i2s (peer));
     return;
   }
+
   if (aa->active == GNUNET_NO)
   {
     aa->active = GNUNET_YES;
     active_addr_count++;
-    recalculate_assigned_bw ();
+    if (ats_mode == SIMPLE)
+    {
+      recalculate_assigned_bw ();
+    }
   }
   else
   {
@@ -452,6 +699,23 @@ GAS_addresses_request_address (const struct GNUNET_PeerIdentity *peer)
 }
 
 
+void
+GAS_addresses_request_address (const struct GNUNET_PeerIdentity *peer)
+{
+  if (GNUNET_NO == running)
+    return;
+
+  if (ats_mode == SIMPLE)
+  {
+    request_address_simple (peer);
+  }
+  if (ats_mode == MLP)
+  {
+    request_address_mlp(peer);
+  }
+}
+
+
 // FIXME: this function should likely end up in the LP-subsystem and
 // not with 'addresses' in the future...
 void
@@ -459,7 +723,12 @@ GAS_addresses_change_preference (const struct GNUNET_PeerIdentity *peer,
                                  enum GNUNET_ATS_PreferenceKind kind,
                                  float score)
 {
-  // do nothing for now...
+  if (GNUNET_NO == running)
+    return;
+#if HAVE_LIBGLPK
+  if (ats_mode == MLP)
+    GAS_mlp_address_change_preference (mlp, peer, kind, score);
+#endif
 }
 
 
@@ -468,19 +737,92 @@ GAS_addresses_change_preference (const struct GNUNET_PeerIdentity *peer,
  * Initialize address subsystem.
  *
  * @param cfg configuration to use
+ * @param stats the statistics handle to use
  */
 void
-GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
+GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                    const struct GNUNET_STATISTICS_Handle *stats)
 {
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
-                                                      "WAN_QUOTA_IN",
-                                                      &wan_quota_in));
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
-                                                      "WAN_QUOTA_OUT",
-                                                      &wan_quota_out));
+  int mode;
+
+  char *quota_wan_in_str;
+  char *quota_wan_out_str;
+
+  running = GNUNET_NO;
+
   addresses = GNUNET_CONTAINER_multihashmap_create (128);
+  GNUNET_assert (NULL != addresses);
+
+  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_IN", &quota_wan_in_str))
+  {
+    if (0 == strcmp(quota_wan_in_str, "unlimited") ||
+        (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_wan_in_str, &wan_quota_in)))
+      wan_quota_in = (UINT32_MAX) /10;
+
+    GNUNET_free (quota_wan_in_str);
+    quota_wan_in_str = NULL;
+  }
+  else
+  {
+    wan_quota_in = (UINT32_MAX) /10;
+  }
+
+  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_OUT", &quota_wan_out_str))
+  {
+    if (0 == strcmp(quota_wan_out_str, "unlimited") ||
+        (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_wan_out_str, &wan_quota_out)))
+      wan_quota_out = (UINT32_MAX) /10;
+
+    GNUNET_free (quota_wan_out_str);
+    quota_wan_out_str = NULL;
+  }
+  else
+  {
+    wan_quota_out = (UINT32_MAX) /10;
+  }
+
+  mode = GNUNET_CONFIGURATION_get_value_yesno (cfg, "ats", "MLP");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MLP mode %u", mode);
+  switch (mode)
+  {
+    /* MLP = YES */
+    case GNUNET_YES:
+#if HAVE_LIBGLPK
+      ats_mode = MLP;
+      /* Init the MLP solver with default values */
+      mlp = GAS_mlp_init (cfg, stats, MLP_MAX_EXEC_DURATION, MLP_MAX_ITERATIONS);
+      if (NULL == mlp)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "MLP mode was configured, but libglpk is not installed, switching to simple mode\n");
+        GNUNET_STATISTICS_update (GSA_stats, "MLP mode enabled", 0, GNUNET_NO);
+        break;
+      }
+      else
+      {
+        GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 1, GNUNET_NO);
+        break;
+      }
+#else
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "MLP mode was configured, but libglpk is not installed, switching to simple mode");
+      GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 0, GNUNET_NO);
+      ats_mode = SIMPLE;
+      break;
+#endif
+    /* MLP = NO */
+    case GNUNET_NO:
+      GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 0, GNUNET_NO);
+      ats_mode = SIMPLE;
+      break;
+    /* No configuration value */
+    case GNUNET_SYSERR:
+      GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 0, GNUNET_NO);
+      ats_mode = SIMPLE;
+      break;
+    default:
+      break;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS started with %s mode\n", (SIMPLE == ats_mode) ? "SIMPLE" : "MLP");
+  running = GNUNET_YES;
 }
 
 
@@ -505,6 +847,9 @@ free_address_it (void *cls, const GNUNET_HashCode * key, void *value)
 void
 GAS_addresses_destroy_all ()
 {
+  if (GNUNET_NO == running)
+    return;
+
   if (addresses != NULL)
     GNUNET_CONTAINER_multihashmap_iterate (addresses, &free_address_it, NULL);
   GNUNET_assert (active_addr_count == 0);
@@ -517,9 +862,17 @@ GAS_addresses_destroy_all ()
 void
 GAS_addresses_done ()
 {
+  running = GNUNET_NO;
   GAS_addresses_destroy_all ();
   GNUNET_CONTAINER_multihashmap_destroy (addresses);
   addresses = NULL;
+#if HAVE_LIBGLPK
+  if (ats_mode == MLP)
+  {
+    GAS_mlp_done (mlp);
+  }
+#endif
+
 }