transport component manipulation traffic for simulation More...

#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.c:

Data Structures
struct	TM_Peer
	Struct containing information about manipulations to a specific peer. More...

struct	DelayQueueEntry
	Entry in the delay queue for an outbound delayed message. More...

Functions
void	GST_manipulation_set_metric (const struct TrafficMetricMessage *tm)
	Set traffic metric to manipulate. More...

static void	send_delayed (void *cls)
	We have delayed transmission, now it is time to send the message. 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...

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...

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_init ()
	Initialize traffic manipulation. More...

void	GST_manipulation_peer_disconnect (const struct GNUNET_PeerIdentity *peer)
	Notify manipulation about disconnect so it can discard queued messages. More...

static int	free_tmps (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Free manipulation information about a peer. More...

void	GST_manipulation_stop ()
	Stop traffic manipulation. More...

Variables
static struct GNUNET_CONTAINER_MultiPeerMap *	peers
	Hashmap contain all peers currently manipulated. More...

static struct GNUNET_TIME_Relative	delay_in
	Inbound delay to apply to all peers. More...

static struct GNUNET_TIME_Relative	delay_out
	Outbound delay to apply to all peers. More...

static struct DelayQueueEntry *	generic_dqe_head
	DLL head for delayed messages based on general delay. More...

static struct DelayQueueEntry *	generic_dqe_tail
	DLL tail for delayed messages based on general delay. More...

static struct GNUNET_SCHEDULER_Task *	generic_send_delay_task
	Task to schedule delayed sending based on general delay. More...

Detailed Description

transport component manipulation traffic for simulation

Author: Christian Grothoff; Matthias Wachs

Definition in file gnunet-service-transport_manipulation.c.

Function Documentation

◆ GST_manipulation_set_metric()

void GST_manipulation_set_metric ( const struct TrafficMetricMessage * tm )

Set traffic metric to manipulate.

Parameters

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:

◆ send_delayed()

static void send_delayed ( void * cls )

static

We have delayed transmission, now it is time to send the message.

Parameters

cls	the `struct DelayQueueEntry` to transmit

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

 {
   struct DelayQueueEntry *dqe = cls;
   struct DelayQueueEntry *next;
   struct TM_Peer *tmp = dqe->tmp;
  
   GNUNET_break (GNUNET_YES ==
                 GST_neighbours_test_connected (&dqe->id));
   if (NULL != tmp)
   {
     tmp->send_delay_task = NULL;
     GNUNET_CONTAINER_DLL_remove (tmp->send_head,
                                  tmp->send_tail,
                                  dqe);
     next = tmp->send_head;
     if (NULL != next)
     {
       /* More delayed messages */
       tmp->send_delay_task = GNUNET_SCHEDULER_add_at (next->sent_at,
                                                       &send_delayed,
                                                       next);
     }
   }
   else
   {
     /* Remove from generic queue */
     generic_send_delay_task = NULL;
     GNUNET_CONTAINER_DLL_remove (generic_dqe_head,
                                  generic_dqe_tail,
                                  dqe);
     next = generic_dqe_head;
     if (NULL != next)
     {
       /* More delayed messages */
       generic_send_delay_task = GNUNET_SCHEDULER_add_at (next->sent_at,
                                                          &send_delayed,
                                                          next);
     }
   }
   GST_neighbours_send (&dqe->id,
                        dqe->msg,
                        dqe->msg_size,
                        dqe->timeout,
                        dqe->cont,
                        dqe->cont_cls);
   GNUNET_free (dqe);
 }

References DelayQueueEntry::cont, DelayQueueEntry::cont_cls, generic_dqe_head, generic_dqe_tail, generic_send_delay_task, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_add_at(), GNUNET_YES, GST_neighbours_send(), GST_neighbours_test_connected(), DelayQueueEntry::id, DelayQueueEntry::msg, DelayQueueEntry::msg_size, DelayQueueEntry::next, TM_Peer::send_delay_task, TM_Peer::send_head, TM_Peer::send_tail, DelayQueueEntry::sent_at, DelayQueueEntry::timeout, and DelayQueueEntry::tmp.

Referenced by GST_manipulation_peer_disconnect(), and GST_manipulation_send().

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.

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_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
[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_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_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_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:

◆ free_tmps()

static int free_tmps	(	void *	cls,
		const struct GNUNET_PeerIdentity *	key,
		void *	value
	)

static

Free manipulation information about a peer.

Parameters

cls	NULL
key	peer the info is about
value	a `struct TM_Peer` to free

Returns: GNUNET_OK (continue to iterate)

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

 {
   struct TM_Peer *tmp = value;
   struct DelayQueueEntry *dqe;
  
   GNUNET_break (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (peers,
                                                       key,
                                                       value));
   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);
   }
   if (NULL != tmp->send_delay_task)
   {
     GNUNET_SCHEDULER_cancel (tmp->send_delay_task);
     tmp->send_delay_task = NULL;
   }
   GNUNET_free (tmp);
   return GNUNET_OK;
 }

References DelayQueueEntry::cont, DelayQueueEntry::cont_cls, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_YES, key, DelayQueueEntry::msg_size, peers, TM_Peer::send_delay_task, TM_Peer::send_head, TM_Peer::send_tail, DelayQueueEntry::tmp, and value.

Here is the call 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;
   }
 }