fixing #3657 (replace ATS_Information with struct), but WIHTOUT fixing ATS testcases yet

22 files changed, 512 insertions, 1112 deletions

diff --git a/src/ats/Makefile.am b/src/ats/Makefile.am
index 4491b08a2..2a14ae73f 100644
--- a/src/ats/Makefile.am
+++ b/src/ats/Makefile.am
@@ -18,8 +18,8 @@ if USE_COVERAGE
   AM_CFLAGS = -fprofile-arcs -ftest-coverage
 endif
 
-noinst_PROGRAMS = \
- gnunet-ats-solver-eval
+#noinst_PROGRAMS = \
+# gnunet-ats-solver-eval
 
 if HAVE_LIBGLPK
   GN_LIBGLPK = -lglpk
@@ -42,21 +42,21 @@ plugin_LTLIBRARIES = \
   $(GN_MLP_LIB) \
   libgnunet_plugin_ats_ril.la
 
-gnunet_ats_solver_eval_SOURCES = \
- gnunet-ats-solver-eval.c gnunet-ats-solver-eval.h \
- gnunet-service-ats_addresses.c gnunet-service-ats_addresses.h \
- gnunet-service-ats_plugins.c gnunet-service-ats_plugins.h \
- gnunet-service-ats_connectivity.c gnunet-service-ats_connectivity.h \
- gnunet-service-ats_feedback.c gnunet-service-ats_feedback.h \
- gnunet-service-ats_performance.c gnunet-service-ats_performance.h \
- gnunet-service-ats_reservations.c gnunet-service-ats_reservations.h \
- gnunet-service-ats_scheduling.c gnunet-service-ats_scheduling.h \
- gnunet-service-ats_normalization.c
-gnunet_ats_solver_eval_LDADD = \
- $(top_builddir)/src/util/libgnunetutil.la \
- libgnunetats.la \
- $(top_builddir)/src/statistics/libgnunetstatistics.la \
- $(LTLIBINTL)
+#gnunet_ats_solver_eval_SOURCES = \
+# gnunet-ats-solver-eval.c gnunet-ats-solver-eval.h \
+# gnunet-service-ats_addresses.c gnunet-service-ats_addresses.h \
+# gnunet-service-ats_plugins.c gnunet-service-ats_plugins.h \
+# gnunet-service-ats_connectivity.c gnunet-service-ats_connectivity.h \
+# gnunet-service-ats_feedback.c gnunet-service-ats_feedback.h \
+# gnunet-service-ats_performance.c gnunet-service-ats_performance.h \
+# gnunet-service-ats_reservations.c gnunet-service-ats_reservations.h \
+# gnunet-service-ats_scheduling.c gnunet-service-ats_scheduling.h \
+# gnunet-service-ats_normalization.c
+#gnunet_ats_solver_eval_LDADD = \
+# $(top_builddir)/src/util/libgnunetutil.la \
+# libgnunetats.la \
+# $(top_builddir)/src/statistics/libgnunetstatistics.la \
+# $(LTLIBINTL)
 
 libgnunetats_la_SOURCES = \
   ats_api_connectivity.c \
diff --git a/src/ats/ats.h b/src/ats/ats.h
index d5d5d6c3f..7e411fb98 100644
--- a/src/ats/ats.h
+++ b/src/ats/ats.h
@@ -27,6 +27,8 @@
 #define ATS_H
 
 #include "gnunet_util_lib.h"
+#include "gnunet_ats_service.h"
+
 
 /**
  * Flag used to indicate which type of client is connecting
@@ -115,16 +117,6 @@ struct AddressAddMessage
   struct GNUNET_MessageHeader header;
 
   /**
-   * Length of the `struct GNUNET_ATS_Information` array that follows this struct.
-   */
-  uint32_t ats_count GNUNET_PACKED;
-
-  /**
-   * Identity of the peer that this address is for.
-   */
-  struct GNUNET_PeerIdentity peer;
-
-  /**
    * Number of bytes in the address that follows this struct.
    */
   uint16_t address_length GNUNET_PACKED;
@@ -135,6 +127,11 @@ struct AddressAddMessage
   uint16_t plugin_name_length GNUNET_PACKED;
 
   /**
+   * Identity of the peer that this address is for.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
    * Internal number this client will henceforth use to
    * refer to this address.
    */
@@ -146,8 +143,12 @@ struct AddressAddMessage
    */
   uint32_t address_local_info GNUNET_PACKED;
 
+  /**
+   * Performance properties of the address.
+   */
+  struct GNUNET_ATS_PropertiesNBO properties;
+
   /* followed by:
-   * - struct GNUNET_ATS_Information [ats_count];
    * - char address[address_length]
    * - char plugin_name[plugin_name_length] (including '\0'-termination).
    */
@@ -167,9 +168,9 @@ struct AddressUpdateMessage
   struct GNUNET_MessageHeader header;
 
   /**
-   * Length of the `struct GNUNET_ATS_Information` array that follows.
+   * Internal number this client uses to refer to this address.
    */
-  uint32_t ats_count GNUNET_PACKED;
+  uint32_t session_id GNUNET_PACKED;
 
   /**
    * Which peer is this about? (Technically redundant, as the
@@ -179,13 +180,9 @@ struct AddressUpdateMessage
   struct GNUNET_PeerIdentity peer;
 
   /**
-   * Internal number this client uses to refer to this address.
-   */
-  uint32_t session_id GNUNET_PACKED;
-
-  /* followed by:
-   * - struct GNUNET_ATS_Information [ats_count];
+   * Performance properties of the address.
    */
+  struct GNUNET_ATS_PropertiesNBO properties;
 
 };
 
@@ -294,17 +291,12 @@ struct PeerInformationMessage
   /**
    *
    */
-  uint32_t ats_count GNUNET_PACKED;
-
-  /**
-   *
-   */
-  uint32_t address_active GNUNET_PACKED;
+  uint16_t address_length GNUNET_PACKED;
 
   /**
    *
    */
-  uint32_t id GNUNET_PACKED;
+  uint16_t plugin_name_length GNUNET_PACKED;
 
   /**
    *
@@ -314,12 +306,12 @@ struct PeerInformationMessage
   /**
    *
    */
-  uint16_t address_length GNUNET_PACKED;
+  uint32_t address_active GNUNET_PACKED;
 
   /**
    *
    */
-  uint16_t plugin_name_length GNUNET_PACKED;
+  uint32_t id GNUNET_PACKED;
 
   /**
    *
@@ -331,8 +323,12 @@ struct PeerInformationMessage
    */
   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in;
 
+  /**
+   * Performance properties of the address.
+   */
+  struct GNUNET_ATS_PropertiesNBO properties;
+
   /* followed by:
-   * - struct GNUNET_ATS_Information [ats_count];
    * - char address[address_length]
    * - char plugin_name[plugin_name_length] (including '\0'-termination).
    */
diff --git a/src/ats/ats_api_performance.c b/src/ats/ats_api_performance.c
index 51980f079..aaaaee089 100644
--- a/src/ats/ats_api_performance.c
+++ b/src/ats/ats_api_performance.c
@@ -364,35 +364,27 @@ process_pi_message (struct GNUNET_ATS_PerformanceHandle *ph,
                     const struct GNUNET_MessageHeader *msg)
 {
   const struct PeerInformationMessage *pi;
-  const struct GNUNET_ATS_Information *atsi;
   const char *plugin_address;
   const char *plugin_name;
   struct GNUNET_HELLO_Address address;
   uint16_t plugin_address_length;
   uint16_t plugin_name_length;
-  uint32_t ats_count;
   int addr_active;
+  struct GNUNET_ATS_Properties prop;
 
   if (ntohs (msg->size) < sizeof(struct PeerInformationMessage))
   {
     GNUNET_break(0);
     return GNUNET_SYSERR;
   }
-
   pi = (const struct PeerInformationMessage *) msg;
-  ats_count = ntohl (pi->ats_count);
   plugin_address_length = ntohs (pi->address_length);
   plugin_name_length = ntohs (pi->plugin_name_length);
   addr_active = (int) ntohl (pi->address_active);
-  atsi = (const struct GNUNET_ATS_Information *) &pi[1];
-  plugin_address = (const char *) &atsi[ats_count];
+  plugin_address = (const char *) &pi[1];
   plugin_name = &plugin_address[plugin_address_length];
   if ((plugin_address_length + plugin_name_length
-      + ats_count * sizeof(struct GNUNET_ATS_Information)
       + sizeof(struct PeerInformationMessage) != ntohs (msg->size))
-      || (ats_count
-          > GNUNET_SERVER_MAX_MESSAGE_SIZE
-              / sizeof(struct GNUNET_ATS_Information))
       || (plugin_name[plugin_name_length - 1] != '\0'))
   {
     GNUNET_break(0);
@@ -401,6 +393,8 @@ process_pi_message (struct GNUNET_ATS_PerformanceHandle *ph,
 
   if (NULL != ph->addr_info_cb)
   {
+    GNUNET_ATS_properties_ntoh (&prop,
+                                &pi->properties);
     address.peer = pi->peer;
     address.address = plugin_address;
     address.address_length = plugin_address_length;
@@ -410,7 +404,7 @@ process_pi_message (struct GNUNET_ATS_PerformanceHandle *ph,
                       addr_active,
                       pi->bandwidth_out,
                       pi->bandwidth_in,
-                      atsi, ats_count);
+                      &prop);
   }
   return GNUNET_OK;
 }
@@ -488,15 +482,14 @@ process_ar_message (struct GNUNET_ATS_PerformanceHandle *ph,
   const struct PeerInformationMessage *pi;
   struct GNUNET_ATS_AddressListHandle *alh;
   struct GNUNET_ATS_AddressListHandle *next;
-  const struct GNUNET_ATS_Information *atsi;
   const char *plugin_address;
   const char *plugin_name;
   struct GNUNET_HELLO_Address address;
   struct GNUNET_PeerIdentity allzeros;
   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_zero;
+  struct GNUNET_ATS_Properties prop;
   uint16_t plugin_address_length;
   uint16_t plugin_name_length;
-  uint32_t ats_count;
   uint32_t active;
   uint32_t id;
 
@@ -507,18 +500,13 @@ process_ar_message (struct GNUNET_ATS_PerformanceHandle *ph,
   }
   pi = (const struct PeerInformationMessage *) msg;
   id = ntohl (pi->id);
-  ats_count = ntohl (pi->ats_count);
   active = ntohl (pi->address_active);
   plugin_address_length = ntohs (pi->address_length);
   plugin_name_length = ntohs (pi->plugin_name_length);
-  atsi = (const struct GNUNET_ATS_Information *) &pi[1];
-  plugin_address = (const char *) &atsi[ats_count];
+  plugin_address = (const char *) &pi[1];
   plugin_name = &plugin_address[plugin_address_length];
   if ( (plugin_address_length + plugin_name_length
-        + ats_count * sizeof(struct GNUNET_ATS_Information)
         + sizeof (struct PeerInformationMessage) != ntohs (msg->size)) ||
-       (ats_count > GNUNET_SERVER_MAX_MESSAGE_SIZE
-        / sizeof(struct GNUNET_ATS_Information)) ||
        (plugin_name[plugin_name_length - 1] != '\0') )
   {
     GNUNET_break(0);
@@ -545,8 +533,7 @@ process_ar_message (struct GNUNET_ATS_PerformanceHandle *ph,
   memset (&allzeros, '\0', sizeof (allzeros));
   if ( (0 == memcmp (&allzeros, &pi->peer, sizeof(allzeros))) &&
        (0 == plugin_name_length) &&
-       (0 == plugin_address_length) &&
-       (0 == ats_count) )
+       (0 == plugin_address_length) )
   {
     /* Done */
     LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -561,7 +548,7 @@ process_ar_message (struct GNUNET_ATS_PerformanceHandle *ph,
                GNUNET_NO,
                bandwidth_zero,
                bandwidth_zero,
-               NULL, 0);
+               NULL);
     GNUNET_free (alh);
     return GNUNET_OK;
   }
@@ -573,12 +560,16 @@ process_ar_message (struct GNUNET_ATS_PerformanceHandle *ph,
   if ( ( (GNUNET_YES == alh->all_addresses) ||
          (GNUNET_YES == active) ) &&
        (NULL != alh->cb) )
+  {
+    GNUNET_ATS_properties_ntoh (&prop,
+                                &pi->properties);
     alh->cb (ph->addr_info_cb_cls,
              &address,
              active,
              pi->bandwidth_out,
              pi->bandwidth_in,
-             atsi, ats_count);
+             &prop);
+  }
   return GNUNET_OK;
 }
 
@@ -641,7 +632,7 @@ process_ats_message (void *cls,
                       GNUNET_NO,
                       GNUNET_BANDWIDTH_value_init (0),
                       GNUNET_BANDWIDTH_value_init (0),
-                      NULL, 0);
+                      NULL);
   }
   ph->backoff = GNUNET_TIME_STD_BACKOFF (ph->backoff);
   ph->task = GNUNET_SCHEDULER_add_delayed (ph->backoff,
@@ -917,8 +908,9 @@ GNUNET_ATS_performance_list_addresses_cancel (struct GNUNET_ATS_AddressListHandl
 const char *
 GNUNET_ATS_print_preference_type (uint32_t type)
 {
-  char *prefs[GNUNET_ATS_PreferenceCount] = GNUNET_ATS_PreferenceTypeString;
-  if (type < GNUNET_ATS_PreferenceCount)
+  const char *prefs[] = GNUNET_ATS_PreferenceTypeString;
+
+  if (type < GNUNET_ATS_PREFERENCE_END)
     return prefs[type];
   return NULL;
 }
@@ -930,7 +922,7 @@ GNUNET_ATS_print_preference_type (uint32_t type)
  *
  * @param ph performance handle
  * @param peer identifies the peer
- * @param ... 0-terminated specification of the desired changes
+ * @param ... #GNUNET_ATS_PREFERENCE_END-terminated specification of the desired changes
  */
 void
 GNUNET_ATS_performance_change_preference (struct GNUNET_ATS_PerformanceHandle *ph,
@@ -946,20 +938,18 @@ GNUNET_ATS_performance_change_preference (struct GNUNET_ATS_PerformanceHandle *p
 
   count = 0;
   va_start(ap, peer);
-  while (GNUNET_ATS_PREFERENCE_END != (kind =
-      va_arg (ap, enum GNUNET_ATS_PreferenceKind) ))
+  while (GNUNET_ATS_PREFERENCE_END !=
+         (kind = va_arg (ap, enum GNUNET_ATS_PreferenceKind) ))
   {
     switch (kind)
     {
     case GNUNET_ATS_PREFERENCE_BANDWIDTH:
       count++;
       (void) va_arg (ap, double);
-
       break;
     case GNUNET_ATS_PREFERENCE_LATENCY:
       count++;
       (void) va_arg (ap, double);
-
       break;
     default:
       GNUNET_assert(0);
@@ -1012,7 +1002,7 @@ GNUNET_ATS_performance_change_preference (struct GNUNET_ATS_PerformanceHandle *p
  * @param ph performance handle
  * @param scope the time interval this valid for: [now - scope .. now]
  * @param peer identifies the peer
- * @param ... 0-terminated specification of the desired changes
+ * @param ... #GNUNET_ATS_PREFERENCE_END-terminated specification of the desired changes
  */
 void
 GNUNET_ATS_performance_give_feedback (struct GNUNET_ATS_PerformanceHandle *ph,
@@ -1029,8 +1019,8 @@ GNUNET_ATS_performance_give_feedback (struct GNUNET_ATS_PerformanceHandle *ph,
 
   count = 0;
   va_start(ap, scope);
-  while (GNUNET_ATS_PREFERENCE_END != (kind =
-      va_arg (ap, enum GNUNET_ATS_PreferenceKind) ))
+  while (GNUNET_ATS_PREFERENCE_END !=
+         (kind = va_arg (ap, enum GNUNET_ATS_PreferenceKind) ))
   {
     switch (kind)
     {
diff --git a/src/ats/ats_api_scanner.c b/src/ats/ats_api_scanner.c
index 64c02acf6..f9c30770e 100644
--- a/src/ats/ats_api_scanner.c
+++ b/src/ats/ats_api_scanner.c
@@ -62,32 +62,38 @@ GNUNET_ATS_print_network_type (enum GNUNET_ATS_Network_Type net)
 
 
 /**
- * Convert a ATS property to a string
+ * Convert ATS properties from host to network byte order.
  *
- * @param type the property type
- * @return a string or NULL if invalid
+ * @param nbo[OUT] value written
+ * @param hbo value read
  */
-const char *
-GNUNET_ATS_print_property_type (enum GNUNET_ATS_Property type)
+void
+GNUNET_ATS_properties_hton (struct GNUNET_ATS_PropertiesNBO *nbo,
+                            const struct GNUNET_ATS_Properties *hbo)
 {
-  switch (type)
-  {
-  case GNUNET_ATS_ARRAY_TERMINATOR:
-    return "TERMINATOR";
-  case GNUNET_ATS_UTILIZATION_OUT:
-    return "UTILIZATION_UP";
-  case GNUNET_ATS_UTILIZATION_IN:
-    return "UTILIZATION_DOWN";
-  case GNUNET_ATS_NETWORK_TYPE:
-    return "NETWORK_TYPE";
-  case GNUNET_ATS_QUALITY_NET_DELAY:
-    return "DELAY";
-  case GNUNET_ATS_QUALITY_NET_DISTANCE:
-    return "DISTANCE";
-  default:
-    GNUNET_break (0);
-    return NULL;
-  }
+  nbo->utilization_out = htonl (hbo->utilization_out);
+  nbo->utilization_in = htonl (hbo->utilization_in);
+  nbo->scope = htonl ((uint32_t) hbo->scope);
+  nbo->distance = htonl (hbo->distance);
+  nbo->delay = GNUNET_TIME_relative_hton (hbo->delay);
+}
+
+
+/**
+ * Convert ATS properties from network to host byte order.
+ *
+ * @param hbo[OUT] value written
+ * @param nbo value read
+ */
+void
+GNUNET_ATS_properties_ntoh (struct GNUNET_ATS_Properties *hbo,
+                            const struct GNUNET_ATS_PropertiesNBO *nbo)
+{
+  hbo->utilization_out = ntohl (nbo->utilization_out);
+  hbo->utilization_in = ntohl (nbo->utilization_in);
+  hbo->scope = ntohl ((uint32_t) nbo->scope);
+  hbo->distance = ntohl (nbo->distance);
+  hbo->delay = GNUNET_TIME_relative_ntoh (nbo->delay);
 }
 
 
diff --git a/src/ats/ats_api_scheduling.c b/src/ats/ats_api_scheduling.c
index ed82dd2ad..f02e4a9e7 100644
--- a/src/ats/ats_api_scheduling.c
+++ b/src/ats/ats_api_scheduling.c
@@ -73,14 +73,9 @@ struct GNUNET_ATS_AddressRecord
   struct Session *session;
 
   /**
-   * Array with performance data about the address.
+   * Performance data about the address.
    */
-  struct GNUNET_ATS_Information *ats;
-
-  /**
-   * Number of entries in @e ats.
-   */
-  uint32_t ats_count;
+  struct GNUNET_ATS_PropertiesNBO properties;
 
   /**
    * Which slot (index) in the session array does
@@ -487,7 +482,6 @@ send_add_address_message (struct GNUNET_ATS_SchedulingHandle *sh,
 {
   struct GNUNET_MQ_Envelope *ev;
   struct AddressAddMessage *m;
-  struct GNUNET_ATS_Information *am;
   char *pm;
   size_t namelen;
   size_t msize;
@@ -497,16 +491,14 @@ send_add_address_message (struct GNUNET_ATS_SchedulingHandle *sh,
   namelen = (NULL == ar->address->transport_name)
     ? 0
     : strlen (ar->address->transport_name) + 1;
-  msize = ar->address->address_length +
-    ar->ats_count * sizeof (struct GNUNET_ATS_Information) + namelen;
-
+  msize = ar->address->address_length + namelen;
   ev = GNUNET_MQ_msg_extra (m, msize, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_ADD);
-  m->ats_count = htonl (ar->ats_count);
   m->peer = ar->address->peer;
   m->address_length = htons (ar->address->address_length);
   m->address_local_info = htonl ((uint32_t) ar->address->local_info);
   m->plugin_name_length = htons (namelen);
   m->session_id = htonl (ar->slot);
+  m->properties = ar->properties;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Adding address for peer `%s', plugin `%s', session %p slot %u\n",
@@ -514,11 +506,7 @@ send_add_address_message (struct GNUNET_ATS_SchedulingHandle *sh,
        ar->address->transport_name,
        ar->session,
        ar->slot);
-  am = (struct GNUNET_ATS_Information *) &m[1];
-  memcpy (am,
-          ar->ats,
-          ar->ats_count * sizeof (struct GNUNET_ATS_Information));
-  pm = (char *) &am[ar->ats_count];
+  pm = (char *) &m[1];
   memcpy (pm,
           ar->address->address,
           ar->address->address_length);
@@ -675,8 +663,7 @@ GNUNET_ATS_session_known (struct GNUNET_ATS_SchedulingHandle *sh,
  * @param sh handle
  * @param address the address
  * @param session session handle, can be NULL
- * @param ats performance data for the address
- * @param ats_count number of performance records in @a ats
+ * @param prop performance data for the address
  * @return handle to the address representation inside ATS, NULL
  *         on error (i.e. ATS knows this exact address already)
  */
@@ -684,8 +671,7 @@ struct GNUNET_ATS_AddressRecord *
 GNUNET_ATS_address_add (struct GNUNET_ATS_SchedulingHandle *sh,
                         const struct GNUNET_HELLO_Address *address,
                         struct Session *session,
-                        const struct GNUNET_ATS_Information *ats,
-                        uint32_t ats_count)
+                        const struct GNUNET_ATS_Properties *prop)
 {
   struct GNUNET_ATS_AddressRecord *ar;
   size_t namelen;
@@ -701,13 +687,10 @@ GNUNET_ATS_address_add (struct GNUNET_ATS_SchedulingHandle *sh,
   namelen = (NULL == address->transport_name)
     ? 0
     : strlen (address->transport_name) + 1;
-  msize = address->address_length +
-    ats_count * sizeof (struct GNUNET_ATS_Information) + namelen;
+  msize = address->address_length + namelen;
   if ((msize + sizeof (struct AddressUpdateMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
       (address->address_length >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
-      (namelen >= GNUNET_SERVER_MAX_MESSAGE_SIZE) ||
-      (ats_count >=
-       GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_ATS_Information)))
+      (namelen >= GNUNET_SERVER_MAX_MESSAGE_SIZE) )
   {
     /* address too large for us, this should not happen */
     GNUNET_break (0);
@@ -729,12 +712,8 @@ GNUNET_ATS_address_add (struct GNUNET_ATS_SchedulingHandle *sh,
   ar->slot = s;
   ar->session = session;
   ar->address = GNUNET_HELLO_address_copy (address);
-  GNUNET_array_grow (ar->ats,
-                     ar->ats_count,
-                     ats_count);
-  memcpy (ar->ats,
-          ats,
-          ats_count * sizeof (struct GNUNET_ATS_Information));
+  GNUNET_ATS_properties_hton (&ar->properties,
+                              prop);
   sh->session_array[s] = ar;
   send_add_address_message (sh, ar);
   return ar;
@@ -793,19 +772,15 @@ GNUNET_ATS_address_del_session (struct GNUNET_ATS_AddressRecord *ar,
  * for later use).  Update bandwidth assignments.
  *
  * @param ar address record to update information for
- * @param ats performance data for the address
- * @param ats_count number of performance records in @a ats
+ * @param prop performance data for the address
  */
 void
 GNUNET_ATS_address_update (struct GNUNET_ATS_AddressRecord *ar,
-                           const struct GNUNET_ATS_Information *ats,
-                           uint32_t ats_count)
+                           const struct GNUNET_ATS_Properties *prop)
 {
   struct GNUNET_ATS_SchedulingHandle *sh = ar->sh;
   struct GNUNET_MQ_Envelope *ev;
   struct AddressUpdateMessage *m;
-  struct GNUNET_ATS_Information *am;
-  size_t msize;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Updating address for peer `%s', plugin `%s', session %p slot %u\n",
@@ -813,25 +788,16 @@ GNUNET_ATS_address_update (struct GNUNET_ATS_AddressRecord *ar,
        ar->address->transport_name,
        ar->session,
        ar->slot);
-  GNUNET_array_grow (ar->ats,
-                     ar->ats_count,
-                     ats_count);
-  memcpy (ar->ats,
-          ats,
-          ats_count * sizeof (struct GNUNET_ATS_Information));
-
+  GNUNET_ATS_properties_hton (&ar->properties,
+                              prop);
   if (NULL == sh->mq)
     return; /* disconnected, skip for now */
-  msize = ar->ats_count * sizeof (struct GNUNET_ATS_Information);
-  ev = GNUNET_MQ_msg_extra (m, msize, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE);
-  m->ats_count = htonl (ar->ats_count);
-  m->peer = ar->address->peer;
+  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE);
   m->session_id = htonl (ar->slot);
-  am = (struct GNUNET_ATS_Information *) &m[1];
-  memcpy (am,
-          ar->ats,
-          ar->ats_count * sizeof (struct GNUNET_ATS_Information));
-  GNUNET_MQ_send (sh->mq, ev);
+  m->peer = ar->address->peer;
+  m->properties = ar->properties;
+  GNUNET_MQ_send (sh->mq,
+                  ev);
 }
 
 
@@ -857,9 +823,6 @@ GNUNET_ATS_address_destroy (struct GNUNET_ATS_AddressRecord *ar)
   GNUNET_break (NULL == ar->session);
   ar->session = NULL;
   ar->in_destroy = GNUNET_YES;
-  GNUNET_array_grow (ar->ats,
-                     ar->ats_count,
-                     0);
   if (NULL == sh->mq)
     return;
   ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED);
diff --git a/src/ats/gnunet-ats-solver-eval.c b/src/ats/gnunet-ats-solver-eval.c
index 8cf4b115b..5645e81c5 100644
--- a/src/ats/gnunet-ats-solver-eval.c
+++ b/src/ats/gnunet-ats-solver-eval.c
@@ -166,7 +166,8 @@ GNUNET_ATS_solver_logging_now (struct LoggingHandle *l)
   /* Store logging data here */
   for (cur = peer_head; NULL != cur; cur = cur->next)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Logging peer id %llu\n", cur->id);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Logging peer id %llu\n", cur->id);
 
     log_p = GNUNET_new (struct LoggingPeer);
     log_p->id = cur->id;
@@ -176,16 +177,18 @@ GNUNET_ATS_solver_logging_now (struct LoggingHandle *l)
     {
       log_p->pref_abs[c] = cur->pref_abs[c];
       log_p->pref_norm[c] = cur->pref_norm[c];
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t %s = %.2f %.2f [abs/rel]\n",
-          GNUNET_ATS_print_preference_type(c),
-          log_p->pref_abs[c], log_p->pref_norm[c]);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "\t %s = %.2f %.2f [abs/rel]\n",
+                  GNUNET_ATS_print_preference_type(c),
+                  log_p->pref_abs[c], log_p->pref_norm[c]);
     }
     GNUNET_CONTAINER_DLL_insert_tail(lts->head, lts->tail, log_p);
 
     for (cur_addr = cur->addr_head; NULL != cur_addr; cur_addr = cur_addr->next)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Logging peer id %llu address %llu \n",
-          cur->id, cur_addr->aid);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Logging peer id %llu address %llu\n",
+                  cur->id, cur_addr->aid);
       log_a = GNUNET_new (struct LoggingAddress);
       log_a->aid = cur_addr->aid;
       log_a->active = cur_addr->ats_addr->active;
@@ -196,9 +199,11 @@ GNUNET_ATS_solver_logging_now (struct LoggingHandle *l)
       {
         log_a->prop_abs[c] = cur_addr->prop_abs[c];
         log_a->prop_norm[c] = cur_addr->prop_norm[c];
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t %s = %.2f %.2f [abs/rel]\n",
-            GNUNET_ATS_print_property_type(c),
-            log_a->prop_abs[c], log_a->prop_norm[c]);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "\t %s = %.2f %.2f [abs/rel]\n",
+                    GNUNET_ATS_print_property_type(c),
+                    log_a->prop_abs[c],
+                    log_a->prop_norm[c]);
       }
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t Active = %i\n", log_a->active);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\t BW in = %llu\n", log_a->assigned_bw_in);
@@ -209,16 +214,17 @@ GNUNET_ATS_solver_logging_now (struct LoggingHandle *l)
   }
 }
 
+
 static void
 logging_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct LoggingHandle *l = cls;
-  l->logging_task = NULL;
 
+  l->logging_task = NULL;
   GNUNET_ATS_solver_logging_now (l);
-
-  l->logging_task = GNUNET_SCHEDULER_add_delayed (l->log_freq, &logging_task, l);
-
+  l->logging_task = GNUNET_SCHEDULER_add_delayed (l->log_freq,
+                                                  &logging_task,
+                                                  l);
 }
 
 struct LoggingHandle *
@@ -395,7 +401,9 @@ GNUNET_ATS_solver_logging_write_to_disk (struct LoggingHandle *l, int add_time_s
               GNUNET_ATS_print_property_type(c),
               log_a->prop_abs[c], log_a->prop_norm[c]);*/
           GNUNET_asprintf(&propstring_tmp,"%s%.3f;%.3f;",
-              propstring, log_a->prop_abs[c], log_a->prop_norm[c]);
+                          propstring,
+                          log_a->prop_abs[c],
+                          log_a->prop_norm[c]);
           GNUNET_free (propstring);
           propstring = GNUNET_strdup(propstring_tmp);
           GNUNET_free (propstring_tmp);
@@ -519,10 +527,10 @@ GNUNET_ATS_solver_logging_free (struct LoggingHandle *l)
 /**
  * Property Generators
  */
-
 static struct PropertyGenerator *prop_gen_head;
 static struct PropertyGenerator *prop_gen_tail;
 
+
 static double
 get_property (struct PropertyGenerator *pg)
 {
@@ -3001,7 +3009,7 @@ get_preferences_cb (void *cls, const struct GNUNET_PeerIdentity *id)
   }
   else
     return GAS_preference_get_by_peer (NULL,
-                                                      id);
+                                       id);
 }
 
 
diff --git a/src/ats/gnunet-ats-solver-eval.h b/src/ats/gnunet-ats-solver-eval.h
index bc5083e34..44ccfe081 100644
--- a/src/ats/gnunet-ats-solver-eval.h
+++ b/src/ats/gnunet-ats-solver-eval.h
@@ -120,8 +120,8 @@ struct LoggingPeer
 
   long long unsigned int id;
   struct GNUNET_PeerIdentity peer_id;
-  double pref_abs[GNUNET_ATS_PreferenceCount];
-  double pref_norm[GNUNET_ATS_PreferenceCount];
+  double pref_abs[GNUNET_ATS_PREFERENCE_END];
+  double pref_norm[GNUNET_ATS_PREFERENCE_END];
   int is_requested;
 
   struct LoggingAddress *addr_head;
@@ -215,7 +215,7 @@ struct GNUNET_ATS_TEST_Operation
   enum OperationType type;
   enum GeneratorType gen_type;
   enum GNUNET_ATS_PreferenceKind pref_type;
-  enum GNUNET_ATS_Property prop_type;
+  // enum GNUNET_ATS_Property prop_type;
 };
 
 struct Episode
diff --git a/src/ats/gnunet-service-ats.c b/src/ats/gnunet-service-ats.c
index 716bd6332..8570b57b6 100644
--- a/src/ats/gnunet-service-ats.c
+++ b/src/ats/gnunet-service-ats.c
@@ -177,7 +177,8 @@ run (void *cls,
     {&GAS_handle_address_add, NULL,
      GNUNET_MESSAGE_TYPE_ATS_ADDRESS_ADD, 0},
     {&GAS_handle_address_update, NULL,
-     GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE, 0},
+     GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE,
+     sizeof (struct AddressUpdateMessage) },
     {&GAS_handle_address_destroyed, NULL,
      GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED,
      sizeof (struct AddressDestroyedMessage) },
diff --git a/src/ats/gnunet-service-ats_addresses.c b/src/ats/gnunet-service-ats_addresses.c
index c4d7f2da9..17f030a6c 100644
--- a/src/ats/gnunet-service-ats_addresses.c
+++ b/src/ats/gnunet-service-ats_addresses.c
@@ -32,186 +32,6 @@
 
 
 /**
- * NOTE: Do not change this documentation. This documentation is based on
- * gnunet.org:/vcs/fsnsg/2014-p2p-ats.git/tech-doku/ats-tech-guide.tex
- * use build_txt.sh to generate plaintext output
- *
- *   1 ATS addresses : ATS address management
- *
- *    This ATS addresses ("addresses") component manages the addresses known to
- *    ATS service and suggests addresses to transport service when it is
- *    interested in address suggestion for a peer. ATS addresses also
- *    instantiates the bandwidth assignment mechanism (solver), notifies it
- *    about changes to addresses and forwards changes to bandwidth assignments
- *    to transport, depending if transport is interested in this change.
- *
- *     1.1 Input data
- *
- *       1.1.1 Addresses
- *
- *    Addresses are added by specifying peer ID, plugin, address, address length
- *    and session, if available. ATS information can be specified if available.
- *
- *       1.1.2 Networks
- *
- *    ATS specifies a fix set of networks an address can belong to. For each
- *    network an inbound and outbound quota will be specified. The available
- *    networks and addtional helper varaibles are defined in
- *    gnunet_ats_service.h. At the moment 5 networks are defined:
- *      * GNUNET_ATS_NET_UNSPECIFIED
- *      * GNUNET_ATS_NET_LOOPBACK
- *      * GNUNET_ATS_NET_LAN
- *      * GNUNET_ATS_NET_WAN
- *      * GNUNET_ATS_NET_WLAN
- *
- *    The total number of networks defined is stored in
- *    GNUNET_ATS_NetworkTypeCount GNUNET_ATS_NetworkType can be used array
- *    initializer for an int array, while GNUNET_ATS_NetworkType is an
- *    initializer for a char array containing a string description of all
- *    networks
- *
- *       1.1.3 Quotas
- *
- *    An inbound and outbound quota for each of the networks mentioned in 1.1.2
- *    is loaded from ats configuration during initialization. This quota defines
- *    to total amount of inbound and outbound traffic allowed for a specific
- *    network. The configuration values used are in section ats:
- *      * "NETWORK"_QUOTA_IN = <value>
- *      * "NETWORK"_QUOTA_IN = <value>
- *
- *    You can specify quotas by setting the <value> to a:
- *      * unrestricted: unlimited
- *      * number of bytes: e.g. 10240
- *      * fancy value: e.g. 64 Kib
- *
- *    unlimited is defined as GNUNET_ATS_MaxBandwidthString and equivalent to
- *    the value GNUNET_ATS_MaxBandwidth Important predefined values for quotas
- *    are:
- *      * GNUNET_ATS_DefaultBandwidth: 65536
- *      * GNUNET_ATS_MaxBandwidth: UINT32_MAX
- *      * GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT: 1024
- *
- *    Details of loading quotas and default values will be described on
- *
- *       1.1.4 Preference values
- *
- *     1.2 Data structures used
- *
- *    Addresse uses struct ATS_Address for each address. The structs are stored
- *    in a linked list and provides a pointer void *solver_information for the
- *    solver to store address specific information. It provides the int values
- *    active which is set to GNUNET_YES if the address is select for transport
- *    use and used, representing that transport service is actively using this
- *    address. Address information are stored in peer, addr, addr_len, plugin.
- *
- *     1.3 Initialization
- *
- *    During initialization a hashmap to store addresses is created. The quotas
- *    for all networks defined for ATS are loaded from configuration. For each
- *    network first the logic will check if the string
- *    GNUNET_ATS_MaxBandwidthString is configured, if not it will try to convert
- *    the configured value as a fancy size and if this fails it will try to use
- *    it as a value_number. If no configuration value is found it will assign
- *    GNUNET_ATS_DefaultBandwidth. The most important step is to load the
- *    configured solver using configuration "[ats]:MODE". Current solvers are
- *    MODE_PROPORTIONAL, MODE_MLP. Interaction is done using a solver API
- *
- *     1.4 Solver API
- *
- *    Solver functions:
- *      * s_init: init the solver with required information
- *      * s_add: add a new address
- *      * s_update: update ATS values or session for an address
- *      * s_get: get prefered address for a peer
- *      * s_del: delete an address
- *      * s_pref: change preference value for a peer
- *      * s_done: shutdown solver
- *
- *    Callbacks: addresses provides a bandwidth_changed_cb callback to the
- *    solver which is called when bandwidth assigned to peer has changed
- *
- *     1.5 Shutdown
- *
- *    During shutdown all addresses are freed and the solver told to shutdown
- *
- *     1.6 Addresses and sessions
- *
- *    Addresses consist of the address itself and a numerical session. When a
- *    new address without a session is added it has no session, so it gets
- *    session 0 assigned. When an address with a session is added and an address
- *    object with session 0 is found, this object is updated with the session
- *    otherwise a new address object with this session assigned is created.
- *
- *       1.6.1 Terminology
- *
- *    Addresses a1,a2 with session s1, s2 are "exact" if:
- *    (a1 == a2)&&(s1 == s2)
- *    Addresses a1,a2 with session s1, s2 are "equivalent" if:
- *    (a1 == a2)&&((s1 == s2)||(s1 == 0)||(s2 == 0)
- *
- *     1.7 Address management
- *
- *    Transport service notifies ATS about changes to the addresses known to
- *    him.
- *
- *       1.7.1 Adding an address
- *
- *    When transport learns a new address it tells ATS and ATS is telling
- *    addresses about it using GAS_address_add. If not known to addresses it
- *    creates a new address object and calls solver's s_add. ATS information are
- *    deserialized and solver is notified about the session and ATS information
- *    using s_update.
- *
- *       1.7.2 Updating an address
- *
- *    Addresses does an lookup up for the existing address with the given
- *    session. If disassembles included ATS information and notifies the solver
- *    using s_update about the update.
- *
- *       1.7.3 Deleting an address
- *
- *    Addresses does an lookup for the exact address and session and if removes
- *    this address. If session != 0 the session is set to 0 and the address is
- *    kept. If session == 0, the addresses is removed.
- *
- *       1.7.4 Requesting an address suggestion
- *
- *    The address client issues a request address message to be notified about
- *    address suggestions for a specific peer. Addresses asks the solver with
- *    s_get. If no address is available, it will not send a response, otherwise
- *    it will respond with the choosen address.
- *
- *       1.7.5 Address suggestions
- *
- *    Addresses will notify the client automatically on any bandwidth_changed_cb
- *    by the solver if a address suggestion request is pending. If no address is
- *    available it will not respond at all If the client is not interested
- *    anymore, it has to cancel the address suggestion request.
- *
- *       1.7.6 Address lifecycle
- *
- *      * (add address)
- *      * (updated address)
- *      * (delete address)
- *
- *     1.8 Bandwidth assignment
- *
- *    The addresses are used to perform resource allocation operations. ATS
- *    addresses takes care of instantiating the solver configured and notifies
- *    the respective solver about address changes and receives changes to the
- *    bandwidth assignment from the solver. The current bandwidth assignment is
- *    sent to transport. The specific solvers will be described in the specific
- *    section.
- *
- *     1.9 Changing peer preferences
- *
- *    The bandwidth assigned to a peer can be influenced by setting a preference
- *    for a peer. The prefernce will be given to to the solver with s_pref which
- *    has to take care of the preference value
- */
-
-
-/**
  * A multihashmap to store all addresses
  */
 struct GNUNET_CONTAINER_MultiPeerMap *GSA_addresses;
@@ -231,124 +51,6 @@ update_addresses_stat ()
 
 
 /**
- * Disassemble ATS information and update performance information in address
- *
- * Updates existing information and adds new information
- *
- * @param dest destination address
- * @param update source ATS information
- * @param update_count number of ATS information in @a update
- * @param delta_dest ats performance information which were updated
- *                              including previous value
- * @param delta_count number of ATS information in the @a delta_dest
- * @return #GNUNET_YES if address was address updated, GNUNET_NO otherwise
- */
-static unsigned int
-disassemble_ats_information (struct ATS_Address *dest,
-                             const struct GNUNET_ATS_Information *update,
-                             uint32_t update_count,
-                             struct GNUNET_ATS_Information **delta_dest,
-                             uint32_t *delta_count)
-{
-  int c1;
-  int c2;
-  int found;
-  int change;
-  struct GNUNET_ATS_Information add_atsi[update_count];
-  struct GNUNET_ATS_Information delta_atsi[update_count];
-  struct GNUNET_ATS_Information *tmp_atsi;
-  uint32_t add_atsi_count;
-  uint32_t delta_atsi_count;
-
-  change = GNUNET_NO;
-  add_atsi_count = 0;
-  delta_atsi_count = 0;
-
-  if (0 == update_count)
-    return GNUNET_NO;
-
-  if (NULL == dest->atsi)
-  {
-    /* Create performance information */
-    dest->atsi =
-        GNUNET_malloc (update_count * sizeof (struct GNUNET_ATS_Information));
-    dest->atsi_count = update_count;
-    memcpy (dest->atsi,
-            update,
-            update_count * sizeof(struct GNUNET_ATS_Information));
-    *delta_dest =
-        GNUNET_malloc (update_count * sizeof (struct GNUNET_ATS_Information));
-    for (c1 = 0; c1 < update_count; c1++)
-    {
-      (*delta_dest)[c1].type = update[c1].type;
-      (*delta_dest)[c1].value = htonl (GNUNET_ATS_VALUE_UNDEFINED);
-    }
-    (*delta_count) = update_count;
-    return GNUNET_YES;
-  }
-
-  for (c1 = 0; c1 < update_count; c1++)
-  {
-    /* Update existing performance information */
-    found = GNUNET_NO;
-    for (c2 = 0; c2 < dest->atsi_count; c2++)
-    {
-      if (update[c1].type == dest->atsi[c2].type)
-      {
-        if (update[c1].value != dest->atsi[c2].value)
-        {
-          /* Save previous value in delta */
-          delta_atsi[delta_atsi_count] = dest->atsi[c2];
-          delta_atsi_count++;
-          /* Set new value */
-          dest->atsi[c2].value = update[c1].value;
-          change = GNUNET_YES;
-        }
-        found = GNUNET_YES;
-        break;
-      }
-    }
-    if (GNUNET_NO == found)
-    {
-      add_atsi[add_atsi_count] = update[c1];
-      add_atsi_count++;
-      delta_atsi[delta_atsi_count].type = update[c1].type;
-      delta_atsi[delta_atsi_count].value = htonl (GNUNET_ATS_VALUE_UNDEFINED);
-      delta_atsi_count++;
-    }
-  }
-
-  if (add_atsi_count > 0)
-  {
-    /* Extend ats performance information */
-
-    tmp_atsi = GNUNET_malloc ((dest->atsi_count + add_atsi_count) *
-        (sizeof (struct GNUNET_ATS_Information)));
-    memcpy (tmp_atsi, dest->atsi,
-        dest->atsi_count * sizeof(struct GNUNET_ATS_Information));
-    memcpy (&tmp_atsi[dest->atsi_count], add_atsi,
-        add_atsi_count * sizeof(struct GNUNET_ATS_Information));
-    GNUNET_free (dest->atsi);
-    dest->atsi = tmp_atsi;
-    dest->atsi_count = dest->atsi_count + add_atsi_count;
-    change = GNUNET_YES;
-  }
-
-  if (delta_atsi_count > 0)
-  {
-    /* Copy delta */
-    (*delta_dest) =
-        GNUNET_malloc (delta_atsi_count * sizeof (struct GNUNET_ATS_Information));
-    memcpy ((*delta_dest), delta_atsi,
-        delta_atsi_count * sizeof(struct GNUNET_ATS_Information));
-    (*delta_count) = delta_atsi_count;
-  }
-
-  return change;
-}
-
-
-/**
  * Free the given address
  *
  * @param addr address to destroy
@@ -366,16 +68,30 @@ free_address (struct ATS_Address *addr)
                                       addr->addr,
                                       addr->addr_len,
                                       GNUNET_NO,
-                                      NULL, 0,
+                                      NULL,
                                       GNUNET_BANDWIDTH_ZERO,
                                       GNUNET_BANDWIDTH_ZERO);
   GNUNET_free (addr->plugin);
-  GNUNET_free_non_null (addr->atsi);
   GNUNET_free (addr);
 }
 
 
 /**
+ * Initialize @a norm.  Sets all historic values to undefined.
+ *
+ * @param norm normalization data to initialize
+ */
+static void
+init_norm (struct GAS_NormalizationInfo *norm)
+{
+  unsigned int c;
+
+  for (c = 0; c < GAS_normalization_queue_length; c++)
+    norm->atsi_abs[c] = UINT64_MAX;
+}
+
+
+/**
  * Create a ATS_address with the given information
  *
  * @param peer peer
@@ -395,8 +111,6 @@ create_address (const struct GNUNET_PeerIdentity *peer,
                 uint32_t session_id)
 {
   struct ATS_Address *aa;
-  unsigned int c1;
-  unsigned int c2;
 
   aa = GNUNET_malloc (sizeof (struct ATS_Address) + plugin_addr_len);
   aa->peer = *peer;
@@ -408,14 +122,10 @@ create_address (const struct GNUNET_PeerIdentity *peer,
   aa->plugin = GNUNET_strdup (plugin_name);
   aa->session_id = session_id;
   aa->local_address_info = local_address_info;
-
-  for (c1 = 0; c1 < GNUNET_ATS_QualityPropertiesCount; c1++)
-  {
-    aa->atsin[c1].avg_queue_index = 0;
-    aa->atsin[c1].norm = DEFAULT_REL_QUALITY;
-    for (c2 = 0; c2 < GAS_normalization_queue_length; c2++)
-      aa->atsin[c1].atsi_abs[c2] = GNUNET_ATS_VALUE_UNDEFINED;
-  }
+  init_norm (&aa->norm_delay);
+  init_norm (&aa->norm_distance);
+  init_norm (&aa->norm_utilization_in);
+  init_norm (&aa->norm_utilization_out);
   return aa;
 }
 
@@ -486,31 +196,6 @@ find_exact_address (const struct GNUNET_PeerIdentity *peer,
 
 
 /**
- * Extract an ATS performance info from an address
- *
- * @param address the address
- * @param type the type to extract in HBO
- * @return the value in HBO or #GNUNET_ATS_VALUE_UNDEFINED in HBO if value does not exist
- */
-static int
-get_performance_info (struct ATS_Address *address,
-                      uint32_t type)
-{
-  uint32_t c1;
-
-  if ((NULL == address->atsi) || (0 == address->atsi_count))
-    return GNUNET_ATS_VALUE_UNDEFINED;
-
-  for (c1 = 0; c1 < address->atsi_count; c1++)
-  {
-    if (ntohl (address->atsi[c1].type) == type)
-      return ntohl (address->atsi[c1].value);
-  }
-  return GNUNET_ATS_VALUE_UNDEFINED;
-}
-
-
-/**
  * Add a new address for a peer.
  *
  * @param peer peer
@@ -519,8 +204,7 @@ get_performance_info (struct ATS_Address *address,
  * @param plugin_addr_len length of the plugin address in @a plugin_addr
  * @param local_address_info the local address for the address
  * @param session_id session id, can be 0
- * @param atsi performance information for this address
- * @param atsi_count number of performance information contained in @a atsi
+ * @param prop performance information for this address
  */
 void
 GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
@@ -529,15 +213,12 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
                    size_t plugin_addr_len,
                    uint32_t local_address_info,
                    uint32_t session_id,
-                   const struct GNUNET_ATS_Information *atsi,
-                   uint32_t atsi_count)
+                   const struct GNUNET_ATS_Properties *prop)
 {
   struct ATS_Address *new_address;
-  struct GNUNET_ATS_Information *atsi_delta;
-  uint32_t atsi_delta_count;
-  uint32_t addr_net;
 
-  if (NULL != find_exact_address (peer, session_id))
+  if (NULL != find_exact_address (peer,
+                                  session_id))
   {
     GNUNET_break (0);
     return;
@@ -548,17 +229,8 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
                                 plugin_addr_len,
                                 local_address_info,
                                 session_id);
-  atsi_delta = NULL;
-  disassemble_ats_information (new_address,
-                               atsi, atsi_count,
-                               &atsi_delta,
-                               &atsi_delta_count);
-  GNUNET_free_non_null (atsi_delta);
-  addr_net = get_performance_info (new_address, GNUNET_ATS_NETWORK_TYPE);
-  if (GNUNET_ATS_VALUE_UNDEFINED == addr_net)
-    addr_net = GNUNET_ATS_NET_UNSPECIFIED;
-
   /* Add a new address */
+  new_address->properties = *prop;
   new_address->t_added = GNUNET_TIME_absolute_get();
   new_address->t_last_activity = GNUNET_TIME_absolute_get();
   GNUNET_assert(GNUNET_OK ==
@@ -573,11 +245,8 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
               session_id);
   /* Tell solver about new address */
   GAS_plugin_solver_lock ();
-  GAS_plugin_new_address (new_address,
-                          addr_net);
-  GAS_normalization_update_property (new_address,
-                                     atsi,
-                                     atsi_count);
+  GAS_plugin_new_address (new_address);
+  GAS_normalization_update_property (new_address); // FIXME: needed?
   GAS_plugin_solver_unlock ();
   /* Notify performance clients about new address */
   GAS_performance_notify_all_clients (&new_address->peer,
@@ -585,8 +254,7 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
                                       new_address->addr,
                                       new_address->addr_len,
                                       new_address->active,
-                                      new_address->atsi,
-                                      new_address->atsi_count,
+                                      &new_address->properties,
                                       GNUNET_BANDWIDTH_value_init (new_address->assigned_bw_out),
                                       GNUNET_BANDWIDTH_value_init (new_address->assigned_bw_in));
 }
@@ -597,18 +265,14 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
  *
  * @param peer peer
  * @param session_id session id, never 0
- * @param atsi performance information for this address
- * @param atsi_count number of performance information contained in @a atsi
+ * @param prop performance information for this address
  */
 void
 GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
                       uint32_t session_id,
-                      const struct GNUNET_ATS_Information *atsi,
-                      uint32_t atsi_count)
+                      const struct GNUNET_ATS_Properties *prop)
 {
   struct ATS_Address *aa;
-  struct GNUNET_ATS_Information *atsi_delta;
-  uint32_t atsi_delta_count;
 
   /* Get existing address */
   aa = find_exact_address (peer,
@@ -630,30 +294,18 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
 
   /* Update address */
   aa->t_last_activity = GNUNET_TIME_absolute_get();
-  atsi_delta = NULL;
-  atsi_delta_count = 0;
-  if (GNUNET_YES ==
-      disassemble_ats_information (aa, atsi,
-                                   atsi_count,
-                                   &atsi_delta,
-                                   &atsi_delta_count))
-  {
-    /* 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));
-
-    GAS_normalization_update_property (aa,
-                                          atsi,
-                                          atsi_count);
-  }
-  GNUNET_free_non_null (atsi_delta);
+  aa->properties = *prop;
+  /* Notify performance clients about updated address */
+  GAS_performance_notify_all_clients (&aa->peer,
+                                      aa->plugin,
+                                      aa->addr,
+                                      aa->addr_len,
+                                      aa->active,
+                                      prop,
+                                      GNUNET_BANDWIDTH_value_init (aa->assigned_bw_out),
+                                      GNUNET_BANDWIDTH_value_init (aa->assigned_bw_in));
+
+  GAS_normalization_update_property (aa);
 }
 
 
@@ -793,7 +445,7 @@ peerinfo_it (void *cls,
               addr->addr,
               addr->addr_len,
               addr->active,
-              addr->atsi, addr->atsi_count,
+              &addr->properties,
               GNUNET_BANDWIDTH_value_init (addr->assigned_bw_out),
               GNUNET_BANDWIDTH_value_init (addr->assigned_bw_in));
   return GNUNET_OK;
@@ -839,7 +491,7 @@ GAS_addresses_get_peer_info (const struct GNUNET_PeerIdentity *peer,
   pi_it (pi_it_cls,
          NULL, NULL, NULL, 0,
          GNUNET_NO,
-         NULL, 0,
+         NULL,
          GNUNET_BANDWIDTH_ZERO,
          GNUNET_BANDWIDTH_ZERO);
 }
@@ -879,8 +531,7 @@ struct AddressIteration
  * @param plugin_addr address
  * @param plugin_addr_len length of @a plugin_addr
  * @param active #GNUNET_YES if this address is actively used
- * @param atsi ats performance information
- * @param atsi_count number of ats performance elements in @a atsi
+ * @param prop performance information
  * @param bandwidth_out current outbound bandwidth assigned to address
  * @param bandwidth_in current inbound bandwidth assigned to address
  */
@@ -891,13 +542,11 @@ transmit_req_addr (struct AddressIteration *ai,
                    const void *plugin_addr,
                    size_t plugin_addr_len,
                    int active,
-                   const struct GNUNET_ATS_Information *atsi,
-                   uint32_t atsi_count,
+                   const struct GNUNET_ATS_Properties *prop,
                    struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
                    struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 
 {
-  struct GNUNET_ATS_Information *atsp;
   struct PeerInformationMessage *msg;
   char *addrp;
   size_t plugin_name_length;
@@ -909,18 +558,13 @@ transmit_req_addr (struct AddressIteration *ai,
   else
     plugin_name_length = 0;
   msize = sizeof (struct PeerInformationMessage) +
-          atsi_count * sizeof (struct GNUNET_ATS_Information) +
           plugin_addr_len + plugin_name_length;
   char buf[msize] GNUNET_ALIGN;
 
   GNUNET_assert (msize < GNUNET_SERVER_MAX_MESSAGE_SIZE);
-  GNUNET_assert (atsi_count <
-                 GNUNET_SERVER_MAX_MESSAGE_SIZE /
-                 sizeof (struct GNUNET_ATS_Information));
   msg = (struct PeerInformationMessage *) buf;
   msg->header.size = htons (msize);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE);
-  msg->ats_count = htonl (atsi_count);
   msg->id = htonl (ai->id);
   if (NULL != id)
     msg->peer = *id;
@@ -931,9 +575,9 @@ transmit_req_addr (struct AddressIteration *ai,
   msg->plugin_name_length = htons (plugin_name_length);
   msg->bandwidth_out = bandwidth_out;
   msg->bandwidth_in = bandwidth_in;
-  atsp = (struct GNUNET_ATS_Information *) &msg[1];
-  memcpy (atsp, atsi, sizeof (struct GNUNET_ATS_Information) * atsi_count);
-  addrp = (char *) &atsp[atsi_count];
+  GNUNET_ATS_properties_hton (&msg->properties,
+                              prop);
+  addrp = (char *) &msg[1];
   if (NULL != plugin_addr)
     memcpy (addrp, plugin_addr, plugin_addr_len);
   if (NULL != plugin_name)
@@ -962,8 +606,7 @@ transmit_req_addr (struct AddressIteration *ai,
  * @param plugin_addr address
  * @param plugin_addr_len length of @a plugin_addr
  * @param active is address actively used
- * @param atsi ats performance information
- * @param atsi_count number of ats performance elements in @a atsi
+ * @param prop performance information
  * @param bandwidth_out current outbound bandwidth assigned to address
  * @param bandwidth_in current inbound bandwidth assigned to address
  */
@@ -974,8 +617,7 @@ req_addr_peerinfo_it (void *cls,
                       const void *plugin_addr,
                       size_t plugin_addr_len,
                       int active,
-                      const struct GNUNET_ATS_Information *atsi,
-                      uint32_t atsi_count,
+                      const struct GNUNET_ATS_Properties *prop,
                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 {
@@ -1006,8 +648,7 @@ req_addr_peerinfo_it (void *cls,
                      plugin_name,
                      plugin_addr, plugin_addr_len,
                      active,
-                     atsi,
-                     atsi_count,
+                     prop,
                      bandwidth_out,
                      bandwidth_in);
 }
@@ -1061,7 +702,7 @@ GAS_handle_request_address_list (void *cls,
   transmit_req_addr (&ai,
                      NULL, NULL, NULL,
                      0, GNUNET_NO,
-                     NULL, 0,
+                     NULL,
                      GNUNET_BANDWIDTH_ZERO,
                      GNUNET_BANDWIDTH_ZERO);
   GNUNET_SERVER_receive_done (client,
diff --git a/src/ats/gnunet-service-ats_addresses.h b/src/ats/gnunet-service-ats_addresses.h
index 2be8277e1..072a3d078 100644
--- a/src/ats/gnunet-service-ats_addresses.h
+++ b/src/ats/gnunet-service-ats_addresses.h
@@ -235,12 +235,12 @@ struct GAS_NormalizationInfo
   /**
    * Averaging queue
    */
-  uint32_t atsi_abs[GAS_normalization_queue_length];
+  uint64_t atsi_abs[GAS_normalization_queue_length];
 
   /**
    * Averaged ATSI values from queue
    */
-  uint32_t avg;
+  uint64_t avg;
 
   /**
    * Normalized values from queue to a range of values [1.0...2.0]
@@ -277,7 +277,7 @@ struct ATS_Address
   /**
    * ATS performance information for this address
    */
-  struct GNUNET_ATS_Information *atsi;
+  struct GNUNET_ATS_Properties properties;
 
   /**
    * Time when address had last activity (update, in uses)
@@ -336,10 +336,25 @@ struct ATS_Address
   int active;
 
   /**
-   * Normalized ATS performance information for this address
-   * Each entry can be accessed using the GNUNET_ATS_QualityProperties avg_queue_index
+   * Normalized delay information for this address.
    */
-  struct GAS_NormalizationInfo atsin[GNUNET_ATS_QualityPropertiesCount];
+  struct GAS_NormalizationInfo norm_delay;
+
+  /**
+   * Normalized distance information for this address.
+   */
+  struct GAS_NormalizationInfo norm_distance;
+
+  /**
+   * Normalized utilization inbound for this address.
+   */
+  struct GAS_NormalizationInfo norm_utilization_in;
+
+    /**
+   * Normalized utilization outbound for this address.
+   */
+  struct GAS_NormalizationInfo norm_utilization_out;
+
 };
 
 
@@ -375,8 +390,7 @@ GAS_addresses_done (void);
  * @param plugin_addr_len length of the @a plugin_addr
  * @param local_address_info the local address for the address
  * @param session_id session id, can never be 0.
- * @param atsi performance information for this address
- * @param atsi_count number of performance information contained in @a atsi
+ * @param prop performance information for this address
  */
 void
 GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
@@ -385,8 +399,7 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
                    size_t plugin_addr_len,
                    uint32_t local_address_info,
                    uint32_t session_id,
-                   const struct GNUNET_ATS_Information *atsi,
-                   uint32_t atsi_count);
+                   const struct GNUNET_ATS_Properties *prop);
 
 
 /**
@@ -394,14 +407,12 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
  *
  * @param peer peer
  * @param session_id session id, can never be 0
- * @param atsi performance information for this address
- * @param atsi_count number of performance information contained in @a atsi
+ * @param prop performance information for this address
  */
 void
 GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
                       uint32_t session_id,
-                      const struct GNUNET_ATS_Information *atsi,
-                      uint32_t atsi_count);
+                      const struct GNUNET_ATS_Properties *prop);
 
 
 /**
@@ -432,7 +443,6 @@ GAS_addresses_destroy_all (void);
  * @param plugin_addr_len length of @a plugin_addr
  * @param address_active is address actively used
  * @param atsi ats performance information
- * @param atsi_count number of ats performance elements in @a atsi
  * @param bandwidth_out current outbound bandwidth assigned to address
  * @param bandwidth_in current inbound bandwidth assigned to address
  */
@@ -443,8 +453,7 @@ typedef void
                                  const void *plugin_addr,
                                  size_t plugin_addr_len,
                                  const int address_active,
-                                 const struct GNUNET_ATS_Information *atsi,
-                                 uint32_t atsi_count,
+                                 const struct GNUNET_ATS_Properties *prop,
                                  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
                                  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in);
 
diff --git a/src/ats/gnunet-service-ats_normalization.c b/src/ats/gnunet-service-ats_normalization.c
index 936f8ca34..c10e5070f 100644
--- a/src/ats/gnunet-service-ats_normalization.c
+++ b/src/ats/gnunet-service-ats_normalization.c
@@ -37,103 +37,65 @@
 /**
  * Range information for normalization of quality properties.
  */
-struct Property
+struct PropertyRange
 {
   /**
-   * Index into the properties array.
-   */
-  uint32_t prop_type;
-
-  /**
-   * Corresponding enum value of the respective quality property.
-   */
-  enum GNUNET_ATS_Property atsi_type;
-
-  /**
    * Minimum value we see for this property across all addresses.
    */
-  uint32_t min;
+  struct GNUNET_ATS_Properties min;
 
   /**
    * Maximum value we see for this property across all addresses.
    */
-  uint32_t max;
+  struct GNUNET_ATS_Properties max;
 };
 
 
 /**
  * Range information for all quality properties we see.
  */
-static struct Property properties[GNUNET_ATS_QualityPropertiesCount];
-
+static struct PropertyRange property_range;
 
 
 /**
  * Add the value from @a atsi to the running average of the
  * given @a ni quality property.
  *
+ * @param current_val the updated value
  * @param ni normalization information to update
- * @param atsi the ats information
  */
 static void
-property_average (struct GAS_NormalizationInfo *ni,
-                  const struct GNUNET_ATS_Information *atsi)
+update_avg (uint64_t current_val,
+            struct GAS_NormalizationInfo *ni)
 {
-  uint32_t current_val;
-  uint32_t res;
-  uint64_t sum;
+  double sum;
   uint32_t count;
   unsigned int c1;
 
-  current_val = ntohl (atsi->value);
-  GNUNET_assert (GNUNET_ATS_VALUE_UNDEFINED != current_val);
   ni->atsi_abs[ni->avg_queue_index++] = current_val;
   if (GAS_normalization_queue_length == ni->avg_queue_index)
     ni->avg_queue_index = 0;
   count = 0;
-  sum = 0;
+  sum = 0.0;
   for (c1 = 0; c1 < GAS_normalization_queue_length; c1++)
   {
-    if (GNUNET_ATS_VALUE_UNDEFINED != ni->atsi_abs[c1])
+    if (UINT64_MAX != ni->atsi_abs[c1])
     {
       count++;
-      sum += ni->atsi_abs[c1];
+      sum += (double) ni->atsi_abs[c1];
     }
   }
   GNUNET_assert (0 != count);
-  res = sum / count;
-  ni->avg = res;
+  ni->avg = sum / count;
 }
 
 
 /**
- * Closure for #find_min_max_it().
- */
-struct FindMinMaxCtx
-{
-  /**
-   * Property we are looking for.
-   */
-  struct Property *p;
-
-  /**
-   * Set to mimimum value observed.
-   */
-  uint32_t min;
-
-  /**
-   * Set to maximum value observed.
-   */
-  uint32_t max;
-};
-
-
-/**
  * Function called for all addresses and peers to find the minimum and
  * maximum (averaged) values for a given quality property.  Given
  * those, we can then calculate the normalized score.
  *
- * @param cls the `struct FindMinMaxCtx`
+ * @param cls the `struct PropertyRange`
  * @param h which peer are we looking at (ignored)
  * @param k the address for that peer
  * @return #GNUNET_OK (continue to iterate)
@@ -143,23 +105,55 @@ find_min_max_it (void *cls,
                  const struct GNUNET_PeerIdentity *h,
                  void *k)
 {
-  struct FindMinMaxCtx *find_res = cls;
+  struct PropertyRange *pr = cls;
   const struct ATS_Address *a = k;
 
-  find_res->max = GNUNET_MAX (find_res->max,
-                              a->atsin[find_res->p->prop_type].avg);
-  find_res->min = GNUNET_MIN (find_res->min,
-                              a->atsin[find_res->p->prop_type].avg);
+  pr->max.utilization_out = GNUNET_MAX (pr->max.utilization_out,
+                                        a->properties.utilization_out);
+  pr->max.utilization_in = GNUNET_MAX (pr->max.utilization_in,
+                                       a->properties.utilization_in);
+  pr->max.distance = GNUNET_MAX (pr->max.distance,
+                                 a->properties.distance);
+  pr->max.delay = GNUNET_TIME_relative_max (pr->max.delay,
+                                            a->properties.delay);
+  pr->min.utilization_out = GNUNET_MIN (pr->min.utilization_out,
+                                        a->properties.utilization_out);
+  pr->min.utilization_in = GNUNET_MIN (pr->min.utilization_in,
+                                       a->properties.utilization_in);
+  pr->min.distance = GNUNET_MIN (pr->min.distance,
+                                 a->properties.distance);
+  pr->min.delay = GNUNET_TIME_relative_min (pr->min.delay,
+                                            a->properties.delay);
   return GNUNET_OK;
 }
 
 
 /**
+ * Compute the normalized value from the given @a ni range
+ * data and the average value.
+ *
+ * @param min minimum value
+ * @param max maximum value
+ * @param ni normalization information to update
+ */
+static void
+update_norm (uint64_t min,
+             uint64_t max,
+             struct GAS_NormalizationInfo *ni)
+{
+  /* max - 2 * min + avg_value / (max - min) */
+  if (min < max)
+    ni->norm = DEFAULT_REL_QUALITY + (ni->avg - min) / (double) (max - min);
+  else
+    ni->norm = DEFAULT_REL_QUALITY;
+}
+
+
+/**
  * Normalize the property value for a given address based
- * on the range we know that property value has globally.
+ * on the range we know that property values have globally.
  *
- * @param cls the `struct Property` with details on the
- *            property and its global range
+ * @param cls NULL
  * @param key which peer are we looking at (ignored)
  * @param value the address for that peer, from where we get
  *            the original value and where we write the
@@ -171,33 +165,20 @@ normalize_address (void *cls,
                    const struct GNUNET_PeerIdentity *key,
                    void *value)
 {
-  struct Property *p = cls;
   struct ATS_Address *address = value;
-  double delta;
-  double update;
-  uint32_t avg_value;
-
-  avg_value = address->atsin[p->prop_type].avg;
-  delta = p->max - p->min;
-  /* max - 2 * min + avg_value / (max - min) */
-  if (delta > DBL_EPSILON)
-    update = DEFAULT_REL_QUALITY + (avg_value - p->min) / delta;
-  else
-    update = DEFAULT_REL_QUALITY;
 
-  if (update == address->atsin[p->prop_type].norm)
-    return GNUNET_OK;
-  address->atsin[p->prop_type].norm = update;
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Normalize `%s' address %p's '%s' with value %u to range [%u..%u] = %.3f\n",
-       GNUNET_i2s (&address->peer),
-       address,
-       GNUNET_ATS_print_property_type (p->atsi_type),
-       address->atsin[p->prop_type].avg,
-       p->min,
-       p->max,
-       address->atsin[p->prop_type].norm);
+  update_norm (property_range.min.delay.rel_value_us,
+               property_range.max.delay.rel_value_us,
+               &address->norm_delay);
+  update_norm (property_range.min.distance,
+               property_range.max.distance,
+               &address->norm_distance);
+  update_norm (property_range.min.utilization_in,
+               property_range.max.utilization_in,
+               &address->norm_utilization_in);
+  update_norm (property_range.min.utilization_out,
+               property_range.max.utilization_out,
+               &address->norm_utilization_out);
   return GNUNET_OK;
 }
 
@@ -205,8 +186,7 @@ normalize_address (void *cls,
 /**
  * Notify about change in normalized property.
  *
- * @param cls the `struct Property` with details on the
- *            property and its global range
+ * @param cls NULL
  * @param key which peer are we looking at (ignored)
  * @param value the address for that peer
  * @return #GNUNET_OK (continue to iterate)
@@ -216,104 +196,84 @@ notify_change (void *cls,
                const struct GNUNET_PeerIdentity *key,
                void *value)
 {
-  struct Property *p = cls;
   struct ATS_Address *address = value;
 
-  GAS_plugin_notify_property_changed (address,
-                                   p->atsi_type,
-                                   address->atsin[p->prop_type].norm);
+  GAS_plugin_notify_property_changed (address);
   return GNUNET_OK;
 }
 
 
 /**
+ * Initialize property range to the values corresponding
+ * to an empty set.
+ *
+ * @param pr range to initialize
+ */
+static void
+init_range (struct PropertyRange *pr)
+{
+  memset (pr, 0, sizeof (struct PropertyRange));
+  pr->min.utilization_out = UINT32_MAX;
+  pr->min.utilization_in = UINT32_MAX;
+  pr->min.distance = UINT32_MAX;
+  pr->min.delay = GNUNET_TIME_UNIT_FOREVER_REL;
+}
+
+
+/**
  * Update and normalize atsi performance information
  *
  * @param address the address to update
- * @param atsi the array of performance information
- * @param atsi_count the number of atsi information in the array
  */
 void
-GAS_normalization_update_property (struct ATS_Address *address,
-                                      const struct GNUNET_ATS_Information *atsi,
-                                      uint32_t atsi_count)
+GAS_normalization_update_property (struct ATS_Address *address)
 {
-  unsigned int c1;
-  unsigned int c2;
-  uint32_t current_type;
-  uint32_t old;
-  struct FindMinMaxCtx find_ctx;
+  const struct GNUNET_ATS_Properties *prop = &address->properties;
+  struct PropertyRange range;
   int range_changed;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Updating %u elements for peer `%s'\n",
-       atsi_count,
+       "Updating properties for peer `%s'\n",
        GNUNET_i2s (&address->peer));
   GAS_plugin_solver_lock ();
-  for (c1 = 0; c1 < atsi_count; c1++)
+  update_avg (prop->delay.rel_value_us,
+              &address->norm_delay);
+  update_avg (prop->distance,
+              &address->norm_distance);
+  update_avg (prop->utilization_in,
+              &address->norm_utilization_in);
+  update_avg (prop->utilization_in,
+              &address->norm_utilization_out);
+
+  init_range (&range);
+  GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+                                         &find_min_max_it,
+                                         &range);
+  if (0 != memcmp (&range,
+                   &property_range,
+                   sizeof (struct PropertyRange)))
   {
-    current_type = ntohl (atsi[c1].type);
-
-    for (c2 = 0; c2 < GNUNET_ATS_QualityPropertiesCount; c2++)
-      if (current_type == properties[c2].atsi_type)
-        break;
-    if (GNUNET_ATS_QualityPropertiesCount == c2)
-    {
-      /* Not a quality property, continue with next element */
-      continue;
-    }
-    /* Calculate running average */
-    old = address->atsin[c2].avg;
-    property_average (&address->atsin[c2],
-                      &atsi[c1]);
-    if (old == address->atsin[c2].avg)
-      continue; /* no change */
-    range_changed = GNUNET_NO;
-    if ( (old == properties[c2].min) ||
-         (old == properties[c2].max) ||
-         (address->atsin[c2].avg < properties[c2].min) ||
-         (address->atsin[c2].avg > properties[c2].max) )
-    {
-      /* need to re-calculate min/max range, as it may have changed */
-      find_ctx.p = &properties[c2];
-      find_ctx.max = 0;
-      find_ctx.min = UINT32_MAX;
-      if (0 ==
-          GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
-                                                 &find_min_max_it,
-                                                 &find_ctx))
-      {
-        GNUNET_break(0);
-        continue;
-      }
-      if ( (find_ctx.min != properties[c2].min) ||
-           (find_ctx.max != properties[c2].max) )
-      {
-        properties[c2].min = find_ctx.min;
-        properties[c2].max = find_ctx.max;
-        /* limits changed, (re)normalize all addresses */
-        range_changed = GNUNET_YES;
-      }
-    }
-    if (GNUNET_YES == range_changed)
-      GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
-                                             &normalize_address,
-                                             &properties[c2]);
-    else
-      normalize_address (&properties[c2],
-                         &address->peer,
-                         address);
-    /* after all peers have been updated, notify about changes */
-    if (GNUNET_YES == range_changed)
-      GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
-                                             &notify_change,
-                                             &properties[c2]);
-    else
-      notify_change (&properties[c2],
-                     &address->peer,
-                     address);
-
+    /* limits changed, (re)normalize all addresses */
+    property_range = range;
+    range_changed = GNUNET_YES;
   }
+  if (GNUNET_YES == range_changed)
+    GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+                                           &normalize_address,
+                                           NULL);
+  else
+    normalize_address (NULL,
+                       &address->peer,
+                       address);
+  /* after all peers have been updated, notify about changes */
+  if (GNUNET_YES == range_changed)
+    GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
+                                           &notify_change,
+                                           NULL);
+  else
+    notify_change (NULL,
+                   &address->peer,
+                   address);
   GAS_plugin_solver_unlock ();
 }
 
@@ -324,16 +284,7 @@ GAS_normalization_update_property (struct ATS_Address *address,
 void
 GAS_normalization_start ()
 {
-  unsigned int c1;
-  const unsigned int existing_properties[] = GNUNET_ATS_QualityProperties;
-
-  for (c1 = 0; c1 < GNUNET_ATS_QualityPropertiesCount; c1++)
-  {
-    properties[c1].prop_type = c1;
-    properties[c1].atsi_type = existing_properties[c1];
-    properties[c1].min = UINT32_MAX;
-    properties[c1].max = 0;
-  }
+  init_range (&property_range);
 }
 
 
diff --git a/src/ats/gnunet-service-ats_normalization.h b/src/ats/gnunet-service-ats_normalization.h
index 2ce9d726f..2a9f68b60 100644
--- a/src/ats/gnunet-service-ats_normalization.h
+++ b/src/ats/gnunet-service-ats_normalization.h
@@ -35,16 +35,12 @@
 
 
 /**
- * Update and normalize a @a atsi performance information
+ * Update and normalize a @a prop performance information
  *
  * @param address the address to update
- * @param atsi the array of performance information
- * @param atsi_count the number of atsi information in the array
  */
 void
-GAS_normalization_update_property (struct ATS_Address *address,
-                                   const struct GNUNET_ATS_Information *atsi,
-                                   uint32_t atsi_count);
+GAS_normalization_update_property (struct ATS_Address *address);
 
 
 /**
diff --git a/src/ats/gnunet-service-ats_performance.c b/src/ats/gnunet-service-ats_performance.c
index 0f17f0bec..c3d9e78eb 100644
--- a/src/ats/gnunet-service-ats_performance.c
+++ b/src/ats/gnunet-service-ats_performance.c
@@ -54,8 +54,7 @@ static struct GNUNET_SERVER_NotificationContext *nc_pic;
  *        to maintain a connection to a peer;
  *        #GNUNET_NO if the address is not actively used;
  *        #GNUNET_SYSERR if this address is no longer available for ATS
- * @param atsi performance data for the address
- * @param atsi_count number of performance records in @a atsi
+ * @param prop performance data for the address
  * @param bandwidth_out assigned outbound bandwidth
  * @param bandwidth_in assigned inbound bandwidth
  */
@@ -66,40 +65,34 @@ notify_client (struct GNUNET_SERVER_Client *client,
                const void *plugin_addr,
                size_t plugin_addr_len,
                int active,
-               const struct GNUNET_ATS_Information *atsi,
-               uint32_t atsi_count,
+               const struct GNUNET_ATS_Properties *prop,
                struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
                struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 {
   struct PeerInformationMessage *msg;
   size_t plugin_name_length = strlen (plugin_name) + 1;
   size_t msize =
-      sizeof (struct PeerInformationMessage) +
-      atsi_count * sizeof (struct GNUNET_ATS_Information) + plugin_addr_len +
-      plugin_name_length;
+    sizeof (struct PeerInformationMessage) +
+    plugin_addr_len +
+    plugin_name_length;
   char buf[msize] GNUNET_ALIGN;
-  struct GNUNET_ATS_Information *atsp;
   struct GNUNET_SERVER_NotificationContext *nc;
   char *addrp;
 
   GNUNET_assert (msize < GNUNET_SERVER_MAX_MESSAGE_SIZE);
-  GNUNET_assert (atsi_count <
-                 GNUNET_SERVER_MAX_MESSAGE_SIZE /
-                 sizeof (struct GNUNET_ATS_Information));
   msg = (struct PeerInformationMessage *) buf;
   msg->header.size = htons (msize);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION);
   msg->id = htonl (0);
-  msg->ats_count = htonl (atsi_count);
   msg->peer = *peer;
   msg->address_length = htons (plugin_addr_len);
   msg->address_active = ntohl ((uint32_t) active);
   msg->plugin_name_length = htons (plugin_name_length);
   msg->bandwidth_out = bandwidth_out;
   msg->bandwidth_in = bandwidth_in;
-  atsp = (struct GNUNET_ATS_Information *) &msg[1];
-  memcpy (atsp, atsi, sizeof (struct GNUNET_ATS_Information) * atsi_count);
-  addrp = (char *) &atsp[atsi_count];
+  GNUNET_ATS_properties_hton (&msg->properties,
+                              prop);
+  addrp = (char *) &msg[1];
   memcpy (addrp, plugin_addr, plugin_addr_len);
   strcpy (&addrp[plugin_addr_len], plugin_name);
   if (NULL == client)
@@ -137,8 +130,7 @@ notify_client (struct GNUNET_SERVER_Client *client,
  *        to maintain a connection to a peer;
  *        #GNUNET_NO if the address is not actively used;
  *        #GNUNET_SYSERR if this address is no longer available for ATS
- * @param atsi performance data for the address
- * @param atsi_count number of performance records in @a atsi
+ * @param prop performance data for the address
  * @param bandwidth_out assigned outbound bandwidth
  * @param bandwidth_in assigned inbound bandwidth
  */
@@ -148,8 +140,7 @@ GAS_performance_notify_all_clients (const struct GNUNET_PeerIdentity *peer,
                                     const void *plugin_addr,
                                     size_t plugin_addr_len,
                                     int active,
-                                    const struct GNUNET_ATS_Information *atsi,
-                                    uint32_t atsi_count,
+                                    const struct GNUNET_ATS_Properties *prop,
                                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
                                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 {
@@ -159,7 +150,7 @@ GAS_performance_notify_all_clients (const struct GNUNET_PeerIdentity *peer,
                  plugin_addr,
                  plugin_addr_len,
                  active,
-                 atsi, atsi_count,
+                 prop,
                  bandwidth_out,
                  bandwidth_in);
   GNUNET_STATISTICS_update (GSA_stats,
@@ -178,8 +169,7 @@ GAS_performance_notify_all_clients (const struct GNUNET_PeerIdentity *peer,
  * @param plugin_addr address
  * @param plugin_addr_len length of @a plugin_addr
  * @param active is address actively used
- * @param atsi ats performance information
- * @param atsi_count number of ats performance elements in @a atsi
+ * @param prop performance information
  * @param bandwidth_out current outbound bandwidth assigned to address
  * @param bandwidth_in current inbound bandwidth assigned to address
  */
@@ -190,8 +180,7 @@ peerinfo_it (void *cls,
              const void *plugin_addr,
              size_t plugin_addr_len,
              int active,
-             const struct GNUNET_ATS_Information *atsi,
-             uint32_t atsi_count,
+             const struct GNUNET_ATS_Properties *prop,
              struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
              struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 {
@@ -211,7 +200,7 @@ peerinfo_it (void *cls,
                  plugin_addr,
                  plugin_addr_len,
                  active,
-                 atsi, atsi_count,
+                 prop,
                  bandwidth_out,
                  bandwidth_in);
 }
diff --git a/src/ats/gnunet-service-ats_performance.h b/src/ats/gnunet-service-ats_performance.h
index 87712552f..abdeb975f 100644
--- a/src/ats/gnunet-service-ats_performance.h
+++ b/src/ats/gnunet-service-ats_performance.h
@@ -44,8 +44,7 @@
  *        to maintain a connection to a peer;
  *        #GNUNET_NO if the address is not actively used;
  *        #GNUNET_SYSERR if this address is no longer available for ATS
- * @param atsi performance data for the address
- * @param atsi_count number of performance records in @a atsi
+ * @param prop performance data for the address
  * @param bandwidth_out assigned outbound bandwidth
  * @param bandwidth_in assigned inbound bandwidth
  */
@@ -55,8 +54,7 @@ GAS_performance_notify_all_clients (const struct GNUNET_PeerIdentity *peer,
                                     const void *plugin_addr,
                                     size_t plugin_addr_len,
                                     int active,
-                                    const struct GNUNET_ATS_Information *atsi,
-                                    uint32_t atsi_count,
+                                    const struct GNUNET_ATS_Properties *prop,
                                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
                                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in);
 
diff --git a/src/ats/gnunet-service-ats_plugins.c b/src/ats/gnunet-service-ats_plugins.c
index fbc047a33..b0bbb910b 100644
--- a/src/ats/gnunet-service-ats_plugins.c
+++ b/src/ats/gnunet-service-ats_plugins.c
@@ -70,22 +70,15 @@ GAS_plugin_notify_preference_changed (const struct GNUNET_PeerIdentity *peer,
 
 
 /**
- * The relative value for a property changed
+ * The relative value for a property changed.
  *
- * @param address the peer
- * @param type the ATS type
- * @param prop_rel the new relative preference value
+ * @param address the peer for which a property changed
  */
 void
-GAS_plugin_notify_property_changed (struct ATS_Address *address,
-                                    enum GNUNET_ATS_Property type,
-                                    double prop_rel)
+GAS_plugin_notify_property_changed (struct ATS_Address *address)
 {
   sf->s_address_update_property (sf->cls,
-                                 address,
-                                 type,
-                                 0,
-                                 prop_rel);
+                                 address);
 }
 
 
@@ -221,8 +214,7 @@ bandwidth_changed_cb (void *cls,
                                       address->addr,
                                       address->addr_len,
                                       address->active,
-                                      address->atsi,
-                                      address->atsi_count,
+                                      &address->properties,
                                       GNUNET_BANDWIDTH_value_init (address->assigned_bw_out),
                                       GNUNET_BANDWIDTH_value_init (address->assigned_bw_in));
 
@@ -481,15 +473,13 @@ GAS_plugin_done ()
  * for talking to the respective peer.
  *
  * @param new_address the new address
- * @param addr_net network scope the address is in
  */
 void
-GAS_plugin_new_address (struct ATS_Address *new_address,
-                        enum GNUNET_ATS_Network_Type addr_net)
+GAS_plugin_new_address (struct ATS_Address *new_address)
 {
   sf->s_add (sf->cls,
              new_address,
-             addr_net);
+             new_address->properties.scope); /* FIXME: remove 3rd arg here! */
 }
 
 
diff --git a/src/ats/gnunet-service-ats_plugins.h b/src/ats/gnunet-service-ats_plugins.h
index 7d76f6431..66eafa4c8 100644
--- a/src/ats/gnunet-service-ats_plugins.h
+++ b/src/ats/gnunet-service-ats_plugins.h
@@ -65,16 +65,12 @@ GAS_plugin_notify_preference_changed (const struct GNUNET_PeerIdentity *peer,
 
 
 /**
- * The relative value for a property changed
+ * The relative value for a property changed.
  *
  * @param address the peer
- * @param type the ATS type
- * @param prop_rel the new relative property value
  */
 void
-GAS_plugin_notify_property_changed (struct ATS_Address *address,
-                                    enum GNUNET_ATS_Property type,
-                                    double prop_rel);
+GAS_plugin_notify_property_changed (struct ATS_Address *address);
 
 
 /**
@@ -85,8 +81,7 @@ GAS_plugin_notify_property_changed (struct ATS_Address *address,
  * @param addr_net network scope the address is in
  */
 void
-GAS_plugin_new_address (struct ATS_Address *new_address,
-                        enum GNUNET_ATS_Network_Type addr_net);
+GAS_plugin_new_address (struct ATS_Address *new_address);
 
 
 /**
diff --git a/src/ats/gnunet-service-ats_preferences.c b/src/ats/gnunet-service-ats_preferences.c
index 3be6d3525..8c0b13ab0 100644
--- a/src/ats/gnunet-service-ats_preferences.c
+++ b/src/ats/gnunet-service-ats_preferences.c
@@ -62,7 +62,7 @@ struct PeerRelative
    * Array of relative preference values, to be indexed by
    * an `enum GNUNET_ATS_PreferenceKind`.
    */
-  double f_rel[GNUNET_ATS_PreferenceCount];
+  double f_rel[GNUNET_ATS_PREFERENCE_END];
 
   /**
    * Number of clients that are expressing a preference for
@@ -99,14 +99,14 @@ struct PreferencePeer
    * Absolute preference values for all preference types
    * as expressed by this client for this peer.
    */
-  double f_abs[GNUNET_ATS_PreferenceCount];
+  double f_abs[GNUNET_ATS_PREFERENCE_END];
 
   /**
    * Relative preference values for all preference types,
    * normalized in [0..1] based on how the respective
    * client scored other peers.
    */
-  double f_rel[GNUNET_ATS_PreferenceCount];
+  double f_rel[GNUNET_ATS_PREFERENCE_END];
 
 };
 
@@ -144,7 +144,7 @@ struct PreferenceClient
    * Array of sums of absolute preferences for all
    * peers as expressed by this client.
    */
-  double f_abs_sum[GNUNET_ATS_PreferenceCount];
+  double f_abs_sum[GNUNET_ATS_PREFERENCE_END];
 
 };
 
@@ -353,7 +353,7 @@ age_values (void *cls,
   int dead;
 
   dead = GNUNET_YES;
-  for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
+  for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Aging preference for peer `%s'\n",
@@ -563,7 +563,7 @@ update_preference (struct GNUNET_SERVER_Client *client,
   struct PeerRelative *r_cur;
   unsigned int i;
 
-  if (kind >= GNUNET_ATS_PreferenceCount)
+  if (kind >= GNUNET_ATS_PREFERENCE_END)
   {
     GNUNET_break(0);
     return;
@@ -584,7 +584,7 @@ update_preference (struct GNUNET_SERVER_Client *client,
     c_cur = GNUNET_new (struct PreferenceClient);
     c_cur->peer2pref = GNUNET_CONTAINER_multipeermap_create (16,
                                                              GNUNET_NO);
-    for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
+    for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
       c_cur->f_abs_sum[i] = DEFAULT_ABS_PREFERENCE;
     GNUNET_CONTAINER_DLL_insert (pc_head,
                                  pc_tail,
@@ -598,7 +598,7 @@ update_preference (struct GNUNET_SERVER_Client *client,
   {
     /* Create struct for peer */
     r_cur = GNUNET_new (struct PeerRelative);
-    for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
+    for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
       r_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
     GNUNET_assert (GNUNET_OK ==
                    GNUNET_CONTAINER_multipeermap_put (preference_peers,
@@ -614,7 +614,7 @@ update_preference (struct GNUNET_SERVER_Client *client,
   {
     /* Not found: create new peer entry */
     p_cur = GNUNET_new (struct PreferencePeer);
-    for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
+    for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
     {
       /* Default value per peer absolute preference for a preference*/
       p_cur->f_abs[i] = DEFAULT_ABS_PREFERENCE;
@@ -710,7 +710,7 @@ GAS_preference_init ()
 
   preference_peers = GNUNET_CONTAINER_multipeermap_create (16,
                                                            GNUNET_NO);
-  for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
+  for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
     defvalues.f_rel[i] = DEFAULT_REL_PREFERENCE;
 }
 
diff --git a/src/ats/gnunet-service-ats_scheduling.c b/src/ats/gnunet-service-ats_scheduling.c
index 74b83bf45..c5539897b 100644
--- a/src/ats/gnunet-service-ats_scheduling.c
+++ b/src/ats/gnunet-service-ats_scheduling.c
@@ -135,13 +135,12 @@ GAS_handle_address_add (void *cls,
                         const struct GNUNET_MessageHeader *message)
 {
   const struct AddressAddMessage *m;
-  const struct GNUNET_ATS_Information *atsi;
   const char *address;
   const char *plugin_name;
   uint16_t address_length;
   uint16_t plugin_name_length;
-  uint32_t ats_count;
   uint16_t size;
+  struct GNUNET_ATS_Properties prop;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' message\n",
@@ -154,38 +153,38 @@ GAS_handle_address_add (void *cls,
     return;
   }
   m = (const struct AddressAddMessage *) message;
-  ats_count = ntohl (m->ats_count);
   address_length = ntohs (m->address_length);
   plugin_name_length = ntohs (m->plugin_name_length);
-  atsi = (const struct GNUNET_ATS_Information *) &m[1];
-  address = (const char *) &atsi[ats_count];
+  address = (const char *) &m[1];
   if (plugin_name_length != 0)
     plugin_name = &address[address_length];
   else
     plugin_name = "";
 
   if ((address_length + plugin_name_length +
-       ats_count * sizeof (struct GNUNET_ATS_Information) +
        sizeof (struct AddressAddMessage) != ntohs (message->size)) ||
-      (ats_count >
-       GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_ATS_Information)) ||
-       ((plugin_name_length > 0) && (plugin_name[plugin_name_length - 1] != '\0')))
+       ( (plugin_name_length > 0) &&
+         (plugin_name[plugin_name_length - 1] != '\0') ) )
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
   }
   GNUNET_STATISTICS_update (GSA_stats,
-                            "# addresses created", 1,
+                            "# addresses created",
+                            1,
                             GNUNET_NO);
+  GNUNET_ATS_properties_ntoh (&prop,
+                              &m->properties);
   GAS_addresses_add (&m->peer,
                      plugin_name,
                      address,
                      address_length,
                      ntohl (m->address_local_info),
                      ntohl (m->session_id),
-                     atsi, ats_count);
-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+                     &prop);
+  GNUNET_SERVER_receive_done (client,
+                              GNUNET_OK);
 }
 
 
@@ -202,38 +201,20 @@ GAS_handle_address_update (void *cls,
                            const struct GNUNET_MessageHeader *message)
 {
   const struct AddressUpdateMessage *m;
-  const struct GNUNET_ATS_Information *atsi;
-  uint32_t ats_count;
-  uint16_t size;
+  struct GNUNET_ATS_Properties prop;
 
-  size = ntohs (message->size);
-  if (size < sizeof (struct AddressUpdateMessage))
-  {
-    GNUNET_break (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-    return;
-  }
   m = (const struct AddressUpdateMessage *) message;
-  ats_count = ntohl (m->ats_count);
-  atsi = (const struct GNUNET_ATS_Information *) &m[1];
-
-  if ((ats_count * sizeof (struct GNUNET_ATS_Information) +
-       sizeof (struct AddressUpdateMessage) != ntohs (message->size)) ||
-      (ats_count >
-       GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_ATS_Information)))
-  {
-    GNUNET_break (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-    return;
-  }
   GNUNET_STATISTICS_update (GSA_stats,
                             "# address updates received",
                             1,
                             GNUNET_NO);
+  GNUNET_ATS_properties_ntoh (&prop,
+                              &m->properties);
   GAS_addresses_update (&m->peer,
                         ntohl (m->session_id),
-                        atsi, ats_count);
-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+                        &prop);
+  GNUNET_SERVER_receive_done (client,
+                              GNUNET_OK);
 }
 
 
diff --git a/src/ats/plugin_ats_mlp.c b/src/ats/plugin_ats_mlp.c
index b97261d46..7d402044f 100644
--- a/src/ats/plugin_ats_mlp.c
+++ b/src/ats/plugin_ats_mlp.c
@@ -62,6 +62,29 @@ enum MLP_Output_Format
 };
 
 
+enum QualityMetrics
+{
+  RQ_QUALITY_METRIC_DELAY = 0,
+  RQ_QUALITY_METRIC_DISTANCE = 1,
+  RQ_QUALITY_METRIC_COUNT = 2
+};
+
+
+static const char *
+print_quality_type (enum QualityMetrics qm)
+{
+  switch (qm){
+  case RQ_QUALITY_METRIC_DELAY:
+    return "delay";
+  case RQ_QUALITY_METRIC_DISTANCE:
+    return "distance";
+  default:
+    GNUNET_break (0);
+    return NULL;
+  }
+}
+
+
 struct MLP_Solution
 {
   int lp_res;
@@ -125,7 +148,7 @@ struct MLP_Problem
   /* Row index constraint 9: relativity*/
   unsigned int r_c9;
   /* Row indices quality metrics  */
-  int r_q[GNUNET_ATS_QualityPropertiesCount];
+  int r_q[RQ_QUALITY_METRIC_COUNT];
   /* Row indices ATS network quotas */
   int r_quota[GNUNET_ATS_NetworkTypeCount];
 
@@ -136,7 +159,7 @@ struct MLP_Problem
   /* Column index Proportionality (R) column */
   int c_r;
   /* Column index quality metrics  */
-  int c_q[GNUNET_ATS_QualityPropertiesCount];
+  int c_q[RQ_QUALITY_METRIC_COUNT];
 
   /* Problem matrix */
   /* Current index */
@@ -161,23 +184,17 @@ struct MLP_Variables
   /* LP MIP Gap */
   double lp_mip_gap;
 
-  /* ATS Quality metrics
-   *
-   * Array with GNUNET_ATS_QualityPropertiesCount elements
-   * contains mapping to GNUNET_ATS_Property*/
-  int q[GNUNET_ATS_QualityPropertiesCount];
-
-  /* Number of quality metrics */
+  /* Number of quality metrics @deprecated, use RQ_QUALITY_METRIC_COUNT */
   int m_q;
 
   /* Number of quality metrics */
   int m_rc;
 
   /* Quality metric coefficients*/
-  double co_Q[GNUNET_ATS_QualityPropertiesCount];
+  double co_Q[RQ_QUALITY_METRIC_COUNT];
 
   /* Ressource costs coefficients*/
-  double co_RC[GNUNET_ATS_QualityPropertiesCount];
+  double co_RC[RQ_QUALITY_METRIC_COUNT];
 
   /* Diversity coefficient */
   double co_D;
@@ -207,7 +224,7 @@ struct MLP_Variables
    * array with GNUNET_ATS_QualityPropertiesCount elements
    * contains mapping to GNUNET_ATS_Property
    * */
-  int rc[GNUNET_ATS_QualityPropertiesCount];
+  int rc[RQ_QUALITY_METRIC_COUNT];
 
 };
 
@@ -584,7 +601,7 @@ mlp_delete_problem (struct GAS_MLP_Handle *mlp)
   mlp->p.r_c4 = MLP_UNDEFINED;
   mlp->p.r_c6 = MLP_UNDEFINED;
   mlp->p.r_c9 = MLP_UNDEFINED;
-  for (c = 0; c < mlp->pv.m_q ; c ++)
+  for (c = 0; c < RQ_QUALITY_METRIC_COUNT ; c ++)
     mlp->p.r_q[c] = MLP_UNDEFINED;
   for (c = 0; c < GNUNET_ATS_NetworkTypeCount; c ++)
     mlp->p.r_quota[c] = MLP_UNDEFINED;
@@ -679,30 +696,6 @@ mlp_solve_to_string (int retcode)
   }
 }
 
-/**
- * Extract an ATS performance info from an address
- *
- * @param address the address
- * @param type the type to extract in HBO
- * @return the value in HBO or GNUNET_ATS_VALUE_UNDEFINED in HBO if value does not exist
- */
-static uint32_t
-get_performance_info (struct ATS_Address *address, uint32_t type)
-{
-  int c1;
-  GNUNET_assert (NULL != address);
-
-  if ((NULL == address->atsi) || (0 == address->atsi_count))
-    return GNUNET_ATS_VALUE_UNDEFINED;
-
-  for (c1 = 0; c1 < address->atsi_count; c1++)
-  {
-    if (ntohl (address->atsi[c1].type) == type)
-      return ntohl (address->atsi[c1].value);
-  }
-  return GNUNET_ATS_VALUE_UNDEFINED;
-}
-
 
 struct CountContext
 {
@@ -960,7 +953,6 @@ mlp_create_problem_add_address_information (void *cls,
   struct ATS_Peer *peer;
   struct MLP_information *mlpi;
   char *name;
-  double prop;
   double cur_bigm;
   uint32_t addr_net;
   uint32_t addr_net_index;
@@ -979,7 +971,7 @@ mlp_create_problem_add_address_information (void *cls,
       return GNUNET_OK;
   }
 
-  addr_net = get_performance_info (address, GNUNET_ATS_NETWORK_TYPE);
+  addr_net = address->properties.scope;
   for (addr_net_index = 0; addr_net_index < GNUNET_ATS_NetworkTypeCount; addr_net_index++)
   {
     if (mlp->pv.quota_index[addr_net_index] == addr_net)
@@ -1110,22 +1102,16 @@ mlp_create_problem_add_address_information (void *cls,
     /* For all quality metrics, set quality of this address */
     if (GNUNET_YES == mlp->opt_dbg_optimize_quality)
     {
-      for (c = 0; c < mlp->pv.m_q; c++)
-      {
-        prop = address->atsin[c].norm;
-        if ((prop < 1.0) && (prop > 2.0))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      "PROP == %.3f \t ",
-                      prop);
-          GNUNET_break (0);
-        }
-        mlp_create_problem_set_value (p,
-                                      p->r_q[c],
-                                      mlpi->c_b,
-                                      prop,
-                                      __LINE__);
-      }
+      mlp_create_problem_set_value (p,
+                                    p->r_q[RQ_QUALITY_METRIC_DELAY],
+                                    mlpi->c_b,
+                                    address->norm_delay.norm,
+                                    __LINE__);
+      mlp_create_problem_set_value (p,
+                                    p->r_q[RQ_QUALITY_METRIC_DISTANCE],
+                                    mlpi->c_b,
+                                    address->norm_distance.norm,
+                                    __LINE__);
     }
   }
 
@@ -1183,11 +1169,14 @@ mlp_create_problem_add_invariant_rows (struct GAS_MLP_Handle *mlp, struct MLP_Pr
     {
       for (c = 0; c < mlp->pv.m_q; c++)
       {
-        GNUNET_asprintf (&name, "c7_q%i_%s", c,
-                         GNUNET_ATS_print_property_type (mlp->pv.q[c]));
+        GNUNET_asprintf (&name,
+                         "c7_q%i_%s", c,
+                         print_quality_type (c));
         p->r_q[c] = mlp_create_problem_create_constraint (p, name, GLP_FX, 0.0, 0.0);
         GNUNET_free (name);
-        mlp_create_problem_set_value (p, p->r_q[c], p->c_q[c], -1, __LINE__);
+        mlp_create_problem_set_value (p,
+                                      p->r_q[c],
+                                      p->c_q[c], -1, __LINE__);
       }
     }
   }
@@ -1222,7 +1211,7 @@ mlp_create_problem_add_invariant_columns (struct GAS_MLP_Handle *mlp, struct MLP
     {
       for (c = 0; c < mlp->pv.m_q; c++)
       {
-        GNUNET_asprintf (&name, "q_%u", mlp->pv.q[c]);
+        GNUNET_asprintf (&name, "q_%u", c);
         p->c_q[c] = mlp_create_problem_create_column (p, name, GLP_CV, GLP_LO, 0.0, 0.0, mlp->pv.co_Q[c]);
         GNUNET_free (name);
       }
@@ -1866,13 +1855,10 @@ GAS_mlp_address_add (void *solver,
 {
   struct GAS_MLP_Handle *mlp = solver;
 
-  GNUNET_assert (NULL != solver);
-  GNUNET_assert (NULL != address);
-
   if (GNUNET_ATS_NetworkTypeCount <= network)
   {
-   GNUNET_break (0);
-   return;
+    GNUNET_break (0);
+    return;
   }
 
   if (NULL == address->solver_information)
@@ -1911,36 +1897,23 @@ GAS_mlp_address_add (void *solver,
  *
  * @param solver solver handle
  * @param address the address
- * @param type the ATSI type in HBO
- * @param abs_value the absolute value of the property
- * @param rel_value the normalized value
  */
 static void
 GAS_mlp_address_property_changed (void *solver,
-                                  struct ATS_Address *address,
-                                  enum GNUNET_ATS_Property type,
-                                  uint32_t abs_value,
-                                  double rel_value)
+                                  struct ATS_Address *address)
 {
   struct MLP_information *mlpi = address->solver_information;
   struct GAS_MLP_Handle *mlp = solver;
-  int c1;
-  int type_index;
-
-  GNUNET_assert (NULL != solver);
-  GNUNET_assert (NULL != address);
 
   if (NULL == mlpi)
   {
-      LOG (GNUNET_ERROR_TYPE_INFO,
-          _("Updating address property `%s' for peer `%s' %p not added before\n"),
-          GNUNET_ATS_print_property_type (type),
-          GNUNET_i2s(&address->peer),
-          address);
-      GNUNET_break (0);
-      return;
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         _("Updating address property for peer `%s' %p not added before\n"),
+         GNUNET_i2s (&address->peer),
+         address);
+    GNUNET_break (0);
+    return;
   }
-
   if (NULL ==
       GNUNET_CONTAINER_multipeermap_get (mlp->requested_peers,
                                          &address->peer))
@@ -1948,34 +1921,26 @@ GAS_mlp_address_property_changed (void *solver,
     /* Peer is not requested, so no need to update problem */
     return;
   }
-  LOG (GNUNET_ERROR_TYPE_INFO, "Updating property `%s' address for peer `%s' to abs %llu rel %.3f\n",
-      GNUNET_ATS_print_property_type (type),
-      GNUNET_i2s(&address->peer),
-      abs_value,
-      rel_value);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Updating properties for peer `%s'\n",
+       GNUNET_i2s(&address->peer));
 
   if (GNUNET_YES == mlp->opt_dbg_feasibility_only)
     return;
 
-  /* Find row index */
-  type_index = -1;
-  for (c1 = 0; c1 < mlp->pv.m_q; c1++)
-  {
-    if (type == mlp->pv.q[c1])
-    {
-      type_index = c1;
-      break;
-    }
-  }
-  if (-1 == type_index)
-  {
-    GNUNET_break (0);
-    return; /* quality index not found */
-  }
-
   /* Update c7) [r_q[index]][c_b] = f_q * q_averaged[type_index] */
-  if (GNUNET_YES == mlp_create_problem_update_value (&mlp->p,
-      mlp->p.r_q[type_index], mlpi->c_b, rel_value, __LINE__))
+  if ( (GNUNET_YES ==
+        mlp_create_problem_update_value (&mlp->p,
+                                         mlp->p.r_q[RQ_QUALITY_METRIC_DELAY],
+                                         mlpi->c_b,
+                                         address->norm_delay.norm,
+                                         __LINE__)) ||
+       (GNUNET_YES ==
+        mlp_create_problem_update_value (&mlp->p,
+                                         mlp->p.r_q[RQ_QUALITY_METRIC_DISTANCE],
+                                         mlpi->c_b,
+                                         address->norm_distance.norm,
+                                         __LINE__)) )
   {
     mlp->stat_mlp_prob_updated = GNUNET_YES;
     if (GNUNET_YES == mlp->opt_mlp_auto_solve)
@@ -2037,17 +2002,14 @@ get_peer_pref_value (struct GAS_MLP_Handle *mlp,
 
   preferences = mlp->env->get_preferences (mlp->env->cls, peer);
   res = 0.0;
-  for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
+  for (c = 0; c < GNUNET_ATS_PREFERENCE_END; c++)
   {
-    if (c != GNUNET_ATS_PREFERENCE_END)
-    {
-      /* fprintf (stderr, "VALUE[%u] %s %.3f \n",
-       *        c, GNUNET_i2s (&cur->addr->peer), t[c]); */
-      res += preferences[c];
-    }
+    /* fprintf (stderr, "VALUE[%u] %s %.3f \n",
+     *        c, GNUNET_i2s (&cur->addr->peer), t[c]); */
+    res += preferences[c];
   }
 
-  res /= (GNUNET_ATS_PreferenceCount -1);
+  res /= GNUNET_ATS_PREFERENCE_END;
   res += 1.0;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -2646,34 +2608,28 @@ libgnunet_plugin_ats_mlp_init (void *cls)
   }
 
   /* Get quality metric coefficients from configuration */
-  int i_delay = MLP_NaN;
-  int i_distance = MLP_NaN;
-  int q[GNUNET_ATS_QualityPropertiesCount] = GNUNET_ATS_QualityProperties;
-  for (c = 0; c < GNUNET_ATS_QualityPropertiesCount; c++)
+  for (c = 0; c < RQ_QUALITY_METRIC_COUNT; c++)
   {
     /* initialize quality coefficients with default value 1.0 */
-      mlp->pv.co_Q[c] = MLP_DEFAULT_QUALITY;
-
-    mlp->pv.q[c] = q[c];
-    if (q[c] == GNUNET_ATS_QUALITY_NET_DELAY)
-      i_delay = c;
-    if (q[c] == GNUNET_ATS_QUALITY_NET_DISTANCE)
-      i_distance = c;
+    mlp->pv.co_Q[c] = MLP_DEFAULT_QUALITY;
   }
 
-  if ( (i_delay != MLP_NaN) &&
-       (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (env->cfg, "ats",
-          "MLP_COEFFICIENT_QUALITY_DELAY", &tmp)) )
-    mlp->pv.co_Q[i_delay] = (double) tmp / 100;
+
+  if (GNUNET_OK ==
+      GNUNET_CONFIGURATION_get_value_size (env->cfg, "ats",
+                                           "MLP_COEFFICIENT_QUALITY_DELAY",
+                                           &tmp))
+    mlp->pv.co_Q[RQ_QUALITY_METRIC_DELAY] = (double) tmp / 100;
   else
-    mlp->pv.co_Q[i_delay] = MLP_DEFAULT_QUALITY;
+    mlp->pv.co_Q[RQ_QUALITY_METRIC_DELAY] = MLP_DEFAULT_QUALITY;
 
-  if ( (i_distance != MLP_NaN) &&
-        (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (env->cfg, "ats",
-          "MLP_COEFFICIENT_QUALITY_DISTANCE", &tmp)) )
-    mlp->pv.co_Q[i_distance] = (double) tmp / 100;
+  if (GNUNET_OK ==
+      GNUNET_CONFIGURATION_get_value_size (env->cfg, "ats",
+                                           "MLP_COEFFICIENT_QUALITY_DISTANCE",
+                                           &tmp))
+    mlp->pv.co_Q[RQ_QUALITY_METRIC_DISTANCE] = (double) tmp / 100;
   else
-    mlp->pv.co_Q[i_distance] = MLP_DEFAULT_QUALITY;
+    mlp->pv.co_Q[RQ_QUALITY_METRIC_DISTANCE] = MLP_DEFAULT_QUALITY;
 
   /* Get minimum bandwidth per used address from configuration */
   if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (env->cfg, "ats",
@@ -2759,7 +2715,7 @@ libgnunet_plugin_ats_mlp_init (void *cls)
   /* Setting MLP Input variables */
   mlp->pv.b_min = b_min;
   mlp->pv.n_min = n_min;
-  mlp->pv.m_q = GNUNET_ATS_QualityPropertiesCount;
+  mlp->pv.m_q = RQ_QUALITY_METRIC_COUNT;
   mlp->stat_mlp_prob_changed = GNUNET_NO;
   mlp->stat_mlp_prob_updated = GNUNET_NO;
   mlp->opt_mlp_auto_solve = GNUNET_YES;
diff --git a/src/ats/plugin_ats_proportional.c b/src/ats/plugin_ats_proportional.c
index 69afa8a52..9ad00bbb3 100644
--- a/src/ats/plugin_ats_proportional.c
+++ b/src/ats/plugin_ats_proportional.c
@@ -25,8 +25,8 @@
  */
 #include "platform.h"
 #include "gnunet_statistics_service.h"
-#include "gnunet_ats_plugin.h"
 #include "gnunet_ats_service.h"
+#include "gnunet_ats_plugin.h"
 #include "gnunet-service-ats_addresses.h"
 
 #define LOG(kind,...) GNUNET_log_from (kind, "ats-proportional",__VA_ARGS__)
@@ -308,7 +308,8 @@ distribute_bandwidth (struct GAS_PROPORTIONAL_Handle *s,
       continue;
     peer_relative_prefs = s->env->get_preferences (s->env->cls,
                                                    &aw->addr->peer);
-    sum_relative_peer_prefences += peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH];
+    sum_relative_peer_prefences
+      += peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH];
     count_addresses++;
   }
   if (count_addresses != net->active_addresses)
@@ -504,27 +505,6 @@ struct FindBestAddressCtx
 
 
 /**
- * Find index of a ATS property type in the quality properties array.
- *
- * @param type ATS property type
- * @return index in the quality array, #GNUNET_SYSERR if the type
- *         was not a quality property
- */
-static int
-find_quality_property_index (enum GNUNET_ATS_Property type)
-{
-  enum GNUNET_ATS_Property existing_types[] = GNUNET_ATS_QualityProperties;
-  unsigned int c;
-
-  for (c = 0; c < GNUNET_ATS_QualityPropertiesCount; c++)
-    if (existing_types[c] == type)
-      return c;
-  GNUNET_break (0);
-  return GNUNET_SYSERR;
-}
-
-
-/**
  * Find a "good" address to use for a peer by iterating over the
  * addresses for this peer.  If we already have an existing address,
  * we stick to it.  Otherwise, we pick by lowest distance and then by
@@ -548,7 +528,6 @@ find_best_address_it (void *cls,
   double best_distance;
   double cur_delay;
   double cur_distance;
-  int index;
   unsigned int con;
   int bw_available;
   int need;
@@ -601,12 +580,10 @@ find_best_address_it (void *cls,
   }
 
   /* Now compare ATS information */
-  index = find_quality_property_index (GNUNET_ATS_QUALITY_NET_DISTANCE);
-  cur_distance = current->atsin[index].norm;
-  best_distance = ctx->best->atsin[index].norm;
-  index = find_quality_property_index (GNUNET_ATS_QUALITY_NET_DELAY);
-  cur_delay = current->atsin[index].norm;
-  best_delay = ctx->best->atsin[index].norm;
+  cur_distance = current->norm_distance.norm;
+  best_distance = ctx->best->norm_distance.norm;
+  cur_delay = current->norm_delay.norm;
+  best_delay = ctx->best->norm_delay.norm;
 
   /* user shorter distance */
   if (cur_distance < best_distance)
@@ -1006,16 +983,10 @@ GAS_proportional_bulk_stop (void *solver)
  *
  * @param solver solver handle
  * @param address the address
- * @param type the ATSI type
- * @param abs_value the absolute value of the property
- * @param rel_value the normalized value
  */
 static void
 GAS_proportional_address_property_changed (void *solver,
-                                           struct ATS_Address *address,
-                                           enum GNUNET_ATS_Property type,
-                                           uint32_t abs_value,
-                                           double rel_value)
+                                           struct ATS_Address *address)
 {
   struct GAS_PROPORTIONAL_Handle *s = solver;
   struct AddressWrapper *asi = address->solver_information;
diff --git a/src/ats/plugin_ats_ril.c b/src/ats/plugin_ats_ril.c
index 78f58e609..0d8b2290c 100644
--- a/src/ats/plugin_ats_ril.c
+++ b/src/ats/plugin_ats_ril.c
@@ -934,29 +934,6 @@ envi_get_state (struct GAS_RIL_Handle *solver, struct RIL_Peer_Agent *agent)
   return state;
 }
 
-/**
- * Retrieves an ATS information value of an address
- *
- * @param address the address in question
- * @param type the ATS information type
- * @return the value
- */
-static unsigned int
-ril_get_atsi (struct ATS_Address *address, uint32_t type)
-{
-  int c1;
-  GNUNET_assert(NULL != address);
-
-  if ((NULL == address->atsi) || (0 == address->atsi_count))
-    return GNUNET_ATS_QUALITY_NET_DELAY == type ? UINT32_MAX : 1;
-
-  for (c1 = 0; c1 < address->atsi_count; c1++)
-  {
-    if (ntohl (address->atsi[c1].type) == type)
-      return ntohl (address->atsi[c1].value);
-  }
-  return GNUNET_ATS_QUALITY_NET_DELAY == type ? UINT32_MAX : 1;
-}
 
 /**
  * Returns the utility value of the connection an agent manages
@@ -975,16 +952,12 @@ agent_get_utility (struct RIL_Peer_Agent *agent)
   preferences = agent->envi->env->get_preferences (agent->envi->env->cls,
                                                    &agent->peer);
 
-  delay_atsi = (double) ril_get_atsi (agent->address_inuse, GNUNET_ATS_QUALITY_NET_DELAY);
+  delay_atsi = agent->address_inuse->norm_delay.norm;
   delay_norm = RIL_UTILITY_DELAY_MAX*exp(-delay_atsi*0.00001);
 
   pref_match = preferences[GNUNET_ATS_PREFERENCE_LATENCY] * delay_norm;
   pref_match += preferences[GNUNET_ATS_PREFERENCE_BANDWIDTH] *
       sqrt((double) (agent->bw_in/RIL_MIN_BW) * (double) (agent->bw_out/RIL_MIN_BW));
-//      sqrt((double) (ril_get_atsi (agent->address_inuse, GNUNET_ATS_UTILIZATION_IN)/RIL_MIN_BW) * (double) (ril_get_atsi (agent->address_inuse, GNUNET_ATS_UTILIZATION_OUT)/RIL_MIN_BW));
-
-//  return (double) (agent->bw_in/RIL_MIN_BW);
-//  return sqrt((double) (agent->bw_in/RIL_MIN_BW) * (double) (agent->bw_out/RIL_MIN_BW));
   return pref_match;
 }
 
@@ -1799,9 +1772,9 @@ ril_network_get_utilized (struct GAS_RIL_Handle *solver, enum GNUNET_ATS_Network
       if (net->type == type)
       {
         if (direction_in)
-          sum += ril_get_atsi (cur->address_inuse, GNUNET_ATS_UTILIZATION_IN);
+          sum += cur->address_inuse->norm_utilization_in.norm;
         else
-          sum += ril_get_atsi (cur->address_inuse, GNUNET_ATS_UTILIZATION_OUT);
+          sum += cur->address_inuse->norm_utilization_out.norm;
       }
     }
   }
@@ -2373,27 +2346,16 @@ GAS_ril_address_delete (void *solver,
  *
  * @param solver solver handle
  * @param address the address
- * @param type the ATSI type
- * @param abs_value the absolute value of the property
- * @param rel_value the normalized value
  */
 static void
 GAS_ril_address_property_changed (void *solver,
-                                  struct ATS_Address *address,
-                                  enum GNUNET_ATS_Property type,
-                                  uint32_t abs_value,
-                                  double rel_value)
+                                  struct ATS_Address *address)
 {
   struct GAS_RIL_Handle *s = solver;
 
   LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "API_address_property_changed() Property '%s' for peer '%s' address %s changed "
-          "to %.2f \n",
-      GNUNET_ATS_print_property_type (type),
-      GNUNET_i2s (&address->peer),
-      address->addr, rel_value);
-
-
+      "Properties for peer '%s' address changed\n",
+      GNUNET_i2s (&address->peer));
   s->parameters.temperature = s->parameters.temperature_init;
   s->parameters.epsilon = s->parameters.epsilon_init;
   ril_step (s);
diff --git a/src/ats/test_ats_api_common.h b/src/ats/test_ats_api_common.h
index 233af72cd..091eb59b6 100644
--- a/src/ats/test_ats_api_common.h
+++ b/src/ats/test_ats_api_common.h
@@ -38,8 +38,7 @@ struct Test_Address
   void *addr;
   size_t addr_len;
 
-  struct GNUNET_ATS_Information *ats;
-  int ats_count;
+  struct GNUNET_ATS_Properties properties;
 
   void *session;
 };
@@ -61,13 +60,11 @@ free_test_address (struct Test_Address *dest);
 void
 create_test_address (struct Test_Address *dest, char * plugin, void *session, void *addr, size_t addrlen);
 
+
 int
 compare_addresses (const struct GNUNET_HELLO_Address *address1, void *session1,
                    const struct GNUNET_HELLO_Address *address2, void *session2);
 
-int
-compare_ats (const struct GNUNET_ATS_Information *ats_is, uint32_t ats_count_is,
-             const struct GNUNET_ATS_Information *ats_should, uint32_t ats_count_should);
 
 struct ATS_Address *
 create_address (const struct GNUNET_PeerIdentity *peer,