gnunet-service-ats_performance.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2011-2015 GNUnet e.V.

     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.

     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.

     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later
 */
#include "platform.h"
#include "gnunet-service-ats.h"
#include "gnunet-service-ats_addresses.h"
#include "gnunet-service-ats_performance.h"
#include "ats.h"


static struct GNUNET_NotificationContext *nc_no_pic;

static struct GNUNET_NotificationContext *nc_pic;


static void
notify_client(struct GNUNET_SERVICE_Client *client,
              const struct GNUNET_PeerIdentity *peer,
              const char *plugin_name,
              const void *plugin_addr,
              size_t plugin_addr_len,
              int active,
              const struct GNUNET_ATS_Properties *prop,
              enum GNUNET_HELLO_AddressInfo local_address_info,
              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) +
    plugin_addr_len +
    plugin_name_length;
  char buf[msize] GNUNET_ALIGN;
  char *addrp;

  if (NULL != prop)
    GNUNET_break(GNUNET_NT_UNSPECIFIED != prop->scope);
  GNUNET_assert(msize < GNUNET_MAX_MESSAGE_SIZE);
  msg = (struct PeerInformationMessage *)buf;
  msg->header.size = htons(msize);
  msg->header.type = htons(GNUNET_MESSAGE_TYPE_ATS_PEER_INFORMATION);
  msg->id = htonl(0);
  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;
  if (NULL != prop)
    GNUNET_ATS_properties_hton(&msg->properties,
                               prop);
  else
    memset(&msg->properties,
           0,
           sizeof(struct GNUNET_ATS_Properties));
  msg->address_local_info = htonl(local_address_info);
  addrp = (char *)&msg[1];
  GNUNET_memcpy(addrp, plugin_addr, plugin_addr_len);
  strcpy(&addrp[plugin_addr_len], plugin_name);
  if (NULL == client)
    {
      GNUNET_notification_context_broadcast(nc_pic,
                                            &msg->header,
                                            GNUNET_YES);
    }
  else
    {
      struct GNUNET_MQ_Envelope *env;

      env = GNUNET_MQ_msg_copy(&msg->header);
      GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client),
                     env);
    }
}


void
GAS_performance_notify_all_clients(const struct GNUNET_PeerIdentity *peer,
                                   const char *plugin_name,
                                   const void *plugin_addr,
                                   size_t plugin_addr_len,
                                   int active,
                                   const struct GNUNET_ATS_Properties *prop,
                                   enum GNUNET_HELLO_AddressInfo local_address_info,
                                   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
                                   struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
{
  GNUNET_break((NULL == prop) ||
               (GNUNET_NT_UNSPECIFIED != prop->scope));
  notify_client(NULL,
                peer,
                plugin_name,
                plugin_addr,
                plugin_addr_len,
                active,
                prop,
                local_address_info,
                bandwidth_out,
                bandwidth_in);
  GNUNET_STATISTICS_update(GSA_stats,
                           "# performance updates given to clients",
                           1,
                           GNUNET_NO);
}


static void
peerinfo_it(void *cls,
            const struct GNUNET_PeerIdentity *id,
            const char *plugin_name,
            const void *plugin_addr,
            size_t plugin_addr_len,
            int active,
            const struct GNUNET_ATS_Properties *prop,
            enum GNUNET_HELLO_AddressInfo local_address_info,
            struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
            struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
{
  struct GNUNET_SERVICE_Client *client = cls;

  if (NULL == id)
    return;
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Callback for peer `%s' plugin `%s' BW out %u, BW in %u \n",
             GNUNET_i2s(id),
             plugin_name,
             (unsigned int)ntohl(bandwidth_out.value__),
             (unsigned int)ntohl(bandwidth_in.value__));
  GNUNET_break(GNUNET_NT_UNSPECIFIED != prop->scope);
  notify_client(client,
                id,
                plugin_name,
                plugin_addr,
                plugin_addr_len,
                active,
                prop,
                local_address_info,
                bandwidth_out,
                bandwidth_in);
}


void
GAS_performance_add_client(struct GNUNET_SERVICE_Client *client,
                           enum StartFlag flag)
{
  struct GNUNET_MQ_Handle *mq;

  mq = GNUNET_SERVICE_client_get_mq(client);
  if (START_FLAG_PERFORMANCE_WITH_PIC == flag)
    {
      GNUNET_notification_context_add(nc_pic,
                                      mq);
      GAS_addresses_get_peer_info(NULL,
                                  &peerinfo_it,
                                  client);
    }
  else
    {
      GNUNET_notification_context_add(nc_no_pic,
                                      mq);
    }
}


void
GAS_performance_init()
{
  nc_no_pic = GNUNET_notification_context_create(32);
  nc_pic = GNUNET_notification_context_create(32);
}


void
GAS_performance_done()
{
  GNUNET_notification_context_destroy(nc_no_pic);
  nc_no_pic = NULL;
  GNUNET_notification_context_destroy(nc_pic);
  nc_pic = NULL;
}

/* end of gnunet-service-ats_performance.c */