gnunet-service-transport_manipulation.h File Reference

#include "platform.h"
#include "gnunet-service-transport_hello.h"
#include "gnunet-service-transport_neighbours.h"
#include "gnunet-service-transport_plugins.h"
#include "gnunet-service-transport_validation.h"
#include "gnunet-service-transport.h"
#include "transport.h"

Include dependency graph for gnunet-service-transport_manipulation.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	GST_manipulation_set_metric (const struct TrafficMetricMessage *tm)
	Set traffic metric to manipulate. More...
void	GST_manipulation_send (const struct GNUNET_PeerIdentity *target, const void *msg, size_t msg_size, struct GNUNET_TIME_Relative timeout, GST_NeighbourSendContinuation cont, void *cont_cls)
	Adapter function between transport's send function and transport plugins. More...
struct GNUNET_TIME_Relative	GST_manipulation_recv (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, const struct GNUNET_MessageHeader *message)
	Adapter function between transport plugins and transport receive function manipulation delays for next send. More...
void	GST_manipulation_manipulate_metrics (const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, struct GNUNET_ATS_Properties *prop)
	Function that will be called to manipulate ATS information according to current manipulation settings. More...
void	GST_manipulation_peer_disconnect (const struct GNUNET_PeerIdentity *peer)
	Notify manipulation about disconnect so it can discard queued messages. More...
void	GST_manipulation_init (void)
	Initialize traffic manipulation. More...
void	GST_manipulation_stop (void)
	Stop traffic manipulation. More...

Function Documentation

GST_manipulation_set_metric()

void GST_manipulation_set_metric

(

const struct TrafficMetricMessage *

tm

)

Set traffic metric to manipulate.

Parameters

message	containing information
tm	message containing information

Definition at line 174 of file gnunet-service-transport_manipulation.c.

{
  static struct GNUNET_PeerIdentity zero;
  struct TM_Peer *tmp;
 
  if (0 == memcmp (&tm->peer,
                   &zero,
                   sizeof(struct GNUNET_PeerIdentity)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received traffic metrics for all peers\n");
    delay_in = GNUNET_TIME_relative_ntoh (tm->delay_in);
    delay_out = GNUNET_TIME_relative_ntoh (tm->delay_out);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received traffic metrics for peer `%s'\n",
              GNUNET_i2s (&tm->peer));
  if (NULL ==
      (tmp = GNUNET_CONTAINER_multipeermap_get (peers,
                                                &tm->peer)))
  {
    tmp = GNUNET_new (struct TM_Peer);
    tmp->peer = tm->peer;
    GNUNET_CONTAINER_multipeermap_put (peers,
                                       &tm->peer,
                                       tmp,
                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
  }
  GNUNET_ATS_properties_ntoh (&tmp->properties,
                              &tm->properties);
  tmp->delay_in = GNUNET_TIME_relative_ntoh (tm->delay_in);
  tmp->delay_out = GNUNET_TIME_relative_ntoh (tm->delay_out);
}

References delay_in, TM_Peer::delay_in, TrafficMetricMessage::delay_in, delay_out, TM_Peer::delay_out, TrafficMetricMessage::delay_out, GNUNET_ATS_properties_ntoh(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_TIME_relative_ntoh(), TM_Peer::peer, TrafficMetricMessage::peer, peers, TM_Peer::properties, TrafficMetricMessage::properties, and zero.

Referenced by handle_client_set_metric().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_manipulation_send()

void GST_manipulation_send	(	const struct GNUNET_PeerIdentity *	target,
		const void *	msg,
		size_t	msg_size,
		struct GNUNET_TIME_Relative	timeout,
		GST_NeighbourSendContinuation	cont,
		void *	cont_cls
	)

Adapter function between transport's send function and transport plugins.

Parameters

target	the peer the message to send to
msg	the message received
msg_size	message size
timeout	timeout
cont	the continuation to call after sending
cont_cls	cls for continuation

Delays message transmission if an artificial delay is configured.

Parameters

target	the peer the message to send to
msg	the message received
msg_size	message size
timeout	timeout
cont	the continuation to call after sending
cont_cls	cls for cont

Definition at line 278 of file gnunet-service-transport_manipulation.c.

{
  struct TM_Peer *tmp;
  struct DelayQueueEntry *dqe;
  struct GNUNET_TIME_Relative delay;
 
  if (NULL != (tmp =
                 GNUNET_CONTAINER_multipeermap_get (peers,
                                                    target)))
    delay = tmp->delay_out;
  else
    delay = delay_out;
  if (0 == delay.rel_value_us)
  {
    /* Normal sending */
    GST_neighbours_send (target,
                         msg,
                         msg_size,
                         timeout,
                         cont, cont_cls);
    return;
  }
  dqe = GNUNET_malloc (sizeof(struct DelayQueueEntry) + msg_size);
  dqe->id = *target;
  dqe->tmp = tmp;
  dqe->sent_at = GNUNET_TIME_relative_to_absolute (delay);
  dqe->cont = cont;
  dqe->cont_cls = cont_cls;
  dqe->msg = &dqe[1];
  dqe->msg_size = msg_size;
  dqe->timeout = timeout;
  GNUNET_memcpy (dqe->msg,
                 msg,
                 msg_size);
  if (NULL == tmp)
  {
    GNUNET_CONTAINER_DLL_insert_tail (generic_dqe_head,
                                      generic_dqe_tail,
                                      dqe);
    if (NULL == generic_send_delay_task)
      generic_send_delay_task = GNUNET_SCHEDULER_add_delayed (delay,
                                                              &send_delayed,
                                                              dqe);
  }
  else
  {
    GNUNET_CONTAINER_DLL_insert_tail (tmp->send_head,
                                      tmp->send_tail,
                                      dqe);
    if (NULL == tmp->send_delay_task)
      tmp->send_delay_task = GNUNET_SCHEDULER_add_delayed (delay,
                                                           &send_delayed,
                                                           dqe);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Delaying %u byte message to peer `%s' with peer specific delay for %s\n",
              (unsigned int) msg_size,
              GNUNET_i2s (target),
              GNUNET_STRINGS_relative_time_to_string (delay,
                                                      GNUNET_YES));
}

References DelayQueueEntry::cont, DelayQueueEntry::cont_cls, delay, delay_out, TM_Peer::delay_out, generic_dqe_head, generic_dqe_tail, generic_send_delay_task, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_multipeermap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, GST_neighbours_send(), DelayQueueEntry::id, msg, DelayQueueEntry::msg, DelayQueueEntry::msg_size, peers, GNUNET_TIME_Relative::rel_value_us, TM_Peer::send_delay_task, send_delayed(), TM_Peer::send_head, TM_Peer::send_tail, DelayQueueEntry::sent_at, timeout, DelayQueueEntry::timeout, and DelayQueueEntry::tmp.

Referenced by handle_client_send().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_manipulation_recv()

struct GNUNET_TIME_Relative GST_manipulation_recv	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session,
		const struct GNUNET_MessageHeader *	message
	)

Adapter function between transport plugins and transport receive function manipulation delays for next send.

Parameters

cls	the closure for transport
address	the address and the peer the message was received from
message	the message received
session	the session the message was received on

Returns

manipulated delay for next receive

Definition at line 355 of file gnunet-service-transport_manipulation.c.

{
  struct TM_Peer *tmp;
  struct GNUNET_TIME_Relative quota_delay;
  struct GNUNET_TIME_Relative m_delay;
 
  if (NULL !=
      (tmp = GNUNET_CONTAINER_multipeermap_get (peers,
                                                &address->peer)))
    m_delay = tmp->delay_in;
  else
    m_delay = delay_in;
 
  quota_delay = GST_receive_callback (cls,
                                      address,
                                      session,
                                      message);
  m_delay = GNUNET_TIME_relative_max (m_delay,
                                      quota_delay);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Delaying next receive for peer `%s' for %s\n",
              GNUNET_i2s (&address->peer),
              GNUNET_STRINGS_relative_time_to_string (m_delay,
                                                      GNUNET_YES));
  return m_delay;
}

Referenced by run().

Here is the caller graph for this function:

GST_manipulation_manipulate_metrics()

void GST_manipulation_manipulate_metrics	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session,
		struct GNUNET_ATS_Properties *	prop
	)

Function that will be called to manipulate ATS information according to current manipulation settings.

Parameters

	address	binary address
	session	the session
	prop[IN|OUT]	metrics to modify
	address	binary address
	session	the session
[in,out]	prop	metrics to modify

Definition at line 355 of file gnunet-service-transport_manipulation.c.

{
  const struct GNUNET_PeerIdentity *peer = &address->peer;
  struct TM_Peer *tmp;
 
  tmp = GNUNET_CONTAINER_multipeermap_get (peers,
                                           peer);
  if (NULL != tmp)
    *prop = tmp->properties;
}

References address, GNUNET_CONTAINER_multipeermap_get(), peer, peers, and TM_Peer::properties.

Referenced by GST_ats_update_delay(), GST_ats_update_distance(), and GST_ats_update_utilization().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_manipulation_peer_disconnect()

void GST_manipulation_peer_disconnect

(

const struct GNUNET_PeerIdentity *

peer

)

Notify manipulation about disconnect so it can discard queued messages.

Parameters

peer	the disconnecting peer

Definition at line 456 of file gnunet-service-transport_manipulation.c.

{
  struct TM_Peer *tmp;
  struct DelayQueueEntry *dqe;
  struct DelayQueueEntry *next;
 
  tmp = GNUNET_CONTAINER_multipeermap_get (peers,
                                           peer);
  if (NULL != tmp)
  {
    while (NULL != (dqe = tmp->send_head))
    {
      GNUNET_CONTAINER_DLL_remove (tmp->send_head,
                                   tmp->send_tail,
                                   dqe);
      if (NULL != dqe->cont)
        dqe->cont (dqe->cont_cls,
                   GNUNET_SYSERR,
                   dqe->msg_size,
                   0);
      GNUNET_free (dqe);
    }
  }
  next = generic_dqe_head;
  while (NULL != (dqe = next))
  {
    next = dqe->next;
    if (0 == memcmp (peer,
                     &dqe->id,
                     sizeof(dqe->id)))
    {
      GNUNET_CONTAINER_DLL_remove (generic_dqe_head,
                                   generic_dqe_tail,
                                   dqe);
      if (NULL != dqe->cont)
        dqe->cont (dqe->cont_cls,
                   GNUNET_SYSERR,
                   dqe->msg_size,
                   0);
      GNUNET_free (dqe);
    }
  }
  if (NULL != generic_send_delay_task)
  {
    GNUNET_SCHEDULER_cancel (generic_send_delay_task);
    generic_send_delay_task = NULL;
    if (NULL != generic_dqe_head)
      generic_send_delay_task
        = GNUNET_SCHEDULER_add_at (generic_dqe_head->sent_at,
                                   &send_delayed,
                                   generic_dqe_head);
  }
}

References DelayQueueEntry::cont, DelayQueueEntry::cont_cls, generic_dqe_head, generic_dqe_tail, generic_send_delay_task, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_get(), GNUNET_free, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, DelayQueueEntry::id, DelayQueueEntry::msg_size, DelayQueueEntry::next, peer, peers, send_delayed(), TM_Peer::send_head, TM_Peer::send_tail, DelayQueueEntry::sent_at, and DelayQueueEntry::tmp.

Referenced by neighbours_disconnect_notification().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_manipulation_init()

void GST_manipulation_init

(

void

)

Initialize traffic manipulation.

Definition at line 415 of file gnunet-service-transport_manipulation.c.

{
  struct GNUNET_TIME_Relative delay;
 
  if ((GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_time (GST_cfg,
                                            "transport",
                                            "MANIPULATE_DELAY_IN",
                                            &delay)) &&
      (delay.rel_value_us > 0))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Delaying inbound traffic for %s\n",
                GNUNET_STRINGS_relative_time_to_string (delay,
                                                        GNUNET_YES));
    delay_in = delay;
  }
  if ((GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_time (GST_cfg,
                                            "transport",
                                            "MANIPULATE_DELAY_OUT",
                                            &delay)) &&
      (delay.rel_value_us > 0))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Delaying outbound traffic for %s\n",
                GNUNET_STRINGS_relative_time_to_string (delay,
                                                        GNUNET_YES));
    delay_out = delay;
  }
  peers = GNUNET_CONTAINER_multipeermap_create (4,
                                                GNUNET_NO);
}

References delay, delay_in, delay_out, GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, GST_cfg, peers, and GNUNET_TIME_Relative::rel_value_us.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_manipulation_stop()

void GST_manipulation_stop

(

void

)

Stop traffic manipulation.

Definition at line 557 of file gnunet-service-transport_manipulation.c.

{
  struct DelayQueueEntry *cur;
 
  GNUNET_CONTAINER_multipeermap_iterate (peers,
                                         &free_tmps,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (peers);
  peers = NULL;
  while (NULL != (cur = generic_dqe_head))
  {
    GNUNET_CONTAINER_DLL_remove (generic_dqe_head,
                                 generic_dqe_tail,
                                 cur);
    if (NULL != cur->cont)
      cur->cont (cur->cont_cls,
                 GNUNET_SYSERR,
                 cur->msg_size,
                 0);
    GNUNET_free (cur);
  }
  if (NULL != generic_send_delay_task)
  {
    GNUNET_SCHEDULER_cancel (generic_send_delay_task);
    generic_send_delay_task = NULL;
  }
}

Referenced by shutdown_task().

Here is the caller graph for this function: