use ATS functions to convert quality network type to string, instead of using string API

5 files changed, 195 insertions, 94 deletions

diff --git a/src/ats/ats_api_scheduling.c b/src/ats/ats_api_scheduling.c
index 6bb595391..4cf48d761 100644
--- a/src/ats/ats_api_scheduling.c
+++ b/src/ats/ats_api_scheduling.c
@@ -77,7 +77,7 @@ struct SessionRecord
   struct Session *session;
 
   /**
-   * Set to GNUNET_YES if the slot is used.
+   * Set to #GNUNET_YES if the slot is used.
    */
   int slot_used;
 };
@@ -122,7 +122,7 @@ struct GNUNET_ATS_SchedulingHandle
   GNUNET_ATS_AddressSuggestionCallback suggest_cb;
 
   /**
-   * Closure for 'suggest_cb'.
+   * Closure for @e suggest_cb.
    */
   void *suggest_cb_cls;
 
@@ -833,34 +833,72 @@ get_addresses (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                                      sh);
 }
 
+
 /**
- * Convert a GNUNET_ATS_NetworkType to a string
+ * Convert a `enum GNUNET_ATS_Network_Type` to a string
  *
  * @param net the network type
  * @return a string or NULL if invalid
  */
 const char *
-GNUNET_ATS_print_network_type (uint32_t net)
+GNUNET_ATS_print_network_type (enum GNUNET_ATS_Network_Type net)
 {
-  char *networks[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
-  if (net < GNUNET_ATS_NetworkTypeCount)
-    return networks[net];
-  return NULL;
+  switch (net)
+    {
+    case GNUNET_ATS_NET_UNSPECIFIED:
+      return "UNSPECIFIED";
+    case GNUNET_ATS_NET_LOOPBACK:
+      return "LOOPBACK";
+    case GNUNET_ATS_NET_LAN:
+      return "LAN";
+    case GNUNET_ATS_NET_WAN:
+      return "WAN";
+    case GNUNET_ATS_NET_WLAN:
+      return "WLAN";
+    case GNUNET_ATS_NET_BT:
+      return "BLUETOOTH";
+    default:
+      return NULL;
+    }
 }
 
+
 /**
  * Convert a ATS property to a string
  *
- * @param type the atsi type
+ * @param type the property type
  * @return a string or NULL if invalid
  */
 const char *
-GNUNET_ATS_print_property_type (uint32_t type)
+GNUNET_ATS_print_property_type (enum GNUNET_ATS_Property type)
 {
-        char *props[GNUNET_ATS_PropertyCount] = GNUNET_ATS_PropertyStrings;
-        if ((type > 0) && (type < GNUNET_ATS_PropertyCount))
-                return props[type];
-        return NULL;
+  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_UTILIZATION_PAYLOAD_OUT:
+    return "UTILIZATION_PAYLOAD_UP";
+  case GNUNET_ATS_UTILIZATION_PAYLOAD_IN:
+    return "UTILIZATION_PAYLOAD_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";
+  case GNUNET_ATS_COST_WAN:
+    return "COST_WAN";
+  case GNUNET_ATS_COST_LAN:
+    return "COST_LAN";
+  case GNUNET_ATS_COST_WLAN:
+    return "COST_WLAN";
+  default:
+    return NULL;
+  }
 }
 
 
@@ -1057,17 +1095,17 @@ GNUNET_ATS_reset_backoff (struct GNUNET_ATS_SchedulingHandle *sh,
   do_transmit (sh);
 }
 
+
 /**
  * We would like to receive address suggestions for a peer. ATS will
  * respond with a call to the continuation immediately containing an address or
  * no address if none is available. ATS can suggest more addresses until we call
- * #GNUNET_ATS_suggest_address_cancel.
- *
+ * #GNUNET_ATS_suggest_address_cancel().
  *
  * @param sh handle
  * @param peer identity of the peer we need an address for
  * @param cont the continuation to call with the address
- * @param cont_cls the cls for the continuation
+ * @param cont_cls the cls for the @a cont
  * @return suggest handle
  */
 struct GNUNET_ATS_SuggestHandle *
@@ -1269,9 +1307,9 @@ GNUNET_ATS_address_add (struct GNUNET_ATS_SchedulingHandle *sh,
  * @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 'ats'
- * @return GNUNET_YES on success, GNUNET_NO if address or session are unknown,
- * GNUNET_SYSERR on hard failure
+ * @param ats_count number of performance records in @a ats
+ * @return #GNUNET_YES on success, #GNUNET_NO if address or session are unknown,
+ * #GNUNET_SYSERR on hard failure
  */
 int
 GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *sh,
@@ -1357,7 +1395,7 @@ GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *sh,
  * @param sh handle
  * @param address the address
  * @param session session handle, can be NULL
- * @param in_use GNUNET_YES if this address is now used, GNUNET_NO
+ * @param in_use #GNUNET_YES if this address is now used, #GNUNET_NO
  * if address is not used any more
  */
 void
diff --git a/src/ats/gnunet-ats-solver-eval.c b/src/ats/gnunet-ats-solver-eval.c
index 0fa83d741..58fe03e25 100644
--- a/src/ats/gnunet-ats-solver-eval.c
+++ b/src/ats/gnunet-ats-solver-eval.c
@@ -1706,17 +1706,19 @@ load_op_stop_set_preference (struct GNUNET_ATS_TEST_Operation *o,
   return GNUNET_OK;
 }
 
+
 static enum GNUNET_ATS_Property
-parse_property_string (const char * str)
+parse_property_string (const char *str)
 {
-  int c = 0;
-  char *props[GNUNET_ATS_PropertyCount] = GNUNET_ATS_PropertyStrings;
+  enum GNUNET_ATS_Property c;
 
   for (c = 0; c < GNUNET_ATS_PropertyCount; c++)
-    if (0 == strcmp(str, props[c]))
+    if (0 == strcmp(str,
+                    GNUNET_ATS_print_property_type (c)))
       return c;
   return 0;
-};
+}
+
 
 static int
 load_op_start_set_property(struct GNUNET_ATS_TEST_Operation *o,
@@ -2770,7 +2772,6 @@ GNUNET_ATS_solvers_load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                                  unsigned long long *in_dest,
                                                  int dest_length)
 {
-  char *network_str[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
   char * entry_in = NULL;
   char * entry_out = NULL;
   char * quota_out_str;
@@ -2782,8 +2783,12 @@ GNUNET_ATS_solvers_load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
   {
     in_dest[c] = 0;
     out_dest[c] = 0;
-    GNUNET_asprintf (&entry_out, "%s_QUOTA_OUT", network_str[c]);
-    GNUNET_asprintf (&entry_in, "%s_QUOTA_IN", network_str[c]);
+    GNUNET_asprintf (&entry_out,
+                     "%s_QUOTA_OUT",
+                     GNUNET_ATS_print_network_type (c));
+    GNUNET_asprintf (&entry_in,
+                     "%s_QUOTA_IN",
+                     GNUNET_ATS_print_network_type (c));
 
     /* quota out */
     if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_out, &quota_out_str))
@@ -2801,21 +2806,28 @@ GNUNET_ATS_solvers_load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
       if (GNUNET_NO == res)
       {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
-              network_str[c], quota_out_str, GNUNET_ATS_DefaultBandwidth);
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
+                      GNUNET_ATS_print_network_type (c),
+                      quota_out_str,
+                      GNUNET_ATS_DefaultBandwidth);
           out_dest[c] = GNUNET_ATS_DefaultBandwidth;
       }
       else
       {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Outbound quota configure for network `%s' is %llu\n"),
-              network_str[c], out_dest[c]);
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Outbound quota configure for network `%s' is %llu\n",
+                      GNUNET_ATS_print_network_type (c),
+                      out_dest[c]);
       }
       GNUNET_free (quota_out_str);
     }
     else
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
-          network_str[c], GNUNET_ATS_DefaultBandwidth);
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
+                  GNUNET_ATS_print_network_type (c),
+                  GNUNET_ATS_DefaultBandwidth);
       out_dest[c] = GNUNET_ATS_DefaultBandwidth;
     }
 
@@ -2835,30 +2847,42 @@ GNUNET_ATS_solvers_load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
       if (GNUNET_NO == res)
       {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
-              network_str[c], quota_in_str, GNUNET_ATS_DefaultBandwidth);
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
+                      GNUNET_ATS_print_network_type (c),
+                      quota_in_str,
+                      GNUNET_ATS_DefaultBandwidth);
           in_dest[c] = GNUNET_ATS_DefaultBandwidth;
       }
       else
       {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Inbound quota configured for network `%s' is %llu\n"),
-              network_str[c], in_dest[c]);
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Inbound quota configured for network `%s' is %llu\n",
+                      GNUNET_ATS_print_network_type (c),
+                      in_dest[c]);
       }
       GNUNET_free (quota_in_str);
     }
     else
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
-          network_str[c], GNUNET_ATS_DefaultBandwidth);
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
+                  GNUNET_ATS_print_network_type (c),
+                  GNUNET_ATS_DefaultBandwidth);
       out_dest[c] = GNUNET_ATS_DefaultBandwidth;
     }
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Loaded quota for network `%s' (in/out): %llu %llu\n", network_str[c], in_dest[c], out_dest[c]);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Loaded quota for network `%s' (in/out): %llu %llu\n",
+                GNUNET_ATS_print_network_type (c),
+                in_dest[c],
+                out_dest[c]);
     GNUNET_free (entry_out);
     GNUNET_free (entry_in);
   }
   return GNUNET_ATS_NetworkTypeCount;
 }
 
+
 /**
  * Information callback for the solver
  *
@@ -2869,9 +2893,9 @@ GNUNET_ATS_solvers_load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
  */
 static void
 solver_info_cb (void *cls,
-    enum GAS_Solver_Operation op,
-    enum GAS_Solver_Status stat,
-    enum GAS_Solver_Additional_Information add)
+                enum GAS_Solver_Operation op,
+                enum GAS_Solver_Status stat,
+                enum GAS_Solver_Additional_Information add)
 {
   char *add_info;
   switch (add) {
@@ -3433,4 +3457,3 @@ main (int argc, char *argv[])
   return res;
 }
 /* end of file ats-testing-experiment.c*/
-
diff --git a/src/ats/gnunet-service-ats_addresses.c b/src/ats/gnunet-service-ats_addresses.c
index f0af8f1a2..89158936d 100644
--- a/src/ats/gnunet-service-ats_addresses.c
+++ b/src/ats/gnunet-service-ats_addresses.c
@@ -1746,7 +1746,6 @@ static unsigned int
 load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
     unsigned long long *out_dest, unsigned long long *in_dest, int dest_length)
 {
-  char *network_str[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
   char * entry_in = NULL;
   char * entry_out = NULL;
   char * quota_out_str;
@@ -1758,8 +1757,12 @@ load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
   {
     in_dest[c] = 0;
     out_dest[c] = 0;
-    GNUNET_asprintf (&entry_out, "%s_QUOTA_OUT", network_str[c]);
-    GNUNET_asprintf (&entry_in, "%s_QUOTA_IN", network_str[c]);
+    GNUNET_asprintf (&entry_out,
+                     "%s_QUOTA_OUT",
+                     GNUNET_ATS_print_network_type (c));
+    GNUNET_asprintf (&entry_in,
+                     "%s_QUOTA_IN",
+                     GNUNET_ATS_print_network_type (c));
 
     /* quota out */
     if (GNUNET_OK
@@ -1786,23 +1789,27 @@ load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
       if (GNUNET_NO == res)
       {
         GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-            _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
-            network_str[c], quota_out_str, GNUNET_ATS_DefaultBandwidth);
+                   _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
+                   GNUNET_ATS_print_network_type (c),
+                   quota_out_str,
+                   GNUNET_ATS_DefaultBandwidth);
         out_dest[c] = GNUNET_ATS_DefaultBandwidth;
       }
       else
       {
         GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-            _("Outbound quota configure for network `%s' is %llu\n"),
-            network_str[c], out_dest[c]);
+                   _("Outbound quota configure for network `%s' is %llu\n"),
+                   GNUNET_ATS_print_network_type (c),
+                   out_dest[c]);
       }
       GNUNET_free(quota_out_str);
     }
     else
     {
       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-          _("No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
-          network_str[c], GNUNET_ATS_DefaultBandwidth);
+                 _("No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
+                 GNUNET_ATS_print_network_type (c),
+                 GNUNET_ATS_DefaultBandwidth);
       out_dest[c] = GNUNET_ATS_DefaultBandwidth;
     }
 
@@ -1830,28 +1837,34 @@ load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
       if (GNUNET_NO == res)
       {
         GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-            _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
-            network_str[c], quota_in_str, GNUNET_ATS_DefaultBandwidth);
+                   _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
+                   GNUNET_ATS_print_network_type (c),
+                   quota_in_str,
+                   GNUNET_ATS_DefaultBandwidth);
         in_dest[c] = GNUNET_ATS_DefaultBandwidth;
       }
       else
       {
         GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-            _("Inbound quota configured for network `%s' is %llu\n"),
-            network_str[c], in_dest[c]);
+                   _("Inbound quota configured for network `%s' is %llu\n"),
+                   GNUNET_ATS_print_network_type (c),
+                   in_dest[c]);
       }
       GNUNET_free(quota_in_str);
     }
     else
     {
       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-          _("No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
-          network_str[c], GNUNET_ATS_DefaultBandwidth);
+                 _("No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
+                 GNUNET_ATS_print_network_type (c),
+                 GNUNET_ATS_DefaultBandwidth);
       in_dest[c] = GNUNET_ATS_DefaultBandwidth;
     }
     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-        "Loaded quota for network `%s' (in/out): %llu %llu\n", network_str[c],
-        in_dest[c], out_dest[c]);
+               "Loaded quota for network `%s' (in/out): %llu %llu\n",
+               GNUNET_ATS_print_network_type (c),
+               in_dest[c],
+               out_dest[c]);
     GNUNET_free(entry_out);
     GNUNET_free(entry_in);
   }
diff --git a/src/ats/plugin_ats_proportional.c b/src/ats/plugin_ats_proportional.c
index 744602eb8..99cbb1b55 100644
--- a/src/ats/plugin_ats_proportional.c
+++ b/src/ats/plugin_ats_proportional.c
@@ -27,6 +27,7 @@
 #include "platform.h"
 #include "gnunet_statistics_service.h"
 #include "gnunet_ats_plugin.h"
+#include "gnunet_ats_service.h"
 #include "gnunet-service-ats_addresses.h"
 
 #define PROP_STABILITY_FACTOR 1.25
@@ -317,7 +318,7 @@ struct Network
   /**
    * Network description
    */
-  char *desc;
+  const char *desc;
 
   /**
    * Total inbound quota
@@ -1293,7 +1294,7 @@ update_active_address (struct GAS_PROPORTIONAL_Handle *s,
   best_address->active = GNUNET_YES;
   address_increment (s, net, GNUNET_NO, GNUNET_YES);
   LOG (GNUNET_ERROR_TYPE_INFO, "Address %p for peer `%s' is now active\n",
-      best_address, GNUNET_i2s (peer)); 
+      best_address, GNUNET_i2s (peer));
   /* Distribute bandwidth */
   distribute_bandwidth_in_network (s, net);
   return best_address;
@@ -1936,7 +1937,6 @@ libgnunet_plugin_ats_proportional_init (void *cls)
   struct GNUNET_ATS_PluginEnvironment *env = cls;
   struct GAS_PROPORTIONAL_Handle *s;
   struct Network * cur;
-  char * net_str[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
   float f_tmp;
   int c;
 
@@ -2022,19 +2022,22 @@ libgnunet_plugin_ats_proportional_init (void *cls)
   for (c = 0; c < env->network_count; c++)
   {
     cur = &s->network_entries[c];
-    cur->total_addresses = 0;
-    cur->active_addresses = 0;
     cur->type = env->networks[c];
     cur->total_quota_in = env->in_quota[c];
     cur->total_quota_out = env->out_quota[c];
-    cur->desc = net_str[c];
+    cur->desc = GNUNET_ATS_print_network_type (c);
     GNUNET_asprintf (&cur->stat_total,
-        "# ATS addresses %s total", cur->desc);
+                     "# ATS addresses %s total",
+                     cur->desc);
     GNUNET_asprintf (&cur->stat_active,
-        "# ATS active addresses %s total", cur->desc);
+                     "# ATS active addresses %s total",
+                     cur->desc);
     LOG (GNUNET_ERROR_TYPE_INFO,
          "Added network %u `%s' (%llu/%llu)\n",
-        c, cur->desc, cur->total_quota_in, cur->total_quota_out);
+         c,
+         cur->desc,
+         cur->total_quota_in,
+         cur->total_quota_out);
   }
   return s;
 }
diff --git a/src/ats/test_ats_api_common.c b/src/ats/test_ats_api_common.c
index b603d6e6d..569ffbce1 100644
--- a/src/ats/test_ats_api_common.c
+++ b/src/ats/test_ats_api_common.c
@@ -95,7 +95,6 @@ compare_ats (const struct GNUNET_ATS_Information *ats_is, uint32_t ats_count_is,
 {
   unsigned int c_o;
   unsigned int c_i;
-  char *prop[] = GNUNET_ATS_PropertyStrings;
   uint32_t type1;
   uint32_t type2;
   uint32_t val1;
@@ -110,21 +109,24 @@ compare_ats (const struct GNUNET_ATS_Information *ats_is, uint32_t ats_count_is,
         type2 = ntohl(ats_should[c_i].type);
         if (type1 == type2)
         {
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS type `%s'\n",
-                        prop[type1]);
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                        "ATS type `%s'\n",
+                        GNUNET_ATS_print_property_type (type1));
             val1 = ntohl(ats_is[c_o].value);
             val2 = ntohl(ats_should[c_i].value);
             if (val1 != val2)
             {
-                GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ATS value `%s' not equal: %u != %u\n",
-                            prop[type1],
+                GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                            "ATS value `%s' not equal: %u != %u\n",
+                            GNUNET_ATS_print_property_type (type1),
                             val1, val2);
                 res = GNUNET_SYSERR;
             }
             else
             {
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS value `%s' equal: %u == %u\n",
-                          prop[type1],
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "ATS value `%s' equal: %u == %u\n",
+                          GNUNET_ATS_print_property_type (type1),
                           val1, val2);
             }
         }
@@ -161,8 +163,12 @@ load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
   {
     in_dest[c] = 0;
     out_dest[c] = 0;
-    GNUNET_asprintf (&entry_out, "%s_QUOTA_OUT", network_str[c]);
-    GNUNET_asprintf (&entry_in, "%s_QUOTA_IN", network_str[c]);
+    GNUNET_asprintf (&entry_out,
+                     "%s_QUOTA_OUT",
+                     GNUNET_ATS_print_network_type (c));
+    GNUNET_asprintf (&entry_in,
+                     "%s_QUOTA_IN",
+                     GNUNET_ATS_print_network_type (c));
 
     /* quota out */
     if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_out, &quota_out_str))
@@ -180,21 +186,28 @@ load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
       if (GNUNET_NO == res)
       {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
-              network_str[c], quota_out_str, GNUNET_ATS_DefaultBandwidth);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
+                    GNUNET_ATS_print_network_type (c),
+                    quota_out_str,
+                    GNUNET_ATS_DefaultBandwidth);
           out_dest[c] = GNUNET_ATS_DefaultBandwidth;
       }
       else
       {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Outbound quota configure for network `%s' is %llu\n"),
-              network_str[c], out_dest[c]);
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Outbound quota configure for network `%s' is %llu\n",
+                      GNUNET_ATS_print_network_type (c),
+                      out_dest[c]);
       }
       GNUNET_free (quota_out_str);
     }
     else
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
-          network_str[c], GNUNET_ATS_DefaultBandwidth);
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
+                  GNUNET_ATS_print_network_type (c),
+                  GNUNET_ATS_DefaultBandwidth);
       out_dest[c] = GNUNET_ATS_DefaultBandwidth;
     }
 
@@ -214,24 +227,35 @@ load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
       if (GNUNET_NO == res)
       {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
-              network_str[c], quota_in_str, GNUNET_ATS_DefaultBandwidth);
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
+                      GNUNET_ATS_print_network_type (c),
+                      quota_in_str,
+                      GNUNET_ATS_DefaultBandwidth);
           in_dest[c] = GNUNET_ATS_DefaultBandwidth;
       }
       else
       {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Inbound quota configured for network `%s' is %llu\n"),
-              network_str[c], in_dest[c]);
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Inbound quota configured for network `%s' is %llu\n",
+                      GNUNET_ATS_print_network_type (c),
+                      in_dest[c]);
       }
       GNUNET_free (quota_in_str);
     }
     else
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
-          network_str[c], GNUNET_ATS_DefaultBandwidth);
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
+                  GNUNET_ATS_print_network_type (c),
+                  GNUNET_ATS_DefaultBandwidth);
       out_dest[c] = GNUNET_ATS_DefaultBandwidth;
     }
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Loaded quota for network `%s' (in/out): %llu %llu\n", network_str[c], in_dest[c], out_dest[c]);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Loaded quota for network `%s' (in/out): %llu %llu\n",
+                GNUNET_ATS_print_network_type (c),
+                in_dest[c],
+                out_dest[c]);
     GNUNET_free (entry_out);
     GNUNET_free (entry_in);
   }