src/ats/test_ats_api_common.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2010,2011 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20 /**
  21  * @file ats/test_ats_api_common.c
  22  * @brief shared functions for ats test
  23  * @author Christian Grothoff
  24  * @author Matthias Wachs
  25  */
  26
  27 #include "test_ats_api_common.h"
  28 #define BIG_M_STRING "unlimited"
  29
  30
  31 void
  32 create_test_address (struct Test_Address *dest, char * plugin, void *session, void *addr, size_t addrlen)
  33 {
  34
  35   dest->plugin = GNUNET_strdup (plugin);
  36   dest->session = session;
  37   if (addrlen > 0)
  38   {
  39     dest->addr = GNUNET_malloc (addrlen);
  40     memcpy (dest->addr, addr, addrlen);
  41   }
  42   else
  43       dest->addr = NULL;
  44   dest->addr_len = addrlen;
  45 }
  46
  47 void
  48 free_test_address (struct Test_Address *dest)
  49 {
  50   GNUNET_free_non_null (dest->plugin);
  51   dest->plugin = NULL;
  52   GNUNET_free_non_null (dest->addr);
  53   dest->addr = NULL;
  54 }
  55
  56 int
  57 compare_addresses (const struct GNUNET_HELLO_Address *address1, void *session1,
  58                    const struct GNUNET_HELLO_Address *address2, void *session2)
  59 {
  60   if (0 != memcmp (&address1->peer, &address2->peer, sizeof (struct GNUNET_PeerIdentity)))
  61   {
  62       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Suggestion with invalid peer id'\n");
  63       return GNUNET_SYSERR;
  64   }
  65   if (0 != strcmp (address1->transport_name, address2->transport_name))
  66   {
  67       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Suggestion with invalid plugin'\n");
  68       return GNUNET_SYSERR;
  69   }
  70   if (address1->address_length != address2->address_length)
  71   {
  72       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Suggestion with invalid address length\n");
  73       return GNUNET_SYSERR;
  74
  75   }
  76   else if (0 != memcmp (address1->address, address2->address, address2->address_length))
  77   {
  78       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Suggestion with invalid address\n");
  79       return GNUNET_SYSERR;
  80   }
  81   if (session1 != session2)
  82   {
  83       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Suggestion with invalid session1 %p vs session2 %p'\n",
  84                   session1, session2);
  85       return GNUNET_SYSERR;
  86
  87   }
  88   return GNUNET_OK;
  89 }
  90
  91
  92 int
  93 compare_ats (const struct GNUNET_ATS_Information *ats_is, uint32_t ats_count_is,
  94              const struct GNUNET_ATS_Information *ats_should, uint32_t ats_count_should)
  95 {
  96   unsigned int c_o;
  97   unsigned int c_i;
  98   char *prop[] = GNUNET_ATS_PropertyStrings;
  99   uint32_t type1;
 100   uint32_t type2;
 101   uint32_t val1;
 102   uint32_t val2;
 103   int res = GNUNET_OK;
 104
 105   for (c_o = 0; c_o < ats_count_is; c_o++)
 106   {
 107     for (c_i = 0; c_i < ats_count_should; c_i++)
 108     {
 109         type1 = ntohl(ats_is[c_o].type);
 110         type2 = ntohl(ats_should[c_i].type);
 111         if (type1 == type2)
 112         {
 113             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS type `%s'\n",
 114                         prop[type1]);
 115             val1 = ntohl(ats_is[c_o].value);
 116             val2 = ntohl(ats_should[c_i].value);
 117             if (val1 != val2)
 118             {
 119                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ATS value `%s' not equal: %u != %u\n",
 120                             prop[type1],
 121                             val1, val2);
 122                 res = GNUNET_SYSERR;
 123             }
 124             else
 125             {
 126               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS value `%s' equal: %u == %u\n",
 127                           prop[type1],
 128                           val1, val2);
 129             }
 130         }
 131     }
 132   }
 133   return res;
 134 }
 135
 136
 137 /**
 138  * Load quotas for networks from configuration
 139  *
 140  * @param cfg configuration handle
 141  * @param out_dest where to write outbound quotas
 142  * @param in_dest where to write inbound quotas
 143  * @param dest_length length of inbound and outbound arrays
 144  * @return number of networks loaded
 145  */
 146 unsigned int
 147 load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg,
 148                                                  unsigned long long *out_dest,
 149                                                  unsigned long long *in_dest,
 150                                                  int dest_length)
 151 {
 152   char *network_str[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
 153   char * entry_in = NULL;
 154   char * entry_out = NULL;
 155   char * quota_out_str;
 156   char * quota_in_str;
 157   int c;
 158   int res;
 159
 160   for (c = 0; (c < GNUNET_ATS_NetworkTypeCount) && (c < dest_length); c++)
 161   {
 162     in_dest[c] = 0;
 163     out_dest[c] = 0;
 164     GNUNET_asprintf (&entry_out, "%s_QUOTA_OUT", network_str[c]);
 165     GNUNET_asprintf (&entry_in, "%s_QUOTA_IN", network_str[c]);
 166
 167     /* quota out */
 168     if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_out, &quota_out_str))
 169     {
 170       res = GNUNET_NO;
 171       if (0 == strcmp(quota_out_str, BIG_M_STRING))
 172       {
 173         out_dest[c] = GNUNET_ATS_MaxBandwidth;
 174         res = GNUNET_YES;
 175       }
 176       if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_STRINGS_fancy_size_to_bytes (quota_out_str, &out_dest[c])))
 177         res = GNUNET_YES;
 178       if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "ats", entry_out,  &out_dest[c])))
 179          res = GNUNET_YES;
 180
 181       if (GNUNET_NO == res)
 182       {
 183           GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
 184               network_str[c], quota_out_str, GNUNET_ATS_DefaultBandwidth);
 185           out_dest[c] = GNUNET_ATS_DefaultBandwidth;
 186       }
 187       else
 188       {
 189           GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Outbound quota configure for network `%s' is %llu\n"),
 190               network_str[c], out_dest[c]);
 191       }
 192       GNUNET_free (quota_out_str);
 193     }
 194     else
 195     {
 196       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("No outbound quota configured for network `%s', assigning default bandwidth %llu\n"),
 197           network_str[c], GNUNET_ATS_DefaultBandwidth);
 198       out_dest[c] = GNUNET_ATS_DefaultBandwidth;
 199     }
 200
 201     /* quota in */
 202     if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_in, &quota_in_str))
 203     {
 204       res = GNUNET_NO;
 205       if (0 == strcmp(quota_in_str, BIG_M_STRING))
 206       {
 207         in_dest[c] = GNUNET_ATS_MaxBandwidth;
 208         res = GNUNET_YES;
 209       }
 210       if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_STRINGS_fancy_size_to_bytes (quota_in_str, &in_dest[c])))
 211         res = GNUNET_YES;
 212       if ((GNUNET_NO == res) && (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "ats", entry_in,  &in_dest[c])))
 213          res = GNUNET_YES;
 214
 215       if (GNUNET_NO == res)
 216       {
 217           GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Could not load quota for network `%s':  `%s', assigning default bandwidth %llu\n"),
 218               network_str[c], quota_in_str, GNUNET_ATS_DefaultBandwidth);
 219           in_dest[c] = GNUNET_ATS_DefaultBandwidth;
 220       }
 221       else
 222       {
 223           GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Inbound quota configured for network `%s' is %llu\n"),
 224               network_str[c], in_dest[c]);
 225       }
 226       GNUNET_free (quota_in_str);
 227     }
 228     else
 229     {
 230       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("No outbound quota configure for network `%s', assigning default bandwidth %llu\n"),
 231           network_str[c], GNUNET_ATS_DefaultBandwidth);
 232       out_dest[c] = GNUNET_ATS_DefaultBandwidth;
 233     }
 234     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]);
 235     GNUNET_free (entry_out);
 236     GNUNET_free (entry_in);
 237   }
 238   return GNUNET_ATS_NetworkTypeCount;
 239 }
 240
 241 /**
 242  * Create a ATS_address with the given information
 243  * @param peer peer
 244  * @param plugin_name plugin
 245  * @param plugin_addr address
 246  * @param plugin_addr_len address length
 247  * @param session_id session
 248  * @return the ATS_Address
 249  */
 250 struct ATS_Address *
 251 create_address (const struct GNUNET_PeerIdentity *peer,
 252                 const char *plugin_name,
 253                 const void *plugin_addr, size_t plugin_addr_len,
 254                 uint32_t session_id)
 255 {
 256   struct ATS_Address *aa = NULL;
 257
 258   aa = GNUNET_malloc (sizeof (struct ATS_Address) + plugin_addr_len + strlen (plugin_name) + 1);
 259   aa->peer = *peer;
 260   aa->addr_len = plugin_addr_len;
 261   aa->addr = &aa[1];
 262   aa->plugin = (char *) &aa[1] + plugin_addr_len;
 263   memcpy (&aa[1], plugin_addr, plugin_addr_len);
 264   memcpy (aa->plugin, plugin_name, strlen (plugin_name) + 1);
 265   aa->session_id = session_id;
 266   aa->active = GNUNET_NO;
 267   aa->used = GNUNET_NO;
 268   aa->solver_information = NULL;
 269   aa->assigned_bw_in = GNUNET_BANDWIDTH_value_init(0);
 270   aa->assigned_bw_out = GNUNET_BANDWIDTH_value_init(0);
 271   return aa;
 272 }
 273
 274 /* end of file test_ats_api_common.c */