src/ats/gnunet-service-ats_performance.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2011-2015 GNUnet e.V.
   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., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20 /**
  21  * @file ats/gnunet-service-ats_performance.c
  22  * @brief ats service, interaction with 'performance' API
  23  * @author Matthias Wachs
  24  * @author Christian Grothoff
  25  *
  26  * TODO:
  27  * - simplify functions by passing a `struct GNUNET_HELLO_Address`
  28  */
  29 #include "platform.h"
  30 #include "gnunet-service-ats.h"
  31 #include "gnunet-service-ats_addresses.h"
  32 #include "gnunet-service-ats_performance.h"
  33 #include "ats.h"
  34
  35
  36 /**
  37  * Context for sending messages to performance clients without PIC.
  38  */
  39 static struct GNUNET_SERVER_NotificationContext *nc_no_pic;
  40
  41 /**
  42  * Context for sending messages to performance clients with PIC.
  43  */
  44 static struct GNUNET_SERVER_NotificationContext *nc_pic;
  45
  46
  47 /**
  48  * Transmit the given performance information to all performance
  49  * clients.
  50  *
  51  * @param pc client to send to, NULL for all
  52  * @param peer peer for which this is an address suggestion
  53  * @param plugin_name 0-termintated string specifying the transport plugin
  54  * @param plugin_addr binary address for the plugin to use
  55  * @param plugin_addr_len number of bytes in plugin_addr
  56  * @param active #GNUNET_YES if this address is actively used
  57  *        to maintain a connection to a peer;
  58  *        #GNUNET_NO if the address is not actively used;
  59  *        #GNUNET_SYSERR if this address is no longer available for ATS
  60  * @param prop performance data for the address
  61  * @param local_address_info information about the local flags for the address
  62  * @param bandwidth_out assigned outbound bandwidth
  63  * @param bandwidth_in assigned inbound bandwidth
  64  */
  65 static void
  66 notify_client (struct GNUNET_SERVER_Client *client,
  67                const struct GNUNET_PeerIdentity *peer,
  68                const char *plugin_name,
  69                const void *plugin_addr,
  70                size_t plugin_addr_len,
  71                int active,
  72                const struct GNUNET_ATS_Properties *prop,
  73                enum GNUNET_HELLO_AddressInfo local_address_info,
  74                struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
  75                struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
  76 {
  77   struct PeerInformationMessage *msg;
  78   size_t plugin_name_length = strlen (plugin_name) + 1;
  79   size_t msize =
  80     sizeof (struct PeerInformationMessage) +
  81     plugin_addr_len +
  82     plugin_name_length;
  83   char buf[msize] GNUNET_ALIGN;
  84   struct GNUNET_SERVER_NotificationContext **uc;
  85   struct GNUNET_SERVER_NotificationContext *nc;
  86   char *addrp;
  87
  88   if (NULL != prop)
  89     GNUNET_break (GNUNET_ATS_NET_UNSPECIFIED != prop->scope);
  90   GNUNET_assert (msize < GNUNET_SERVER_MAX_MESSAGE_SIZE);
  91   msg = (struct PeerInformationMessage *) buf;
  92   msg->header.size = htons (msize);
  93   msg->header.type = htons (GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION);
  94   msg->id = htonl (0);
  95   msg->peer = *peer;
  96   msg->address_length = htons (plugin_addr_len);
  97   msg->address_active = ntohl ((uint32_t) active);
  98   msg->plugin_name_length = htons (plugin_name_length);
  99   msg->bandwidth_out = bandwidth_out;
 100   msg->bandwidth_in = bandwidth_in;
 101   if (NULL != prop)
 102     GNUNET_ATS_properties_hton (&msg->properties,
 103                                 prop);
 104   else
 105     memset (&msg->properties,
 106             0,
 107             sizeof (struct GNUNET_ATS_Properties));
 108   msg->address_local_info = htonl (local_address_info);
 109   addrp = (char *) &msg[1];
 110   memcpy (addrp, plugin_addr, plugin_addr_len);
 111   strcpy (&addrp[plugin_addr_len], plugin_name);
 112   if (NULL == client)
 113   {
 114     GNUNET_SERVER_notification_context_broadcast (nc_pic,
 115                                                   &msg->header,
 116                                                   GNUNET_YES);
 117   }
 118   else
 119   {
 120     uc = GNUNET_SERVER_client_get_user_context (client,
 121                                                  struct GNUNET_SERVER_NotificationContext *);
 122     if (NULL == uc)
 123     {
 124       GNUNET_break (0);
 125       return;
 126     }
 127     nc = *uc;
 128     GNUNET_SERVER_notification_context_unicast (nc,
 129                                                 client,
 130                                                 &msg->header,
 131                                                 GNUNET_YES);
 132   }
 133 }
 134
 135
 136 /**
 137  * Transmit the given performance information to all performance
 138  * clients.
 139  *
 140  * @param peer peer for which this is an address suggestion
 141  * @param plugin_name 0-termintated string specifying the transport plugin
 142  * @param plugin_addr binary address for the plugin to use
 143  * @param plugin_addr_len number of bytes in @a plugin_addr
 144  * @param active #GNUNET_YES if this address is actively used
 145  *        to maintain a connection to a peer;
 146  *        #GNUNET_NO if the address is not actively used;
 147  *        #GNUNET_SYSERR if this address is no longer available for ATS
 148  * @param prop performance data for the address
 149  * @param local_address_info information about the local flags for the address
 150  * @param bandwidth_out assigned outbound bandwidth
 151  * @param bandwidth_in assigned inbound bandwidth
 152  */
 153 void
 154 GAS_performance_notify_all_clients (const struct GNUNET_PeerIdentity *peer,
 155                                     const char *plugin_name,
 156                                     const void *plugin_addr,
 157                                     size_t plugin_addr_len,
 158                                     int active,
 159                                     const struct GNUNET_ATS_Properties *prop,
 160                                     enum GNUNET_HELLO_AddressInfo local_address_info,
 161                                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
 162                                     struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 163 {
 164   GNUNET_break ( (NULL == prop) ||
 165                  (GNUNET_ATS_NET_UNSPECIFIED != prop->scope) );
 166   notify_client (NULL,
 167                  peer,
 168                  plugin_name,
 169                  plugin_addr,
 170                  plugin_addr_len,
 171                  active,
 172                  prop,
 173                  local_address_info,
 174                  bandwidth_out,
 175                  bandwidth_in);
 176   GNUNET_STATISTICS_update (GSA_stats,
 177                             "# performance updates given to clients",
 178                             1,
 179                             GNUNET_NO);
 180 }
 181
 182
 183 /**
 184  * Iterator for called from #GAS_addresses_get_peer_info()
 185  *
 186  * @param cls closure with the `struct GNUNET_SERVER_Client *` to inform.
 187  * @param id the peer id
 188  * @param plugin_name plugin name
 189  * @param plugin_addr address
 190  * @param plugin_addr_len length of @a plugin_addr
 191  * @param active is address actively used
 192  * @param prop performance information
 193  * @param local_address_info information about the local flags for the address
 194  * @param bandwidth_out current outbound bandwidth assigned to address
 195  * @param bandwidth_in current inbound bandwidth assigned to address
 196  */
 197 static void
 198 peerinfo_it (void *cls,
 199              const struct GNUNET_PeerIdentity *id,
 200              const char *plugin_name,
 201              const void *plugin_addr,
 202              size_t plugin_addr_len,
 203              int active,
 204              const struct GNUNET_ATS_Properties *prop,
 205              enum GNUNET_HELLO_AddressInfo local_address_info,
 206              struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
 207              struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 208 {
 209   struct GNUNET_SERVER_Client *client = cls;
 210
 211   if (NULL == id)
 212     return;
 213   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 214               "Callback for peer `%s' plugin `%s' BW out %u, BW in %u \n",
 215               GNUNET_i2s (id),
 216               plugin_name,
 217               (unsigned int) ntohl (bandwidth_out.value__),
 218               (unsigned int) ntohl (bandwidth_in.value__));
 219   GNUNET_break (GNUNET_ATS_NET_UNSPECIFIED != prop->scope);
 220   notify_client (client,
 221                  id,
 222                  plugin_name,
 223                  plugin_addr,
 224                  plugin_addr_len,
 225                  active,
 226                  prop,
 227                  local_address_info,
 228                  bandwidth_out,
 229                  bandwidth_in);
 230 }
 231
 232
 233 /**
 234  * Register a new performance client.
 235  *
 236  * @param client handle of the new client
 237  * @param flag flag specifying the type of the client
 238  */
 239 void
 240 GAS_performance_add_client (struct GNUNET_SERVER_Client *client,
 241                             enum StartFlag flag)
 242 {
 243   if (START_FLAG_PERFORMANCE_WITH_PIC == flag)
 244   {
 245     GNUNET_SERVER_notification_context_add (nc_pic,
 246                                             client);
 247     GNUNET_SERVER_client_set_user_context (client,
 248                                            &nc_pic);
 249     GAS_addresses_get_peer_info (NULL,
 250                                  &peerinfo_it,
 251                                  client);
 252   }
 253   else
 254   {
 255     GNUNET_SERVER_notification_context_add (nc_no_pic,
 256                                             client);
 257     GNUNET_SERVER_client_set_user_context (client,
 258                                            &nc_no_pic);
 259   }
 260 }
 261
 262
 263 /**
 264  * Initialize performance subsystem.
 265  *
 266  * @param server handle to our server
 267  */
 268 void
 269 GAS_performance_init (struct GNUNET_SERVER_Handle *server)
 270 {
 271   nc_no_pic = GNUNET_SERVER_notification_context_create (server, 32);
 272   nc_pic = GNUNET_SERVER_notification_context_create (server, 32);
 273 }
 274
 275
 276 /**
 277  * Shutdown performance subsystem.
 278  */
 279 void
 280 GAS_performance_done ()
 281 {
 282   GNUNET_SERVER_notification_context_destroy (nc_no_pic);
 283   nc_no_pic = NULL;
 284   GNUNET_SERVER_notification_context_destroy (nc_pic);
 285   nc_pic = NULL;
 286 }
 287
 288 /* end of gnunet-service-ats_performance.c */